OS in Rust?

Redox: 

The OS Written Entirely in Rust! 🦀 Is This the Future of Computing? - YouTube

Jeremy Soller: "10 Years of Redox OS and Rust" | RustConf 2025 - YouTube

there are several operating systems and microkernels written in Rust. Rust’s memory safety, concurrency guarantees, and lack of a runtime or garbage collector make it an incredibly popular language for modern systems programming, especially for microkernels and embedded "micro" operating systems.

Here are the most notable micro-operating systems and microkernels written in Rust:

1. Redox OS (General Purpose Microkernel)

Redox OS is by far the most famous and mature operating system written entirely in Rust[1]. It is a Unix-like, general-purpose operating system built on a custom microkernel[1][2].

• Design: It strictly follows the microkernel architecture, keeping the kernel as small as possible and pushing drivers, file systems, and network stacks into user space to prevent system-wide crashes.

• Current State: It is highly usable for an experimental OS. It features a complete GUI (the Orbital desktop, and recently integrating System76's COSMIC apps), a web browser (NetSurf), and command-line utilities[1][3].

2. Tock OS (Secure Embedded OS)

Tock is a secure, embedded operating system designed for microcontrollers (like ARM Cortex-M and RISC-V)[4].

• Design: Tock acts much like a microkernel for IoT devices. It runs a core kernel in privileged mode and isolates untrusted applications (which can be written in any language) in unprivileged user space[4][5].

• Use Case: It is actively used in industry for Root-of-Trust (RoT) implementations and secure embedded environments (such as OpenTitan and Microsoft Pluton)[5].

3. Hubris OS (Message-Passing Embedded Microkernel)

Created by Oxide Computer Company, Hubris is a lightweight, open-source operating system designed for deeply embedded systems.

• Design: It features a microkernel-style architecture that heavily relies on memory protection and isolated tasks (called "servers"). Instead of direct function calls between components, everything communicates via a synchronous message-passing system.

4. Theseus OS (Experimental / Language-Based OS)

While not a traditional microkernel, Theseus is a heavily researched, from-scratch OS written in Rust that achieves similar (and often better) goals of isolation and modularity.

• Design: Instead of using hardware (like the MMU) to isolate components into different address spaces like a traditional microkernel, Theseus uses a "Single Address Space Operating System" (SASOS) model. It relies entirely on Rust's compiler, type system, and borrow checker to guarantee that modules cannot corrupt one another.

5. Drone OS (Real-Time OS)

Drone is an embedded real-time operating system (RTOS) written in Rust[6]. While traditionally called an RTOS rather than a microkernel, it fits the description of a "micro-OS." It is heavily optimized for energy efficiency, interrupt-driven design, and minimal footprint for modern microcontrollers.

6. Unikernels (RustyHermit)

If by "micro-OS" you are referring to extremely small, single-purpose virtual machines used in cloud computing, Rust has a strong presence there as well. RustyHermit (a Rust rewrite of HermitCore) is a unikernel designed to run standard Rust applications on bare metal or hypervisors with incredibly fast boot times and a tiny footprint, as the application and OS are compiled into a single binary.

Hobbyist & Niche Microkernels

Because Rust is so well-suited to the task, the GitHub ecosystem is full of experimental microkernels:

• Rux: A hobbyist microkernel attempting to replicate the capability-based security architecture of the mathematically verified seL4 microkernel, but utilizing Rust's borrow checker for memory safety[7].

• LiberSystem: A new experimental microkernel OS based on typed objects and capability-based security, stepping away from the traditional POSIX/Unix "everything is a file" model[8].

• Aero: A modern, unix-like microkernel written in Rust that focuses on high performance and running modern Linux binaries.