A Unix-like, Linux-compatible kernel written in Rust with an asynchronous core and modular architecture.
Moss is a Unix-like, Linux-compatible kernel written in Rust and AArch64 assembly. It features an asynchronous kernel core built on Rust's async/await model and binary compatibility with Linux userspace applications, allowing it to run common Linux utilities. The project explores modern kernel design with a focus on safety, modularity, and concurrency.
Systems programmers, kernel developers, and Rust enthusiasts interested in operating system development, asynchronous design, or exploring Linux compatibility in a Rust-based kernel.
Developers choose Moss for its innovative use of Rust's async/await in kernel space, which eliminates common deadlock classes, and its modular architecture that simplifies porting to new hardware platforms while maintaining Linux binary compatibility.
Rust Linux-compatible kernel
Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.
Leverages Rust's async/await model to enforce that spinlocks cannot be held over sleep points, eliminating a common class of kernel deadlocks as highlighted in the async core section.
Implements 105+ Linux syscalls and runs dynamically linked Arch Linux binaries, enabling execution of common utilities like bash and strace without modification.
Features a well-defined Hardware Abstraction Layer that simplifies porting to other architectures such as x86_64 or RISC-V, as described in the architecture overview.
Uses libkernel to run over 230 logic tests on host machines (e.g., x86) before bare-metal deployment, reducing development friction for kernel validation.
Explicitly not production-hardened per the README's philosophy, meaning it lacks long-term stability guarantees and may have undiscovered bugs or breaking changes.
Filesystem drivers are incomplete; for instance, FAT32 is read-only and Ext2/3/4 has only partial write support, limiting practical storage use cases.
Binary compatibility is currently restricted to AArch64, so running Linux binaries on other architectures requires additional porting work, despite the modular HAL.
Requires niche toolchains like aarch64-none-elf and QEMU for emulation, which can be a barrier compared to more accessible kernel development environments.