Open-source project
maestro-os/maestro avatar
maestro-os/maestro

Maestro: a Rust kernel that reimplements Linux system calls from scratch

Lightweight, Linux-compatible kernel, written in Rust to leverage the safety of the typesystem. Aiming to remove as much legacy as possible while supporting most usecases

3,342 stars112 forksRustAGPL-3.0

At a glance

What is it?
Maestro is a lightweight Unix-like kernel written in Rust, targeting x86_64 and x86 with roughly 30 percent of Linux's system calls implemented. It is a research and learning project, not a production operating system.
Who is it for?
Maestro is for kernel developers, Rust systems programmers and people who want to read or modify a small Unix-like kernel that boots real ELF binaries. It is not for anyone who needs a stable system: the README says the project is in early stage development, highly unstable and missing many features, and warns against production use.
Can I use it commercially?
Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • maestro-os/maestro3,342 ★ · +7
Star history
Repository2026-09-242026-11-15
maestro-os/maestro3.3k3.3k

7 Stars in the last 52 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What Maestro solves, and for whom

Maestro is a kernel, not a distribution. The README states plainly that the repository is not a full operating system in itself, only the kernel. The stated goal is a lightweight Unix-like kernel that uses Rust's type system for reliability, while removing as much legacy as possible and still supporting most use cases. That framing tells you who the project is for. It is for people who want to study or extend a Unix-like kernel in a memory-safe language, and for developers who want a small code base where the whole boot path, scheduler and filesystem layer can be read in a sitting. It is not for anyone deploying services. The README carries a warning in bold: the project is in early stage development, highly unstable, misses a lot of features, and should not be used in production. Treat that warning as the project's own scope statement rather than boilerplate. The repository layout matches the claim of a kernel-only artifact: kernel/, macros/, mod/ for kernel modules, utils/, inttest/ for integration tests, and doc/ for the book. There is no userland tree, because the userland comes from elsewhere, which is what makes the Linux system call surface the central compatibility question.

How the kernel is structured: syscalls, VFS, scheduler, memory

The mechanism that matters most is Linux system call compatibility. The README says roughly 30 percent of Linux's system calls are implemented. That single number determines almost everything about what will run: an ELF binary that only touches the implemented subset will start, and one that does not will fail in ways the kernel has no obligation to make graceful. Around that surface, the kernel implements a Virtual FileSystem with mountpoints, ext2 as the only real filesystem, MBR and GPT partition parsing, and virtual filesystems at /tmp and /proc, plus an initramfs in cpio format. Unix pipes and sockets and device files are present, so the process and file abstractions are recognisably Unix rather than a custom model. Process handling includes a preemptible scheduler inspired by FreeBSD's ULE scheduler, symmetric multiprocessing, POSIX signals, and CPU topology enumeration. Memory management uses a buddy allocator, an internal allocator with similarities to dlmalloc, per-process virtual memory, overcommitting, copy-on-write and a page cache. Drivers are deliberately narrow: PS/2 keyboard with forward compatibility for USB keyboards, IDE/PATA and NVMe. PCI enumeration and basic ACPI support are in place. The terminal is VGA text mode with partial ANSI escape code support, and timekeeping draws on PIT, RTC, APIC timer and HPET. The design trade-off is visible in the feature list itself: ext2 only, no network stack mentioned, partial ANSI, partial syscall coverage. Each omission buys a smaller kernel to read and change, and each one narrows what the kernel can host. If you need a filesystem beyond ext2 or a terminal that renders more than a subset of escape sequences, this is the wrong tool and the README does not pretend otherwise.

Installing Maestro and running it the first time

There are two documented paths. The README points to a separate installer repository, maestro-install, which builds a full operating system from an ISO file. The alternative is to build the OS by hand from the kernel crate and the kernel's book. Both end in something you boot in QEMU or VirtualBox, or on a physical machine. Start with the by-hand path, since it is the one the README spells out. Change into the kernel crate:

bash
cd kernel/

The README then directs you to kernel/README.md for the build and run instructions, so that file, not the top-level README, is where the actual cargo invocation lives. Do not guess flags from the top-level document; it does not give them. Before building, confirm the toolchain channel, because the repository pins it in rust-toolchain.toml and the badge in the README reads the version from kernel/Cargo.toml. If you want the documentation locally, the book is built with mdbook and mdbook-mermaid, which the README says are required:

bash
cargo install mdbook mdbook-mermaid

Then generate and build the book:

bash
mdbook-mermaid install doc/
mdbook build doc/

The README states the result is accessible at doc/book/index.html. Read that book before attempting a boot, because it is the only place the project documents general kernel usage. When you do boot, expect the environment shown in the README's screenshot: neofetch and bash running on the OS. That is the realistic first milestone, not a login prompt on your laptop.

Where Maestro breaks: the syscall gap and the driver list

