The latest milestone of the Rust-based Redox OS delivers its first complete desktop environment, but the project warns that the system is still far too raw for bare-metal installations. Version 0.9.0, released on September 12, 2024, introduces the Orbital Desktop—a ground-up rewrite of the graphical interface in pure Rust—and a host of kernel and driver improvements that inch the microkernel OS closer to everyday usability. The official guidance? Test it inside a virtual machine, and absolutely do not attempt a dual-boot.

What shipped in Redox OS 0.9.0

The headliner is, without question, the Orbital Desktop. Unlike the previous redox-utils-based GUI that leaned on SDL2, Orbital is a native Rust application built on the Orbclient library. It provides a compositing window manager, a taskbar, a launcher, and a set of core utilities such as a file manager, text editor, terminal emulator, and a calculator. The entire desktop is rendered using a software rasterizer, so no GPU drivers are required—a deliberate choice that sacrifices speed for broad compatibility while the graphics stack matures.

Under the hood, the kernel and drivers gained significant attention. The redoxfs filesystem now supports file truncation and directory file size tracking, and the nvme driver can handle multiple controllers and namespaces. The pcid driver was rewritten to use the PCI Express configuration space correctly, and the xhci USB driver can now reset ports and detect device disconnects. Networking saw a major overhaul: the rtl8168d NIC driver is new, and the e1000 driver now handles packet fragmentation and link status changes. The ipcd daemon, which handles inter-process communication, was hardened against crashes.

On the userland side, the relibc C library—Redox’s own libc implementation—now supports more POSIX functions, dynamic linking with dlopen, and C++ thread-local storage. This enabled the porting of dozens of new programs, including bash, grep, make, nano, and vim. The build system also got a boost: the entire OS can now be compiled using Rust’s native cargo without a separate Makefile, and a pre-built toolchain for 64-bit Linux hosts simplifies cross-compilation.

Crucially, the project published a new, beginner-friendly “Getting Started” guide and a dedicated page for testing the OS with QEMU or VirtualBox. The message is clear: this release is meant to be explored in a sandbox.

What this means for you

If you’re a curious tinkerer or a developer intrigued by Rust-based operating systems, Redox 0.9.0 is finally at a point where you can get a real sense of the project’s direction. The Orbital Desktop, while still rough around the edges, shows what a pure-Rust userland might look like: fast compilation, memory safety guarantees, and a clean break from legacy X11 or Wayland protocols. Programs launch quickly, and the desktop feels responsive, albeit with occasional graphical glitches.

But let’s be direct: this is not a daily-driver candidate. Hardware support remains extremely limited. You will not get audio, Wi-Fi, Bluetooth, or accelerated graphics. The filesystem, while improving, is not crash-proof. The project itself states that “Redox doesn’t yet support most hardware” and that “you should not try to install this on bare metal unless you are willing to lose data.” That’s not boilerplate; it’s a genuine warning from developers who know their code is not battle-tested.

For Windows users hearing about this for the first time, the value is educational. Redox is not a competitor to Windows, or even to mainstream Linux distributions. It’s a research operating system that pushes the boundaries of what Rust can do at the kernel level. The microkernel architecture—where device drivers, file systems, and network stacks run as isolated userspace processes—offers inherent security and fault tolerance. If a driver crashes, the kernel keeps running. That’s a promise Linux’s monolithic kernel cannot make without major trade-offs.

Developers will find the most immediate utility. The entire OS is a living example of low-level Rust patterns: how to handle interrupts, manage memory, and structure drivers without unsafe bloat. The project’s codebase is readable and well-documented, making it an excellent teaching tool. And because it uses a custom libc, porting existing C/C++ applications is a deep-dive into how Unix programs actually work.

System administrators who manage fleets of Linux servers might file this under “interesting, but not actionable.” They’re right—for now. But the broader trend of memory-safe systems programming is real, and Redox is a pioneering experiment that could influence tomorrow’s infrastructure.

The long road to 0.9

