CppCon 2025 Trip Report – tipi.build by EngFlow

CppCon 2025 was packed with insightful talks, technical deep-dives, and exciting announcements for the C++ community. Our team at EngFlow had the chance to attend, share our work and connect with developers and toolmakers shaping the future of C++.

We attended both as a developer team and as a conference sponsor. We organized an exclusive Build & Tooling Happy Hour with great minds of the build space in the presidential suite, and we're already planning to make it a tradition!

Thanks to some strategic banner placement, we also "claimed" the freezer full of ice cream during Monday’s afternoon break — a sweet start to the week!

Here are the highlights from the sessions we attended and the talks we gave, plus key takeaways and resources if you’d like to dive deeper.

Instrumenting the Stack: Strategies for End-to-end Sanitizer Adoption

Damien Buhl, tipi.build by EngFlow

Damien (@daminetreg) from our team, introduced a practical approach to enabling C++ safety checks, dealing with the issue of instrumenting the complete stack and the related challenges learned from real-life projects our users are building on cmake-re.

Sanitizers and static-analyzers like clang-tidy are a good answer to the safety requirements addressed by the NSA, enabling them is however hard. As for example Memory Sanitizer stands out as the most powerful—yet the most challenging — because it requires a fully instrumented build.

Damien demonstrated how to achieve this using plain CMake and cmake-re, showcasing the ready-to-use cmake-re MSan, Asan, UBSan, TSan & clang-tidy builds environments, in addition to tips we learned with our users on instrumenting third-party dependencies.

The new MemorySanitizer (MSAN) environment showcases one of the big advantage of cmake-re containerized builds, as it makes it possible to run these kinds of sanitizer builds even when you're not running Linux as your host OS.

Our talk ended on a summary of what Florent (@Orphis) presented a StockholmCpp meetup earlier this year: Clang and libc++'s feature named Thread Safety Annotation. Go watch his talk while we wait for the CppCon version.

👉🏻 If you like to get sanitizer instrumented builds in a click; head to cmake-re sanitizers environments: ready-to-use cmake-re MSan, Asan, UBSan, TSan build environments with examples (Github Stars ⭐️ appreciated! 😇).

Session Link

MSVC C++ Dynamic Debugging: Full Debuggability of Optimized Code

This talk by the Microsoft team showcased a game-changing approach to debugging optimized builds. Traditionally, developers had to choose between debuggable but slow Debug builds and fast but opaque Release builds.

Key innovation:
The MSVC compiler can now track inlined functions and produce both debug and release binaries from the same intermediate representation. This means you get full debugging capabilities without losing runtime performance, and no extra compilation pass is needed.

Takeaway:
The future default workflow could be optimized builds with debug symbols enabled by default, making debugging faster and more accessible.

Modern CMake: Past, Present, and Future

Bill Hoffman, Kitware

Bill Hoffman walked through CMake’s evolution and shared a roadmap for upcoming features, including improvements relevant to build performance enthusiasts.

During the talk Bill was evaluating the different features added over time and whether they achieved the goals they had. It was inspiring to hear how Bill looked back at CMake's origins and shared the journey of its ongoing evolution.

Highlights:

• SBOM (Software Bill of Materials) support: allowing automatic generation of SPDX SBOMs.
• Improved instrumentation and profiling, includes trace.json generation allowing Perfetto performance analysis.
• FASTBuild generator adding official support for another build system with build distribution capability (albeit using a very different approach to what we do at EngFlow)
• Parallel install feature to speed up packaging: just run the --target install/parallel to reduce installation time
  • We will add this to HermeticFetchContent as this should speedup the last step of library deployment.
• Presentation of CPS (CMake Package Specification) support.
• CMake Linting features coming : this is huger, there are many flavours of CMake, a linter will actually help standardize furthermore the ecosystem.

We were particularly excited to see profiling improvements and we will be looking into how CMake's and EngFlow's profiling can be combined for even better build insights. The profiling tool seem to be very suited to combine traces of different tools and we may be able to neatly present our users with some advanced diagnostics like our diffing input trees on cache misses to helping teams identify and fix cacheability issues.

