# lunatic-solutions/lunatic **Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/lunatic-solutions-lunatic).** _How this analysis was created: the description and tags below were written by an AI model that read this project's README and public documentation pages; stars, license and language come straight from the GitHub API. The model does not read the source code._ 4,867 stars · 147 forks · Rust · Apache-2.0 ## Links - GitHub: https://github.com/lunatic-solutions/lunatic - Homepage: https://lunatic.solutions - awesome-repositories: https://awesome-repositories.com/repository/lunatic-solutions-lunatic.md ## Topics `actors` `assemblyscript` `erlang` `lunatic` `runtime` `rust` `vm` `wasm` `webassembly` ## Description Lunatic is a WebAssembly runtime and concurrent process manager that implements an Erlang-inspired model of lightweight concurrency and fault tolerance. It functions as a distributed actor system where isolated processes communicate via message passing across a network of linked nodes. The system utilizes a WebAssembly sandbox environment to isolate memory and restrict system call permissions for each individual process. This capability-based security model ensures that processes are sandboxed to safely execute untrusted code. The platform provides a fault-tolerant supervision tree for hierarchical monitoring and automatic restarts of failing processes. It manages high-concurrency workloads using a preemptive work-stealing scheduler to execute thousands of lightweight green threads. The runtime supports distributed system coordination by clustering nodes across different physical machines and handles network traffic for protocols such as TCP and WebSockets. ## Tags ### Programming Languages & Runtimes - [Green Threads](https://awesome-repositories.com/f/programming-languages-runtimes/concurrent-thread-execution/green-threads.md) — Runs thousands of concurrent lightweight green threads with minimal memory overhead to handle massive simultaneous workloads. - [Server-Side WebAssembly Runtimes](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly/embedded-webassembly-runtimes/extensible-webassembly-runtimes/server-side-webassembly-runtimes.md) — Acts as a server-side runtime that executes WebAssembly components as application handlers for scalable server applications. ([source](https://lunatic.solutions/docs)) - [High-Concurrency Runtimes](https://awesome-repositories.com/f/programming-languages-runtimes/high-concurrency-runtimes.md) — Designed as a high-concurrency runtime that manages massive parallelism and efficient resource utilization for lightweight tasks. - [Lightweight Process Management](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/task-orchestration-frameworks/concurrency-management-libraries/structured-concurrency-managers/lightweight-process-management.md) — Manages the execution of thousands of low-overhead lightweight processes to handle massive amounts of simultaneous tasks. ([source](https://cdn.jsdelivr.net/gh/lunatic-solutions/lunatic@main/README.md)) - [Supervision Trees](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/hierarchical-tree-structures/supervision-trees.md) — Utilizes hierarchical supervision trees to monitor child processes and automatically restart them upon failure. - [WebAssembly](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/webassembly.md) — Provides a comprehensive runtime for executing portable WebAssembly binary code with high-concurrency and fault-tolerance features. - [Work-Stealing Schedulers](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/concurrency-models/concurrency/execution-models/actor-models/work-stealing-schedulers.md) — Employs a work-stealing scheduler to balance lightweight actor tasks across OS threads and ensure fair execution. ### Data & Databases - [Asynchronous Message Passings](https://awesome-repositories.com/f/data-databases/data-exchange-protocols/runtime-data-exchange/actor-messaging/asynchronous-message-passings.md) — Provides asynchronous, non-blocking message passing between isolated processes using runtime-managed queues to avoid shared state. ### Operating Systems & Systems Programming - [Process Isolation](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/process-and-memory-management/process-isolation.md) — Isolates every process in its own memory space to prevent a crash in one unit from affecting others. ([source](https://cdn.jsdelivr.net/gh/lunatic-solutions/lunatic@main/README.md)) ### Security & Cryptography - [Code Sandboxing Environments](https://awesome-repositories.com/f/security-cryptography/application-and-system-security/sandbox-and-isolation/code-sandboxing-environments.md) — Provides isolated execution environments that protect the host system by sandboxing untrusted or generated code. - [Wasm Sandboxes](https://awesome-repositories.com/f/security-cryptography/application-and-system-security/sandbox-and-isolation/isolated-execution-sandboxes/wasm-sandboxes.md) — Utilizes WebAssembly sandboxes to isolate the memory of every execution unit, preventing crashes from affecting other processes. - [Capability-Based Access Controls](https://awesome-repositories.com/f/security-cryptography/capability-based-access-controls.md) — Implements a security model that grants permissions via delegatable authorization objects to safely execute untrusted code. ([source](https://lunatic.solutions/)) - [Capability-Based Security](https://awesome-repositories.com/f/security-cryptography/security/policies/capability-authorization/capability-based-security.md) — Implements a capability-based security model that restricts system call access to the network and filesystem on a per-process basis. - [Process Restriction Policies](https://awesome-repositories.com/f/security-cryptography/security/policies/host-resource-access/file-system-access-controls/path-access-restrictions/path-access-restrictions/process-restriction-policies.md) — Enforces granular capability limits on sandboxed processes, specifically restricting network and filesystem access at the system call level. ([source](https://cdn.jsdelivr.net/gh/lunatic-solutions/lunatic@main/README.md)) ### Software Engineering & Architecture - [Node Clustering](https://awesome-repositories.com/f/software-engineering-architecture/cluster-load-balancing/node-clustering.md) — Connects multiple runtime instances into a secure cluster to spread computing workloads across different physical machines. ([source](https://lunatic.solutions/)) - [Fiber-Based Concurrent Execution](https://awesome-repositories.com/f/software-engineering-architecture/concurrent-task-execution/fiber-based-concurrent-execution.md) — Executes isolated, lightweight tasks in a high-concurrency environment to prevent individual failures from impacting the system. ([source](https://lunatic.solutions/)) - [Distributed Actor Frameworks](https://awesome-repositories.com/f/software-engineering-architecture/distributed-actor-frameworks.md) — Provides a framework implementing the actor model for building scalable systems across a network of linked nodes. - [Distributed Cluster Coordination](https://awesome-repositories.com/f/software-engineering-architecture/distributed-cluster-coordination.md) — Enables multiple runtime instances to connect over a network to coordinate workloads and synchronize state across different machines. - [Fault Tolerance Implementation](https://awesome-repositories.com/f/software-engineering-architecture/fault-tolerance-strategies/fault-tolerance-implementation.md) — Implements automated recovery mechanisms using supervision trees to ensure system continuity when processes fail. - [Message Passing Channels](https://awesome-repositories.com/f/software-engineering-architecture/message-passing-channels.md) — Provides synchronized communication primitives via channels for exchanging data between isolated processes without shared state. - [Distributed Node Connectivity](https://awesome-repositories.com/f/software-engineering-architecture/node-lifecycle-management/distributed-node-connectivity.md) — Links multiple runtime instances across a network to coordinate work and synchronize data in a distributed environment. ([source](https://cdn.jsdelivr.net/gh/lunatic-solutions/lunatic@main/README.md)) - [Distributed Coordination Systems](https://awesome-repositories.com/f/software-engineering-architecture/distributed-coordination-systems.md) — Includes mechanisms for managing state and synchronizing workloads across a cluster of distributed runtime nodes. - [Preemptive Scheduling Mechanisms](https://awesome-repositories.com/f/software-engineering-architecture/task-scheduling/asynchronous-schedulers/asynchronous-thread-schedulers/goroutine-scheduling-models/preemptive-scheduling-mechanisms.md) — Uses a preemptive scheduling mechanism to force context switches, preventing long-running tasks from blocking system threads. ([source](https://cdn.jsdelivr.net/gh/lunatic-solutions/lunatic@main/README.md)) ### System Administration & Monitoring - [Process Lifecycle Monitors](https://awesome-repositories.com/f/system-administration-monitoring/process-monitors/process-lifecycle-monitors.md) — Provides actor-level lifecycle monitoring to create, cancel, and monitor processes via a fault-tolerant supervision system. ([source](https://cdn.jsdelivr.net/gh/lunatic-solutions/lunatic@main/README.md)) - [OTP-Style Supervision Trees](https://awesome-repositories.com/f/system-administration-monitoring/process-supervision/otp-style-supervision-trees.md) — Implements Erlang-inspired hierarchical supervision trees that automatically restart failed child processes to ensure high availability. ### DevOps & Infrastructure - [Portable Binaries](https://awesome-repositories.com/f/devops-infrastructure/portable-binaries.md) — Ships as a single compiled binary that executes across different hardware architectures and operating systems without recompilation. ([source](https://lunatic.solutions/))