Redox OS started in 2015 as a one-person project by Jeremy Soller. The original goal was audacious: build a complete, general-purpose operating system written entirely in Rust, from the kernel up. In the nine years since, the project has attracted over 200 contributors and has gradually assembled the pieces needed for a self-hosting development environment.

Prior releases were more proof-of-concept than interactive systems. Version 0.3.5 (2017) shipped the first simple GUI; 0.5.0 (2019) made the OS self-hosting on real hardware; 0.6.0 (2020) introduced a revamped cookbook build system; and 0.8.0 (2022) delivered massive C library compatibility improvements. Each step was painstakingly slow because the contributors were not merely porting existing code—they were rewriting fundamental components like the TCP/IP stack, the PCI driver, and the filesystem in a language that enforces strict ownership rules.

The 0.9.0 release represents a pivot from “can we build this?” to “can you use this?” The Orbital Desktop is the most visible part of that shift. Previous GUIs were stopgap measures; Orbital was built from scratch in 2023/2024 to be the permanent, native desktop. Its design is intentionally simple, drawing inspiration from early CDE and Windows 95 interfaces, because the team wanted a functional shell before worrying about flash.

This version also marks the first time the project has actively discouraged bare-metal installs. Earlier releases were often tested by enthusiasts who booted directly on old laptops, but as the complexity grew, so did the risk of data corruption. The team’s decision to officially promote VM-only testing is a sign of maturity: they’re focusing on getting the core right before tackling the infinite hardware variability of the real world.

What you should do right now

If you want to try Redox OS 0.9.0, follow this path:

  1. Choose your virtualizer.
    - QEMU is the primary supported option, with command-line examples given in the project’s README. On Windows hosts, the quickest method is to use the pre-built QEMU binaries from the MSYS2 project or install qemu-system-x86_64 via a package manager like winget or choco.
    - VirtualBox is also documented, though the guest additions are absent, so you’re limited to a 1024×768 resolution.

  2. Download the ISO. Head to the official Redox website and grab the redox_x86_64.iso from the 0.9.0 release. The image is around 200 MB and boots in seconds.

  3. Configure the VM. Allocate at least 2 GB of RAM and two CPU cores. Don’t enable EFI; Redox currently only boots via BIOS. For networking, use the e1000 adapter type in QEMU or the Intel PRO/1000 MT Desktop in VirtualBox.

  4. Boot and explore. The Orbital Desktop launches automatically. You’ll see a launcher in the bottom-left corner that opens a start menu. Try the terminal, file manager, and text editor. Check what commands work: ls, cat, netstat, and even cargo are present.

  5. Do NOT install to disk. The installer is functional, but the project strongly advises against using it on a machine with data you care about. If you must experiment with persistence, do so inside a VM with a virtual disk image you can discard.

For Windows users who aren’t comfortable with command-line hypervisors, the simplest route is VirtualBox. Create a new VM, choose “Other” as the OS type, mount the ISO, and start. The experience is a reminder of early Linux desktop from two decades ago: functional but brittle.

Developers who want to contribute should consult the project’s CONTRIBUTING guide. The team is actively seeking help with drivers, documentation, and application ports. And because the entire build now uses cargo, you can compile the OS from source on a Windows host with Rust installed and the cross-compilation toolchain.

The horizon

The Redox team has already outlined what’s next for 0.10 and beyond. Top priorities include a Vulkan-capable graphics stack (using the Rust ash crate), an audio subsystem, and a native browser engine. The latter is a monster task—the current plan involves compiling a subset of Servo, the Rust-written browser engine, into a self-contained websurfer application.

More importantly, the project is beginning to explore formal verification of the microkernel’s IPC mechanisms. That’s a far-off goal, but it underscores Redox’s unique position: it’s not just another Unix clone, but a testbed for what an OS can look like when memory safety is guaranteed by the compiler and security boundaries are enforced by architecture, not convention.

For now, the 0.9.0 milestone is a tangible artifact of that vision. It’s not ready for your main PC, but inside a VM window, it offers a glimpse of a future where operating systems can be small, auditable, and resistant to entire classes of bugs that still plague Windows and Linux. That’s worth an hour of tinkering.