Learn
Coding exercises built from real, merged open-source pull requests. The PR's own tests are the pass/fail bar, the merge commit is the ground truth — solve it in your browser, no local setup.
[ COURSES ]
Database Internals
Build the core pieces of a database from scratch -- parsing, query execution, joins, indexing, concurrency, and crash recovery -- each grounded in how Postgres, DuckDB, and SQLite actually implement the same concept.
21 exercises
Language Runtimes
How the tools you already use actually work: a bytecode interpreter loop like CPython's, a cooperative task scheduler like Go's goroutine scheduler -- implemented from scratch, grounded in the real runtimes' source.
11 exercises
Distributed Systems
The mechanisms that make a cluster of unreliable machines behave like one reliable system: reconciliation control loops and consistent hashing, grounded in how Kubernetes actually implements the same ideas.
11 exercises
Compilers
How source code becomes something a machine can run: parsing expressions into an AST with correct operator precedence, and an optimization pass that folds constant subexpressions -- grounded in how TypeScript and LLVM do the same jobs.
4 exercises
Networking
The mechanisms that keep one bad dependency from taking your whole system down: rate limiting and circuit breaking, grounded in how Envoy actually implements the same ideas at the edge of every request.
5 exercises
AI/LLM Internals
How a large language model actually turns text into tokens and logits into words: byte-pair encoding and sampling strategies, grounded in how llama.cpp, vLLM, and transformers implement the same mechanisms.
7 exercises
Streaming & CDC
The mechanisms behind durable event streams and change-data-capture pipelines: a log-structured commit log with sparse indexing, consumer group coordination, exactly-once delivery, outbox-pattern CDC routing, and event-time window watermarking -- grounded in how Kafka, Debezium, and Flink actually implement the same ideas.
5 exercises
OS / Kernel Internals
How the kernel underneath every process actually works: a vruntime-ordered scheduler runqueue like CFS, the two-list page-reclaim scheme that protects the page cache from one-off scans, the multi-level page table walk that turns a virtual address into a physical one, the readiness-list mechanics behind epoll, and the write-ahead journal that keeps filesystem metadata consistent across a crash -- all grounded in real Linux kernel source.
5 exercises
Version Control Internals
The mechanisms underneath Git: content-addressable object storage with built-in corruption detection, the Myers diff algorithm that powers `git diff`, packfile delta compression, three-way merge conflict resolution, and merge-base (lowest common ancestor) finding in a commit DAG -- grounded in how Git's own C source implements the same ideas.
5 exercises
Frontend Internals
The algorithms hiding inside every modern UI framework: keyed virtual-DOM reconciliation, an interruptible fiber work loop, the hook linked list behind useState, fine-grained reactive dependency tracking, and batched update scheduling -- grounded in how React and Vue actually implement the same ideas.
5 exercises
JVM & Garbage Collection Internals
How a real JVM actually runs your code: a stack-based bytecode interpreter, a copying young-generation garbage collector, concurrent tri-color marking with a write barrier, classfile constant pool resolution, and the JIT's escape analysis for stack allocation -- grounded in HotSpot's real OpenJDK source.
5 exercises
Graphics & Rendering Internals
The math and data structures underneath a rendering pipeline, stripped down to pure, testable Python: barycentric-coordinate triangle rasterization, per-pixel z-buffer depth testing, bounding volume hierarchies for accelerated ray-object intersection, retained-mode scene-graph diffing, and texture atlas bin-packing -- grounded in how a real software rasterizer, pbrt, and a real scene-graph library actually implement the same ideas.
5 exercises
Big Data Processing
The mechanisms behind batch big-data engines: how Spark splits a job into stages at shuffle boundaries, recovers lost data by recomputing RDD lineage instead of replicating it, and picks between a broadcast and a shuffle join -- plus the columnar storage layouts underneath, Parquet's row-group/page structure and Arrow's zero-copy in-memory format -- grounded in how Spark, Parquet, and Arrow actually implement these ideas.
5 exercises