lunatic-solutions/lunatic

Features

• Green Threads - Runs thousands of concurrent lightweight green threads with minimal memory overhead to handle massive simultaneous workloads.
• Server-Side WebAssembly Runtimes - Acts as a server-side runtime that executes WebAssembly components as application handlers for scalable server applications.
• Asynchronous Message Passings - Provides asynchronous, non-blocking message passing between isolated processes using runtime-managed queues to avoid shared state.
• Process Isolation - Isolates every process in its own memory space to prevent a crash in one unit from affecting others.
• High-Concurrency Runtimes - Designed as a high-concurrency runtime that manages massive parallelism and efficient resource utilization for lightweight tasks.
• Lightweight Process Management - Manages the execution of thousands of low-overhead lightweight processes to handle massive amounts of simultaneous tasks.
• Supervision Trees - Utilizes hierarchical supervision trees to monitor child processes and automatically restart them upon failure.
• WebAssembly - Provides a comprehensive runtime for executing portable WebAssembly binary code with high-concurrency and fault-tolerance features.
• Code Sandboxing Environments - Provides isolated execution environments that protect the host system by sandboxing untrusted or generated code.
• Wasm Sandboxes - Utilizes WebAssembly sandboxes to isolate the memory of every execution unit, preventing crashes from affecting other processes.
• Capability-Based Access Controls - Implements a security model that grants permissions via delegatable authorization objects to safely execute untrusted code.
• Capability-Based Security - Implements a capability-based security model that restricts system call access to the network and filesystem on a per-process basis.
• Process Restriction Policies - Enforces granular capability limits on sandboxed processes, specifically restricting network and filesystem access at the system call level.
• Node Clustering - Connects multiple runtime instances into a secure cluster to spread computing workloads across different physical machines.
• Fiber-Based Concurrent Execution - Executes isolated, lightweight tasks in a high-concurrency environment to prevent individual failures from impacting the system.
• Distributed Actor Frameworks - Provides a framework implementing the actor model for building scalable systems across a network of linked nodes.
• Distributed Cluster Coordination - Enables multiple runtime instances to connect over a network to coordinate workloads and synchronize state across different machines.
• Fault Tolerance Implementation - Implements automated recovery mechanisms using supervision trees to ensure system continuity when processes fail.
• Message Passing Channels - Provides synchronized communication primitives via channels for exchanging data between isolated processes without shared state.
• Distributed Node Connectivity - Links multiple runtime instances across a network to coordinate work and synchronize data in a distributed environment.
• Process Lifecycle Monitors - Provides actor-level lifecycle monitoring to create, cancel, and monitor processes via a fault-tolerant supervision system.
• OTP-Style Supervision Trees - Implements Erlang-inspired hierarchical supervision trees that automatically restart failed child processes to ensure high availability.
• Portable Binaries - Ships as a single compiled binary that executes across different hardware architectures and operating systems without recompilation.
• Work-Stealing Schedulers - Employs a work-stealing scheduler to balance lightweight actor tasks across OS threads and ensure fair execution.
• Distributed Coordination Systems - Includes mechanisms for managing state and synchronizing workloads across a cluster of distributed runtime nodes.
• Preemptive Scheduling Mechanisms - Uses a preemptive scheduling mechanism to force context switches, preventing long-running tasks from blocking system threads.

Star history