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: “Rust at The Edge: AI Development, Edge Deployment, Real World Inference”
Presented by: Wyliodrin Sponsored by: AI|Coustics
Host: Alexandru Radovici & Razvan Serban
Cost: $500 (before taxes and fees)
Time: 9am-6pm
Running AI models on edge devices, such as smartphones and wearables, opens up exciting opportunities. Rust is particularly well-suited for harnessing this potential and advancing how we deploy and reason with AI models on these devices.
In this hands-on workshop at RustConf 2025, you will explore practical, real-world scenarios while building essential skills and gaining a foundational understanding of embedded AI programming using Rust. Join us as we discover how Rust enables you to deploy and engage with AI applications on edge devices.
Note:
We’re thrilled to share that the Raspberry Pi devices for the workshop will be kindly provided by our sponsor, AI|Coustics. Due to limited stock, Pis will be shared between pairs—one device for every two participants. If you’d prefer to work solo and have a Raspberry Pi 4 (8GB RAM) or better, feel free to bring it along! Would you like to pick one up before the workshop? Go for a Raspberry Pi 5 with 8GB RAM if you can—it’s the preferred model for the hands-on you’ll be doing. Whether you’re sharing or bringing your own device, we’ll make sure everyone gets hands-on time and leaves with the experience of something cool running locally from Hugging Face.
Workshop Goals/Outcomes
- Gain a clear and accessible understanding of core AI concepts, including deep learning, on-device computer vision, and natural language processing (NLP), by starting from foundational principles. This knowledge will empower you to delve into advanced AI topics.
- Gain hands-on experience by deploying an AI model to an embedded device using Rust. This experience will enable you to apply theoretical knowledge in real-world settings.
- Demystify the fundamentals of embedded AI inference using Rust, providing participants with a solid practical approach to AI projects for edge devices.
- Begin your journey by familiarizing yourself with essential AI crates and tools within the Rust ecosystem. Then, gain clarity on how to adapt and extend models for AI inference on edge devices.
- Analyze the trade-offs between efficiency, portability, and other practical considerations when deploying and inferring AI models on edge devices. This analysis will help participants make informed technical decisions.
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.