Mastering `std::execution`: A Hands-On Workshop is a two-day onsite training course with programming examples, taught by Mateusz Pusz It is offered at the Gaylord Rockies from 09:00 to 17:00 Aurora time (MDT) on Saturday and Sunday, September 12th and 13th, 2026 (immediately prior to the conference). Lunch is included.
◈ Register Here ◈ See Other Offerings ◈
Course Description
Abstract
Asynchrony and parallelism are no longer optional “add-ons”—they are the core of modern software. However, the industry has long struggled with a fragmented landscape of concurrency models. This intensive 2-day pre-conference hands-on workshop dives into the future of the language: the C++26 `std::execution` framework.
We will cover the complete Senders/Receivers model included in the latest C++26 Standard Library such as specialized schedulers, advanced task spawning, and enhanced coordination primitives.
Crucially, you do not need to wait for C++26 to ship. While we are teaching the future Standard, we will work with the production-ready reference implementation that is fully compatible with C++20. This means the patterns, performance optimizations, and architectural shifts you learn in this workshop can be deployed to your production codebase the very next day.
Through a 70% hands-on approach, you will move from low-level threading to building declarative, high-performance task graphs that are efficient, thread-safe, and effortlessly scalable across CPUs and GPUs.
The CppCon Advantage
With `std::execution` being the most significant addition to the Standard in years, many of the core conference sessions this week will focus on its internals, its impact on the industry, and its integration with other features. This workshop is designed to be your “on-ramp”—providing the deep technical foundation and hands-on experience needed to fully grasp and benefit from the advanced `std::execution` talks throughout the main CppCon program.
What You Will Learn?
- C++26 Framework Architecture: Master Senders, Receivers, and Schedulers—the new vocabulary of C++.
- Declarative Pipelines: Build complex asynchronous flows that propagate errors and handle cancellation automatically.
- Beyond P2300: Explore the full suite of C++26 extensions and algorithms recently voted into the Standard.
- Immediate Deployment: Learn how to integrate the reference implementation into existing C++20 production environments.
- Conference Readiness: Gain the prerequisite knowledge to navigate the deep-dive concurrency sessions during the CppCon main event.
Workshop Details
- Structure:
- 30% Lecture: Modern concurrency theory and C++26 Standard evolution.
- 70% Hands-on Coding: Real-world problem solving using the latest framework implementations.
Environment
- A laptop with a web browser.
- All exercises will be implemented using Compiler Explorer, leveraging the production-ready reference library (e.g., stdexec).
Prerequisites
Proficiency in Modern C++ (C++20 features like concepts or lambdas are helpful).
No prior knowledge of `std::execution` is required.’
Course Topics
We will cover the following topics:
- Motivation
- Framework Introduction
- the structure of an asynchronous processing pipeline
- data parallelism with senders
- cancellation support
- transferring the work
- Sender algorithms library
- Error handling
- Performance Optimizations
- Structured Spawning
- Custom Senders and Schedulers
- `std::execution` vs Coroutines
- Testing Asynchronous Code
Course Instructor
Mateusz Pusz is a software architect, principal engineer, and security champion with over 20 years of experience designing, writing, and maintaining C++ code for fun and for a living. His main areas of interest and expertise are Modern C++, code performance, low latency, safety, and maintainability.
As the founder of Train IT, Mateusz provides dedicated C++ training and consulting services to corporations worldwide, drawing on over 15 years of teaching experience. He contributes to the industry as a conference speaker and as an active voting member of the ISO C++ Committee (WG21), where he helps shape the language’s future alongside the world’s top experts.
Committed to software safety, Mateusz is also the founder and primary author of the mp-units project, an open-source library that strives to make the world safer by ensuring the correct handling of physical quantities in software.