R0KernelPath

About KernelPath

A single source of truth for one of the most rewarding journeys in all of computing: learning enough to contribute to the Linux kernel — the software that runs on billions of phones, servers, cars, and supercomputers.

Who this is for

Anyone curious about how computers really work, especially younger learners and self-taught programmers. It assumes zero prior knowledge at the start — the first modules explain what a bit is and how a transistor switches — and builds, brick by brick, all the way to writing device drivers, fuzzing the kernel, and emailing your first patch to a maintainer.

How it's organized

262 modules across 30 tracks, split into two parts. Part I — The Kernel Path is ordered so each track builds on the last, from bits to a merged patch. Part II — The CS Core is a full undergraduate computer-science curriculum modelled on MIT 6-3 and Stanford CS. Every module stands on its own with an overview, the core concepts (with real code), a diagram, common pitfalls, hands-on exercises, curated resources, and checkpoints.

Part I · The Kernel Path
  1. 00Foundations of Computing— How a machine computes at all — from transistors to running programs.
  2. 01C Programming Mastery— The language the kernel is written in, learned to the bone.
  3. 02Computer Architecture & Microprocessors— What your code actually runs on.
  4. 03Assembly & the Machine— Talking to the CPU in its own words.
  5. 04Operating Systems Theory— The timeless ideas every kernel implements.
  6. 05Linux as a System— Mastering Linux as a power user and systems programmer.
  7. 06Tools of the Trade— Git, GCC, GDB, Make, perf, QEMU — a kernel hacker's toolbox.
  8. 07Linux Kernel Internals— Inside the world's most important codebase.
  9. 08Device Drivers— Where the kernel meets real hardware.
  10. 09Kernel Development Practice— Build, boot, test, and debug your own kernel.
  11. 10Contributing to Linux— The patch, the mailing list, the maintainer — getting code merged.
  12. 11The Cutting Edge— eBPF, Rust, io_uring, and the future of the kernel.
Part II · The CS Core
  1. 12Mathematics for Computer Science— Discrete math: the logic, proofs and structures all of CS is built on.
  2. 13Linear Algebra, Calculus & Probability— The continuous math that powers graphics, ML and theory.
  3. 14Programming Abstractions & Paradigms— How to think in abstractions — functional, OOP, interpreters.
  4. 15Data Structures— The containers that make algorithms possible.
  5. 16Algorithms— Designing and analyzing efficient solutions.
  6. 17Theory of Computation & Complexity— What can be computed, and how hard it is.
  7. 18Programming Languages— Semantics, type systems and the lambda calculus.
  8. 19Compilers— Turning source code into machine code, stage by stage.
  9. 20Databases— Storing, querying and protecting data at scale.
  10. 21Computer Networks— How the Internet actually moves bits.
  11. 22Distributed Systems— Many computers, one system — consensus, replication, fault tolerance.
  12. 23Artificial Intelligence— Search, logic, planning and reasoning under uncertainty.
  13. 24Machine Learning— Learning from data: the classical ML toolkit.
  14. 25Deep Learning & Modern AI— Neural networks, transformers and generative models.
  15. 26Security & Cryptography— Attacking and defending systems; the math of secrets.
  16. 27Computer Graphics & Vision— Making and understanding images.
  17. 28Software Engineering & Systems Design— Building software that lasts and scales.
  18. 29HCI, Ethics & the Profession— Computing for, and about, humans.

How to use it

  • Go in order if you're new.Track 0 → Track 11 is a genuine curriculum. Don't skip the foundations; the kernel punishes hand-waving.
  • Jump around if you're not. Already know C? Start at Computer Architecture or Kernel Internals. Use ⌘K to search any topic.
  • Build everything. Reading about a spinlock teaches you nothing. Do the exercises. Compile the code. Boot the kernel in QEMU.
  • Tinker in the Sandbox. Play with bits, run code, test regexes, and watch sorting algorithms race — hands-on tools to make the ideas stick.
  • Mark modules complete as you finish them. Your progress is saved in your browser and shown on the progress dashboard. Export it to back it up.

The visualizations

The hardest ideas in systems — virtual-memory translation, the CPU pipeline, protection rings, the syscall boundary, the patch lifecycle — come with hand-built, interactive visualizations you can poke at. Every other module includes a generated diagram so there's always something to see, not just read.

How it was built

The curriculum content was authored by a fleet of 260+ AI agents working in parallelacross two waves — one specialist educator per module — then assembled into this site (Next.js, deployed on Vercel). It's open source and MIT licensed; corrections and additions are welcome on GitHub.

The best canonical sources

When in doubt, these are the references the pros actually use:

Ready?

Start at module 01 →