ROADMAP.md

Roadmap

Status tracker for every phase and lesson. The status glyphs in this file feed the website (site/build.js parses them into site/data.js); do not change their shape.

Total: 421 lessons across 20 phases, ~706 hours at your own pace.

Legend: ✅ Complete  ·  🚧 In Progress  ·  ⬚ Planned

Phase 0: Setup & Tooling — ✅ (~13 hours)

#	Lesson	Status	Est.
01	The CS Toolchain — What You'll Install and Why	✅	~45 min
02	Terminal, Shell, Pipes, Job Control	✅	~60 min
03	Git Deep — Internals, Refs, Rebase, Bisect	✅	~90 min
04	C/C++ Toolchain — gcc, clang, ld, ar, make	✅	~75 min
05	Rust Toolchain — cargo, rustup, build profiles	✅	~60 min
06	Build Systems — Make, CMake, Bazel, Cargo	✅	~75 min
07	Debuggers — gdb, lldb, rust-gdb, core dumps	✅	~75 min
08	Profilers — perf, valgrind, instruments, flamegraphs	✅	~75 min
09	Editor Setup — Neovim/VS Code with LSP, DAP	✅	~60 min
10	Linux for Builders — proc, sys, cgroups, namespaces	✅	~75 min
11	Docker & Devcontainers for CS Work	✅	~60 min
12	Documentation & Diagrams — Markdown, Mermaid, plantuml	✅	~45 min

Phase 1: Discrete Math & Logic Foundations — ✅ (~25 hours)

#	Lesson	Status	Est.
01	Propositional Logic & Truth Tables	✅	~45 min
02	Predicate Logic & Quantifiers	✅	~60 min
03	Proof Techniques — Direct, Contradiction, Induction	✅	~75 min
04	Sets, Relations, Functions	✅	~60 min
05	Equivalence Relations & Partitions	✅	~45 min
06	Partial Orders, Lattices, Hasse Diagrams	✅	~60 min
07	Cardinality, Countability, Diagonalization	✅	~60 min
08	Combinatorics — Counting, Permutations, Combinations	✅	~75 min
09	Pigeonhole, Inclusion-Exclusion, Catalan	✅	~60 min
10	Generating Functions	✅	~75 min
11	Recurrence Relations & the Master Theorem	✅	~75 min
12	Asymptotic Notation — Big-O, Θ, Ω, o, ω	✅	~60 min
13	Number Theory — Divisibility, GCD, Bezout	✅	~60 min
14	Modular Arithmetic & Fermat / Euler	✅	~60 min
15	Primes, Sieves, Primality Tests	✅	~75 min
16	Boolean Algebra & Karnaugh Maps	✅	~60 min
17	Graph Theory I — Basics, Traversals, Trees	✅	~75 min
18	Graph Theory II — Coloring, Matching, Planarity	✅	~75 min
19	Discrete Probability & Expectation	✅	~60 min
20	Markov Chains & Random Walks (Discrete)	✅	~60 min
21	Information & Coding Theory (Discrete)	✅	~60 min
22	Phase Capstone — A Proof Companion CLI	✅	~90 min
23	Linear Algebra Foundations	✅	~90 min
24	Calculus and Continuous Math	✅	~90 min

Phase 2: Programming Foundations & Memory Model — ✅ (~20 hours)

#	Lesson	Status	Est.
01	What Is a Program, Really (Compilation, Linking, Loading)	✅	~60 min
02	Values, Types, Variables, Scope	✅	~45 min
03	Control Flow — Branches, Loops, Recursion	✅	~60 min
04	Functions, the Stack, and Calling Conventions	✅	~75 min
05	Pointers, Addresses, and Indirection (in C)	✅	~75 min
06	The Heap — malloc, free, fragmentation	✅	~75 min
07	Arrays, Strings, and Bounds	✅	~60 min
08	Structs, Unions, Bitfields, Alignment	✅	~60 min
09	Errors — Returns, errno, exceptions, Result types	✅	~60 min
10	Ownership and Borrowing — the Rust model	✅	~75 min
11	Lifetimes, References, RAII	✅	~75 min
12	Generics, Traits, Polymorphism	✅	~75 min
13	Modules, Packages, Linkage	✅	~45 min
14	The Preprocessor and Macros (C, Rust)	✅	~45 min
15	Build a Pool Allocator (from scratch in C)	✅	~90 min
16	Build a Bump and Arena Allocator (in Rust)	✅	~90 min
17	Defensive Programming — Asserts, Invariants, ASAN/UBSAN	✅	~60 min
18	Phase Capstone — A Tiny Manual-Memory Library	✅	~75 min

