Workshops
Taking place on Tuesday, September 2, 2025. Limited to in-person RustConf attendees who have added a workshop to their conference ticket during registration.
The immersive, hands-on workshops at RustConf are an excellent chance to roll up your sleeves and tackle a fascinating Rust topic with a small cohort of Rustaceans, led by an expert instructor. Workshops will take place on Tuesday, September 2 at the Hyatt Regency in Downtown Seattle and are only available for in-person attendees of the main conference.
ABOUT “ASYNC DAY”
This year, three of our four workshops are focused on asynchronous Rust by popular demand! We’ve designed this collection of workshops for developers who want to go beyond the theory and build real-world Rust-y async systems with confidence. Async Day workshops are your chance to dive deep into asynchronous Rust. Whether you’re just starting with Rust or building production-grade systems, these workshops are led by seasoned experts who live and breathe async. You’ll walk away with practical code, deeper insight, and the tools to build the systems that fascinate you.
Learn more about all our workshops below!
Note: Each workshop will run concurrently, so it will only be possible to attend one.
Workshop 1: To Be Announced
Details coming soon!
Time: 9am-6pm
Workshop 2: “Async Design Patterns in Rust” (Async Day)
Host: Conrad Ludgate
Cost: $375 USD (before taxes and fees)
Time: 10am-3:30pm
So you’ve chosen to use Rust. Maybe it’s for performance, maybe it’s because the type system gives you more confidence in your code. Whatever the reason, you might need to use Async. Rust has chosen not to have a deep integration with a runtime, so if you want access to lightweight virtual threads, you need some manual effort.
Virtual threads are a very popular design concept nowadays. OS Threads are great, but they are not always the most efficient. When you have thousands of threads, you start to notice slowdowns and large memory usage. Virtual threads allow for much more efficient use of CPU and much lower memory usage. Async Rust is a very powerful tool, but it’s got some rough edges. It does take some effort to learn how to wield it effectively. This workshop will give you the training.
Workshop Goals/Outcomes
- Learn how to design your async applications in a high level way, utilizing the Rust memory model to shape the design of your tasks.
- Learn the fundamental patterns of async Rust. Cancellation, Graceful shutdowns, Structured Concurrency, etc.
- Work with low latency, utilizing streams and byte processing.
- Work effectively with thousands of tasks, with efficient inter-task synchronization.
Workshop 3: “Asynchronous Rust & C++” (Async Day)
Host: Aida Getoeva
Cost: $375 USD (before taxes and fees)
Time: 10am-3:30pm
Integrating a new language into an established ecosystem is always challenging. Whether you’re starting a greenfield Rust project or rewriting existing C++ components, getting hands on it at first can feel very intimidating. There are limited resources on the tooling available and even less so on the async FFI interfaces. And if you encountered a segfault? Oh, it’s the whole wild west.
This workshop will equip you with the knowledge to build seamless integrations, covering everything from practical tooling for C++/Rust bindings to handling complicated asynchronous interfaces.
Workshop Goals/Outcomes
- Learn about the FFI tools for C++/Rust, the pros and cons.
- Write complex async bridges between C++/Rust.
- Learn how to ensure that the resulting API is safe, sound and native to the language.
- Gain awareness of the potential bugs and bottlenecks and have clues on how to debug and fix them.
Workshop 4: “Async Fundamentals” (Async Day)
Host: Herbert Wolverson
Cost: $375 USD (before taxes and fees)
Time: 10am-3:30pm
Asynchronous Rust was added to Rust in version 1.39 (November 2019), and has a reputation for being hard-to-use and error-prone. Despite this reputation, async Rust is extremely useful – from high-performance networking to embedded systems, async opens design doors that are otherwise unavailable.
In this hands-on workshop, we’ll start with the async basics – and quickly develop high-performance REST and gRPC APIs. We’ll cover some patterns for resource sharing and design, and dive into some of the pitfalls – and how to avoid them. We’ll also cover the hot topic of isolating async from the rest of your program – allowing you to have your cake, and eat it!
Workshop Goals/Outcomes
- Participants will understand the difference between synchronous and asynchronous Rust, and when to apply each.
- Gain hands-on experience building a REST API with Tokio+Axum, and a simple gRPC API with Tokio+Tonic.
- Practice separating synchronous and asynchronous portions of programs – avoiding async’s “viral” nature, and focusing on what works best for their tasks.
- Practice and understand some strategies for memory and resource management in asynchronous Rust.
- Understand at a high-level why Rust async works the way it does – and the flexibility it grants you, from embedded to enterprise. Participants will also have an understanding of some of the pitfalls and difficulties they may encounter – and how Rust is improving these areas.
- Understand the benefits of “protocol only” design – for synchronous or asynchronous development.