Welcome to AirsSys

AirsSys is a comprehensive collection of system programming components designed for the AirsStack ecosystem. It provides secure, modular, and high-performance tools for building robust concurrent applications with strong security guarantees.

Overview

AirsSys consists of multiple specialized components that work together to provide a complete system programming solution:

🛡️ OSL (OS Layer Framework)

Secure, cross-platform abstraction over operating system functionality with comprehensive audit trails and security policy enforcement.

Key Features:

• Cross-platform OS abstraction (filesystem, process, network)
• Built-in ACL and RBAC security policies
• Comprehensive activity logging and audit trails
• Middleware pipeline for extensibility
• Helper functions for common operations

Use Cases:

• Secure application development requiring system resources
• Enterprise system administration with compliance requirements
• Foundation for higher-level AirsStack components

⚡ RT (Actor Runtime)

Lightweight Erlang-Actor model runtime system for high-concurrency applications with BEAM-inspired supervision and fault tolerance.

Key Features:

• Zero-cost actor abstraction with compile-time type safety
• BEAM-inspired supervision trees (OneForOne, OneForAll, RestForOne)
• High performance: ~625ns actor spawn, 4.7M msgs/sec throughput
• Broker-based message routing with backpressure control
• Comprehensive monitoring and observability

Use Cases:

• High-concurrency servers requiring fault tolerance
• Event-driven architectures with complex state management
• System programming with reliable process supervision
• Microservice coordination

🧩 WASM (Component Framework)

Production-ready WebAssembly component framework for building fault-tolerant, scalable component-based systems with actor-based runtime integration.

Key Features:

• Dual-trait pattern: lifecycle management (Child) + message handling (Actor)
• Automatic crash recovery with configurable restart strategies
• High performance: 286ns component spawn, 6.12M msg/sec throughput
• O(1) registry lookup (36ns) with perfect scalability (10-1,000 components)
• Comprehensive supervision with exponential backoff
• Production-ready documentation (19 docs, 6 examples)

Use Cases:

• Pluggable component architectures requiring isolation
• Fault-tolerant systems with automatic recovery
• High-throughput message processing (6M+ msg/sec)
• Multi-component orchestration with supervision

Component Status

Component	Status	Documentation
airssys-osl	✅ Complete	View Docs
airssys-rt	✅ Complete	View Docs
airssys-wasm	✅ Production Ready	View Docs
airssys-wasm-cli	⏳ In Development	Not yet migrated
airssys-osl-macros	⏳ In Development	Not yet migrated
airssys-wasm-component	⏳ In Development	Not yet migrated

WASM Component Framework

airssys-wasm has completed Phase 6 validation with 945 integration tests (100% pass) and 28 performance benchmarks (all targets exceeded). Documentation includes 19 comprehensive guides, 6 working examples, and production deployment resources. Quality score: 9.7/10.

Quick Start

OSL Quick Start

use airssys_osl::helpers::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Filesystem operations with built-in security
    let data = b"Hello, World!".to_vec();
    write_file("/tmp/test.txt", data, "admin").await?;
    let content = read_file("/tmp/test.txt", "admin").await?;

    // Process operations
    let output = spawn_process("echo", vec!["Hello!".to_string()], "admin").await?;

    // Network operations
    let listener = network_listen("127.0.0.1:0", "admin").await?;

    Ok(())
}

RT Quick Start

use airssys_rt::prelude::*;
use async_trait::async_trait;

// Define message type
#[derive(Debug, Clone)]
enum CounterMsg {
    Increment,
    GetCount(tokio::sync::oneshot::Sender<u64>),
}

impl Message for CounterMsg {
    const MESSAGE_TYPE: &'static str = "counter";
}

// Define actor
struct CounterActor {
    count: u64,
}

// Implement Actor trait
#[async_trait]
impl Actor for CounterActor {
    type Message = CounterMsg;
    type Error = std::io::Error;

    async fn handle_message<B: MessageBroker<Self::Message>>(
        &mut self,
        msg: Self::Message,
        ctx: &mut ActorContext<Self::Message, B>,
    ) -> Result<(), Self::Error> {
        match msg {
            CounterMsg::Increment => self.count += 1,
            CounterMsg::GetCount(reply) => {
                let _ = reply.send(self.count);
            }
        }
        Ok(())
    }
}

WASM Quick Start

use airssys_rt::prelude::*;
use airssys_wasm::actor::ComponentActor;
use async_trait::async_trait;

// Define component with lifecycle and message handling
#[derive(Clone)]
struct MyComponent {
    state: Arc<RwLock<ComponentState>>,
}

// Lifecycle management (Child trait)
impl Child for MyComponent {
    fn pre_start(&mut self, context: &ChildContext) -> Result<(), ChildError> {
        println!("Component starting: {}", context.component_id);
        Ok(())
    }
}

// Message handling (Actor trait)
#[async_trait]
impl Actor for MyComponent {
    type Message = MyMessage;
    type Error = ComponentError;

    async fn handle_message(
        &mut self,
        message: Self::Message,
        context: &ActorContext,
    ) -> Result<(), Self::Error> {
        // Process message with automatic supervision
        Ok(())
    }
}

Design Philosophy

Security by Default

All AirsSys components implement a deny-by-default security model. Operations are only permitted when explicitly allowed by security policies, with comprehensive audit trails for compliance.

Zero-Cost Abstractions

AirsSys leverages Rust's zero-cost abstractions to provide high-level APIs without runtime overhead. Generic constraints and compile-time monomorphization eliminate the need for dynamic dispatch in hot paths.

Modular Architecture

Components are designed to work independently or together. Use OSL for secure system operations, RT for actor-based concurrency, WASM for component isolation, or combine them for complete system programming solutions.

Fault Tolerance

Following Erlang/OTP principles, AirsSys embraces the "let it crash" philosophy. Supervisor trees monitor process health and automatically restart failed components with configurable strategies.

Integration

AirsSys components are designed to integrate seamlessly:

// OSL actors managed by RT supervisor
use airssys_rt::supervisor::OSLSupervisor;
use airssys_osl::operations::filesystem::FileReadOperation;

// RT manages OSL operations with fault tolerance
let supervisor = OSLSupervisor::new(broker.clone());
supervisor.start().await?;

// WASM components supervised by RT SupervisorNode
use airssys_wasm::actor::ComponentActor;
let component = MyComponent::new();
let component_ref = supervisor_ref
    .send(SupervisorMessage::SpawnChild(Box::new(component)))
    .await?;

See Integration Guide for detailed patterns and examples.

Getting Started

Choose your path based on your needs:

1. Getting Started Guide - Installation and basic setup
2. Architecture Overview - System design and principles
3. OSL Documentation - OS abstraction layer
4. RT Documentation - Actor runtime system
5. WASM Documentation - Component framework
6. Examples - Practical usage patterns

Resources

• Repository: github.com/airsstack/airssys
• Issues: Report bugs and request features
• API Documentation: Run cargo doc --open in the repository
• Contributing: See Contributing Guide

License

AirsSys is dual-licensed under:

• Apache License 2.0
• MIT License

You may choose either license at your option.

---

Current Version: 0.1.0
Last Updated: December 2025