Phase 3: Data Structures — ✅ (~30 hours)

#	Lesson	Status	Est.
01	Arrays & Dynamic Arrays (amortized analysis)	✅	~60 min
02	Singly and Doubly Linked Lists	✅	~60 min
03	Stacks & Queues (array and list backings)	✅	~45 min
04	Deques, Ring Buffers, Circular Queues	✅	~60 min
05	Hash Tables — Open Addressing vs Chaining	✅	~90 min
06	Hash Function Design — Universal, Tabulation, SipHash	✅	~75 min
07	Binary Trees — Traversal and Recursion Patterns	✅	~60 min
08	Binary Search Trees & Rotations	✅	~75 min
09	AVL Trees	✅	~75 min
10	Red-Black Trees	✅	~90 min
11	Splay Trees & Treaps	✅	~75 min
12	B-Trees and B+-Trees	✅	~90 min
13	Heaps & Priority Queues (binary, Fibonacci, pairing)	✅	~75 min
14	Tries and Radix Trees	✅	~75 min
15	Suffix Trees and Suffix Arrays	✅	~90 min
16	Disjoint Set Union (Union-Find)	✅	~60 min
17	Segment Trees & Fenwick (BIT)	✅	~90 min
18	Sparse Tables & RMQ	✅	~60 min
19	Skip Lists	✅	~60 min
20	Bloom Filters, Cuckoo Filters, Count-Min Sketch	✅	~75 min
21	LSM Trees and Write-Optimized Structures	✅	~75 min
22	Persistent / Immutable Data Structures	✅	~75 min
23	Graphs — Representations and APIs	✅	~60 min
24	Concurrent Data Structures Preview (Treiber stack, MS queue)	✅	~75 min
25	Phase Capstone — A Generic DS Library in Rust with Invariants	✅	~120 min

Phase 4: Algorithms & Complexity Analysis — ✅ (~37 hours)

#	Lesson	Status	Est.
01	Analyzing Algorithms — Recurrences, Master Theorem in Action	✅	~60 min
02	Sorting I — Insertion, Selection, Bubble, and Why They Lose	✅	~45 min
03	Sorting II — Merge, Quick (and Quickselect)	✅	~75 min
04	Sorting III — Heap, Intro, Tim	✅	~75 min
05	Sorting IV — Linear-Time: Counting, Radix, Bucket	✅	~60 min
06	Searching — Binary, Exponential, Ternary, Interpolation	✅	~60 min
07	Divide & Conquer Patterns	✅	~60 min
08	Dynamic Programming I — 1D, Memoization, Tabulation	✅	~75 min
09	Dynamic Programming II — 2D and Beyond	✅	~75 min
10	DP III — Bitmask, Digit, Tree, DP on DAGs	✅	~90 min
11	Greedy Algorithms & Matroids	✅	~75 min
12	Backtracking, Branch & Bound	✅	~75 min
13	Graph Algorithms I — BFS, DFS, Topo, SCC	✅	~75 min
14	Graph Algorithms II — Dijkstra, Bellman-Ford, A*	✅	~75 min
15	Graph Algorithms III — Floyd-Warshall, Johnson, APSP	✅	~60 min
16	Minimum Spanning Trees — Prim, Kruskal, Borůvka	✅	~60 min
17	Network Flow — Ford-Fulkerson, Edmonds-Karp, Dinic	✅	~90 min
18	Matching — Bipartite, Hopcroft-Karp, Hungarian	✅	~75 min
19	String Matching — KMP, Z, Boyer-Moore	✅	~75 min
20	Suffix Structures in Action — Aho-Corasick, LCP	✅	~75 min
21	Hashing in Algorithms — Rabin-Karp, Rolling Hashes	✅	~60 min
22	Computational Geometry I — Convex Hull, Sweep Line	✅	~75 min
23	Computational Geometry II — kd-Tree, R-Tree, Range Query	✅	~75 min
24	Randomized Algorithms — Las Vegas vs Monte Carlo	✅	~60 min
25	Approximation Algorithms — Vertex Cover, TSP, Set Cover	✅	~75 min
26	Online Algorithms & Competitive Analysis	✅	~60 min
27	Streaming Algorithms — Frequency, Quantiles, HyperLogLog	✅	~75 min
28	Parallel Algorithms — PRAM, Brent, Map-Reduce style	✅	~75 min
29	Amortized Analysis Deep — Aggregate, Accounting, Potential	✅	~60 min
30	Phase Capstone — Algorithm Cookbook + Benchmark Harness	✅	~120 min
31	Numerical Methods and Scientific Computing	✅	~90 min

Phase 5: Theory of Computation — ✅ (~20 hours)

#	Lesson	Status	Est.
01	What Counts as Computation?	✅	~45 min
02	Finite Automata — DFAs	✅	~60 min
03	NFAs and Subset Construction	✅	~60 min
04	Regular Expressions ↔ Automata	✅	~75 min
05	Build a Regex Engine (Thompson construction)	✅	~90 min
06	Pumping Lemma for Regular Languages	✅	~45 min
07	Context-Free Grammars	✅	~60 min
08	Pushdown Automata & CFG Equivalence	✅	~75 min
09	Chomsky and Greibach Normal Forms	✅	~60 min
10	Parsing Theory — CYK and Earley	✅	~75 min
11	Turing Machines & Variants	✅	~75 min
12	Build a Turing Machine Simulator	✅	~75 min
13	Decidability and the Halting Problem	✅	~60 min
14	Rice's Theorem & Undecidable Properties	✅	~60 min
15	Time Complexity Classes — P, NP, EXP	✅	~60 min
16	NP-Completeness — Cook-Levin and Reductions	✅	~90 min
17	Space Complexity — L, NL, PSPACE, Savitch	✅	~75 min
18	Phase Capstone — A Toy Proof Assistant for Reductions	✅	~90 min

Phase 6: Digital Logic & Computer Architecture — ✅ (~28 hours)

#	Lesson	Status	Est.
01	Bits, Bytes, Two's Complement, IEEE 754	✅	~60 min
02	Transistors → Logic Gates	✅	~60 min
03	Combinational Logic — Adders, Mux, Decoders	✅	~75 min
04	Sequential Logic — Latches, Flip-Flops, FSMs	✅	~75 min
05	Build an ALU in HDL	✅	~90 min
06	Registers, Register Files, Memory Banks	✅	~60 min
07	The Datapath — Single-Cycle CPU	✅	~90 min
08	Control Unit — Microcoded vs Hardwired	✅	~75 min
09	ISA Design — RISC vs CISC, RISC-V Tour	✅	~60 min
10	RISC-V Assembly — Hands-On	✅	~75 min
11	Pipelining — 5-Stage, Hazards, Forwarding	✅	~90 min
12	Branch Prediction — Static, Dynamic, Tournament	✅	~75 min
13	Out-of-Order Execution & Tomasulo	✅	~90 min
14	Memory Hierarchy — Cache Mapping & Coherence	✅	~90 min
15	Cache Performance — Locality, Blocking, Prefetch	✅	~75 min
16	Virtual Memory — TLB, Page Tables, MMU	✅	~75 min
17	I/O — DMA, MMIO, Interrupts	✅	~60 min
18	SIMD & Vector ISAs — AVX, SVE, RVV	✅	~75 min
19	GPU Architecture — SIMT, Warps, Memory Hierarchy	✅	~75 min
20	Modern Microarchitecture Tour (Apple Silicon, AMD Zen)	✅	~60 min
21	Power, Heat, Reliability — Why Cores Stopped Scaling	✅	~45 min
22	Phase Capstone — A 5-Stage Pipelined RISC-V CPU in HDL	✅	~150 min

Phase 7: Operating Systems — ✅ (~30 hours)

