The complete path to
Linux kernel development
An exhaustive, visual, and totally free roadmap — 262 modules across 30 tracks. Part I takes you from what a bit is to sending a patch to the Linux kernel. Part II is a complete MIT / Stanford CS degree — algorithms, theory, compilers, databases, networks, AI, and more. Every concept explained, visualized, and linked to the best resources on Earth.
press ⌘K to jump to any topic
Read the instruction at the address in the Program Counter (PC) from memory into the Instruction Register.
The CPU repeats this loop billions of times per second. Click a stage to inspect it.
Learn in order, or jump in
The tracks build on each other — but every module is self-contained, with its own diagram, code, and curated resources.
See it, don't just read it
Hard ideas — paging, pipelines, the syscall boundary — come with hand-built interactive visualizations and a diagram per module.
Track every step
Mark modules complete as you go. Your progress is saved in your browser and shown across the whole roadmap.
Part I · The Kernel Path
From transistors to your first merged Linux kernel patch.
Foundations of Computing
8 modulesHow a machine computes at all — from transistors to running programs.
What Is Computation? Bits, Bytes, Binary & Hex
Master the language hardware speaks: why computers are binary, how to fluently read and write in binary and hex, and why a kibibyte is not a kilobyte.
Boolean Logic & Logic Gates
Two values, a handful of operations, and a universe of computation — Boolean logic is the language your CPU speaks at the deepest level.
From Transistors to Gates (CMOS)
Every CPU is billions of tiny switches — here is how electrons, silicon, and geometry conspire to compute anything.
Number Systems & Two's Complement
Two's complement is the elegant relabeling that lets a single adder circuit serve both positive and negative integers — and understanding it deeply is the foundation of reading kernel code without being surprised.
Data Representation: Integers, Floats, Text
Every bit you'll ever flip in the kernel comes down to how numbers, fractions, and text are encoded in binary — master these fundamentals and nothing at the low level will ever surprise you again.
The Von Neumann Architecture
The stored-program computer: one deceptively simple idea — instructions are just numbers in memory — that bootstrapped the entire software industry and whose consequences you will encounter on every kernel patch you ever write.
The Memory Hierarchy
Every byte you touch travels through a speed-vs-capacity pyramid — mastering this hierarchy is the single biggest lever for writing fast systems code.
How a Program Runs: Source to Execution
Master the five-stage pipeline that turns C source into a running process, and gain the mental model that underlies every systems-programming tool and kernel debugging technique you will ever use.
C Toolchain & Translation Phases
The C toolchain is the translation machine that converts human-readable source into silicon-executable instructions — mastering it means you understand exactly what your machine is running.
Types, Variables, Operators
Master how C maps your variables to raw bytes, how the compiler silently transforms your arithmetic, and why every kernel developer needs these rules memorized before touching a driver.
Control Flow & Functions
Master the conditional branches, loops, goto, and function calls that are the skeleton of every C program — including the Linux kernel itself.
Pointers: The Heart of C
Pointers give C programs direct access to memory addresses — mastering them is mastering the language the kernel is written in.
Arrays, Strings & Pointer Arithmetic
Master the deep identity between arrays and pointers in C — the mental model that separates systems programmers from everyone else.
Dynamic Memory: malloc, free & the Heap
Master the heap: learn how malloc, free, and allocators give your programs dynamic memory — and why misusing them causes the subtlest, most dangerous bugs in systems code.
The Stack, Calling Conventions & Stack Frames
The call stack is the invisible scaffolding that makes functions work — understanding its exact layout, byte by byte, is the first step to seeing what compilers and CPUs really do.
Structs, Unions, Enums & Bitfields
Master every aggregate type in C — structs, unions, enums, and bitfields — and learn why their memory layout is the secret language of hardware, protocols, and the Linux kernel itself.
Function Pointers & Callbacks
Function pointers are C's superpower for runtime polymorphism — and the entire Linux kernel driver model is just one giant, beautiful ops-struct dispatch table.
The C Preprocessor & Macros
Master the C preprocessor from basic #define to kernel-grade macro idioms like container_of, X-macros, and compile-time assertions — the invisible layer that makes Linux portable across hundreds of architectures.
Multi-file Projects, Linkage & Storage Classes
Master how C programs are split across files, how names cross (or don't cross) file boundaries, and how these mechanisms underpin every Linux kernel driver and subsystem.
Undefined Behavior & the C Memory Model
C's deliberate under-specification of dangerous operations is not a flaw but a contract — and understanding every clause of that contract is the difference between code that survives the optimizer and code that becomes a CVE.
Bit Manipulation Techniques
Master the complete language of bits — from individual flag operations to kernel-level bitmap APIs — so you can read, write, and contribute to the most performance-critical systems code on the planet.
Debugging C: GDB, Valgrind & Sanitizers
Master the art of seeing inside broken C programs — using GDB, Valgrind, and sanitizers to catch memory bugs, undefined behavior, and crashes before they find you in production.
CPU Anatomy: ALU, Registers, Control Unit, Datapath
A CPU core is a symphony of specialized circuits — registers hold the notes, the ALU plays them, the control unit conducts, and the datapath is the stage they all share.
ISAs: RISC vs CISC, x86 / ARM / RISC-V
An ISA is the contract between software and silicon — understanding RISC vs CISC, x86/ARM/RISC-V trade-offs, and why the kernel must speak every dialect is the foundation of everything low-level.
The Fetch-Decode-Execute Cycle
The fetch-decode-execute cycle is the heartbeat of every CPU — master this loop and you understand the substrate on which the entire Linux kernel runs.
Pipelining
Pipelining is the assembly-line trick that lets a CPU start a new instruction every clock cycle by overlapping the five stages of instruction execution across multiple instructions simultaneously.
Hazards & Branch Prediction
Hazards are the price of pipelining; branch prediction is the hardware's educated gamble to keep paying it as rarely as possible.
Superscalar, Out-of-Order & Speculative Execution
Modern CPUs execute dozens of instructions simultaneously by renaming registers, reordering operations, and betting on the future — all while appearing perfectly sequential to your program.
Caches Deep Dive: Associativity & Coherence
Caches are the single biggest lever between your code's theoretical speed and what the hardware actually delivers — mastering them is mastering modern systems.
Virtual Memory, the MMU, TLB & Paging
Virtual memory is the hardware-enforced illusion that every process owns all of memory — understanding it means understanding isolation, performance, and the entire Linux MM subsystem.
Privilege Levels, Protection Rings & CPU Modes
The CPU itself decides who to trust — privilege rings are not an OS policy but a silicon guarantee, and every system call is a tightly controlled leap across that boundary.
Interrupts, Exceptions & Traps
Interrupts are the nervous system of a computer — this module explains exactly how hardware events hijack the CPU, save its soul, and hand control to the kernel.
I/O: MMIO, Port I/O, DMA & Buses (PCIe)
From the humble IN instruction to multi-gigabyte DMA rings and MSI-X vectors: every mechanism that lets a CPU talk to real hardware, made rigorous.
Multicore, SMP, NUMA & Memory Models
From bare silicon to lock-free algorithms: how multiple cores share memory without chaos, and the formal rules every kernel developer must internalize to write correct concurrent code.
x86-64 Assembly Basics
x86-64 assembly is the raw language your CPU actually speaks — master it and the entire stack from C down to silicon becomes transparent.
ARM / AArch64 Assembly Basics
AArch64 is a clean, regular, load-store RISC architecture that runs the world's mobile and server silicon — learning it unlocks kernel development, compiler output, and correct concurrent programming on modern hardware.
Calling Conventions & ABIs (System V)
The System V AMD64 ABI is the treaty every function call on Linux honors — master it and disassembly becomes a conversation you can read fluently.
Reading Compiler Output (Godbolt)
Learn to read the machine language your compiler writes — and see exactly what it does to your C, your optimizations, and your bugs.
Inline Assembly in C
GCC extended inline assembly is the precise contract language between C code and the CPU, and reading it fluently unlocks the kernel's most performance-critical and architecture-specific internals.
RISC-V Assembly: The Open ISA
RISC-V is the clean, open, royalty-free ISA that finally lets you hold an entire instruction set in your head — and its Linux kernel port is the best place to start reading real architecture-specific kernel code.
What Is an OS? Kernel vs Userspace
The operating system kernel is the single piece of hardware-enforced trusted software that turns raw, dangerous silicon into safe, shared, programmable abstractions — and understanding precisely how it does that is the foundation of all kernel work.
Processes & the Process Model
A process is not a program — it is the living, breathing execution of one, complete with its own memory universe, identity, and a kernel-maintained dossier that makes multitasking possible.
Threads & Concurrency
Threads are the units of execution that share an address space — and that sharing is exactly what makes concurrency both powerful and treacherous.
CPU Scheduling
CPU scheduling is the OS's art of creating the illusion of simultaneous execution by deciding, nanosecond by nanosecond, which process deserves the CPU next — and every design choice is a negotiation between throughput, fairness, and responsiveness.
Inter-Process Communication (IPC)
IPC is the art of breaking process isolation safely — master the six mechanisms, their copy-vs-share tradeoffs, and the kernel machinery underneath, and you will understand how every real Linux system actually communicates.
Synchronization: Locks, Mutexes, Semaphores
Synchronization is the art of making concurrent threads cooperate instead of collide — from atomic hardware primitives all the way to the sleeping abstractions that prevent your OS from corrupting itself.
Deadlock & Race Conditions
Master the two great failure modes of concurrent systems — races and deadlocks — with the formal theory, vivid intuition, and practical tools that every kernel contributor depends on.
Memory Management: Allocation, Paging, Segmentation
From raw RAM to virtual address spaces: how kernels allocate, protect, and lie about memory — and why that lying is the foundation of modern computing.
Virtual Memory, Demand Paging & Page Replacement
Master the elegant illusion of virtual memory: how demand paging, page faults, replacement algorithms, and copy-on-write let every process believe it owns all of RAM.
File Systems Concepts
File systems are the art of imposing persistent, named, hierarchical structure on a block device — and surviving crashes while doing it.
I/O Subsystems & Device Management
The I/O subsystem is the kernel's great equalizer — the layered architecture that makes a keyboard, an NVMe SSD, and a GPU all look like file descriptors to your program.
System Calls & the User/Kernel Boundary
The system call is the only door between your program and the kernel — and understanding exactly how that door works, from the CPU privilege ring to the vDSO fast-path, is the foundation of every kernel contribution you will ever make.
Kernel Architectures: Monolithic vs Microkernel vs Hybrid
The architectural choice of what lives in kernel space defines every security, performance, and reliability tradeoff in any OS — and understanding it makes Linux's design legible.
The Boot Process: Firmware to init
Trace the exact path from electrical power to PID 1 — every stage, every memory address, every handoff — so you understand what the kernel inherits and why it is designed to start from nothing.
Linux History, Philosophy, Distros & Licensing
From a Finnish student's 1991 email to a movement that powers every Android phone, supercomputer, and cloud server: understand how Linux came to be, why it is structured the way it is, and why the license is not a detail but a load-bearing wall.
The Shell & Command-Line Mastery
Master Bash and Unix pipelines — the transparent window into the Linux kernel's process, I/O, and signal abstractions that every kernel developer lives inside.
The Filesystem Hierarchy & Everything Is a File
Linux's most elegant idea: the entire system state — devices, processes, kernel internals — is reachable through a single unified namespace of files you can read, write, and stat with the same five system calls.
Processes & Signals in Linux
Processes are the kernel's atoms of execution — this module teaches you to see them, poke them, signal them, and understand why they sometimes refuse to die.
Users, Permissions & Capabilities
The kernel's identity and permission system: from numeric UIDs to fine-grained capabilities, this is how Linux decides who can do what.
systemd & Init Systems
PID 1 is not just process number one — it is the kernel's handoff point to userspace, and understanding how systemd uses cgroups, socket activation, and structured logging to manage that handoff gives you a complete mental model of a running Linux system.
Linux Networking from Userspace
Master the complete journey of a network packet — from your C program's write() call, through the kernel's TCP/IP stack, across the wire, and back — using real tools, real code, and real kernel internals.
Package Management & Building from Source
Master the full lifecycle of Linux software — from signed package archives through the configure/make dance to hand-building the kernel itself — so no build failure can stop you.
Git Deep: The Kernel's Workflow
Git is not just a version-control tool — it is the kernel community's collaborative nervous system, and understanding its internals transforms you from a user into a power contributor.
GCC & Clang: Compilation Deep Dive
Master GCC and Clang — from source text to optimized machine code — and understand exactly how the Linux kernel is built.
Make & the Kernel Build System (Kbuild/Kconfig)
Master GNU Make from first principles, then climb to the Linux kernel's Kbuild/Kconfig system and build your first kernel image and loadable module from source.
GDB & Kernel Debugging (kgdb/KASAN)
Master the art of interrogating both userspace programs and a live Linux kernel — from GDB's assembly-level superpowers to catching memory bugs mid-flight with KASAN.
The ELF Format & Binary Tools
ELF is the universal language your compiler, linker, loader, and kernel all speak — master it and binaries become transparent.
Linkers & Loaders Deep
From source file to running process: understand how the linker stitches object files together, how the loader maps them into memory, and how the kernel uses linker scripts to build itself.
Tracing & Profiling: ftrace, perf, strace, ltrace
See exactly what your kernel is doing — from individual syscalls to CPU flamegraphs — using the professional tracing tools that Linux developers live inside.
QEMU & Virtualization for Kernel Dev
Master QEMU to build, boot, and debug custom Linux kernels safely — your own pocket lab where crashing the OS is just a restart away.
The Kernel Source Tree Layout
The Linux kernel source tree is a 30-million-line city — this module is your map, compass, and street-level tour guide.
Kernel Coding Style & Conventions
Master the unwritten rules that are actually written down: how the Linux kernel community formats, names, and structures code so patches get merged instead of rejected.
Kernel Data Structures
Master the kernel's intrusive, allocation-free data structure toolkit — from the elegant container_of macro to per-CPU variables — and unlock the ability to read and write any kernel subsystem's object management code.
Kernel Memory: Buddy, Slab, kmalloc/vmalloc
The kernel's memory allocators are a masterpiece of layered engineering — from raw pages to object caches — and understanding them is the foundation of all kernel programming.
Process Management: task_struct, fork, exec
Dissect the task_struct — the kernel's complete dossier on every running thing — and trace how fork, exec, and exit create, transform, and destroy processes at the source-code level.
The Linux Scheduler: CFS, EEVDF & Scheduling Classes
The Linux scheduler is a beautiful piece of engineering that decides, thousands of times per second, which of the thousands of tasks on your machine gets to run — and for exactly how long.
System Call Implementation in the Kernel
Trace a system call from the userspace `syscall` instruction all the way through entry assembly, the dispatch table, SYSCALL_DEFINE macros, argument validation, and back — then add your own.
Interrupt Handling: Top/Bottom Halves, softirqs, workqueues
Master the kernel's interrupt handling split — from hardware signal to deferred bottom half — and write fast, correct, context-aware driver code.
Kernel Synchronization: Spinlocks, RCU, Atomics, Barriers
Kernel synchronization is the art of keeping shared data sane when dozens of CPUs and interrupt handlers all reach for it at once — get it wrong and the kernel silently corrupts itself.
The Virtual File System (VFS) Layer
VFS is Linux's C-based object system for file I/O: four core objects, four vtable structs, and one elegant dispatch layer that lets ext4, NFS, and /proc all answer the same open() call.
The Block Layer & I/O Scheduling
Trace a read() syscall from VFS all the way to hardware, mastering bio structures, blk-mq request queues, and the schedulers that decide what hits the disk next.
The Page Cache & Memory Reclaim
The page cache is Linux's beating heart: it makes your disk feel like RAM, and understanding how it fills, ages, and yields memory under pressure is the key to mastering kernel I/O and memory management.
Networking Stack Internals
Every packet you send travels a precisely engineered path through kernel memory, interrupt handlers, and protocol state machines — understanding this path is understanding how the internet actually works.
Time, Timers & the Kernel
The kernel's relationship with time — from coarse jiffy ticks to nanosecond-precision hrtimers — is what makes scheduling, networking, audio, and real-time systems possible.
Kernel Modules (LKM) Lifecycle
Kernel modules are plug-in extensions for the Linux kernel — this module teaches you their complete lifecycle, from writing and loading to symbol sharing and signed verification.
Kernel Debugging: Oops, Panic & Crash Analysis
Master the full forensic loop: from a raw kernel oops scrolling past on a console to the exact line of C that caused it, using addr2line, kdump, crash, and the kernel's own debugging infrastructure.
The Linux Driver Model
The Linux Driver Model is the elegant object-oriented spine that lets thousands of drivers speak a single language to buses, devices, and the kernel itself.
Character Device Drivers
Build a real character device driver from scratch — mastering the major/minor system, the file_operations vtable, and the kernel/userspace memory boundary that makes Linux drivers both powerful and safe.
Block Device Drivers
Build a working /dev/ block device from scratch by mastering gendisk, blk-mq tag sets, and the complete I/O path from write() to your driver's queue_rq callback.
Platform Devices & the Device Tree
Master the Device Tree and platform driver — the machinery that lets a single Linux kernel binary boot on thousands of different ARM boards without knowing their hardware at compile time.
Interrupt Handling in Drivers
Master the complete lifecycle of a hardware interrupt inside a Linux driver — from the electrical signal to request_irq(), the top/bottom-half split, threaded handlers, and the strict rules of atomic context.
Concurrency & Locking in Drivers
Master the rules that separate correct concurrent driver code from the kind that silently corrupts data, hangs machines, and makes it into CVE advisories.
Accessing Hardware: MMIO & ioremap
Master the kernel's precise contracts for reaching hardware registers and making devices read and write RAM safely — the foundation every real device driver is built on.
Writing Your First Real Driver
Build a complete Linux character driver from zero — probe, sysfs, read/write, ioctl, and testing — and understand exactly why every line exists.
Building, Configuring & Installing a Custom Kernel
From `git clone` to a custom kernel booting on your machine — the complete, expert-level workflow every kernel contributor needs.
Your First Kernel Module: Hello, World
Build, load, debug, and tear down a real Linux kernel module from scratch — no kernel recompile needed.
Kernel Testing: kselftests, KUnit & syzkaller
Master the three-layer kernel testing arsenal — kselftest, KUnit, and syzkaller — and learn to write tests that maintainers trust and fuzzers cannot break.
Static Analysis & Sanitizers: sparse, smatch, KASAN, lockdep
Master the kernel's full checker arsenal — from sparse type annotations to KASAN shadow memory — so your patches arrive already proven correct by the same tools the 0day robot uses.
The Kernel Community & Maintainer Hierarchy
The Linux kernel is governed not by a company org chart but by a living, trust-based network of maintainers — learning to navigate it is the difference between a patch that lands and one that vanishes.
The Patch Workflow: format-patch, send-email, checkpatch
Master the complete patch lifecycle — from a clean commit to a well-formatted, correctly-threaded email series that maintainers will actually read and merge.
Finding Your First Contribution
Find your foothold in the kernel codebase, craft a real patch, and survive the review gauntlet — from first clone to first Signed-off-by.
Reviewing, Feedback & Patch Versions
Master the complete patch review lifecycle: how to respond, revise, version, and attribute so your patches actually land.
The Release Cycle: Merge Window, -rc, linux-next
The Linux kernel's 10-week heartbeat: how 15,000 commits per cycle travel from a contributor's inbox through maintainer trees, linux-next, and Linus's merge window to the kernel your devices run.
DCO, Signed-off-by & Documentation Contributions
The Developer Certificate of Origin is your cryptographic handshake with the Linux community — a legally meaningful promise that lets millions of contributors collaborate without lawyers in the loop.
eBPF: The Programmable Kernel
eBPF turns the Linux kernel into a safely programmable platform — letting you inject verified, JIT-compiled logic into hundreds of kernel hooks without a reboot or a kernel module.
Rust for Linux
Rust is rewriting the rules of kernel development — here is why that matters, how it works, and how you can write your first safe kernel module today.
io_uring: Modern Async I/O
io_uring gives userspace a shared-memory highway into the kernel, eliminating syscall overhead and unifying all async I/O under a single elegant ring-buffer interface.
Kernel Security: KASLR, SMEP/SMAP, Spectre/Meltdown
The kernel is a fortress under constant siege — learn every wall, gate, and tripwire that keeps it standing.
Virtualization & KVM
KVM turns the Linux kernel itself into a hypervisor by exposing the CPU's hardware virtualization extensions, letting you run complete operating systems with near-native speed inside ordinary processes.
Containers from the Kernel's View: Namespaces & cgroups
Containers are not a kernel feature — they're a process dressed in namespaces and constrained by cgroups, and you're going to build one from scratch.
Real-Time Linux (PREEMPT_RT)
PREEMPT_RT transforms Linux from a throughput-optimized OS into a deterministic real-time system by making nearly every kernel code path preemptible and converting interrupt handlers into schedulable threads.
Scheduler Extensibility: sched_ext & BPF Schedulers
sched_ext lets you write a verified-safe Linux scheduler as a BPF program that loads at runtime — no kernel patches, no reboots, no panics, just pure scheduling policy in your hands.
Part II · The CS Core
A full 4-year MIT / Stanford computer-science curriculum.
Mathematics for Computer Science
8 modulesDiscrete math: the logic, proofs and structures all of CS is built on.
Logic & Propositions
Logic is the grammar of precise thought — the formal language that turns vague reasoning into proofs, programs, and verifiable truth.
Proofs & Proof Techniques
Proofs are the language of mathematics — master the core techniques and you gain the power to establish truth with absolute certainty.
Mathematical Induction & Recursion
Induction is the engine that lets finite proofs capture infinite truths — master it, and recursion becomes a superpower.
Sets, Relations & Functions
The bedrock language of all of mathematics and computer science: how to describe collections, relationships, and mappings with precision.
Combinatorics & Counting
Counting is the foundation of algorithm analysis and probability — master these elegant rules and you can measure the size of any universe of possibilities.
Discrete Probability
Master the mathematics of uncertainty — sample spaces through Bayes' theorem, random variables, expectation, and the union bound — the probabilistic toolkit every CS algorithm relies on.
Graph Theory
Graph theory is the mathematics of relationships — it gives you a universal language for modeling networks, circuits, maps, and algorithms, and the tools to reason about them rigorously.
Number Theory for CS
Number theory is the hidden engine of modern cryptography, hashing, and distributed systems — mastering it transforms you from a user of RSA into someone who truly understands why it works.
The continuous math that powers graphics, ML and theory.
Calculus Essentials
Calculus is the mathematics of continuous change — and the hidden engine inside every gradient descent, physics simulation, probability distribution, and rendering algorithm in computer science.
Multivariable Calculus & Gradients
Gradients turn the geometry of multivariable functions into arrows that point uphill — and machine learning runs entirely on following them downhill.
Linear Algebra I: Vectors & Matrices
Vectors and matrices are the universal language of data transformation — master them and you hold the key to machine learning, graphics, physics simulation, and most of modern science.
Linear Algebra II: Eigenvalues & SVD
Eigenvalues and SVD are the X-ray vision of linear algebra — they reveal the hidden skeleton of any linear transformation.
Probability Theory
Probability theory is the mathematical language of uncertainty — the foundation beneath every algorithm that learns, infers, or decides under incomplete information.
Statistics & Inference
Statistics and inference transform raw data into justified beliefs — learning from noise to reason under uncertainty with mathematical precision.
Optimization & Gradient Descent
Optimization and gradient descent: the engine that trains every model you will ever build, rooted in the geometry of functions and the calculus of steepest descent.
Information Theory
Information theory reveals the fundamental limits of compression and communication by quantifying uncertainty as a precise mathematical quantity called entropy.
Programming Abstractions & Paradigms
8 modulesHow to think in abstractions — functional, OOP, interpreters.
Abstraction & Computational Thinking
Abstraction is the single most powerful idea in all of computer science — the art of hiding complexity behind clean interfaces so that each layer of a system can be understood, built, and reasoned about independently.
Recursion & Recursive Data
Recursion is not just a programming trick — it is the natural language of self-referential structure, and mastering it means learning to see problems as they really are.
Higher-Order Functions & Functional Programming
Functions are data too — mastering higher-order functions unlocks a way of thinking that transforms how you design, compose, and reason about programs.
Data Abstraction & Abstract Data Types
Data abstraction is the art of drawing a clean boundary between what a type does and how it does it — the foundational discipline that makes large software possible.
Object-Oriented Programming
Object-Oriented Programming is a paradigm that organizes computation around objects — bundled data and behavior — enabling modularity, reuse, and expressive modeling of complex systems.
Generic Programming & Polymorphism
Generic programming lets you write code that is correct for all types at once — the closest thing computer science has to mathematical universality.
Modularity, State & Environments
Master the environment model of evaluation, closures, and mutable state — the conceptual bedrock that explains how every function, variable, and module in every language actually works.
Building an Interpreter
Build a language from scratch by writing an interpreter that evaluates itself — the metacircular evaluator reveals that a programming language is just a program.
Arrays, Lists, Stacks & Queues
Master the four foundational data structures — arrays, linked lists, stacks, and queues — by understanding WHY each exists and what physical reality of memory makes them tick.
Hash Tables
Hash tables turn arbitrary keys into array indices, achieving average-case O(1) insertion, deletion, and lookup through ingenious randomization and collision management.
Trees & Binary Search Trees
Trees are the data structure that makes the chaos of unordered data navigable in logarithmic time — and understanding why they degrade is the key to mastering every balanced variant that follows.
Balanced Trees: AVL, Red-Black & B-Trees
Balanced trees are the engineering backbone of every database and filesystem — they guarantee O(log n) operations by enforcing geometric height bounds through clever structural invariants and rotations.
Heaps & Priority Queues
Heaps are the elegant data structure that lets you always find the best option in O(1) and maintain order in O(log n) — the secret engine inside every efficient scheduler, shortest-path algorithm, and sorting routine.
Graphs: Representations
Graphs are the universal language of relationships — learn to speak it fluently by mastering the two fundamental ways computers store them.
Tries & String Data Structures
Tries and their cousins turn string search from O(n·m) guesswork into O(m) certainty by encoding the shared structure of a language directly into a tree.
Union-Find & Advanced Structures
Master the four workhorse structures that make seemingly impossible queries run in near-linear time: Union-Find, Segment Trees, Fenwick Trees, and Skip Lists.
Algorithm Analysis & Asymptotics
Algorithm analysis gives you the vocabulary and tools to predict, compare, and reason about the efficiency of any algorithm before running a single line of code.
Sorting Algorithms
From O(n²) intuition to O(n log n) optimality and beyond — a complete, rigorous tour of comparison and non-comparison sorting.
Divide & Conquer
Divide and conquer is the master key that unlocks logarithmic depth in computation — split the problem, solve the pieces, and merge your way to elegance and speed.
Greedy Algorithms
Greedy algorithms commit irrevocably to locally optimal choices — and the art is proving that this audacity is correct.
Dynamic Programming
Dynamic Programming turns exponential brute-force into polynomial elegance by recognizing that the best solution to a big problem is built from the best solutions to smaller, overlapping ones.
Graph Traversal: BFS, DFS & Applications
BFS and DFS are the two fundamental graph exploration strategies — every advanced graph algorithm is built on one of them.
Shortest Paths
Shortest paths reveal how to navigate a weighted world efficiently — from Dijkstra's greedy insight to Bellman-Ford's dynamic programming elegance to A*'s guided search.
Minimum Spanning Trees
Minimum spanning trees reveal the cheapest skeleton hiding inside any weighted graph, and two elegant greedy algorithms — guided by one unifying theorem — find it in near-linear time.
Network Flow
Network flow transforms graph problems into optimization puzzles, revealing deep structural theorems that unite matching, connectivity, and resource allocation under one elegant framework.
NP-Completeness & Reductions
NP-completeness is the mathematical proof that thousands of practical problems are all equally hard — and that cracking one would crack them all.
Randomized & Approximation Algorithms
Randomization and approximation are not signs of weakness — they are the most powerful tools in the algorithm designer's arsenal when exact deterministic solutions are too slow or provably impossible.
String Algorithms
String algorithms reveal how to search, index, and decode sequences at machine speed — the backbone of search engines, compilers, and genomics.
Finite Automata & Regular Languages
Finite automata are the simplest machines that can recognize patterns — and their limits reveal the deepest truths about what computation itself can and cannot do.
Regular Expressions & the Pumping Lemma
Regular expressions and finite automata are two faces of the same coin — the pumping lemma is the scalpel that cuts away everything they cannot describe.
Context-Free Grammars & Pushdown Automata
Context-free grammars and pushdown automata reveal the recursive heart of programming languages — where finite memory meets infinite structure.
Turing Machines & the Church-Turing Thesis
Turing machines define what computation IS — and their most beautiful theorem is a proof that some things can never be computed, by any machine, ever.
Decidability & the Halting Problem
Some problems are mathematically impossible to solve — not hard, not slow, but provably unsolvable by any program that could ever exist.
Reducibility & Undecidability
Reducibility is the universal key that unlocks undecidability: once you know one problem is unsolvable, you can prove infinitely many others are too — and Rice's Theorem shows the entire landscape of program-behavior questions is permanently out of reach.
Time Complexity: P and NP
P vs NP is the deepest unsolved question in computer science: can every problem whose solution is easy to check also be solved efficiently?
NP-Completeness in Depth
NP-completeness reveals the deepest mystery in all of computer science: why some problems seem to resist every clever algorithm ever invented — and why thousands of them all share the same fate.
Space Complexity & Beyond
Space complexity reveals that asking "how much memory does a computation need?" leads to a rich hierarchy rivaling time complexity — and sometimes collapses it in surprising ways.
Syntax, Semantics & the Lambda Calculus
Lambda calculus is the 50-line mathematical model that secretly IS every functional programming language — master it and you understand the foundations of Haskell, ML, Scheme, and the type-theoretic universe.
Operational & Denotational Semantics
Formal semantics gives programs unambiguous mathematical meaning — making compilers, verifiers, and type systems provably correct.
Type Systems & Type Checking
Type systems are the mathematical discipline of classifying program expressions so that a compiler can prove, before running a single line, that certain classes of runtime errors simply cannot happen.
Polymorphism & Type Inference
Polymorphism and type inference reveal how a language can be simultaneously flexible and safe — writing one function that works for all types while a compiler proves it correct without a single annotation.
Advanced Type Features
From simple tags to proofs-as-programs: master the type-level abstractions that make compilers your ally instead of your enemy.
Memory Management & Garbage Collection
From malloc/free to generational GC to Rust's borrow checker — every strategy for who controls memory, how it works under the hood, and what guarantees it buys you.
Concurrency Models
Master the five major models for managing concurrent computation — shared memory, CSP, actors, STM, and async/await — understanding not just their mechanics but the deep tradeoffs that determine which model belongs in which system.
Paradigms & Metaprogramming
From Turing machines to Lisp macros: how the way you think about computation shapes the programs you can write — and the languages you can build.
The Anatomy of a Compiler
A compiler is not magic — it is a sequence of elegant, well-defined transformations that carry source text all the way to running machine code, and understanding each phase makes you a better programmer forever.
Lexical Analysis
Lexical analysis transforms raw source text into a structured stream of tokens by formalizing the language of valid words as regular expressions, then mechanically constructing recognizers via NFA-to-DFA conversion.
Parsing: Top-Down
Top-down parsing turns a context-free grammar into a working parser by predicting, from the current token alone, exactly which production rule to apply — no backtracking required.
Parsing: Bottom-Up
Bottom-up parsing transforms flat token streams into parse trees by building meaning from the leaves up, using a stack-driven automaton whose power scales from LR(0) to the full LR(1) hierarchy.
Abstract Syntax Trees & Semantic Analysis
ASTs are the moment source code becomes a data structure your compiler can reason about — semantic analysis is where that data structure learns what the program means.
Type Checking & Inference in Compilers
Type checking is the compiler's built-in proof system — a static guardian that catches whole classes of bugs before a single instruction executes.
Intermediate Representations
Intermediate Representations are the universal language compilers use to analyze, optimize, and translate programs — the crucial bridge between source code and machine reality.
Code Generation & Register Allocation
Transform the abstract syntax tree into real machine instructions — navigating the gap between infinite virtual registers and the brutal reality of a finite CPU.
Optimization
Compilers don't just translate code — they transform it into something faster, smaller, and smarter than any human would write by hand.
The Relational Model
The relational model is the mathematical foundation — based on set theory and first-order logic — that makes every SQL database provably correct and query-optimizable.
SQL in Depth
SQL is the declarative language that lets you say *what* data you want and trust the database engine to figure out *how* to retrieve it — mastering it means mastering set theory, relational algebra, and the art of composable queries.
Database Design & Normalization
Master the art of organizing data so it stays consistent, queryable, and free of the hidden redundancy bugs that corrupt real systems.
Storage & Indexing
From spinning-disk physics to B+ tree surgery — master how databases actually store, find, and serve billions of rows at hardware speed.
Query Processing & Optimization
Query optimization is the art of automatically turning a declarative SQL statement into the fastest possible execution plan — the engine's brain that separates toy databases from industrial ones.
Transactions & ACID
Transactions give databases a superpower: all-or-nothing bundles of operations that survive crashes and concurrent chaos — the bedrock of every financial, medical, and social system on earth.
Concurrency Control
Concurrency control is the art of letting many transactions run simultaneously while making the database behave as if they ran one at a time.
Recovery & Durability
ARIES and write-ahead logging: how databases survive crashes and guarantee that committed transactions are never lost, no matter what fails.
Distributed & NoSQL Databases
Distributed and NoSQL databases let you trade some guarantees for massive scale — understanding exactly what you give up, and when it is worth it, is the art.
The Internet & Layered Architecture
The Internet is an impossibly complex system made tractable by one elegant idea: layered abstraction that separates policy from mechanism at every level.
The Link Layer & Ethernet
The link layer is where bits on a wire become reliable hops between neighbors — framing, addressing, and arbitration are the invisible contract every Ethernet frame silently enforces.
The Network Layer & IP Routing
The network layer is the global addressing and routing fabric that makes the internet one logical network out of millions of heterogeneous physical ones.
The Transport Layer: TCP & UDP
TCP and UDP are the two workhorses of the internet's transport layer — one promises every byte arrives in order, the other gets out of the way and lets you move fast.
Congestion Control
Congestion control is the distributed algorithm that prevents the internet from collapsing under its own traffic — TCP's self-imposed braking system that makes global fairness emerge from purely local decisions.
The Application Layer: DNS & HTTP
From typing a URL to getting a webpage: master DNS resolution, HTTP evolution, and the application-layer protocols that power the entire web.
Network Security: TLS & Beyond
TLS, PKI, and the full network-security stack — from wire-level attacks to the cryptographic handshake that protects every HTTPS connection you've ever made.
Modern Networking
From radio waves to globally distributed software — how modern networking transcends the wire.
Why Distributed Systems Are Hard
Distributed systems fail in ways that single machines never do — understanding why is the foundation of every reliable system at scale.
Communication & RPC
Remote Procedure Calls bridge the illusion of local function calls across unreliable networks, demanding precise contracts for serialization, failure semantics, and delivery guarantees.
Time, Clocks & Ordering
Time is not global in distributed systems — logical clocks give us the only ordering that actually matters: causality.
Replication & Consistency Models
Replication is the art of keeping multiple copies of data consistent — a battle between availability and truth that shapes every distributed system you will ever build.
Consensus: Paxos & Raft
Consensus algorithms let a cluster of unreliable machines agree on a single value — reliably — even when nodes crash and messages get lost.
Distributed Transactions
Distributed transactions reveal the fundamental tension between correctness and availability: making multiple nodes agree is possible, but never free.
The CAP Theorem & Tradeoffs
The CAP theorem is not a choice between three properties but a precise mathematical statement about what distributed systems can guarantee when the network betrays you.
MapReduce & Large-Scale Data
MapReduce and large-scale data processing: how Google, Hadoop, and Spark turned petabyte problems into embarrassingly parallel ones you can solve with a few hundred lines of code.
Fault Tolerance & Reliability
Fault tolerance is the art of building systems that keep their promises even when the world actively tries to break them.
Intelligent Agents & Problem Formulation
AI is the science of building agents that perceive the world and act rationally to achieve goals — and this module shows you exactly how to think about that, rigorously.
Uninformed & Informed Search
Master the art of navigating state spaces — from blind BFS/DFS through the elegant optimality guarantees of A* — and understand exactly why and when each algorithm finds the shortest path.
Adversarial Search & Games
From tic-tac-toe to chess engines: how adversarial search turns combinatorial game trees into optimal decisions through minimax, alpha-beta pruning, and probabilistic rollouts.
Constraint Satisfaction Problems
Constraint Satisfaction Problems transform combinatorial puzzles into a structured search through variable assignments, where smart propagation and ordering can slash exponential costs to near-linear.
Logic & Knowledge Representation
Logic gives AI a language for thought — first-order logic, resolution, and knowledge bases are the bedrock on which machines can reason, prove, and know.
Planning
Classical planning transforms the dream of "act rationally toward goals" into precise algorithms — turning goal-directed intelligence from philosophy into computable reality.
Probabilistic Reasoning & Bayesian Networks
Master the mathematics of belief under uncertainty — Bayesian networks, exact and approximate inference, hidden Markov models, and Kalman filters — the probabilistic backbone of every serious AI system.
Markov Decision Processes
MDPs give you the mathematical language to turn "act wisely under uncertainty over time" into a precise optimization problem — and solve it exactly.
Foundations of Machine Learning
Machine learning teaches computers to improve from experience — turning raw data into generalizing functions without being explicitly programmed for every case.
Linear & Logistic Regression
From scatter plots to decision boundaries: the geometric and probabilistic foundations that underpin nearly every supervised learning system ever built.
Bias-Variance & Regularization
Master the fundamental tension in all of machine learning: models that memorize versus models that generalize, and the elegant mathematical tools that navigate between them.
Support Vector Machines & Kernels
SVMs find the widest possible street between classes, then use the kernel trick to bend that street through curved, high-dimensional space — giving you a provably optimal linear classifier that secretly solves nonlinear problems.
Decision Trees & Ensembles
From a single question at the root to a forest of millions of trees — decision trees and ensembles transform greedy splits and Shannon entropy into the most practical and powerful models in modern machine learning.
Unsupervised Learning
Unsupervised learning discovers hidden structure in unlabeled data — clustering, density estimation, and dimensionality reduction are its core instruments.
Neural Networks & Backpropagation
Neural networks learn by composing simple units into deep hierarchies, then flowing error signals backward through the chain rule to sculpt every weight toward better predictions.
Evaluation & ML in Practice
Learn to measure what actually matters: the art and science of honestly evaluating whether your model is learning or just memorizing.
Deep Networks & Optimization
Master the engineering that makes deep networks trainable: why depth wins, why gradients die or explode, and the precise algorithms (He init, BatchNorm, Dropout, Adam) that solved each problem.
Convolutional Neural Networks
Convolutional Neural Networks exploit the spatial structure of images through local receptive fields, weight sharing, and hierarchical feature extraction — turning raw pixels into rich representations.
Sequence Models & RNNs
Recurrent neural networks model sequences by threading hidden state through time — and every modern language model traces its lineage through the LSTM's elegant solution to vanishing gradients.
Attention & Transformers
Attention is all you need: how a simple query-key-value lookup revolutionized sequence modeling and became the backbone of every frontier AI system.
Large Language Models
From raw text to world-knowledge engines: how GPT-scale transformers are pretrained, scaled, and aligned into the language models that are reshaping computing.
Generative Models
Generative models teach machines to imagine — from encoding latent structure in VAEs to adversarial games in GANs to denoising diffusion that sculpts images from pure noise.
Reinforcement Learning
Reinforcement learning is the mathematics of learning by doing — an agent discovers optimal behavior through trial, error, and reward signals, from Atari games to Go to robotic locomotion.
Embeddings & Representation Learning
Embeddings transform raw tokens into geometry where meaning becomes distance — the foundational trick behind every modern AI system.
Security Principles & Threat Modeling
Security is not a feature you bolt on — it is a mindset you build in from the first line of design.
Symmetric Cryptography
Symmetric cryptography is the art of scrambling data so thoroughly that only someone with the secret key can unscramble it — the bedrock of every encrypted connection on earth.
Public-Key Cryptography
Public-key cryptography solves the ancient key distribution problem by exploiting mathematical trapdoors — functions easy to compute but computationally infeasible to reverse without secret information.
Hashing, MACs & Digital Signatures
Build the rigorous foundation of modern security: from one-way hash functions through MACs to digital signatures and the PKI chain of trust that secures every HTTPS connection.
Software Security & Exploitation
Master the attacker's playbook — buffer overflows, ROP chains, and integer bugs — then understand every defensive layer that modern systems deploy to stop them.
Web Security
Web security is the art of defending stateful, multi-party HTTP applications against adversaries who control user input, network traffic, and the browser itself.
Network & Systems Security
From TLS handshakes to sandboxed processes, learn how real systems defend themselves — and why defenders must be right every time while attackers need to be right only once.
Privacy & Modern Cryptography
Modern cryptography gives us mathematical superpowers: you can prove you know a secret without revealing it, compute on data you cannot see, and browse the web without anyone knowing where you went.
The Graphics Pipeline & Rasterization
Transform a scene full of 3D triangles into pixels on a screen — understanding every mathematical step the GPU takes, from model coordinates to final color.
Transformations & Homogeneous Coordinates
Homogeneous coordinates are the algebraic sleight-of-hand that lets a single 4×4 matrix unify translation, rotation, scale, and perspective projection into one composable operation — the mathematical backbone of every 3D renderer ever built.
Lighting, Shading & Materials
From photons to pixels: master the physics of light transport, build Phong's elegant reflection model, and understand why shading algorithms are the soul of 3D rendering.
Ray Tracing & Global Illumination
Ray tracing simulates light transport physically, casting rays from the camera into a scene and recursively tracing reflections, refractions, and shadows to render photorealistic images from first principles.
Geometry: Curves, Surfaces & Meshes
From a triangle soup to smooth surfaces: master the mathematical machinery that lets computers model, deform, and render any shape in 3D.
Image Processing Fundamentals
Master the mathematics of pixels: learn how convolution, Fourier analysis, and filtering give computers the ability to see edges, blur noise, and understand images.
Computer Vision
Computer vision teaches machines to see: from handcrafted edge detectors and keypoint descriptors to deep networks that surpass human accuracy on recognition benchmarks.
Animation & Physical Simulation
From a single keyframe to a living world: the mathematics and algorithms that bring motion, flesh, and physics to digital life.
Software Design Principles
Master the timeless principles — cohesion, coupling, SOLID, information hiding, and modularity — that transform a tangle of code into a system that stays comprehensible and changeable as it grows.
Specifications, Abstraction & Invariants
Specifications, abstraction functions, and representation invariants are the invisible contracts that let you build complex software from trustworthy components — they are how professionals tame complexity.
Testing & Test-Driven Development
Testing is not just checking if code works — it is a formal discipline for specifying behavior, preventing regression, and building systems you can trust to change.
Design Patterns
The 23 Gang of Four design patterns are the shared vocabulary of professional software engineering — named, reusable solutions to recurring design problems that embody decades of wisdom about making code flexible, testable, and maintainable.
Version Control & Collaboration
Master the distributed snapshot system that powers collaborative software engineering — from the Merkle DAG under Git's hood to branching strategies, code review culture, and CI/CD pipelines that keep teams of hundreds moving fast without breaking things.
Concurrency & Parallelism in Software
Master the art of making programs do many things at once — safely, efficiently, and without losing your mind to data races and deadlocks.
System Design & Scalability
System design is the art of building software that survives contact with reality — millions of users, hardware failures, and the relentless entropy of distributed systems.
Software Architecture & APIs
How to organize large software systems so they can grow, change, and survive contact with reality — from layered monoliths to microservices, and from REST APIs to GraphQL.
Human-Computer Interaction
HCI is the discipline that makes computers serve humans — not the other way around — by grounding design in psychology, empirical testing, and iterative refinement.
Interface & Interaction Design
Interface and interaction design is the art and science of shaping the gap between human intention and machine response — making complex systems feel obvious.
Accessibility & Inclusive Design
Accessibility is a correctness property of software: a system that excludes users with disabilities is a system with bugs, not a system lacking features.
Computer Ethics & Society
Computing shapes society at every level — understanding your ethical obligations as an engineer is not optional, it is the difference between building tools that liberate and ones that harm.
AI Ethics, Privacy & Data
AI systems encode the values of their creators — this module teaches you to see those values, interrogate them, and build more just systems.
The Practice of Computing as a Career
From paper to pull request to paycheck: a rigorous map of how CS knowledge is created, shared, and turned into a career.
262modules between you and Ring 0.
The kernel is just C, patience, and a thousand small ideas you can actually learn. Start at the very beginning.
Start with module 01 →