[ path · the build course is live ]
Operating Systems in Rust
Write a real x86-64 operating system from scratch in Rust — bootloader, kernel, memory management, scheduler, user mode, filesystem, shell — one auto-graded stage at a time. Not Linux: the machinery under it, built by you.
No fake progress bars: a chapter turns solid here when its labs actually grade, not when a marketing date arrives.
[ the syllabus, so far ]
Every unit on the path, in the order you’ll build it.
The first labs of every live chapter are free — and during beta, a free account opens all of them. The order isn’t optional for anyone: each unit unlocks when the one before it is done.
ch. 01Rust for Systems Programming
Enough Rust to write a kernel: you will own memory without a garbage collector, lay structs out to a byte-exact ABI, reach through raw pointers in unsafe code, build without the standard library, and drive the cargo and toolchain machinery that targets bare metal — each of them the way an OS actually uses them.
Why it’s here: Rust for systems programming — ownership, unsafe, no_std. Mini-course, planned.
[ shared chapter ] one course, 2 paths — counted once
finish it on either path and both show this chapter complete — nothing to redo, transfer, or re-prove.
open this chapter with your progress → · sequential unlock applies to everyone — during beta, every live lab is open to a free account
ch. 02x86-64 for OS Builders
A working mental model of the machine your kernel runs on: the three operating modes and how a CPU walks between them, how the GDT and privilege rings gate what code may do, how four levels of page tables turn a virtual address into a physical one, how interrupts and exceptions reach your handlers, and how to talk to real devices over I/O ports.
Why it’s here: Registers, privilege rings, paging, interrupts and device I/O at the hardware level — read off the running machine rather than off a diagram. Six labs, all live: every stage adds a probe that interrogates the CPU you booted and reports what it found. Reuses the OS course's QEMU grader unchanged.
open this chapter with your progress → · sequential unlock applies to everyone — during beta, every live lab is open to a free account
ch. 03Build an OS from Scratch
A 64-bit kernel you booted yourself, and then kept building until it was a system you could use: a boot stub and bootloader you wrote, long mode, console and serial drivers, GDT/TSS and an IDT that catches CPU exceptions, live timer and keyboard interrupts, a physical frame allocator and page tables and a working heap, a scheduler that becomes preemptive, ring 3 with syscalls and per-process address spaces, a block device and a filesystem, and the shell you type into at the end — every stage verified by booting your own kernel in QEMU.
Why it’s here: The build course, and the spine of this path — one course that runs all the way from the boot stub to your own shell. All 18 labs are live: boot → long mode → kernel I/O → GDT/IDT → interrupts → memory (frame allocator, paging, heap) → scheduling → user mode and per-process address spaces → a filesystem → and the shell finale you type into.
From an empty disk to a kernel that catches faults and takes interrupts.
Own the machine's RAM — frames, page tables, then a working heap.
More than one thing at a time, first by cooperation and then by force.
Drop to ring 3, cross the syscall boundary, give each program its own world.
A disk you can read, then files and directories on top of it.
The part you type into — and the proof the rest of it works.
open this chapter with your progress → · sequential unlock applies to everyone — during beta, every live lab is open to a free account
[ the other end of the line ]
What you’ll have when the line runs out.
Not a certificate of attendance. A machine — and the repo history that proves you built it.
- ✓A bootloader written byte by byte — real mode to long mode, your instructions first.
- ✓A kernel with virtual memory — page tables you mapped, a heap you allocated.
- ✓Preemptive scheduling and user mode — processes, isolation, syscalls.
- ✓A filesystem on a disk your driver runs — files that survive a reboot.
- ✓A shell at the end of it all — every keystroke through code you wrote.
- ✓18 verified completions — earned by official runs, yours for good, in your private repo.
[you] kernel 0.18.0 · 128 MiB · vga + serial gdt · idt · paging · sched · fs — all yours $ ls / bin/ docs/ hello.txt $ uptime ticks: 48210 (100 Hz) · tasks: 3 $
the last thing the path grades: this prompt, answering
[ questions ]
Asked before starting.
[ q ]Do I need to know Rust — or operating systems — already?
No, and no. That’s what the path shape is for: chapter 1 teaches exactly the Rust the build uses, chapter 2 teaches the machine, and nothing in the build course assumes anything the line hasn’t already covered.
[ q ]What do I need on my machine?
A Mac or Linux box (or WSL2), Git, and about 2 GB of disk. Lab 00 walks you through the rest — the Rust toolchain and QEMU — and checks the whole setup builds before anything is at stake.
[ q ]Is this “learn the Linux kernel”?
No — and we won’t pretend it is. You’re building your own kernel: the same machinery — paging, scheduling, syscalls, filesystems — with your own hands, at a scale one person can hold in their head. It’s the difference between touring the engine room and building the engine.
[ q ]What makes a verified completion meaningful?
Official grades run on our servers, on exactly the checks your local run just made — nothing held back. What’s different is that we compute the verdict and record it, not you. If it says your code did it, your code did it.
[ q ]Who owns the code I write?
You do, unambiguously. sboot start unpacks the course into a folder on your machine and prints the git init that turns it into a repo — private until you push it, and our tests and grader are never inside it. Cancel any time and every line stays with you.
[ q ]What does it cost?
Free during beta — every live lab is open to a free account. Paid plans arrive at launch; the first labs of every chapter stay free so you can always try the real thing first.
[ unit 1 of 31 ]
The line starts at the left end.
The first lab is a page you can read tonight. The other end is yours to earn.