[ built, not watched ]
Build real expertise, one system at a time.
Structured paths, not scattered tutorials: ordered courses that end with a real system you built. The flagship path goes from an empty disk to your own operating system — storage engines, compilers and more are on the bench. Every lab is graded by running what you wrote.
Free to start · no credit card · every live lab is open to a free account.
$ sboot test 07-interrupts [ ok ] idt loads without faulting 0.4s [ ok ] remaps the PIC off the CPU exceptions 0.7s [ ok ] timer ticks at 100 Hz 2.1s [ ok ] keyboard IRQ drains port 0x60 1.3s [ ok ] serial console stays responsive 0.6s 5/5 · practice run — run sboot submit for the official grade$
the flagship path, lab 07 — exactly as it looks on your machine: your editor, your kernel, our checks
[ the proof — the flagship’s finale ]
Expertise you can run.
Every course site on the internet promises “real skills.” Ours ships with a binary attached: this is lab 18, the last unit on the flagship path — a shell answering on a filesystem, disk driver, and scheduler you wrote yourself. Not our demo. The thing you built, in your repo, bootable forever.
[you] kernel 0.18.0 · 128 MiB · vga + serial gdt · idt · paging · sched · fs — all yours $ ls / bin/ docs/ hello.txt $ cat hello.txt from an empty disk to this prompt. $
where the path ends: your prompt, on your OS — the last thing we grade
[ the flagship path · operating systems in rust ]
Three courses. One line. 31 units.
Not a pile of tutorials — a single sequence. The Rust you’ll need, the machine you’ll run on, then the operating system you’ll build. Each unit opens when the one before it is done.
[ the catalog ]
Build the systems that make you the expert.
Real systems, in guided paths — ordered courses with every prerequisite on the line. The OS build course is live end to end; everything else is labeled exactly as real as it is.
Operating Systems in Rust
Boot to shell: paging, preemption, user mode, a filesystem — a real kernel, yours. Three courses on one line, prerequisites included.
Start the path →[ path 02 · databases ][ in development ]Storage & Databases
A storage engine from scratch — pager, B-tree, WAL — then a SQL front end over it. Chapter 01 is shared with the OS path.
See the path — honest states →Build a Compiler
A compiler for a small language, built end to end: a lexer and recursive-descent parser, a typed AST, a bytecode compiler and stack VM, then native code generation — every phase written and tested by you.
Build a Container Runtime
A container runtime from first principles: Linux namespaces and cgroups, an overlay root filesystem, an OCI image puller, virtual-network plumbing, and a tiny scheduler that places containers across nodes.
Build a Distributed Messenger
A mini-WhatsApp built from scratch: a wire protocol, a fan-out delivery service, presence and read receipts, replicated storage, and the consensus that keeps replicas in agreement when servers fail.
Build an OS from Scratch in C
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.
What should we build next?
The catalog grows one real system at a time. Watch the storage path being built — and tell us what should follow it.
follow the build →[ note ] courses are chapters of a path, never standalone products — the Rust primer opens both live paths, and finishing it on one counts on the other.
[ how it works ]
Every unit moves the same way: concept → canon → build.
A page of theory, the best thing ever written on it, and the code you’re about to make real. You don’t watch a video and nod along — you build, and the grade comes from running what you built.
A one-page lesson
The idea you’re about to build, in a page. Enough to act on, short enough to actually read.
The best thing written on it
The right chapter of the right book — the Intel SDM, OSTEP, the 8259A datasheet — curated, so you never wonder what to read next.
A project that proves it
You implement it in a real system, and sboot submit grades it by running it.
sboot test [ local ][ unlimited · private ]
Instant feedback on the published checks — and when something breaks, it tells you about your kernel, not ours.
$ sboot test 09-paging [ ok ] identity-maps the kernel image [ ok ] enables the NX bit in EFER [fail] maps the framebuffer in the higher half └ your PML4 entry 511 is present, but the PDPT it points at is all zeroes — you built the table, then never wrote it 4/5 · run it again when you’ve changed something
sboot submit [ official ][ verified completion ]
The official run. Pass it and the unit is verified — recorded on your path, earned by a kernel that actually booted.
$ sboot submit 07-interrupts ── official run · booting your kernel [ ok ] remaps the PIC off the CPU exceptions [ ok ] timer ticks at 100 Hz [ ok ] keyboard IRQ drains port 0x60 ✓ verified completion · 07-interrupts → recorded · next on the path: 08-frame-alloc
[ built, not watched ]
No videos to nod along to. Every completion is a system that actually ran.
[ paths, not projects ]
Prerequisites live on the line itself. You never leave to go learn something first.
[ your repo, your machine ]
Your system lives in a private workspace on your machine — a git repo from the first commit, with none of our tests or grader inside it. Push it to GitHub when you want; you keep everything.
[ earned, not self-reported ]
Verified completions come from official runs of your code — and they’re yours for good.
[ you’ve watched enough tutorials ]
Unit 1 is free. So are the next few.
Write the systems experts are trusted with — starting tonight, at the left end of the line. No credit card.
Not ready yet? Get launch updates instead: