Async Rust powers some of the most performance-critical infrastructure on the internet, from network proxies to database systems. A lot of developers have used async Rust, but far fewer actually understand how it works under the hood – the Future trait, Pin, wakers, the runtime scheduler. This makes it hard to debug production issues like stuck tasks, understand what's actually happening performance-wise, or make informed decisions about how to architect your system.

This hands-on workshop goes beyond using async Rust to understanding how it actually works. We'll start with a bit of the origin story – why async Rust was designed the way it was, which helps explain concepts like Pin and manual polling that can seem arbitrary at first. Then we'll build our own minimal async runtime from scratch. We'll implement the core machinery: the Future trait, the waker system, and a basic executor. This gives us the foundation to dive into Tokio itself – how its scheduler works, how I/O types actually integrate with the OS, how timers are implemented.

The final section is all about applying this knowledge to real-world problems. We'll instrument runtimes to track poll times, identify tasks that are blocking the executor, and debug "stuck" tasks that appear to stop making progress. You'll leave with both a solid mental model of how async Rust works and practical debugging techniques you can use immediately.