Takeaway:
Modern CMake is becoming a more powerful tool for performance diagnostics and scalable builds, making it easier to maintain high-performance CI/CD pipelines.

Cutting C++ Exception Time by 93.4%

Khalil Estell

Exception handling is often avoided in embedded systems due to performance concerns. Khalil Estell demonstrated how to make exceptions practical and efficient on microcontrollers, covering:

• Re-enabling exceptions in gcc-arm.
• Tackling unbounded memory usage and RTTI bloat.
• Optimizing unwinding for performance-critical scenarios.

While many optimizations are relevant primarily to embedded developers, there were fascinating insights about how RTTI impacts binary size. Only RTTI associated with actually thrown exception types remains in the binary, meaning careful design can keep size overhead low.

Takeaway:
C++ exceptions can be optimized for microcontrollers, making them a viable error-handling strategy even in constrained environments.

Session link

Best Practices for AI Tool Use

Jason Turner

Jason Turner explored how to get meaningful results from AI tools, emphasizing prompt quality and providing examples of common pitfalls, especially when dealing with C++-specific tasks.

While much of the talk focused on comparing bad vs. good prompts, there were some entertaining examples showing how LLMs struggle with the complexity of C++.

Takeaway:
AI can be a helpful assistant, but developers must carefully craft prompts and review output to avoid subtle bugs or misunderstandings.

Session link

Concept-based Generic Programming

Bjarne Stroustrup

Bjarne’s opening keynote was an ode to the power of C++ Concepts, showing how they allow developers to formalize type systems in ways that are:

• Safe – enforcing constraints at compile-time.
• Flexible – supporting a range of implementations.
• Low-verbosity – reducing boilerplate in both implementation and usage.

He also reiterated his preference for Concepts over Contracts, though both have their place in modern C++.

Takeaway:
Concepts are not just theoretical — they are practical tools for building expressive, safe, and efficient libraries.

Watch keynote

Implementing the Standard Library: Libc++ Design and Testing

This session offered a peek into how libc++ is tested and validated. Highlights included:

• Using static_assert for direct feature testing.
• Leveraging Clang’s -verify option to check expected compile-time errors.
• The role of the LIT (LLVM Integrated Tester) framework.

Takeaway:
Modern testing approaches in libc++ demonstrate how thorough, automated testing can ensure standard library quality and reliability.

More on LIT

Changing /std:c++14 to /std:c++20 – Migration Lessons

Migrating codebases between C++ standards can be challenging. This session walked through the journey from C++14 to C++20, via C++17.

Key points:

• Two-step migration: C++14 → C++17 → C++20 for smoother adoption.
• Code changes were relatively straightforward.
• Review and landing process was harder, requiring small, incremental commits.

Takeaway:
Plan migrations as incremental steps, focusing on tooling and review processes as much as code changes.

Watch previous talk on YouTube

Could We Handle an ABI Break Today?

The session explored the implications of an ABI break across major C++ standard libraries.

Takeaway:
For many serious projects, building from source makes handling ABI instability feasible. Less critical projects can continue to rely on stable legacy ABIs when needed.

Session link

Note: Our plain-CMake module HermeticFetchContent helps re-building dependencies from source passing the correct flags to dependencies too, reusing binary packages when necessary and navigate ABI-Breaks easily.

How to Affect the Future of C++ Standard in 60 Minutes

A practical guide to influencing the evolution of C++:

• Implementing prototypes of standard library features is a great way to contribute.
• Real-world implementations validate and refine design proposals before they’re standardized.

Takeaway:
The best way to shape the future of C++ is to prototype, test, and share your work with the standards community.

Session link

How to Tame Packs, std::tuple, and std::integer_sequence

An engaging and educational talk on working with parameter packs and common pitfalls when handling compile-time sequences.

It featured a nice C++20 each_in_tuple() implementation visiting the pro and cons of each approach.