The limit that will bite first is the system call coverage. Roughly 30 percent of Linux's system calls are implemented, and the README does not enumerate which. That means the failure mode is not a clean error message but a program that starts and then dies at the first unimplemented call, which is harder to diagnose than a binary that refuses to load. For anyone porting software, the practical work is auditing the syscalls your program actually issues before you blame the kernel. Hardware is the second boundary. The implemented driver list is PS/2 keyboard, IDE/PATA and NVMe, with PCI enumeration and basic ACPI. There is no mention of a network driver, so anything that expects network access is out of scope on the evidence available. AArch64 is listed as planned, not supported, so the supported architectures are x86_64 and x86 only. The filesystem layer supports ext2 alone, which rules out the ext4, XFS or Btrfs volumes most modern images ship with. The terminal is VGA text mode with partial ANSI escape code support, so full-screen terminal applications that lean on escape sequences will render incorrectly. And the README's own warning about instability is not a formality: an early stage kernel that overcommits memory and implements copy-on-write will have bugs in exactly those paths, and there is no release history to suggest a stabilisation cadence.

Maestro against Linux and the other Rust kernels

The obvious comparison is Linux itself, and the difference is not performance but provenance. Linux carries decades of legacy interfaces and drivers; Maestro's stated aim is to remove as much of that legacy as possible while keeping Unix semantics, which is why it reimplements Linux's system calls rather than inventing a new interface. That choice is pragmatic, because it lets existing ELF binaries and userland tools be the test suite, but it also means Maestro inherits a compatibility target it can only partially meet, at roughly 30 percent of the syscall surface. A second comparison is with the broader family of Rust kernels, where the same bet is placed in different ways: some target embedded or unikernel workloads and skip POSIX entirely, while Maestro keeps processes, POSIX signals, pipes, sockets, device files and a VFS with mountpoints. That is a heavier scope than a unikernel and a lighter one than Linux, and it is the reason the project can run bash and neofetch at all. The honest read is that Maestro competes with Linux on readability and with unikernels on Unix compatibility, and wins neither contest outright. Its value is that the whole thing is small enough to understand, which is a property Linux cannot offer at any price.

Licence, maintenance and the cost of upgrading

Maestro is licensed under AGPL-3.0, per the repository's COPYING file and the licence badge in the README. That is a strong copyleft licence with a network clause, and it is unusual for a kernel; Linux is GPL-2.0. If you modify Maestro and let users interact with it over a network, the AGPL's source-availability obligation is the part to read carefully. This is not legal advice, and anyone embedding the kernel in a product should have the licence reviewed rather than assume the outcome. On maintenance, the last push to the default branch was on 2026-08-23, so the repository is not archived and has recent activity, but the README describes the project as early stage and highly unstable, and the repository has no published releases. There is no versioned release channel to upgrade along, which means upgrading is following master and rebuilding the kernel crate. The book under doc/ is generated with mdbook, so documentation changes arrive as source edits rather than published artifacts. The practical cost of tracking the project is therefore a pinned Rust toolchain from rust-toolchain.toml, a rebuild of the kernel, and a re-run of inttest/ to see what the current tree actually passes. Budget for breakage on every pull.

Editorial conclusion

Maestro is for kernel developers, Rust systems programmers and people who want to read or modify a small Unix-like kernel that boots real ELF binaries. It is not for anyone who needs a stable system: the README says the project is in early stage development, highly unstable and missing many features, and warns against production use. Before adopting it, verify that your target hardware is covered by the implemented drivers (PS/2 keyboard, IDE/PATA, NVMe) and that the system calls your workload needs are among the roughly 30 percent implemented, then build the kernel crate and the book to confirm the toolchain matches rust-toolchain.toml.

Frequently asked questions

How do I install Maestro?

The README gives two routes: use the maestro-install installer to build a full operating system from an ISO file, or build the OS by hand by changing into the kernel crate with cd kernel/ and following kernel/README.md. The resulting OS can then be run in a virtual machine such as QEMU or VirtualBox, or on a physical machine.

How do I use Maestro?

You use the kernel by booting it and running ELF programs against its Linux system call interface, of which roughly 30 percent are implemented. The README points to the kernel's book under doc/ for general information on how to use the kernel, and the book is built with mdbook and mdbook-mermaid into doc/book/index.html.

Can I install Maestro on Windows?

The README does not describe a Windows install path. Maestro is a kernel that targets x86_64 and x86 and is run in a virtual machine such as QEMU or VirtualBox or on a physical machine, and the documented build steps run from the kernel crate with a pinned Rust toolchain.

Official sources

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

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/maestro-os-maestro.svg)](https://hysenlabs.com/projects/maestro-os-maestro)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/maestro-os-maestro.svg)](https://hysenlabs.com/projects/maestro-os-maestro)

Was this useful?