After more than 26 years, CMake continues to evolve alongside the C++ ecosystem. To remain effective, it has had to adapt to significant language changes, increasingly complex package management, and the sheer scale of modern codebases. This talk examines four major areas of recent development: C++ modules, the Common Package Specification (CPS), build instrumentation, and distributed execution. For each area, we will cover the challenges involved in implementing the feature, the solutions that have been developed, and how CMake helps you apply those solutions in real-world projects.
C++ modules place new demands on build systems, requiring earlier and more accurate knowledge of dependencies and tighter integration with compilers. Both named modules and import std are supported in CMake today. We will explore how CMake performs dynamic dependency scanning and the coordination needed to turn module semantics into a practical build graph. This work required close cooperation with compiler vendors and has helped extend module support across the broader ecosystem.
We will also examine CPS (the Common Package Specification), which addresses the fragility of ad-hoc metadata used in traditional package discovery. As dependency graphs grow, manual configuration becomes a liability. We will discuss the current state of CPS support in CMake and how a machine-readable package description format improves reproducibility and toolchain interoperability.
The latter half of the talk shifts from modeling to performance. In large projects, identifying bottlenecks is the first step toward meaningful optimization. We will demonstrate how to use the CMake Instrumentation API to generate detailed traces showing where time is spent, both during configuration and the build.
Finally, we examine how to act on that data through distributed builds. We will look at scaling across machine farms using the native FASTBuild generator, compiler-launcher integration, and other distributed execution strategies supported by CMake.
This talk focuses on real-world constraints, trade-offs, and lessons learned from evolving a long-lived tool to meet the practical demands of modern C++ development.
View Slides
Mr. Hoffman is a founder of Kitware and currently serves as Chairman of the Board, Vice President, and Chief Technical Officer (CTO). He is the original author and la ead architect of CMake, an open source, cross-platform build and configuration tool that is used by millions of developers around the world, and he is the co-author of the accompanying text, Mastering CMake. Using his 20+ years of experience with large software systems development, Mr. Hoffman is also a major technical contributor to Kitware’s Visualization Toolkit, Insight Toolkit, and ParaView projects.
As CTO, Mr. Hoffman’s emphasis is on software development methodologies and establishing best practices across the breadth of Kitware’s development efforts. As one of the visionaries leading the quality software process efforts at Kitware, Bill has been instrumental in adopting agile programming practices, fueling Kitware’s software development. He is a frequent speaker on these subjects at CppCon, C++Now, and other conferences.
Mr. Hoffman received a B.S. in Computer Science from the University of Central Florida and an M.S. in Computer Science from Rensselaer Polytechnic Institute (RPI). Prior to the formation of Kitware, he spent nine years at the General Electric Corporate Research and Development center, working in the Computer Vision Group. He has planned and taught several graduate-level courses at RPI as well as a course in object-oriented programming at New York University.