#	Lesson	Status	Est.
01	What an OS Actually Does (and Doesn't)	✅	~45 min
02	The Boot Process — BIOS, UEFI, GRUB	✅	~60 min
03	Hello World as a Bootloader (in asm + C)	✅	~90 min
04	Privilege Modes, Traps, and System Calls	✅	~75 min
05	Processes — fork, exec, wait	✅	~75 min
06	Threads, TLS, Context Switching	✅	~75 min
07	Scheduling — FCFS, RR, MLFQ, CFS, EDF	✅	~90 min
08	Virtual Memory in the OS — Demand Paging	✅	~75 min
09	Page Replacement — LRU, Clock, ARC	✅	~60 min
10	The Kernel Heap — slab and slub allocators	✅	~75 min
11	File Systems I — VFS, inodes, journaling	✅	~90 min
12	File Systems II — ext4, btrfs, ZFS deep cuts	✅	~75 min
13	I/O Architecture — Block, Char, syscalls, vfs	✅	~60 min
14	Synchronization in the Kernel — Spinlocks, RCU	✅	~75 min
15	Deadlock — Detection, Prevention, Avoidance	✅	~60 min
16	IPC — Pipes, FIFOs, Shared Memory, sockets	✅	~75 min
17	Signals — Delivery, Handling, Pitfalls	✅	~60 min
18	Devices and Drivers — Char, Block, Net	✅	~75 min
19	Containers — namespaces, cgroups, seccomp	✅	~75 min
20	Virtualization — Type 1/2 Hypervisors, KVM	✅	~75 min
21	Microkernels and Unikernels	✅	~60 min
22	Real-Time and Embedded OS	✅	~60 min
23	Linux Internals Tour — The Source Tree	✅	~75 min
24	Phase Capstone — 'nanos': A Bootable Mini-Kernel	✅	~180 min

Phase 8: Compilers & Programming Language Design — ✅ (~29 hours)

#	Lesson	Status	Est.
01	The Compilation Pipeline — End to End	✅	~45 min
02	Lexing I — Regex → DFA → Lexer	✅	~75 min
03	Lexing II — Hand-Written Scanners	✅	~60 min
04	Parsing I — Recursive Descent	✅	~75 min
05	Parsing II — LL(1), Predictive Tables	✅	~75 min
06	Parsing III — LR, SLR, LALR, GLR	✅	~90 min
07	PEG Parsers and Packrat	✅	~60 min
08	Parser Generators (yacc/bison/lalrpop/tree-sitter)	✅	~60 min
09	AST Design and Visitor Patterns	✅	~60 min
10	Semantic Analysis — Symbol Tables, Scopes	✅	~75 min
11	Type Checking — Mono, Sub, Inference (HM)	✅	~90 min
12	Intermediate Representation — Three-Address Code	✅	~75 min
13	SSA Form — Construction and Dominance	✅	~90 min
14	Classic Optimizations — DCE, CSE, Inlining, LICM	✅	~90 min
15	Loop Optimization & Vectorization	✅	~75 min
16	Register Allocation — Linear Scan vs Graph Coloring	✅	~90 min
17	Code Generation — Instruction Selection, Scheduling	✅	~75 min
18	Linkers and Loaders	✅	~60 min
19	Garbage Collection — Mark-Sweep, Copying, Generational	✅	~90 min
20	JIT Compilation — V8, JVM, LuaJIT principles	✅	~75 min
21	LLVM in Practice — IR, Passes, Backends	✅	~75 min
22	Phase Capstone — A Self-Hosting Compiler	✅	~180 min

Phase 9: Computer Networks — ✅ (~27 hours)

#	Lesson	Status	Est.
01	The Stack — Why Layers (OSI vs TCP/IP)	✅	~45 min
02	Physical & Link Layers — Ethernet, MAC, ARP	✅	~60 min
03	Network Layer — IPv4, IPv6, Subnetting, CIDR	✅	~75 min
04	Routing I — Static, Distance Vector	✅	~60 min
05	Routing II — Link State (OSPF), BGP	✅	~75 min
06	NAT, ICMP, DHCP, IPAM	✅	~60 min
07	Transport — UDP, TCP State Machine	✅	~90 min
08	TCP Congestion Control — Reno, CUBIC, BBR	✅	~75 min
09	QUIC and HTTP/3	✅	~75 min
10	Sockets API — Build a TCP Echo Server	✅	~75 min
11	Build a userspace TCP/IP stack (toy)	✅	~120 min
12	DNS — Resolvers, Records, DNSSEC	✅	~75 min
13	HTTP/1.1, HTTP/2 — Wire Format and Multiplexing	✅	~75 min
14	TLS in the Network Course (Handshake Overview)	✅	~60 min
15	WebSockets, SSE, gRPC	✅	~60 min
16	Firewalls, NAT Traversal, STUN/TURN/ICE	✅	~60 min
17	CDNs and Anycast	✅	~60 min
18	Load Balancers — L4 vs L7, Algorithms	✅	~60 min
19	P2P Networks — Kademlia, BitTorrent	✅	~75 min
20	Software-Defined Networking & eBPF	✅	~75 min
21	Network Programming in Rust (async + tokio)	✅	~75 min
22	Phase Capstone — An HTTP/2 Server on a Custom TCP Stack	✅	~150 min

Phase 10: Databases & Storage Systems — ✅ (~29 hours)

#	Lesson	Status	Est.
01	What a Database Actually Is	✅	~45 min
02	The Relational Model & Relational Algebra	✅	~75 min
03	SQL — DDL, DML, Joins, Subqueries	✅	~75 min
04	Normalization 1NF → BCNF (and 4NF)	✅	~75 min
05	Physical Storage — Pages, Slotted Pages	✅	~60 min
06	Buffer Pool Management & Replacement	✅	~75 min
07	Indexing — B+ Trees in DBs	✅	~90 min
08	Indexing — Hash, Bitmap, GiST	✅	~60 min
09	LSM-Tree Storage Engines (LevelDB/RocksDB style)	✅	~90 min
10	Query Execution — Iterator vs Vectorized	✅	~75 min
11	Join Algorithms — Nested Loop, Hash, Sort-Merge	✅	~75 min
12	Query Optimization — Plans, Cost, Cardinality	✅	~90 min
13	Transactions — ACID, Anomalies	✅	~75 min
14	Isolation Levels — Read Committed → Serializable	✅	~75 min
15	Concurrency Control — 2PL, OCC, MVCC	✅	~90 min
16	Recovery — WAL, ARIES	✅	~90 min
17	NoSQL — KV, Document, Wide-Column, Graph	✅	~60 min
18	Distributed DBs — Sharding, Replication, Spanner	✅	~75 min
19	Columnar Storage & OLAP — Parquet, DuckDB	✅	~75 min
20	Vector Databases — HNSW, IVF, PQ	✅	~75 min
21	Time-Series and Event-Sourced Stores	✅	~60 min
22	Phase Capstone — Build an MVCC KV Store with a SQL Frontend	✅	~180 min

Phase 11: Distributed Systems — ✅ (~28 hours)

#	Lesson	Status	Est.
01	What Distribution Costs You	✅	~45 min
02	Failure Models — Crash, Omission, Byzantine	✅	~60 min
03	Time — Physical, Logical, Lamport Clocks	✅	~75 min
04	Vector Clocks and Causal Order	✅	~75 min
05	The FLP Impossibility Result	✅	~60 min
06	CAP and PACELC — Read Honestly	✅	~60 min
07	Consensus I — Paxos (Single-Decree)	✅	~90 min
08	Consensus II — Multi-Paxos and Variants	✅	~75 min
09	Consensus III — Raft (with a working implementation)	✅	~120 min
10	Replication — Leader/Follower, Quorum	✅	~75 min
11	Eventual Consistency & Read-Repair	✅	~60 min
12	CRDTs — Counters, Sets, Sequences	✅	~90 min
13	Gossip Protocols & SWIM	✅	~60 min
14	Distributed Transactions — 2PC, 3PC, Sagas	✅	~90 min
15	Distributed File Systems — GFS, HDFS	✅	~75 min
16	MapReduce, Spark, Dataflow	✅	~75 min
17	Service Discovery, Membership, Leader Election	✅	~60 min
18	Distributed Caches — Memcached, Redis, consistent hashing	✅	~60 min
19	Message Queues & Streams — Kafka, NATS	✅	~75 min
20	Microservices vs Monolith — Real Trade-offs	✅	~60 min
21	Observability — Metrics, Traces, Logs in Distributed Systems	✅	~60 min
22	Phase Capstone — A Raft-Replicated KV Store with Snapshotting	✅	~180 min

Phase 12: Cryptography & Security — ✅ (~30 hours)

#	Lesson	Status	Est.
01	What Cryptography Actually Promises	✅	~45 min
02	Classical Ciphers and Why They Fail	✅	~45 min
03	Symmetric I — Stream Ciphers and One-Time Pad	✅	~60 min
04	Symmetric II — Block Ciphers, AES Internals	✅	~90 min
05	Modes of Operation — ECB, CBC, CTR, GCM	✅	~75 min
06	Hash Functions — SHA-2, SHA-3, BLAKE	✅	~75 min
07	MACs and HMAC	✅	~60 min
08	Authenticated Encryption (AEAD)	✅	~60 min
09	Public Key I — Diffie-Hellman	✅	~75 min
10	Public Key II — RSA Internals & Padding	✅	~90 min
11	Public Key III — Elliptic Curves & Ed25519	✅	~90 min
12	Digital Signatures — ECDSA, EdDSA, BLS	✅	~75 min
13	KDFs, PBKDF2, scrypt, Argon2	✅	~60 min
14	TLS 1.3 — Handshake, Records, 0-RTT	✅	~90 min
15	Build a Toy TLS 1.3 Client	✅	~120 min
16	PKI, Certs, Transparency	✅	~60 min
17	Zero-Knowledge Proofs — Sigma, zk-SNARK overview	✅	~75 min
18	Post-Quantum — Kyber, Dilithium, SPHINCS+	✅	~60 min
19	Side-Channels — Timing, Cache, Spectre/Meltdown	✅	~75 min
20	Memory-Safety Attacks — Stack Smash, ROP, ASLR	✅	~90 min
21	Web Security — XSS, CSRF, SQLi, SSRF, deserialization	✅	~90 min
22	Threat Modeling — STRIDE, DREAD, attack trees	✅	~60 min
23	CTF Toolkit — pwntools, GDB, Ghidra	✅	~75 min
24	Phase Capstone — A TLS 1.3 Library + a Mini-CTF	✅	~150 min

Phase 13: Concurrent & Parallel Computing — ✅ (~28 hours)

#	Lesson	Status	Est.
01	Concurrency vs Parallelism — Get This Right	✅	~45 min
02	Race Conditions, Atomicity, Visibility	✅	~60 min
03	Memory Models — Sequential Consistency vs Relaxed	✅	~90 min
04	Locks — Mutex, RW Lock, Spinlock, Ticket Lock	✅	~75 min
05	Condition Variables and Monitors	✅	~75 min
06	Semaphores and the Classics (Producer/Consumer, Dining)	✅	~60 min
07	Atomics, CAS, ABA Problem	✅	~75 min
08	Lock-Free Data Structures — Treiber Stack, MS Queue	✅	~90 min
09	Wait-Free Algorithms and Their Limits	✅	~60 min
10	Software Transactional Memory	✅	~60 min
11	Futures, Promises, async/await	✅	~75 min
12	Reactor and Proactor Patterns — epoll, kqueue, io_uring	✅	~90 min
13	Tokio and the Async Runtime in Rust	✅	~75 min
14	CSP and Go Channels	✅	~60 min
15	The Actor Model — Erlang and Akka principles	✅	~60 min
16	Parallel Patterns — Map, Reduce, Pipeline, Scan	✅	~75 min
17	Work-Stealing Schedulers	✅	~90 min
18	SIMD Programming in Practice	✅	~75 min
19	GPU Programming — CUDA Basics	✅	~90 min
20	GPU Programming — WebGPU / Compute Shaders	✅	~75 min
21	MPI and Distributed-Memory Parallelism	✅	~75 min
22	Phase Capstone — A Work-Stealing Scheduler + Lock-Free Queue	✅	~150 min

Phase 14: Computer Graphics & Visualization — ✅ (~23 hours)

#	Lesson	Status	Est.
01	Pixels, Colors, Gamma	✅	~45 min
02	The Graphics Pipeline at 30,000 ft	✅	~45 min
03	Linear Algebra for Graphics — Transforms, Projections	✅	~75 min
04	Rasterization I — Lines and Triangles	✅	~75 min
05	Rasterization II — Z-buffer, Clipping, Culling	✅	~75 min
06	Shading Models — Lambert, Phong, Blinn-Phong	✅	~60 min
07	Physically Based Rendering — BRDF, Microfacet	✅	~90 min
08	Shaders 101 — Vertex and Fragment	✅	~75 min
09	Build a Software Rasterizer (in Rust)	✅	~120 min
10	Ray Tracing I — Whitted Style	✅	~90 min
11	Ray Tracing II — Path Tracing, Monte Carlo	✅	~90 min
12	Acceleration Structures — BVH, kd-Tree	✅	~75 min
13	Real-Time Techniques — Deferred, Tiled, Cluster	✅	~75 min
14	Modern APIs — Vulkan, Metal, WebGPU compared	✅	~60 min
15	Compute Shaders for Non-Graphics Work	✅	~60 min
16	Animation, Skinning, IK	✅	~60 min
17	Visualization — D3, deck.gl, scientific plotting	✅	~45 min
18	Phase Capstone — A Path Tracer + a Triangle Rasterizer	✅	~180 min

Phase 15: Systems Programming & Performance — ✅ (~24 hours)

#	Lesson	Status	Est.
01	How to Think About Performance	✅	~45 min
02	Measurement Discipline — Benchmarks That Don't Lie	✅	~75 min
03	Profiling — perf, dtrace, Instruments, eBPF	✅	~75 min
04	Flamegraphs, Hotspots, and Reading Stacks	✅	~60 min
05	Cache-Aware Algorithm Design	✅	~75 min
06	False Sharing and NUMA	✅	~75 min
07	Branch Prediction and Layout Tricks	✅	~60 min
08	Vectorization in Practice (auto and intrinsics)	✅	~75 min
09	Memory Allocators in Production — jemalloc, mimalloc	✅	~75 min
10	Zero-Copy and mmap	✅	~60 min
11	Asynchronous I/O — io_uring Deep Dive	✅	~90 min
12	Kernel Bypass — DPDK, SPDK, AF_XDP	✅	~75 min
13	Lock Contention Patterns and Cures	✅	~75 min
14	Coroutines and Stackful vs Stackless Concurrency	✅	~75 min
15	C++ Low-Latency Idioms	✅	~75 min
16	Rust for High Performance — UnsafeCell, MaybeUninit, alignment	✅	~75 min
17	Power, Frequency Scaling, Thermal Throttling	✅	~45 min
18	Reliability Engineering — Tail Latency, Hedging	✅	~60 min
19	Capacity Planning and Little's Law	✅	~60 min
20	Phase Capstone — A Profile-Guided Optimization Walk-Through	✅	~150 min

Phase 16: Software Engineering & Architecture — ✅ (~25 hours)

#	Lesson	Status	Est.
01	What Makes Software 'Engineered'	✅	~45 min
02	Naming, Cohesion, Coupling	✅	~45 min
03	SOLID Principles — Demystified	✅	~60 min
04	GoF Patterns That Still Matter	✅	~75 min
05	Modern Patterns — Functional Core / Imperative Shell	✅	~60 min
06	Refactoring Catalogue and Mechanics	✅	~75 min
07	Code Review Practice	✅	~45 min
08	Domain-Driven Design — Bounded Contexts, Aggregates	✅	~90 min
09	Hexagonal / Clean Architecture	✅	~60 min
10	Event-Driven Architectures	✅	~60 min
11	CQRS and Event Sourcing	✅	~75 min
12	Microservices — When and When Not	✅	~60 min
13	API Design — REST, GraphQL, gRPC Trade-offs	✅	~75 min
14	Versioning, Deprecation, Compatibility	✅	~60 min
15	Monorepos vs Polyrepos	✅	~45 min
16	Dependency Management & SemVer	✅	~45 min
17	Build & CI/CD — Pipelines That Don't Suck	✅	~60 min
18	Observability as a Design Concern	✅	~60 min
19	Technical Debt — Measure, Pay Down, Negotiate	✅	~60 min
20	Architecture Decision Records (ADRs)	✅	~45 min
21	Reading Large Codebases	✅	~60 min
22	Phase Capstone — Refactor a Real OSS Repo + ADR Bundle	✅	~150 min
23	Human-Computer Interaction Design Principles	✅	~75 min
24	Software Project Management and Estimation	✅	~60 min

Phase 17: Testing, Verification & Formal Methods — ✅ (~23 hours)

#	Lesson	Status	Est.
01	Why We Test (and what tests don't prove)	✅	~45 min
02	Unit, Integration, E2E — Pyramid vs Trophy	✅	~60 min
03	Test Doubles — Stubs, Mocks, Fakes, Spies	✅	~60 min
04	Property-Based Testing — QuickCheck, Hypothesis	✅	~75 min
05	Fuzz Testing — libFuzzer, AFL++, structured fuzzing	✅	~90 min
06	Mutation Testing	✅	~60 min
07	Coverage — What It Tells You and What It Doesn't	✅	~45 min
08	Contracts and Design by Contract	✅	~60 min
09	Hoare Logic — Pre/Post/Invariant	✅	~75 min
10	Separation Logic Primer	✅	~75 min
11	Model Checking — TLA+ Hands-On	✅	~120 min
12	TLA+ for Distributed Protocols	✅	~90 min
13	Alloy and Lightweight Modeling	✅	~75 min
14	SMT Solvers — Z3 in Practice	✅	~75 min
15	Symbolic Execution — KLEE, angr	✅	~75 min
16	Proof Assistants — Coq/Lean/Isabelle Primer	✅	~90 min
17	Verified Software — seL4, CompCert, etc.	✅	~60 min
18	Phase Capstone — Specify, Model-Check, and Prove a Lock-Free Algorithm	✅	~150 min

Phase 18: Programming Language Paradigms & Type Theory — ✅ (~19 hours)

#	Lesson	Status	Est.
01	What 'Paradigm' Means (and Doesn't)	✅	~45 min
02	Lambda Calculus — Reduction, Encodings	✅	~90 min
03	Simply Typed Lambda Calculus	✅	~75 min
04	Polymorphism — System F, ML, Bounded Quantification	✅	~75 min
05	Type Inference — Hindley-Milner Reconstruction	✅	~90 min
06	Subtyping, Variance, Higher-Kinded Types	✅	~75 min
07	Dependent Types — A Tour	✅	~75 min
08	Linear and Affine Types — Rust's Lineage	✅	~60 min
09	Algebraic Effects vs Monads	✅	~75 min
10	Functional Programming Deep — Haskell Idioms	✅	~75 min
11	OOP Deep — Inheritance, Composition, Mixins, Traits	✅	~60 min
12	Logic Programming — Prolog and Unification	✅	~75 min
13	Dataflow and Reactive — RxJS, FRP	✅	~60 min
14	DSL Design — Internal and External	✅	~60 min
15	Phase Capstone — A Bidirectional Type-Checker for STLC + Extensions	✅	~150 min

Phase 19: Capstone Projects — ✅ (~219 hours)

#	Lesson	Status	Est.
01	Build a Compiler for a Pascal-like Language	✅	~720 min
02	Build a Kernel That Boots, Schedules, Pages	✅	~960 min
03	Build a Distributed KV Store (Raft + MVCC)	✅	~840 min
04	Build a SQL Database with B+-Tree Index	✅	~840 min
05	Build a User-Space TCP/IP Stack	✅	~720 min
06	Build a Path Tracer with BVH	✅	~600 min
07	Build a Chess Engine with Search & Eval	✅	~720 min
08	Build a Search Engine (Crawler + Index + Ranker)	✅	~840 min
09	Build a Container Runtime	✅	~600 min
10	Build a Toy ML Framework (autodiff, optimizers)	✅	~720 min
11	Build a TLS 1.3 Client + Server	✅	~720 min
12	Build a Distributed Build System (Bazel-style cache)	✅	~720 min
13	Build a Toy Browser (HTML/CSS layout + render)	✅	~840 min
14	Build a Static Analyzer for C with Abstract Interpretation	✅	~720 min
15	Build a Verified Sorting Library in Coq/Lean	✅	~600 min
16	Build a Quantum Circuit Simulator	✅	~480 min
17	Build a GPU Rasterizer in WebGPU	✅	~600 min
18	Open Capstone — Learner-Defined, Mentor-Reviewed	✅	~900 min