Courses / Course 04 · Os
You end up withA Unix shell you wrote; a small RISC-V operating system with processes, paging, user mode, system calls and a file system; an x86-64 kernel in Rust with interrupts, paging and a heap allocator; xv6 extended through MIT's nine labs; and Linux kernel modules you built and loaded, with enough Linux internals to read the kernel's source.
Why build one when the agent never touches the kernel? Because every bug that isn’t in your code is in this layer: the process that won’t die, the memory that’s “free” but not available, the container that sees a different filesystem, the syscall that’s suddenly slow. After this track, fork, page faults, file descriptors and context switches are things you’ve implemented, not words in a stack trace. Hacker News has voted these tutorials up since 2008. Every step below shows its HN score and quotes what HN said.
How this track is ordered, and why it skips the boot sector. Most OS tutorials start by writing a 512-byte bootloader for the legacy PC BIOS. HN’s experienced hobbyists keep warning against that:
“Because if you want to write an OS, don’t write a bootloader first. This article essentially describes a stage 1 bootloader on top of legacy BIOS firmware. It will teach you about historical x86 minutiae, which is nothing but a hindrance if you want to understand OS concepts.”
So the track goes from the outside in: the system-call interface first, then a whole small OS on RISC-V (which has none of x86’s legacy boot steps), then x86-64 in depth with a ready-made bootloader, then a real teaching Unix, then Linux. The boot-sector tutorials are an optional detour in Stage 3.
How to read the receipts.
Short, illustrated articles on what happens from power-on to a running kernel, how a process is laid out in memory, and how the kernel manages memory. Read How Computers Boot Up, Anatomy of a Program in Memory and How the Kernel Manages Your Memory.
“Gustavo Duarte’s (not to be confused with Androider Matias Duarte) blog posts are awesome.”
The textbook for this track, in three parts: virtualization (processes, scheduling, memory), concurrency (threads, locks) and persistence (disks, file systems). Read the virtualization chapters now, and keep reading as the later stages reach each topic. Its companion repository, ostep-projects, has graded projects in C, including a shell and several xv6 kernel projects.
“Even with 20 years writing software professionally under my belt, the ways this book shifted my perceptions on topics I assumed I knew well was surprising!”
“There was a long period of time after I “learned to code” where everything still seemed like magic. Working through this book for 10 weeks in my OS course at school was when the magic finally become real and concrete.”
A working shell in a few hundred lines: read a line, split it, fork, exec, wait. Then extend it yourself with pipes and redirection, using the processes-shell project from ostep-projects as the spec.
“This article is good in that it shows that starting processes boils down to the system calls fork(), exec(), wait(), etc.”
“A nice complement to this article is the MIT 6.828 shell exercise. It provides the command loop and parsing for you, and then has you implement command execution, redirection, and pipes.”
Alternative: Writing a Unix Shell · Indradhanush Gupta · https://indradhanush.github.io/blog/writing-a-unix-shell-part-1/ · 407 points, submitted 4× (2017–2018). A slower multi-part series that builds the same loop step by step. “This is a great illustration of how non-trivial a production quality shell is.” (pacaro, 2017 · comment)
A complete small OS, end to end: boot, exceptions, a memory allocator, processes and context switching, page tables, user mode, system calls, a disk driver and a file system, with a shell on top. It’s the whole map at small scale before Stages 3 and 4 fill in each region.
“I wrote this book so you can spend a boring weekend writing an operating system from scratch. You don’t have to write it in C - you can use your favorite programming language, like Rust or Zig.”
“Based on my experience in “hobby” OS programming, I would add setting up GDB debugging as early as possible.”
Alternative, in Rust: The Adventures of OS: Making a RISC-V Operating System using Rust · Stephen Marz · https://osblog.stephenmarz.com/ · 1,017 points across 25 submissions of its chapters (2019–2023). “I’ve been following along with no prior Rust or OS programming knowledge and have found it immensely refreshing.” (StanAngeloff, 2020 · comment). The caveat: “My only criticism is that sometimes there’s parts in your tutorial that are missing but present in your os.” (webgoat, 2020 · comment)
A 64-bit x86 kernel, one post at a time: a freestanding binary, a minimal kernel booted with the bootloader crate, VGA text output, testing inside QEMU, CPU exceptions, double faults, hardware interrupts, paging, heap allocation, allocator designs, and async/await multitasking. This is the depth on interrupts and page tables that Stage 2 skimmed.
“Not only this is interesting well understandable Rust code for non-Rust developer, but it is also one of the best tutorial how page tables work on modern PC CPUs.”
“Phil’s articles seems so much more accessible for someone just wanting to dip their toes in the water.”
Alternatives in C (32-bit x86):
MIT’s undergraduate OS course (formerly 6.828 and 6.S081). xv6 is a re-implementation of Sixth Edition Unix, small enough to read in full alongside its book. The nine labs have you change it: Unix utilities, system calls, page tables, traps, copy-on-write fork, a network driver, locks, the file system, and mmap. Each lab ships with tests you run yourself. Use the 2025 edition: the Fall 2026 schedule was still under construction when this track was checked.
“I do not consider myself an expert in operating systems or C, but digging through the xv6 source code is quite fun, the code is easily readable and very newby friendly.”
“You are only 9,000 lines of code away from fully understanding basic operating systems concepts!”
HN’s caveat (about OS courses in general, from a student of a similar course built on Pintos): one classmate’s description was “a crash course in enabling and disabling interrupts in order to prevent segfaults and pagefaults.” (the_real_me, 2022 · comment). Self-learners get the tests but no course staff, so budget time for debugging alone.
Lighter alternative: the xv6 projects in ostep-projects (step 1), which UW-Madison uses with OSTEP. “The projects in their class at the University of Wisconsin-Madison were mainly making edits to the xv6 OS.” (bgschulman31, 2022 · comment)
Build and load modules into a running Linux kernel: character devices, /proc and sysfs files, ioctl, blocking processes, interrupt handlers. It’s kept current for modern kernels (the page was last updated in September 2026) and includes a QEMU-based setup, so a broken module doesn’t take down your machine.
“A detailed, hands-on, build a kernel module right away kind of tutorial. Bravo.”
How the real kernel boots, initialises, handles interrupts and system calls, keeps time and manages memory, traced through the actual source. After xv6 it’s readable: you know what each piece is for.
“It includes details like what bits you need to set in order to enable a particular paging mode, so it’s really enough detail to actually do something.”
Writing a file system from scratch in Rust · Carlos Galdino · https://blog.carlosgaldino.com/writing-a-file-system-from-scratch-in-rust.html · 546 points, submitted 2× (2020–2023) · Free · ~1–2 weeks. An ext4-inspired file system with a superblock, block groups and inodes, mounted through FUSE. Do it after the xv6 file-system lab. “for my money, this is the best way to describe the high level function and behavior of a filesystem that I have ever seen.” (unethical_ban, 2020 · comment). The caveat: it teaches the classic design. “When files that can be fragmented regularly reach sizes in the gigabytes, using extents is the best way to track their data blocks in an efficient manner.” (didgetmaster, 2023 · comment)
Linux From Scratch · https://www.linuxfromscratch.org/ · 2,330 points, submitted 14× (2011–2026) · Free · ~1–3 weeks. Not a kernel tutorial: you build a whole Linux system from source, toolchain first. It shows what a distribution is made of. “whenever someone asks me what they should read to get a deeper understanding of what a Linux distribution is, I point them to this.” (steve1977, 2026 · comment). The caveat: “But each time it just turned into a copy-incomprehensible-commands-into-the-terminal exercise at some point, and I lost motivation.” (sieste, 2024 · comment)
Build the machine your OS runs on: emulators. Every kernel in this track ran on hardware QEMU pretended to be. An emulator is that pretence written by you: a fetch-decode-execute loop, memory, a timer, a UART, and the traps and interrupts the kernel depends on. The three steps below grow from a weekend toy to a machine that boots the xv6 you studied in Stage 4.
Write Your Own Virtual Machine · Justin Meiners and Ryan Pendleton · https://www.jmeiners.com/lc3-vm/ · 1,235 points, submitted 9× (2018–2026) · Free · ~a weekend. An emulator for the LC-3, a 16-bit teaching computer, in about 250 lines of C, which ends by playing 2048 and a roguelike. Its trap routines, the LC-3’s keyboard and console calls, are the tutorial’s own picture of an operating system: “trap routines which you can think of as the operating system or API for the LC-3.” “This will be a fun weekend project for me” (tombert, 2018 · comment). The caveat is the machine itself: “Alas, educational architectures like the Brookshear Machine and Little Computer look nothing like real ones, making them worse than useless” (saithound, 2024 · comment). Treat it as a warm-up and move to a real instruction set next.
Writing a RISC-V Emulator in Rust · Asami Doi · https://book.rvemu.app/ · 259 points, submitted 3× (2020–2025) · Free · ~4–8 weeks. A 64-bit RISC-V emulator, built up until xv6 boots on it: CSRs, privilege levels, exceptions, the PLIC and CLINT, a UART, virtio and paging. The catch is that the prose stops early. “Just a heads-up that only the first three chapters are available so far.” (quantummagic, 2025 · comment). The companion repository, rvemu-for-book, has the code for all ten steps, so read the chapters that exist, then work from the code and the RISC-V privileged spec. The author on the goal: “I already succeeded to run xv6 in my RISC-V emulator” (d0iasm, 2020 · comment)
mini-rv32ima · CNLohr · https://github.com/cnlohr/mini-rv32ima · 205 points · Free · a few evenings to read. A 32-bit RISC-V emulator in about 400 lines of C, with no MMU, that runs Linux. Read it after your own emulator works, to see how small the job can be. “I admire the dedication and consistency it takes to stick to rv32 no MMU only to be able yo fit it into very minimal environments in the end.” (bippingchip, 2022 · comment). Its README credits pimaker’s Linux in a Pixel Shader (524 points, submitted 7×), a write-up of the same kind of emulator running inside a VRChat GPU shader.
If you’d rather emulate a console. The Game Boy is HN’s usual first real system. Pan Docs (255 points, submitted 4×) is the hardware reference: “It contains all the technical documentation you need while leaving the implementation up to you.” (aquova, 2023 · comment). Robert Heaton’s Gameboy Doctor (155 points) compares your CPU’s log line by line against a known-good one for Blargg’s test ROMs. Expect the screen to be harder than the CPU: “Personally, I’ve had more trouble understanding the PPU behavior than i did about the cpu instructions and timings.” (chrsig, 2022 · comment)
OSDev Wiki · https://wiki.osdev.org/ · 422 points across 30 submissions of its pages (2011–2026) · Free. The hobbyist reference for hardware details, toolchains and “bare bones” starting points.
“You’ll need to build your own GNU toolchain (gcc + binutils + gdb) for cross compiling (don’t try to use the one that ships with your OS, it will subtly fail when you don’t expect it to), get an emulator (e.g. qemu or bochs) and a bootloader to get started.”
The other reference is the xv6 book, linked from the 6.1810 page in step 5.
Checked against HN on 2026-11-08 (candidates_receipts.json), not used:
Emulator candidates checked, not used: Tiny Emulators (Andre Weissflog, 734 points), Selfie (697 points; a self-compiling C compiler, RISC-V emulator and hypervisor), Weird things I learned while writing an x86 emulator (Tim Misiak, 571 points), TinyEMU (Fabrice Bellard, 542 points), Emulator 101 (520 points; an 8080 Space Invaders emulator, site unreachable on 2026-11-08), I wrote a GameBoy emulator for my hobby OS (axle, 286 points), Writing a Game Boy emulator, Cinoop (CTurt, 244 points), How to Write a Computer Emulator (Marat Fayzullin, 187 points), The Ultimate Game Boy Talk (Michael Steil, 168 points), and Tobias Langhoff’s CHIP-8 guide (45 points).
Not yet checked: Bran’s Kernel Development Tutorial, James Molloy’s kernel tutorials, Harvard’s OS/161, Stanford’s Pintos, Lions’ Commentary on UNIX, Tanenbaum’s MINIX books, Hypervisor in 1,000 Lines.
phase1-stories/data/os_candidates.json). Bare “kernel” and “linux” were avoided as release-news noise; “bare metal” and “system calls” still brought in cloud and performance stories, which were skipped by hand.phase1-stories/scripts/check_track.py.phase1-stories/data/emulators_candidates.json), 16 checked. Emulator 101 returned HTTP 403 to our checker on 2026-11-08 and was left out. Writing a RISC-V Emulator in Rust’s published pages and its companion repository’s ten steps were checked the same day.tracks/os/receipts.json (resources used) and candidates_receipts.json (all 46 checked).