A twelve-week, cohort-based deep-dive into advanced Rust — the parts you skip in tutorials, the parts that bite you in production. We will write a custom async runtime, a lock-free queue, and an embedded driver. Then we will profile them. Then we will break them and fix them.
Result, ?, impl Trait, and at least one previous project. Time: ~10 hr/week — two live sessions, code, office hours.
Build a working executor from scratch — futures, wakers, a task queue, an I/O reactor backed by epoll/kqueue. Roughly 1,200 lines. Replaces tokio for a class of single-thread workloads.
A multi-producer, single-consumer queue using only atomic operations. We benchmark against crossbeam, document the memory ordering choices, and prove correctness with loom.
Write a hardware abstraction layer for an ESP32-C3 dev board. no_std, no allocator. We register-poke a UART driver, build an embedded-hal trait impl, and ship it to crates.io.
'_ elision rules, why 'static isn't what you think. We refactor a real crate.UnsafeCell, NonNull, miri, the soundness rules nobody told you about.Future by hand, the waker contract, why poll returns Poll, executor design tradeoffs.Pin<Box<T>>, when you don't, the pin-project macro, and writing a self-referential type by hand.std::sync.macro_rules! deeply, then proc-macros, syn, quote, span hygiene. We write a small derive macro for our HAL.Vela is a former Rust compiler engineer at Mozilla (2017–22) and edge-platform tech lead at Cloudflare Workers (2022–25). She has authored 412 commits to rust-lang/rust, including the original Pin stabilization design notes and the bulk of the trait-resolver refactor that landed in 1.65.
She has taught Rust full-time since 2025 — first as a paid faculty member at the Recurse Center, now independently through Your Business. Cohort_06 was the sixth offering of this program; 178 graduates have shipped crates that now collectively have 4.2M downloads on crates.io.
fn longest<'a>( x: &'a str, y: &'a str, ) -> &'a str { if x.len() > y.len() { x } else { y } } fn main() { let r; { let tmp = String::from("hi"); r = longest("hello", &tmp); } // tmp dropped here println!("{}", r); // E0597 }
fn longest<'a, 'b: 'a>( x: &'a str, y: &'b str, ) -> &'a str { if x.len() > y.len() { x } else { y } } // or — better — change the call site: fn main() { let tmp = String::from("hi"); let r = longest("hello", &tmp); println!("{}", r); // ✓ }
'a, 'b: 'a — papers over a deeper question: should this function signature exist at all? In week 01 we walk through three alternative signatures, why each is worse or better, and the variance rules that actually govern the choice. Watch the full lesson (free, no signup) →
I have been writing Rust professionally for four years and I learned more about Pin in week 04 than I had in the previous 800 hours of writing Rust. The lock-free queue alone was worth the tuition.
Vela's pacing is brutal in the best way. There is no time wasted on syntax review. I came in with two years of Rust and left writing macros without consulting cargo expand.
I do not write embedded code professionally and I now have an esp-blink-style HAL on crates.io with 4,200 downloads. That repo got me three interviews and the job I now hold.
The single-track tuition gets you everything in the cohort — twelve weeks of live sessions, all recordings, two office hours per week, three artifact projects, and the cohort Slack for life.
The 1:1 mentorship track adds a weekly hour with Vela for code review on your artifact PRs. We cap mentorship at 12 seats per cohort and they go fast — cohort_07 has 4 left.
Twelve weeks of cohort access. Everything you need to ship the three artifacts and finish.
Everything in single, plus one private 60-minute call with Vela each week for code review on your artifacts.