C++20 Modules: A Gentle Hands-On Workshop
C++20 Modules promise a new way to organize C++ code, reduce reliance on traditional header files, and create clearer boundaries between interfaces and implementations. But moving from understanding the idea of modules to actually using them in a project can be challenging.
This hands-on, code-first workshop takes a practical approach to C++20 Modules. Rather than spending the session on slides and theory, you'll work through a small C++ library and application, gradually evolving the project as new module concepts are introduced.
Using just your compiler, CMake, editor, and terminal, you'll see how modules behave in practice, where they fit into modern C++ projects, and some of the tooling and ecosystem limitations you should be aware of today.
What you'll learn
During the workshop, you'll learn how to:
Create and consume your first C++20 module
Set up and build C++ Modules using CMake
Separate a module's interface from its implementation
Structure a module implementation across multiple files
Work with existing header files alongside modules
Understand where headers should and should not be included
Explore module attachment and why it matters
Translate private implementation details header/source file structures into their module equivalents
Split larger module interfaces using partitions
Explore how the std module can reduce reliance on standard library headers
What you'll build
You'll start with a simple library consisting of a single module and an application that uses it.
From there, you'll progressively evolve the project. You'll separate interfaces from implementations, distribute code across multiple files, introduce existing headers, investigate module attachment, and explore how familiar C++ project structures translate into a modules-based architecture.
Each change introduces another aspect of C++20 Modules, so rather than learning features in isolation, you'll see how they affect the structure and build process of an actual project.
By the end of the workshop, you'll have taken a small C++ library from a traditional project structure to a working modular architecture, built with CMake. Along the way, you'll learn where module interfaces, implementation units, partitions, headers, and the std module fit into a real project.
Instructor
Lieven is a passionate software developer, architect, team lead, manager, coach, mentor, with 30 years of experience. He is passionate about C++, software craftsmanship, and clean code. His career started in the text-to-speech domain and then moved to video recognition technology for traffic environments. During the last 16 years he is active in the satellite communication industry.
Since spring 2026, he founded his own consulting company CppDriven, providing services in coaching and workshops for teams on modern C++ and it's Eco-system of tools. He will guide you through the evolution of C++ and mentor you on improving the quality of your code and testing practices.
Lieven also contributes to several open source projects and is the lead developer of the open source IDE Code::Blocks. He is also the lead coach of the Coderdojo division in Ghent, Belgium where he lives. A major focus is on sharing knowledge on C++, coaching people to grow in C++, and maintaining and raising the bar on quality.
Workshop roadmap
1. Your first C++20 moduleStart with a module contained in a single file. Learn about the primary module interface, how another part of the application consumes it, and how to configure modules with CMake.
2. Separating interface and implementationSplit the module into a more structured interface and implementation and see what happens when each part of the project changes.
3. Organizing modules across multiple filesExplore how to distribute the implementation of a library across multiple files rather than keeping everything in one place.
4. Modules and existing headersReal-world C++ projects won't become entirely modular overnight. Learn how traditional header files interact with modules and how they should be included within an implementation.
5. Headers inside module interfacesExplore what happens when a header is needed by the module interface itself and whether familiar header-related practices still apply in a modules-based project.
6. Understanding module attachmentTake a closer look at module attachment, including a brief look at name mangling, to understand why the placement of header includes can matter.
7. Moving from header/source pairs to modulesSee how familiar header and source file combinations used to solve sub-problems can be translated into their modules-based counterparts.
8. Splitting larger interfacesLearn how module partitions can help organize a larger interface into multiple logical pieces.
9. Exploring the std moduleSee how the std module can be used in a fresh project to access the C++ standard library without relying on traditional standard library headers.
Who is this workshop for?
This workshop is designed for:
C++ developers who have heard about Modules but haven't started using them
Developers working with traditional header/source C++ projects who want to understand the modules approach
C++ developers interested in modernizing how their projects are structured
Engineers who want practical experience with C++20 Modules and CMake
Developers looking for a gentle introduction before exploring more advanced module usage
You don't need previous experience with C++ Modules. You should, however, be comfortable with basic C++ development, compiling projects, and working with CMake.
Can’t attend live? The session will be recorded, and all registered attendees will receive access to the full recording along with the workshop code and supporting resources after the session.