Every lesson is below — no marketing summary, no roadmap-shaped voids. If a topic isn't covered here, it isn't covered. We do not skip syntax review on the readme; we skip it because we do not teach it.
The core "you thought you understood it" reset. By the end of week 04 you have built a working single-thread async executor with a real I/O reactor and shipped it as artifact_01.
Concurrency without locks, correctness without anxiety. Loom catches the bugs your tests cannot. We close the phase with criterion benchmarks against crossbeam.
The world without an allocator. We write a HAL driver for the ESP32-C3, ship it to crates.io, and learn the release engineering nobody teaches.
Variance, sub-typing, HRTB, '_ elision, and why 'static is rarely what you actually want. We deconstruct three real lifetime errors from the standard library's history and then refactor a real production crate to remove half its 'a annotations.
The four most common misconceptions, and the model the borrow checker actually uses.
Co-, contra-, and invariance. Why &mut T is invariant and what that costs you.
Reading and writing for<'a> Fn(&'a T), when you need it, when you don't.
What 'static actually is, when it leaks, and three patterns that avoid it entirely.
When unsafe is justified, when it isn't. UnsafeCell, NonNull, miri, the soundness rules nobody told you about, and the "interior mutability" patterns that make unsafe usually unnecessary. The lab is a real bug we find with miri and fix without unsafe at all.
The Stacked Borrows model in plain English, and how miri uses it.
Reading and writing safety docs. The "what could go wrong" exercise.
The one primitive that makes RefCell, Mutex, and Atomic* all possible.
A real bug from a real crate, found by miri. We fix it three different ways.
Building Future by hand, the Waker contract, why poll returns Poll<T>, and the design choices baked into tokio, async-std, smol, and embassy. By the end of the week you start writing kov.
Implementing Future by hand for three small types — Ready, Sleep, Channel.
Cloning, RawWaker, vtables, and the "do not block in poll" rule.
Task queue, run-to-completion vs. work-stealing, single-thread first principles.
Wiring mio epoll/kqueue into your executor — first kov code drop.
When you need Pin<Box<T>>, when you don't, the pin-project macro internals, and writing a self-referential type by hand without unsafe-pinning footguns. We finish kov this week.
The motivating example: self-referential generators in async-await.
The three rules. Reading the pin-project-lite source.
By hand, without macros, with safety docs. Then again with pin-project.
Polish, README, doc tests, crate metadata. First crate live on crates.io.
Acquire, Release, AcqRel, SeqCst — when each one buys you what. Reading the C++11 memory model, cache lines, false sharing, and how to actually pick orderings without copy-pasting from Stack Overflow. Guest: Niko Matsakis on rustc's atomics work.
The four orderings and what they cost on x86, ARM, and RISC-V.
The "happens-before" relation in plain English. The exercise: a producer/consumer.
Padding, alignment, repr(align), CachePadded from crossbeam.
The atomics lowering work in rustc and the next ten years of memory ordering.
CAS loops, the ABA problem, hazard pointers, epoch-based reclamation. We design the MPSC queue we'll ship in week 8. Paper-club Friday: Michael & Scott '96.
Compare-and-swap, retry loops, when they live-lock.
Why naïve lock-free stacks break, and the four standard solutions.
Architecture session — we white-board the queue we'll ship.
Read Michael & Scott 1996 together, line by line. Implement the pseudocode.
How loom permutes thread interleavings, how to set it up in your crate, how to interpret a failed loom test, mocking std::sync. The lab is debugging a real loom failure live.
Permutation strategies, model checking, the cost-model.
Cargo features, conditional imports, cfg(loom), the loom::sync shim.
Reading loom's interleaving trace and turning it into a fix.
We deliberately break flume-lock and find the bug live with loom.
criterion, perf, flamegraph, samply. Reading assembly. When inlining matters. Cache-line awareness in real code. We ship flume-lock and benchmark it head-to-head against crossbeam.
Sample size, warm-up, throughput vs. latency, and the report HTML.
perf, samply, the cargo-flamegraph harness, interpreting the inverted icicle.
cargo-show-asm, when #[inline] changes things, when it doesn't.
v0.1.0 to crates.io. Bench against crossbeam. Documentation review.
Building without an allocator, panic handlers, target triples, the embedded-hal traits. We pick the ESP32-C3, ship dev boards to every cohort member, and start writing a real HAL driver.
The crate graph implications, panic handlers, no-allocator patterns.
--target, build-std, the cortex-m vs. riscv32 split.
Reading embedded-hal 1.0, the GPIO + UART + I²C trait stories.
Probe-rs setup, register-poking the UART, getting "hello world" out the wire.
macro_rules! deeply, then proc-macros, syn, quote, span hygiene. We write a small derive macro for our HAL — #[derive(Register)] — and then read part of the serde implementation.
Capture types, repetition, the order-of-evaluation rules, common foot-guns.
The three flavors. syn + quote + proc-macro2. Span hygiene.
We write #[derive(Register)] for the HAL by the end of session.
The serde derive — the most-cited proc-macro in the ecosystem. We read it.
Calling C, being called by C, callbacks, lifetime stories at the FFI boundary, ABI compatibility, and the soundness debt that accumulates at the edge of your crate. Guest: Stjepan Glavina on async-std + FFI.
repr(C), repr(transparent), how struct layout actually works.
Generating bindings both directions. The "what's safe to expose?" rules.
Trampolines, leaking Box, the user-data idiom.
FFI lessons from async-std and smol.
Cargo metadata, semver, docs.rs config, CI matrices, MSRV, release engineering. We publish all 32 cohort artifacts. There is a real release party.
Every field in Cargo.toml that matters at publish time.
The patch / minor / major rules, the cargo-semver-checks tool.
The matrix, MSRV pinning, GitHub Actions for Rust crates.
Live cohort-wide ship party. All 32 artifacts publish to crates.io. We celebrate.
This is not an introductory program. Six months of production Rust is the minimum, and most graduates have one to four years of Rust on the job. If you are new to Rust, finish the Book first, ship one project, then come back.
The application is one short form on the enroll page. There is no interview, but we will reject applicants who appear to be at the wrong level — a $1,200 refund six weeks in helps no one.
impl Trait in argument and return positions without consulting the Rustonomicon.Pin safety contract — most graduates didn't either.Two live sessions per week (Tuesday + Thursday, 5pm Pacific, ~75 minutes each), a Friday office-hours block, and full-cohort Slack. Every live session is recorded, captioned, and available within 12 hours.
Roughly half the cohort attends synchronously, half asynchronously. The artifacts are paced for synchronous, but the deadlines are soft — what matters is shipping by week 12.
If after two passes you still want in, the application is one short form and there is no interview. We promise a yes-or-no within 48 hours.