Skip to main content

Learn · Topic path

Operating Systems

How a kernel takes a bare CPU to an interactive shell: boot, memory, interrupts, processes, system calls and files. Start with the hardware concepts the kernel depends on, build a real AArch64 kernel on QEMU, then explore the hard parts interactively.

Chapters
13
Project
1
Explorer
1

Recommended path

  1. Read Computer Architecture · ch. 5 · 27 min read

    Computer Memory Hierarchy: Registers, Cache, RAM, and Virtual Memory

    Registers, caches, RAM and virtual memory from the hardware side

  2. Explore Explorer

    CPU Cache Explorer: feel why locality matters

    Tune associativity and block size, replay access patterns, see every hit and miss.

  3. Build OS project · ch. 1–3

    Why build an OS, the toolchain, and the ARM64 boot process

  4. Build OS project · ch. 4–5

    First output over the UART and the kernel memory layout

  5. Build OS project · ch. 6 · 23 min read

    AArch64 Virtual Memory & the MMU: Teaching the CPU to Lie

  6. Explore Explorer

    Virtual Memory Explorer: walk the tables you just built

    Walk an AArch64 page table, watch the TLB fill and trigger page faults.

  7. Build OS project · ch. 7–13

    Exceptions, heap allocator, processes, syscalls, Rust, filesystem and shell

Every chapter

From Silicon to Shell: Building an OS for ARM and More

  1. 1 Why Build an OS?
  2. 2 Toolchain Setup
  3. 3 The ARM Boot Process
  4. 4 Hello, UART
  5. 5 Memory Layout
  6. 6 Virtual Memory & the MMU
  7. 7 Exceptions & Interrupts
  8. 8 Heap Allocator
  9. 9 Processes & Context Switching
  10. 10 System Calls
  11. 11 Bringing in Rust
  12. 12 Simple Filesystem
  13. 13 Building the Shell

Frequently asked questions

Do I need real hardware to learn OS development?

No. The kernel in this path runs on QEMU's virt machine, which emulates a full AArch64 system, so a macOS or Linux machine with a cross-compiler and QEMU is enough.

Should I learn computer architecture before operating systems?

You don't have to finish the architecture path first, but the memory hierarchy chapter is the first step here because the MMU, caches and page faults come up again as soon as the kernel manages memory.

Is C enough, or do I need assembly?

Basic C is the prerequisite. The small amount of AArch64 assembly the kernel needs, for the boot stub, exception vectors and context switch, is explained line by line where it appears.

How long does the full path take?

The kernel project alone is estimated at 25 to 40 hours including implementation and debugging. Add the reading time of the memory chapter and the time you spend in the explorers.