template <typename Tuple, typename F>
constexpr void each_in_tuple(Tuple&& t, F&& f) {
    constexpr size_t n = std::tuple_size_v<std::remove_reference_t<Tuple>>;
    return unroll<n>([&](auto i) {
        if constexpr (requires { f(i, std::get<i>(std::forward<Tuple>(t))); }) {
            return f(i, std::get<i>(std::forward<Tuple>(t)));
        } else {
            return f(std::get<i>(std::forward<Tuple>(t)));
        }
    });
}

Takeaway:
With the right patterns, complex template metaprogramming becomes manageable and maintainable.

Session link

What C++ Needs to Be Safe

Exploring contracts in C++, this session demonstrated how they finally made it into the standard after a long journey.

• Contracts can define precise, verifiable expectations in code.
• Example: Adding a contract to sqrt() shows both the power and complexity involved.
• Contracts complement testing, rather than replace it.

Takeaway:
Contracts are a promising tool for safer, more robust C++ code, but their real value comes when combined with strong unit tests.

Session link

C++ Performance Tips: Cutting Down on Unnecessary Objects

From the Microsoft Chromium team, this talk focused on reducing unnecessary object copies, which can hurt performance.

• Many inefficiencies can be detected using Clang-Tidy.
• Chromium’s developer documentation and compiler plugins enforce best practices.

Key Points:

• We want in-place construction without copies or moves.
• Pass non-trivial objects by reference.
• Use view types (std::string_view, std::span).
• Use in-place constructors for STL types.
• Use emplace.
• Use transparent comparators for std::string in associative containers.
• Move data to compile time.
• Use clang-tidy checks and warnings to catch costly object copies early, keeping performance high without compromising maintainability.

Session link

Clean Code! Horrible Performance?

This talk reminded us that "clean code" is subjective. While clean APIs are important, performance sometimes requires tradeoffs.

Key message:
If performance improvements lead to less ergonomic or more complex APIs, make sure you have a clear and strong justification for the tradeoff.

Takeaway:
Balance readability and performance — neither should come at the other’s total expense.

Session link

Reflection: C++’s Decade-Defining Rocket Engine

In his CppCon 2025 keynote, Herb Sutter gave a clear overview of the new reflection capabilities in C++, showing how developers can now inspect and work with types, functions, and classes at compile time.

He emphasized that reflection opens the door to a more modular, library-driven approach to extending the language: if a feature doesn’t need compiler support, it could instead be built on top of reflection.

Herb also highlighted reflection’s role in generating language bindings — by annotating methods, developers could automatically produce wrappers for other ecosystems, moving C++ closer to serving as a common "lingua franca."

Reflection has the potential to simplify interoperability, reduce boilerplate, and reshape how C++ code is designed and shared, marking a pivotal shift for the language's future.

Watch the Keynote on Youtube

Lightning Talks

Lightning Talks session are excellent, it's often the most exciting, fun and insightful talks you can have at the conference, it wouldn't be possible without the ambiance and the energy spurred by the other longer talks.

We tried to contribute to this fabulous sessions run my Michael Caisse this year, as much as we could, and Florent (@Orphis) and Yannic (@pysco68) gave 2 nice talks :

• The Lifecycle of this CMake Lightning Talk by Yannic Staudt, as Yannic likes to put it "a talk about attempting to write a talk for CMake Pranksters".
• Reducing Binary Bloat with Thin Archives by Florent Castelli (@Orphis) which showcased how to save 1/3rd of build trees disk space used, leveraging llvm-ar thin archives with a simple trick and integrating it in CMake!

Final Thoughts

CppCon 2025 showcased the continued evolution of C++ as both a language and an ecosystem. From cutting-edge debugging techniques to advances in build tooling and standard library design, the conference highlighted how collaboration across the community drives innovation.

We left inspired to continue building faster, safer, and more scalable tooling.

tipi.build by EngFlow is committed to accelerate C++ development and enable innovations to happen in our beloved ecosystem.

Give cmake-re a try and test drive our ready-made sanitizer-enabled and static analyzer-enabled build environments to support us in our journey to accelerate C++ development and enable even more innovation in the C++ ecosystem!