Ten courses across systems, languages, distributed computing, interface engineering, and security — taught by working practitioners. Take one. Take all of them. The structure is the point.
Each course is taught once a year. Most courses run twelve weeks; a few are shorter. Cohorts cap at twenty-four. We don't run anything we wouldn't recommend to a friend.
Memory, concurrency, and the cost of every line.
We descend through the stack until you can read assembly without flinching. Profile what really runs. Reason about cache lines. Earn the right to optimize. The lab is unforgiving — bring espresso.
What to do when the network lies.
Consensus, replication, and the ugly truth about clocks. Build a small Raft from scratch; lose sleep over Byzantine generals. Read the original papers — Lamport, Schneider, Brewer — and argue with them.
Build a language. Then build the tools that make it usable.
From parser to typechecker to bytecode. Then the boring-but-essential part: a formatter, a language server, a debugger. The work that makes a language a tool people actually want to reach for.
Code that humans actually want to touch.
Typography, motion, latency budgets, accessibility — the engineering behind taste. We treat the interface as the API humans use, and we hold it to the same standard.
Trust, but verify. Then verify again.
Implement the primitives. Break the textbook protocols. Patch them. We read RFCs the way other programs read poetry, and we treat side-channel attacks like the inevitabilities they are.
Types as proofs; programs as evidence.
Lambda calculus through dependent types — by writing tiny interpreters at each step. Read SICP, then put it down and write your own. We finish with effects: how to make pure programs do things.
B-trees, WAL, MVCC — and what really happens at COMMIT.
Build a small storage engine. Write the WAL. Implement MVCC. By the end you'll be able to read PostgreSQL's source without panic, and explain "isolation level" to a skeptical CTO without metaphors.
Threads, queues, and the patterns that survive a 3 a.m. page.
Actors. Channels. Futures. Locks. Backpressure. We work in three languages so you stop confusing the syntax with the idea, and end with a chaos-tested job runner you'd actually deploy.
From rasterization to ray tracing — and the math in between.
Shaders, compute kernels, the BRDF, denoising. Build a small renderer in WebGPU and then in Metal so you understand what's framework and what's hardware. Linear algebra is required — you'll feel it.
Reading, writing, rewriting — software as a literary practice.
Our shortest course and the one most graduates say they wish they'd taken first. We treat code review as criticism, comments as prose, APIs as authorship. You'll write three small programs and rewrite each four times.
From sockets to streaming — and why protocols outlive products.
Read RFCs the way other programs read poetry. Build a working HTTP/2 server from sockets up. Watch a packet trace and explain — frame by frame — exactly what's happening to it. We finish by designing a small wire format you'd actually be willing to ship.
Single courses run on rolling admission. Cohort XIII (the full programme, all six twelve-week tracks) opens January 2026. Either path begins with the same five-minute application.
Begin your application