Redox Operating System
Origins (2015)
April 2015 — the first public commits/announcement of Redox appear on GitHub/GitLab; the project name plays on Rust → “redox” (reduction-oxidation / rust). Jeremy Soller is credited as the original creator/architect and early driver of the project. Redox was started before Rust 1.0 and was one of the earliest full OS efforts in Rust.
Early goals: reimagine a general-purpose Unix-like OS using Rust’s safety guarantees, with a focus on security, modularity (microkernel) and modern tooling rather than simply porting Linux code.
Design and technical foundations
Language & kernel: written primarily in Rust (plus some assembly). Uses a microkernel architecture (influenced by systems like seL4, MINIX, Plan 9).
Userland & libraries: the project develops its own libc implementation (relibc) and Rust-native userland utilities. It provides a package manager (pkgutils) and a native filesystem (RedoxFS).
GUI and tooling: Orbital is the native display/windowing system; Ion is a shell implementation; there are GUI apps and a browser (NetSurf) ported for demos.
Public attention & early years (2015–2018)
The project received attention from Rust and systems communities shortly after appearing (front-page discussion on programming sites, Hacker News, etc.). Community contributors joined and built out early components.
Through these years Redox evolved from an experimental unikernel idea into a fuller microkernel design and expanded userland packages. The project maintained development on GitLab/GitHub and periodic “This Year in Redox” updates.
Releases & development milestones
2019 — Improvements to memory usage and more functional ISOs were released (tags/releases visible in the repo; some ISO sizes reduced dramatically by 2019 improvements).
2020–2023 — steady development, community contributions, and packaging work continued. The project matured many subsystems (pkgutils, RedoxFS improvements, porting steps toward ARM64). Public release cadence slowed at times but project governance matured (see next section).
June 21, 2023 — Redox elected its first Board of Directors (formalizing governance while Jeremy Soller remained project BDFL/architect). This marks a move toward more structured community governance.
September 9, 2024 — Redox 0.9.0: a notable preview/stability milestone announced on the official site (release notes, monthly status updates introduced in 2024). The project began publishing monthly community updates in 2024 to increase transparency.
2024–2025 — continued activity (monthly status posts, efforts toward Wayland support, integration/adoption of COSMIC desktop components and compositor work, ARM64 porting progress). The project remains active with frequent news posts (e.g., June & July 2025 posts).
Community, contributors & institutional links
Lead / founder: Jeremy Soller (principal engineer at System76) is the founder and long-time project lead/architect. System76 has shown interest/collaboration (several cross-project discussions and COSMIC / compositor activity were mentioned publicly).
Contributors: Redox is community-driven with contributors on GitLab/GitHub. The codebase is open source (MIT), and the project publishes news, docs and release notes on its site and GitLab.
Notable technical achievements & aims
Rust-first OS — demonstrates how a high-level, memory-safe language can be used for kernel and system development.
RedoxFS — a purpose-built filesystem designed for the OS (journaling, integrity features).
Microkernel design — isolates services in userland for safety and modularity, inspired by formally verified systems.
Current status & roadmap (as of latest posts)
Status: actively developed, but pre-stable. The project produces preview releases (0.x) and publishes monthly reports (2024 onward). It is progressive but not yet a drop-in replacement for mainstream desktop/server OSes.
Ongoing work: Wayland/COSMIC compositor integration, ARM64 porting, RedoxFS and bootloader enhancements, usability improvements, packaging and more complete userland.
Coverage & commentary
Technical press and communities (LWN, InfoWorld, ItsFOSS and others) have covered Redox at various stages, emphasizing its experimental nature, the promise of Rust for systems, and the long road to feature parity with Linux/BSD. The LWN/Rust/os coverage provides useful context on technical tradeoffs and progress.
How to try Redox (short)
Official site has downloads, documentation and links to the GitLab/GitHub mirrors. There are ISO previews for x86_64; ARM64 work is in progress. See the docs for building from source and the “book” for architecture details.
Short timeline (high-level)
2015 (Apr) — Project created / first commits.
2016–2018 — community growth, early architecture refinements.
2019 — significant memory/ISO size improvements and public releases.
2023 (Jun) — First Board of Directors elected (formal governance).
2024 (Sep 9) — Release of 0.9.0 (preview/stability milestone); monthly updates begin.
2024–2025 — continued development, COSMIC integration plans, monthly news posts and community activity.
Where I got this (major sources)
Redox official site and news / release pages.
Redox documentation (“The Redox Operating System — book / introduction / origin story”).
Project repos / releases (GitLab / GitHub mirrors).
Coverage and analysis (LWN, ItsFOSS) and community posts.
If you want, I can now (pick one):
Produce a detailed, dated changelog compiled from Git tags and release notes (version by version up to 0.9.0), or
Summarize the technical architecture (microkernel design, IPC model, RedoxFS internals, relibc, pkgutils) in more depth, or
Show how to build and run the latest Redox ISO in a VM (step-by-step).
Redox OS is a Unix-like operating system written almost entirely in the Rust programming language. Its history is intrinsically linked to the rise of Rust and a growing desire for safer, more secure, and more reliable systems software.
1. The Origin: A Vision for Safety and Correctness (2015)
Redox OS was created by Jeremy Soller, who is also a principal engineer at System76. The project began in 2015 and was first announced to the public in 2015.
Core Motivation: The primary driving force behind Redox was to leverage the memory safety and concurrency guarantees of the Rust programming language to build a modern, microkernel-based OS that would be inherently resistant to whole classes of bugs and security vulnerabilities (like buffer overflows, use-after-free errors, and data races) that plague operating systems written in C and C++.
Philosophical Foundations: The project was founded on several key principles:
Security: Achieved through memory safety, a microkernel design, and a strong permission system.
Reliability: By using Rust, the goal was to eliminate many sources of crashes and undefined behavior at compile time.
Portability: Designed to be portable across different CPU architectures.
Modularity: A core tenet of the microkernel architecture, where as much as possible (device drivers, file systems, etc.) runs in userspace as separate “servers.”
2. The Evolution and Key Milestones (2015 - Present)
The development of Redox OS has been a continuous, community-driven effort. Unlike a corporate project, its history is marked by technical milestones rather than versioned public releases.
Key Technical Developments:
The Microkernel (redox-kernel): The heart of Redox is a microkernel that handles only the most fundamental tasks: inter-process communication (IPC), memory management, and CPU scheduling. Everything else is a separate userspace process.
The ion Shell: One of the first and most mature components. ion is a modern, pipeline-oriented shell that is both a daily-driver for developers within Redox and a standalone project that can be run on Linux and macOS.
The TFS File System (RedoxFS): A custom file system designed with safety, scalability, and metadata features in mind, also written in Rust.
Orbital GUI: A modern, compositing windowing system and GUI protocol for Redox. An earlier, simpler GUI called Redox-UI was used before Orbital’s development.
Package Management (bpm): The Redox Package Manager was an early tool for managing software. The project has since explored other package management ideas, reflecting the ongoing nature of development.
Ports of Common Tools: A significant effort has gone into porting the GNU libc alternative (relibc) and a substantial portion of the Rust ecosystem to run on Redox, allowing many standard Unix tools and Rust programs to be compiled for the OS.
Project Growth and Community:
Redox OS has garnered a dedicated community of developers and enthusiasts who are passionate about its goals. Development is coordinated primarily through GitHub and a public Zulip chat.
It has been a testbed and proving ground for Rust’s systems programming capabilities. The project has, at times, contributed to the evolution of Rust itself by identifying needs and pushing the boundaries of what’s possible with the language.
While not yet a daily-driver OS for most, it has reached a level of maturity where it can run in a virtual machine (like QEMU or VirtualBox) and support a basic graphical desktop environment, a web browser (a port of Firefox, often called “NetSurf” or “Lynx” in earlier builds), and essential development tools.
3. The Present Status and Legacy (2024)
As of 2024, Redox OS remains under active development but is firmly in the “research and development” phase.
Not a General-Purpose OS Yet: It is not ready to replace Windows, Linux, or macOS on mainstream hardware. Hardware support, especially for laptops with complex components, is limited.
A Working Proof-of-Concept: Its greatest achievement is being a fully functional, self-hosting proof-of-concept that demonstrates the viability of a modern OS written in a memory-safe language.
Influence: Redox OS has had a significant philosophical influence. It stands as a concrete example that alternatives to the C/C++ dominance in OS development are not only possible but practical. It has inspired other projects and contributed to the broader conversation about system security.
Future Goals: The roadmap includes improving hardware support, expanding the package ecosystem, enhancing the GUI, and continuing to refine the core kernel and drivers.
Summary Timeline
2015: Project initiated by Jeremy Soller.
2015-2016: Early development, creation of the kernel, initial shell (ion), and file system.
2016-Present: Continuous, iterative development. Introduction of the Orbital GUI, ports of common software, and steady improvement of core components.
Present Day: An active open-source project that serves as a research OS and a demonstration of memory-safe operating system design. It is a functional OS for exploration and development but not for mainstream use.
