moss is a Unix-like, Linux-compatible kernel written in Rust and Aarch64 assembly.

It features a modern, asynchronous core, a modular architecture abstraction layer, and binary compatibility with Linux userspace applications (currently capable of running most BusyBox commands).

• Full support for aarch64.
• A well-defined HAL allowing for easy porting to other architectures (e.g., x86_64, RISC-V).
• Memory Management:
  • Full MMU enablement and page table management.
  • Copy-on-Write (CoW) pages.
  • Safe copy to/from userspace async functions.
  • Kernel and userspace page fault management.
  • Buddy allocator for physical addresses and smalloc for boot allocations and tracking memory reservations.

One of the defining features of moss is its usage of Rust's async/await model within the kernel context:

• All non-trivial system calls are written as async functions, sleep-able functions are prefixed with .await.
• The compiler enforces that spinlocks cannot be held over sleep points, eliminating a common class of kernel deadlocks.

• Full task management including scheduling and task migration via IPIs.
• Currently implements 51 Linux syscalls; sufficient to execute most BusyBox commands.
• Advanced forking capabilities via clone().
• Process and thread signal delivery and raising support.

• Virtual File System with full async abstractions.
• Drivers:
  • Ramdisk block device implementation.
  • FAT32 filesystem driver (ro).
  • devtmpfs driver for kernel character device access.

moss is built on top of libkernel, a utility library designed to be architecture-agnostic. This allows logic to be tested on a host machine (e.g., x86) before running on bare metal.

• Address Types: Strong typing for VA (Virtual), PA (Physical), and UA (User) addresses.
• Containers: VMA management, generic page-based ring buffer (kbuf), and waker sets.
• Sync Primitives: spinlock, mutex, condvar, per_cpu.
• Test Suite: A comprehensive suite of 230+ tests ensuring functionality across architectures (e.g., validating Aarch64 page table parsing logic on an x86 host).

You will need QEMU for aarch64 emulation and dosfstools to create the virtual file system.

sudo apt install qemu-system-aarch64 dosfstools

Additionally you will need a version of the aarch64-none-elf toolchain installed.

To install aarch64-none-elf on any os, download the correct release of aarch64-none-elf onto your computer, unpack it, then export the bin folder to path.

Run the following command

nix shell nixpkgs#pkgsCross.aarch64-embedded.stdenv.cc nixpkgs#pkgsCross.aarch64-embedded.stdenv.cc.bintools

First, run the following script to prepare the binaries for the image:

This will download and build the necessary dependencies for the kernel and put them into the build directory.

Once that is done, you can create the image using the following command:

sudo ./scripts/create-image.sh

This will create an image file named moss.img in the root directory of the project, format it as VFAT 32 and create the necessary files and directories for the kernel.

This script needs to run with sudo to mount the image through a loop device, which is required to properly create the image for the kernel to work.

To build the kernel and launch it in QEMU:

Because libkernel is architecturally decoupled, you can run the logic tests on your host machine:

cargo test -p libkernel --target x86_64-unknown-linux-gnu

moss is under active development. Current focus areas include:

• Basic Linux Syscall Compatibility (Testing through BusyBox).
• Networking Stack: TCP/IP implementation.
• Scheduler Improvements: Task load balancing.
• A fully read/write capable filesystem driver (e.g., ext2/4).
• Expanding coverage beyond the current 49 calls.

Contributions are welcome! Whether you are interested in writing a driver, porting to x86, or adding syscalls.

Distributed under the MIT License. See LICENSE for more information.