CppCon 2026

Reverse-mode automatic differentiation (AD) computes exact gradients with respect to thousands of inputs in roughly the time of a single function evaluation. If you write numerical C++ for finance, scientific computing, or ML and you care about performance, this talk will show you where AD overhead actually comes from and what to do about it.

A straightforward operator-overloading implementation records every arithmetic operation onto a tape and replays it backward to propagate derivatives. On real numerical code this easily introduces 50-100x overhead, and most of that has nothing to do with calculus. It is heap allocation on every operation. It is cache misses walking the tape backward. It is branch mispredictions at memory chunk boundaries. It is recording tape entries for operations where none of the operands are even being differentiated.

We work through a series of C++ techniques that bring this down to around 4x on production code in finance. The two that matter most: a chunked arena allocator with cache-line alignment and branch-prediction hints that turns the recording hot path into a pointer bump and a store, and expression templates that collapse an entire right-hand side into one tape push with all derivatives accumulated in a compile-time-sized stack buffer. We pull up compiler output to show the abstraction really does compile away.

After the big two, we get into the smaller wins that are still worth knowing about: skipping zero adjoints during the backward sweep to exploit sparsity, picking derivative formulas at compile time that reuse the forward result instead of recomputing it, and demoting active-times-passive operations from binary to unary to halve their tape footprint. We also show how a should-record check propagated through the expression tree lets the tape skip entire statements when no operand is active, and how aggressive inlining lets the compiler eliminate these checks entirely for passive subexpressions, so the cost of asking is zero when the answer is no. We benchmark each one in isolation on four numerical workloads ranging from 8 to 161 sensitivities, so you can see what each technique is actually worth.

Recruiters Pri Trivedi and Brian Leone of Bloomberg will spend their lunch answering your career-related questions. Bring all of them.
Which college classes build a strong first CV? How should you handle a technical interview? How can you learn and grow by participating in and contributing to open source? What does a first job actually look like? Why is C++ still deeply valued, and where can your experience with it get you hired? What role will AI tools play in building a career that matters?
Bloomberg is hiring, and Pri and Brian will happily talk about that. However. this is a lunch, not a pitch, so the agenda will follow whatever the room asks - no question is too basic. Students are especially welcome to attend.

C++20 modules are finally usable end to end, from your own modules to 'import std;' The functional build-system support with real diagnostics. This talk teaches modules the way #include was once taught: with small files, a build, and concrete use cases. Modules stopped being experimental somewhere around 2025. This session builds the mental model from scratch: what a primary module interface unit is, how partitions and implementation units fit together, and, crucially, how import differs from #include in ways that matter day to day. It uses a small library, exposes it as a module, splits it across partitions, consumes import std; and observes the compile-time effect. Then it answers the questions every team hits in week one: how modules interact with macros, with templates in headers, with header-only dependencies, and with a mixed codebase that can't convert everything at once. The examples will be using CMake, clang and recent gcc. You will leave able to structure a small library as a module, explain why a macro didn't cross a module boundary, and plan an incremental adoption that doesn't require converting the whole tree.

The C++ Core Guidelines is quickly gaining popularity as the main C++ coding standard in the industry. The official introduction of the standard states the following: "Many of the rules are designed to be supported by an analysis tool. One way of thinking about these guidelines is as a specification for tools that happens to be readable by humans."

We took up this challenge: we built the tools, implemented a subset of the C++ Core Guidelines, and applied them to more than 8,000 industrial embedded software projects. That was not an easy undertaking, because the defined “rule enforcements” contain all kinds of caveats, shortcomings, unclarities, exceptions etc.

During this talk, we will explore the conceptual obstacles we encountered during implementation, how we have addressed them, and what remains to be done to make the C++ Core Guidelines the de facto standard in C++ programming.

Tooling Track sessions are sponsored by Optiver.

Clang is the C++ compiler used by hundreds of millions of developers every day, yet most of those developers have never looked inside it. The codebase can feel intimidating, with millions of lines of C++, an unfamiliar architecture, and a review process with its own customs. But once you know the map, contributing is surprisingly accessible.

This session is a live, code-first walkthrough of the full contribution cycle for Clang. Starting from a clone of the LLVM monorepo, we will configure a development build, locate the right subsystem for a real reported bug, write a regression test, fix the bug, and verify the fix. We will then extend that foundation to implement a small but complete language feature: adding a new diagnostic, walking through Sema, the AST, and the diagnostic engine as we go. Every step attendees see on screen can be replicated on their own laptops during and after the session.

Attendees will leave with a mental model of Clang's layered architecture (driver, frontend, Sema, CodeGen), a workflow for finding the code responsible for any given compiler behavior, and enough familiarity with the test infrastructure and review process to open their first pull request.

Tooling Track sessions are sponsored by Optiver.