Maestro: An Early-Stage Rust Kernel Aiming for Linux Compatibility

What Maestro is attempting and who it is for

Maestro is a Unix-like kernel written in Rust. Its stated goal is a lightweight operating system that uses Rust's type system safety features to be reliable. The README is unambiguous about its current state: early stage development, highly unstable, and missing many features. The README says directly, 'Do not use it in production.'

This is a project for engineers who want to participate in building a Rust-based Unix-compatible kernel from the ground up, or who want a smaller codebase than the Linux kernel to study memory management, process scheduling, filesystem implementation, and driver development in Rust. The repository is not a full operating system. The kernel itself is the product; an installer exists separately to combine it into a bootable image.

Architecture support is currently limited. x86_64 and x86 are implemented and working. AArch64 is listed as planned. The README does not document a timeline for AArch64 support.

What is implemented: system calls, drivers, and the memory model

The README describes the implemented features as a non-exhaustive list. Linux system calls are approximately 30% implemented. The kernel has a working set of drivers: a PS/2 keyboard driver with forward compatibility for USB keyboards, an IDE/PATA driver, and an NVMe driver. PCI device enumeration and basic ACPI support are present.

Memory management includes a buddy allocator, an internal allocator with similarities to dlmalloc, per-process virtual memory, overcommitting, copy-on-write, and a page cache. These are the foundational primitives that any modern operating system kernel needs.

Process management covers CPU topology enumeration, a preemptible scheduler inspired by FreeBSD's ULE scheduler, Symmetric Multiprocessing (SMP), and POSIX signals. The Unix file abstraction is implemented with a Virtual FileSystem supporting mountpoints, the ext2 filesystem (only), MBR and GPT disk partitions, virtual filesystems for /tmp and /proc, initramfs via cpio, Unix pipes and sockets, and device files.

The terminal supports VGA text mode and partial ANSI escape code handling. Clock sources include PIT, RTC, the APIC Timer, and HPET. ELF binary loading is implemented, which is what allows programs like bash and neofetch to run on the kernel.

Building, running, and reading the kernel documentation

Maestro is only the kernel, not a complete operating system. Two paths exist to run it. The first uses the maestro-install project, which builds a full operating system from an ISO file. The second is building manually, which the kernel's book documents.

The kernel source lives in the kernel/ subdirectory. The README instructs:

cd kernel/

Then follow the instructions in kernel/README.md. The operating system built from the kernel runs in QEMU, VirtualBox, or on a physical machine.

The documentation is a book built with mdbook. To build it, first install the tools:

cargo install mdbook mdbook-mermaid

Then initialize and build:

mdbook-mermaid install doc/
mdbook build doc/

The built book lands at doc/book/index.html. This book is the primary reference for kernel internals, build instructions, and architecture decisions. The project blog at blog.lenot.re documents development progress in longer-form posts.

The repository layout: kernel, macros, modules, and utilities

The top-level directory has a clear structure. The kernel/ directory contains the kernel crate itself. The macros/ directory holds Rust procedural macros used by the kernel. The mod/ directory contains kernel module support. The utils/ directory holds utility code. The doc/ directory is the mdbook documentation source. The inttest/ directory contains integration tests.

The rust-toolchain.toml at the root pins the Rust toolchain version, consistent with the expectation that kernel code requires a specific compiler version. The rustfmt.toml provides formatting configuration. The AI.md file at the root is a prompt file for AI coding assistants working with the codebase.

Modules and drivers are a first-class concept. The README lists kernel modules in the feature set, and the mod/ directory at the top level reflects that the module system is separate from the core kernel. This mirrors the Linux kernel's loadable module infrastructure, though at a much earlier stage of completeness.

AGPL-3.0 and the implications for embedding or forking

Maestro is licensed under the GNU Affero General Public License version 3. This is a stronger copyleft license than the Linux kernel's GPL-2.0. AGPL-3.0 requires that if you distribute the kernel or run a modified version in a way that users interact with it over a network, you must make the complete source code of your version available under the same license.

For a kernel that runs locally in a virtual machine or on a test machine, the practical difference from GPL is limited. For a company that builds a product using Maestro and distributes or deploys that product, the AGPL requires releasing modifications. This is a meaningful constraint compared to the permissive MIT or Apache-2.0 licenses common in many Rust infrastructure projects.

Teams considering Maestro as a study project or a contribution target are not affected by this in the same way. Contributors submitting patches must agree to the AGPL terms. The license choice also affects how the kernel compares to other Rust OS projects with different licensing policies.

Maestro versus Redox OS: different maturity levels, different designs

Redox OS is the best-known Rust-based Unix-like operating system and the most direct point of comparison. Both projects aim to build a Unix-compatible OS in Rust. The difference lies in maturity and architectural approach.

Redox OS has a longer development history than Maestro, a larger contributor base, and more complete support for running Linux binaries and applications. Maestro is at a much earlier stage, with approximately 30% of Linux system calls and a single supported filesystem (ext2). The README's own framing as 'early stage development, highly unstable' reflects this gap honestly.

For an engineer who wants to run something useful on a Rust kernel today, Redox is the more complete option. For an engineer who wants a smaller, more comprehensible Rust kernel codebase to study or contribute to, Maestro's smaller scope can be an advantage. The active development pace, with a last push on 2026-08-23, shows the project is moving, but the distance to a production-capable kernel remains significant.

Editorial conclusion

Maestro suits engineers who want to study a Unix-like kernel implementation in Rust or who want to contribute to a growing Linux-compatible kernel experiment. It is not suitable for any production workload. The AGPL-3.0 license means any distribution of the kernel or a modified version requires releasing the source under the same terms. Check the kernel's book, built from doc/ with mdbook, for the current feature boundaries before deciding how much Linux compatibility to expect.

Frequently asked questions

Official sources

1. Issues
2. License: AGPL-3.0
3. maestro-os/maestro on GitHub
4. Project website
5. README