Poseidon-fan/linux-0.11-rs: Linux 0.11 rewritten in idiomatic Rust: kernel, std-style user library, and 60+ coreutils — boots on i386 in QEMU. · GitHub

A modern Rust rewrite of the Linux 0.11 kernel — boots on i386 in
QEMU, runs a self-hosted Unix-style userland.

$ cd kernel && make run
…
Welcome to linux-0.11-rs.
https://github.com/Poseidon-fan/linux-0.11-rs
(login: 0 @ linux-rs :: Wed May 27 09:35:43 UTC 2026)
[root@linux-rs /root]# ls /bin | wc -l
69

linux-0.11-rs rebuilds the 1991 Linux 0.11 kernel from scratch in modern
Rust. It keeps the original system’s semantics — what it does — while
rethinking how it’s expressed: stronger types, clearer module boundaries,
idiomatic abstractions everywhere. The kernel boots on emulated i386
hardware, runs a full init → shell → coreutils stack, and ships with the
tooling to build your own bootable image in one command.

• A kernel with most of what Linux 0.11 had — processes, virtual memory
  with demand paging and CoW fork, the Minix v1 filesystem, ATA disk
  driver, VGA + PS/2 console, 8250 serial console, TTY layer, signals, and
  the complete syscall table.
• A Rust user-space “std” — user_lib mirrors the public shape of
  std::🔥 so user programs read like
  ordinary Rust, not like syscall plumbing.
• A real userland — 80+ coreutils plus a hand-written POSIX-subset
  shell (sh) with pipelines, control flow, functions, glob, command and
  arithmetic substitution, and an interactive line editor with Tab
  completion and history.
• One-command images — tools/build-disk.sh compiles every user
  program, lays them out into a Unix-style filesystem, and packs the
  result into a bootable disk image.
• Companion image tools — mbrkit and
  miniximg are standalone crates, useful on their own for
  any project that touches MBR or Minix v1 images.
• Devcontainer included — clone, open in VS Code, hit “Reopen in
  Container”, run make run.

# Build every user program, lay out /etc /dev /bin, pack into disk.img.
tools/build-disk.sh

# Build the kernel and boot it in QEMU.
cd kernel && make run            # VGA console
cd kernel && make run-console    # serial console (-nographic)

You’ll land at a shell prompt in /root. Try:

ls /bin                              # browse what's installed
echo $((1 + 2 * 3))                  # arithmetic expansion
for f in /etc/*; do echo $f; done    # for loop + glob
fact() 🔥
fact 7                               # → 5040
ec<TAB>                              # completes to `echo `
↑                                    # walks command history

Outside a devcontainer you’ll also need a recent Rust nightly (pinned in
rust-toolchain.toml), qemu-system-i386, the x86_64-linux-gnu-*
cross-binutils, and the local image/test tools:

tools/install-tools.sh        # installs mbrkit, miniximg, ktest onto PATH

End-to-end tests boot the kernel under QEMU and drive the serial console
from short .ktest scripts under ktest/suites/.

tools/run-tests.sh                              # run everything
tools/run-tests.sh --suite=shell                   # one suite
tools/run-tests.sh --test-set=shell.basic          # one test
tools/run-tests.sh --disable-reboot             # share one QEMU across tests

kernel/              The kernel itself
user_lib/            std-style user-space library
user_lib_macros/     proc-macro: #[user_lib::main]
user_program/        ~80 coreutils + the `sh` shell
ktest/               end-to-end test runner driving QEMU over serial
mbrkit/              MBR disk-image CLI (also on crates.io)
miniximg/            Minix-fs image CLI and library
rootfs/              disk-image content template (/etc, /root, …)
tools/               developer scripts (build-disk.sh, run-tests.sh, …)
tutorial/            mdbook walkthrough (work in progress)
.devcontainer/       ready-to-use dev environment

• Kernel — substantially feature-complete relative to Linux 0.11.
  Floppy support is intentionally out of scope; ongoing work is on polish
  and tooling.
• User library — covers what the shell and coreutils need today.
• Userland — usable for real interactive work.
• Tutorial — early draft; the long-term plan is a complete
  build-from-scratch walkthrough.

cargo install mdbook
cd tutorial && mdbook serve --open

• Thanks to yuan-xy/Linux-0.11 for
  providing the original Linux 0.11 kernel source used as an important
  reference during development.
• Many parts of this project were also inspired by or implemented with
  reference to rcore-os/rCore-Tutorial-v3.

See LICENSE.