🌐 Interesting & Awesome Operating Systems

A comprehensive, structured, deeply‑researched guide to the most fascinating open‑source operating systems — including the experimental MyOS2026.

• Introduction
• Why This List Exists
• Categories of Interesting Operating Systems
• Master Comparison Table
• Detailed Category Breakdowns
  • 1. Research & Experimental OSes
  • 2. Security & Privacy OSes
  • 3. Microkernel & Modular OSes
  • 4. Retro & Hobbyist OSes
  • 5. Unique Linux Distributions
  • 6. Cloud & Immutable OSes
  • 7. Mobile & Embedded OSes
• How to run locally
• Contributing
• License

Operating systems are among the most complex and creative artifacts humans build. Beyond mainstream OSes lies a vast universe of experimental, retro, academic, security‑focused, and hobbyist systems — each with its own philosophy and architecture.

This document is a comprehensive, structured, human‑readable guide to the most interesting open‑source OSes, including the custom experimental OS MyOS2026.

This repository aims to:

• Help OS enthusiasts explore unconventional systems
• Provide OS‑dev learners with inspiration and reference material
• Preserve knowledge of rare and historical OSes
• Compare architectures, kernel models, and design philosophies
• Serve researchers, educators, and hobbyists with a single curated resource

This README covers OSes across these categories:

1. Research & Experimental OSes
2. Security & Privacy OSes
3. Microkernel & Modular OSes
4. Retro & Hobbyist OSes
5. Unique Linux Distributions
6. Cloud & Immutable OSes
7. Mobile & Embedded OSes

Below is a consolidated, README‑ready table comparing notable open‑source OSes by architecture, kernel type, purpose, uniqueness, and a short hint for getting started. Each OS name links to its official site or canonical repo/docs for quick access.

A modern experimental OS built using SPEC‑kit, designed for modularity, reproducibility, and OS‑dev experimentation.

Key Characteristics

• Architecture: x86_64
• Kernel Type: Modular monolithic
• Shell: Minimal shell with essential commands
• Networking: Fully functional TCP/IP stack
• Userland: RustyBox (BusyBox‑Rust)
• Build System: Declarative /speckit.specify
• Boot Status: Boots successfully with working drivers

Uniqueness

• SPEC‑driven OS evolution
• Rust‑based userland components
• Clean modular architecture for learning and experimentation

A clean‑slate, Linux‑compatible OS kernel written almost entirely in safe Rust, pioneering the framekernel architecture. Unsafe Rust is confined to a small, auditable framework called OSTD, keeping the memory‑safety trusted computing base minimal. Won the SOSP 2025 Best Paper award for its CortenMM memory‑management scheme.

Key Characteristics

• Architecture: x86‑64 (Tier 1), Intel TDX, RISC‑V 64 (Tier 2), LoongArch 64 (experimental)
• Kernel Type: Framekernel — monolithic performance with microkernel‑inspired safe/unsafe separation
• Language: Rust (~88%), C (~8%), Assembly
• Linux compatibility: 230+ Linux syscalls; runs unmodified Linux binaries
• Tooling: OSDK — purpose‑built toolkit making kernel dev feel like standard Rust app dev
• TEE support: Intel TDX for confidential computing

Uniqueness

• Only the OSTD layer may use unsafe; rest of the kernel is provably memory‑safe
• Targets data centres, confidential VMs, autonomous vehicles, and embodied AI
• AsterNixOS: experimental Linux distribution built on top of Asterinas

• Plan 9 — distributed, everything‑is‑a‑file model
• Inferno — Limbo language and Styx protocol for networked resources
• Redox — Rust microkernel research with modern tooling
• Fuchsia — Zircon microkernel and capability model
• Genode — framework for building componentized OSes

• Ironclad — formally verified kernel in SPARK/Ada; correctness proven at the language and proof level
• Qubes OS — VM‑based isolation
• Tails — amnesic, Tor‑routed
• Whonix — gateway + workstation
• Subgraph OS — sandboxed apps on a hardened Linux base
• OpenBSD — proactive security hardening

• Minix 3 — self‑healing microkernel for reliability
• GNU Hurd — multiserver architecture on Mach
• seL4 — formally verified microkernel for high assurance
• L4 Family — high‑performance microkernels for embedded systems
• Fuchsia and Genode — modern microkernel and component frameworks

• Haiku — BeOS successor with multimedia focus
• SerenityOS — retro UI with modern C++ codebase
• ToaruOS, Visopsys, KolibriOS, MenuetOS, TempleOS — from‑scratch hobbyist systems
• ReactOS, AROS, AmigaOS, RISC OS — compatibility and legacy ecosystems

• NixOS — declarative, reproducible system configuration
• Guix System — functional package management and FSF alignment
• Alpine Linux — minimal, musl + BusyBox for small images
• Void Linux — runit init, musl/glibc options
• Tiny Core — extremely small live distro

• Flatcar Container Linux — immutable OS for container workloads
• RancherOS (archived) — container‑centric OS with Docker userland
• SmartOS — Illumos‑based with ZFS and Zones for cloud virtualization

• postmarketOS — long lifecycle mobile Linux for phones
• Sailfish OS — gesture UI and community ports
• Zephyr Project, FreeRTOS — RTOSes for constrained devices

Below are concise, copy‑pasteable instructions to build and run the OSes from the table locally. Start with the Prerequisites, then use the Generic QEMU workflow, and finally follow the per‑OS quick run snippets for common projects. Each snippet shows the minimal commands to build or obtain an image and boot it in QEMU or a VM.

• Host OS: Linux (Ubuntu/Debian recommended) or macOS; Windows via WSL2 for many builds.
• Common packages: git, build-essential, gcc, clang, nasm, qemu-system-x86, qemu-system-aarch64, ninja, cmake, python3, pkg-config.
• Rust toolchain: rustup, cargo for Rust projects.
• Cross toolchains: gcc-multilib, binutils-multiarch, aarch64-linux-gnu-gcc when building ARM targets.
• Virtualization: VirtualBox or libvirt/virt-manager for VM images; enable virtualization in BIOS.
• USB flashing: dd or balenaEtcher.
• Embedded toolchains: vendor SDKs, west and Zephyr SDK for Zephyr; MCU toolchains for FreeRTOS.

git clone <repo-url>
cd <repo-dir>

# build (examples)
cargo build --release          # Rust workspace
make -j$(nproc)                # Makefile projects
mkdir build && cd build
cmake -G Ninja .. && ninja     # CMake + Ninja

# boot image in QEMU (x86_64)
qemu-system-x86_64 -m 1024 -drive file=path/to/image.img,format=raw -serial mon:stdio -net nic -net user

• MyOS2026

git clone https://example.org/MyOS2026.git
cd MyOS2026
cargo build --workspace --release
make image
qemu-system-x86_64 -m 1024 -drive file=out/myos2026.img,format=raw -serial mon:stdio

• Asterinas

# Requires Rust nightly + OSDK
cargo install cargo-osdk
git clone https://github.com/asterinas/asterinas.git
cd asterinas
make build
make run  # boots in QEMU

• Redox

git clone https://github.com/redox-os/redox.git
cd redox
make all
qemu-system-x86_64 -m 2048 -drive file=target/qemu/redox.img,format=raw -serial mon:stdio

• SerenityOS

git clone https://github.com/SerenityOS/serenity.git
cd serenity/Meta
./makeall.sh
./run

• Fuchsia Follow upstream docs; example:

git clone https://fuchsia.googlesource.com/fuchsia
# use fx toolchain per docs
fx set workstation.x64
fx build
fx qemu

• Qubes / Tails / Whonix Download official ISO or VM images, verify signatures, and boot in a VM or on hardware.

Contributions are welcome. Please submit:

• New OS entries or corrections
• Architecture, kernel, or language updates
• Build/run hints, screenshots, or diagrams
• Additional categories or historical notes

When adding entries, keep rows concise and include a short Hint showing how to build or run (example: make + QEMU command or official ISO instructions).

This document is released under the MIT License. You are free to copy, modify, and distribute it.