Loading…
arrow_back View All Dates
Wednesday, September 16
 

09:00 MDT

Escaping the AST: A Data-Oriented, Lock-Free Parallel Compiler Architecture
Wednesday September 16, 2026 09:00 - 10:00 MDT
The architecture of legacy compilers presents limitations for modern software development. As codebases scale, developers face increased compilation times. While language complexity is often cited, key architectural bottlenecks include pointer-chasing across deeply nested ASTs (cache misses), single-threaded type resolution, and significant thread-lock contention (RwLock) during parallel semantic analysis. What happens when we discard the Abstract Syntax Tree entirely and apply strict Data-Oriented Design to the compiler itself?

In this session, we will explore the internal architecture of the Vx compiler frontend—a heterogeneous systems programming language to safely maximize utilization of available CPU cores. We will dissect how to translate complex, tree-like program semantics into flat, contiguous arrays of 256-bit bit-packed Global Identifiers (GIDs).

By stepping away from traditional recursive tree-walking and object-oriented compiler design, attendees will learn how to implement high-throughput parallel pipelines.

This talk is not just for language designers. The architectural patterns used to build the Vx compiler—flattening graphs into arrays, deferred identity, and lock-free synchronization boundaries—are directly applicable to any C++ developer building high-performance, multithreaded systems.

Presenters
avatar for Aditya Kumar

Aditya Kumar

Software Engineer, Google
I've been working on LLVM since 2012. I've contributed to modern compiler optimizations like GVNHoist, Hot Cold Splitting, Hexagon specific optimizations, clang static analyzer, libcxx, libstdc++, and graphite framework of gcc.
Wednesday September 16, 2026 09:00 - 10:00 MDT
Willow Lake 3/4/5

09:00 MDT

Awaiters and Awaitables
Wednesday September 16, 2026 09:00 - 10:00 MDT
C++20 coroutines come with a reputation for complexity — and writing your own coroutine return type deserves that reputation. But here is the good news: you probably don't have to. With std::generator in C++23, high-quality libraries like Asio and cppcoro today, and std::task on its way in C++26, most developers can simply write co_await and move on.

There is one gap, however. Sooner or later, every developer using coroutines needs to bridge an existing asynchronous interface — a timer, an I/O operation, a thread pool callback, a legacy future — into the coroutine world. That bridge is built with awaiters and awaitables, and that is exactly what this session teaches.

We will start from first principles: what does co await actually do? We will demystify the three functions that form the awaiter protocol — await ready, await suspend, and await resume — and build a clear mental model for each. We will implement a real awaiter from scratch, then explore how symmetric control transfer keeps the call stack flat across deeply chained async operations. Next, we will learn how to make any existing type co await-able without modifying it, using operator co await, and how await transform lets you restrict or adapt awaitable behavior to a specific coroutine context. Finally, we will look at how to write cancellation-aware awaiters using std::stop token, so your coroutines respond promptly when work is no longer needed.

No prior coroutines experience is assumed. If you know what co await looks like on the surface but not what happens underneath it, this session is for you. You will leave with both the knowledge and the code to wrap any asynchronous operation into a first-class co await expression.

Presenters
avatar for Mateusz Pusz

Mateusz Pusz

C++ Trainer, Train IT
Mateusz Pusz is a C++ architect and voting member of the ISO C++ Committee (WG21), with 100% meeting attendance since 2017. As an active contributor to Library Evolution, he originated variable template template parameters (P2008, now part of C++26), co-authored heterogeneous lookup... Read More →
Wednesday September 16, 2026 09:00 - 10:00 MDT
Colorado A

09:00 MDT

Breaking the Speed Limit: Building a High-Throughput Hashing Engine With C++26
Wednesday September 16, 2026 09:00 - 10:00 MDT
Modern storage hardware has evolved at a breakneck pace. PCIe Gen 5 NVMe drives can push data at 10 GB/s, yet standard C++ file abstractions often leave them starving for data. Many developers think they need to abandon portability in favor of unmaintainable, OS-specific kernel bypasses to achieve the throughput necessary to saturate these drives. This session is for developers writing high-throughput, performance-critical applications who want to hit bare-metal speeds without sacrificing clean architecture, cross-platform support, or type safety.

Using a high-throughput cryptographic hashing engine as a concrete case study, this presentation demonstrates how to design a hardware-saturating data pipeline built entirely on the idioms of C++26. We will explore how the mathematical design of an algorithm - specifically BLAKE3's binary Merkle tree structure - can be mapped directly to wide SIMD vector lanes and concurrent CPU cores. We will walk through an execution model that completely bypasses the OS page cache, orchestrates memory without heap allocations on the hot path, and unifies OS kernel quirks in a portable way.

By the end of this presentation, you will learn how to replace rigid thread pools with lock-free, asynchronous execution graphs using Sender/Receiver paradigms (std::execution) and vectorization (std::simd). Crucially, we will focus on the build engineering required to make this work today. We will cover how to use advanced CMake tooling to safely compile multi-architecture vector binaries from a single source of truth, how to prevent LTO cross-contamination, and how to structure your pipeline today to seamlessly absorb upcoming C++ features in a world of trailing vendor toolchains.

Presenters
YS

Yannic Staudt

co-founder, tipi.build
Wednesday September 16, 2026 09:00 - 10:00 MDT
Red Rock 8/9

09:00 MDT

AI is UB with Better PR
Wednesday September 16, 2026 09:00 - 10:00 MDT
C++ runs the world’s systems, and with that comes a responsibility for safety and stability. Avoiding AI entirely gives up on incredible potential benefits, but using AI without guardrails poses significant risks to our critical systems. How does AI fit into this world? This talk examines effective and ineffective approaches to using AI in systems that cannot afford “slop.” We will explore several case studies where AI produced significant value in C++, and several where it did not. The pattern that emerges is consistent: AI thrives when it is orchestrating well-defined, deterministic components, translating between them intelligently without being trusted to reason correctly on its own. When AI is asked to be the system rather than connect the system, things fall apart.

Presenters
avatar for Andy Soffer

Andy Soffer

Andy Soffer is a lapsed mathematician turned software engineer. He spent eight years at Google, before founding BrontoSource in late 2024. His time at Google culminated in leading the C++ Core Libraries team (responsible for Abseil and GoogleTest) and the C++ Large Scale Refactoring... Read More →
Wednesday September 16, 2026 09:00 - 10:00 MDT
Colorado B

09:00 MDT

CUDA Tile C++: Practical Automatic Parallelization for the GPU
Wednesday September 16, 2026 09:00 - 10:00 MDT
CUDA Tile C++ is a novel C++ DSL and compiler that automatically parallelizes array operations across GPU threads while presenting a single logical thread to the programmer. In CUDA Tile C++, parallelism is expressed through SIMD-style operations on arrays of data called "tiles" while memory accesses are written using structured memory abstractions. The compiler analyzes the tile and memory operations to generate an equivalent multi-threaded program that leverages the advanced hardware capabilities of modern GPUs. This allows the user to write simple programs that exploit GPU parallelism without needing to manage low level hardware concurrency.

As GPU architectures evolve to meet the demands of high performance computing, the traditional multi-threaded GPU programming model becomes increasingly unwieldy. To achieve optimal performance, the GPU programmer must manage a growing variety of hardware features including shared memory, Tensor Memory Accelerators, and Tensor Cores. Traditional CUDA code is deeply coupled to the underlying hardware resulting in complex and non-portable algorithms. The CUDA Tile C++ compiler removes the need for coordinating these low level hardware details, freeing the user to reason about their algorithm rather than asynchronous code.

The tile programming model introduces three key abstractions:

  • cuda::tiles::tile - a multi-dimensional array with value semantics whose operations are parallelized across the GPU
  • cuda::tiles::tensor_span - a view into a multi-dimensional in-memory array with an interface similar to std::mdspan
  • Tile Views - adapters that present a uniform "chunking" of a tensor_span which gives the compiler visibility into memory access patterns
In this talk, we will explore how these abstractions allow NVIDIA's Tile C++ compiler to schedule the program across hardware threads all while preserving the illusion of a single-threaded abstract machine to the user.

Presenters
avatar for Ezra Stein

Ezra Stein

Senior Compiler Engineer, NVIDIA
Ezra Stein is a Senior Compiler Engineer working on NVIDIA's CUDA C++ Frontend team. Since joining the company in 2025, Ezra has focused primarily on the design and implementation of CUDA Tile C++. Prior to working at NVIDIA, Ezra spent 5 years developing MATLAB to C++ source-to-source... Read More →
Wednesday September 16, 2026 09:00 - 10:00 MDT
Red Rock 6/7

10:30 MDT

How C++26 changes the way we write code
Wednesday September 16, 2026 10:30 - 12:00 MDT
The upcoming C++26 Standard is a major update of the language and one of the most impactful releases in the history of C++.

std::simd transforms high-performance C++ by raising vectorisation to a portable standard abstraction. The new sender/receiver execution library provides a powerful generic framework that redefines asynchronous programming in C++. Contract assertions introduce scalable and configurable correctness checks for identifying program defects and making C++ code safer. Finally, reflection – the most eagerly anticipated feature of C++26 – profoundly reshapes how we reason about C++ and what we can accomplish with it.

This talk is the third installment in a popular series exploring how each new C++ Standard changes the way we write code – from everyday idioms to advanced patterns – with a practical focus on what matters most to real-world developers. This is not a firehose talk that tries to cram as many additions to the latest Standard as possible into one hour. Instead, we focus deliberately on just a handful of particularly impactful features and highlight the essential ideas every C++ developer needs to understand.


Presenters
avatar for Timur Doumler

Timur Doumler

Senior Software Engineer, Citadel Securities
Timur Doumler is a software engineer specialising in low-latency and real-time C++. He works at Citadel Securities and is an active member of the ISO C++ standard committee, where he has (co-)authored many successful proposals including [[assume]], std::inplace_vector, and contract... Read More →
Wednesday September 16, 2026 10:30 - 12:00 MDT
Colorado A

12:00 MDT

QRT Community Lunch
Wednesday September 16, 2026 12:00 - 14:00 MDT
Take a break from the sessions and join fellow C++ community members
for lunch and conversation.

Sherry Sontag will host the discussion.

The Qube Research and Technologies team will be there throughout. Come say hello and chat with
them about opportunities at QRT and what it's like to work on C++
there.

Advance registration was required for this lunch and is now closed.
Wednesday September 16, 2026 12:00 - 14:00 MDT
Colorado C

12:30 MDT

[Open Content] C++23: Ask Me Anything and Book Signing
Wednesday September 16, 2026 12:30 - 13:30 MDT
C++23 is the latest evolution in modern C++ programming that is now fully supported by the latest versions of GCC, Clang, and Visual C++.

As the first release after introducing several new key features with C++20, which can be seen as the beginning of a new release cycle, it contains both significant extensions and improvement of various features introduced with C++20 and a couple of new language and library features.

In my new book "C++23 - The Complete Guide", I cover all aspects of tis release.

This session gives you the opportunity to talk with me about C++23 and discuss various aspects of in in general or a bit in detail.
Presenters
avatar for Nicolai Josuttis

Nicolai Josuttis

Author and Teacher
I teach and teach and teach and teach C++. For centuries. Still learning this language. However in principle, C++ is no longer teachable...
Wednesday September 16, 2026 12:30 - 13:30 MDT
Red Rock 6/7

13:00 MDT

Official ISO C++ WG21 SG meeting of low latency/embedded/games/finance and Machine Learning
Wednesday September 16, 2026 13:00 - 16:30 MDT

Presenters
avatar for Michael Wong

Michael Wong

CTO, Distinguished Engineer, YetiWare
Michael Wong is the CTO of YetiWare an AI company, and was a Distinguished Engineer/VP of R&D at Codeplay/Intel. He is a current Director and VP of ISOCPP, Chair of the C++ Direction Group, and a 25 year senior member of the C++ Standards Committee with more than 15 years of experience... Read More →
Wednesday September 16, 2026 13:00 - 16:30 MDT
Red Rock 1

14:00 MDT

Embedded-Friendly C++: Modern Features That Make a Difference
Wednesday September 16, 2026 14:00 - 15:00 MDT
C++ is used in many fields. One that sticks out is the embedded domain. You're often working with tight constraints. Writing software is challenging and fun at the same time.

What has C++ done to support this field? What new options do you have to avoid undefined behavior and write more efficient and robust code?

In this talk, I will present various library elements as well as language improvements that make writing embedded software better.

We'll look at real-world tasks like turning raw byte blobs into usable data structures, aka type punning, of course, without triggering undefined behavior. C++23 supports you in a new way with std::start_lifetime_as .

Transferring data via a network comes with its challenges. You have to care about the byte order. Oh, and how can you make sure that there are no padding bytes included? Well, I have an answer for you.

And then there is a brand-new feature in C++26: static reflection. I will present examples of how and where reflection in C++ eases embedded development.

By the end of this talk, you know the most important improvements in C++ for embedded or similar environments.

Presenters
avatar for Andreas Fertig

Andreas Fertig

C++ Trainer & Consultant
Andreas Fertig is an expert C++ trainer and consultant who delivers engaging and impactful training sessions, both on-site and remotely, to teams around the globe. As an active member of the C++ standardization committee, Andreas contributes directly to shaping the future of the language... Read More →
Wednesday September 16, 2026 14:00 - 15:00 MDT
Red Rock 8/9

14:00 MDT

Turbocharging Native Code Performance: Compiler Optimizations, Profile-guided Optimizations, and Beyond
Wednesday September 16, 2026 14:00 - 15:00 MDT
Making native code fast is a team sport: efficient algorithms, high-performance libraries, memory-conscious design, and modern hardware all play a role. But the critical link between your code and the hardware it runs on is the optimizing compiler.

This talk explores new & improved compiler optimizations in Visual Studio 2026, and how these improve the performance of existing C++ code with minimal source changes. We will examine both architecture-independent optimizations (such as improved scalar replacement, vectorization, and loop transformations) and architecture-specific enhancements (such as AVX-512 and NEON specific optimizations). Along the way, we will connect high-level C++ constructs to the generated assembly and CPU behavior to build an intuition for how performance improvements are realized. While the talk discusses Visual Studio code generation & optimizations, the tools and analysis apply to all native platforms & compilers.

We will also introduce sample-based profile-guided optimizations (SPGO) which uses the runtime characteristics of your application to guide optimization decisions, WITHOUT requiring traditional instrumentation. You will learn how SPGO works, how to apply it in practice, and where it delivers measurable gains: typically in the 5-15% range across real world native codebases.

Attendees will leave with a practical understanding of how to reason about native code performance, and how to leverage SPGO to turbocharge the performance of their code.

Presenters
avatar for Eric Brumer

Eric Brumer

Engineering Manager, MSVC, Microsoft
Eric is an engineering manager on the Microsoft C++ Team, working on the compiler back-end.
Wednesday September 16, 2026 14:00 - 15:00 MDT
Willow Lake 3/4/5

14:00 MDT

Rule of 0,1,2,5,6,7,8,9,10?
Wednesday September 16, 2026 14:00 - 15:00 MDT
As of C++11 there are 6 special member functions that the compiler will generate for us if we don't do anything to get in the way.

But there are many other member functions, in the form of comparison operators, that we can =default explicitly

Which of these should we =default? How do we help the compiler, or stay out of its way?

How many do we need to implement? When can you trust the compiler or not?A

Presenters
avatar for Jason Turner

Jason Turner

Sole Proprietor, Jason Turner
Jason is host of the YouTube channel C++Weekly, co-host emeritus of the podcast CppCast, author of C++ Best Practices, and author of the first casual puzzle books designed to teach C++ fundamentals while having fun!
Wednesday September 16, 2026 14:00 - 15:00 MDT
Colorado A

14:00 MDT

The Ghost in the Heap: Defeating a Memory Thief
Wednesday September 16, 2026 14:00 - 15:00 MDT
In the C++ world, it is often assumed that proper object lifetime management ensures a memory footprint that scales with an application’s actual needs. However, long-running systems are frequently sabotaged by heap pinning: a phenomenon in which Resident Set Size (RSS) refuses to shrink even after significant deallocations. This results in a critical, 'invisible' overhead that defies standard leak-detection tools and can lead to system thrashing and even Out Of Memory (OOM) kills.

Heap pinning occurs when long-lived allocations are interleaved with transient ones, creating a structural barrier that prevents the underlying allocator from releasing memory back to the system. A single persistent allocation can 'pin' an entire block of physical memory, forcing the OS to keep it mapped even if the surrounding space is empty. Consequently, the process footprint reflects historical peak usage rather than the current live state.

In this talk, we will bridge the disconnect between C++ deallocations and physical memory reclamation. You will learn to use allocator-aware objects and std::pmr resources to eliminate pinning by strategically segregating allocations based on their expected lifetimes. We will also demonstrate how to diagnose these 'ghost' overheads when traditional heap profilers fall short. You’ll leave the session equipped to identify and resolve these fragmentation traps, ensuring your application’s memory footprint finally stays proportional to its actual state.

Presenters
avatar for Nicolas Arroyo

Nicolas Arroyo

Software Architect, Bloomberg
Nicolas Arroyo has spent two decades crafting C++ in high-stakes environments, spanning VoIP, embedded systems, distributed systems, and low-latency financial infrastructure. Currently, he specializes in building performance-analysis tooling, system-level benchmarking, and eliminating... Read More →
Wednesday September 16, 2026 14:00 - 15:00 MDT
Red Rock 6/7

14:00 MDT

Refactoring Techniques and Strategies (a Tale in Three Acts)
Wednesday September 16, 2026 14:00 - 15:00 MDT
Refactoring is defined as "the process of changing a software system in a way that does not alter the external behavior of the code yet improves its internal structure", and is a core skill and process in modern software development. From "cleaning up a little mess" to handling legacy code to improving testability to completely changing architecture, refactoring is the process to achieve that elusive thing, "clean, elegant, and maintainable code".

This talk will cover the basics of Refactoring from three angles. First, we will cover a few of the most important refactoring techniques and connect them to other well-known points of good C++ style.

Second, we'll talk about how to decide what and where to refactor. Common "code smells" are good places to start, but we will also discuss how to look for "seams" along which code can be cut, and how to find hints left in the code by previous developers that can point the way.

Third, we'll discuss how to successfully execute refactoring, even on a busy team and a big code base. What is the "blast radius" of a change, how to minimize the disruption it causes, and how to avoid annoying co-workers in the process.

Presenters
avatar for Dave Steffen

Dave Steffen

Principal Software Engineer, SciTec Inc
Dave Steffen completed his Ph.D. in theoretical physics at Colorado State University in 2003, and promptly changed course for a career in software engineering. He has worked primarily in defence and aerospace, and is currently a technical lead at SciTec Inc.'s Boulder office. For... Read More →
Wednesday September 16, 2026 14:00 - 15:00 MDT
Colorado B

14:00 MDT

Automatic Splitting of Translation Units: Compiler-Agnostic Compiler Frontend Parallelization
Wednesday September 16, 2026 14:00 - 15:00 MDT
AI agents are accelerating code generation at an unprecedented pace, yet C++ file is still compiled as a monolithic translation unit, meaning a many-core machine often cannot rebuild a template-heavy file much faster than a single core. Header-heavy designs, inline functions, and templates compound the problem: the same bodies are parsed repeatedly, and small edits can invalidate an entire translation unit.

This talk presents a compiler-agnostic technique for splitting translation units into smaller independently compilable units. Using libclang, the tool rewrites headers and sources into declaration-only interfaces plus generated .cpp fragments, backed by a shared preamble that can turn into a C++ module, precompiled header, cached serialized AST and a source-map. The fragments compile in parallel, then link into a binary functionally equivalent to the original monolithic build.

Expect benchmarks from major codebases covering compile-time, link-time, and run-time performance; live demos of fast incremental updates that avoid reprocessing unchanged code as well as an analysis of the resulting binaries layout.

Tooling Track sessions are sponsored by Optiver.
Presenters
avatar for Damien Buhl

Damien Buhl

co-founder, tipi.build by EngFlow
Damien (aka daminetreg), co-founder tipi.build by EngFlow is an enthusiast C++ developer. Opensource entrepreneur, CppCon Speaker, GameMaker.fr community founder, Qt for Android contributor and Boost.Fusion maintainer since 2014.
Wednesday September 16, 2026 14:00 - 15:00 MDT
Homestead 3/4

15:15 MDT

Back to Basics: Memory Alignment
Wednesday September 16, 2026 15:15 - 16:15 MDT
Have you ever wondered why your C++ class suddenly doubled in size, or why reordering its members made it smaller? This talk introduces memory alignment in C++ from the ground up - what it is, why it is critical, and how compilers handle it under the hood. We’ll start from first principles: how modern CPUs read memory, the difference between aligned and unaligned access, and the performance costs of getting it wrong. Using benchmarks, we’ll see just how impactful misalignment can be. From there, we’ll dive into how compilers lay out data members in structs and classes, and how simple reordering can reduce memory footprint. Live coding examples will illustrate how padding is introduced and how tools like alignas, alignof, and std::align give you precise control. We’ll also look at packed data structures, which trade alignment guarantees for compactness - common in network protocols. While they can save space, they also introduce risks like undefined behavior when misused. Through real-world examples, you'll learn when packed structures make sense, and when they’re a hazard. By the end of the talk, you'll walk away with a solid intuition for alignment and the confidence to manage memory layout effectively in your programs.

Presenters
avatar for Sarthak Sehgal

Sarthak Sehgal

Tech Lead, Maven Securities
Sarthak Sehgal is a C++ Software Engineer at a high-frequency options market-making firm based in Chicago. He is passionate about low-level programming, performance optimization, and their applications in financial systems. Outside of work, he shares insights on C++ and finance on... Read More →
Wednesday September 16, 2026 15:15 - 16:15 MDT
Colorado B

15:15 MDT

C++ Views and Pipelines
Wednesday September 16, 2026 15:15 - 16:15 MDT
C++ Views were introduced with C++20 and extended with C++23 and C++26. They are lightweight objects that specify how to use (specific) elements of collections and their values. By composed into pipelines, programmers can easily define complex processing of collections of data.

However, the use of views also has pitfalls and traps. Therefore you should know about * The consequences of reference semantics * The problems of caching Views * The problems of using const with views * The Filter View Fiasco

This talk gives an overview about both the technology and where to pay special attention.

Presenters
avatar for Nicolai Josuttis

Nicolai Josuttis

Author and Teacher
I teach and teach and teach and teach C++. For centuries. Still learning this language. However in principle, C++ is no longer teachable...
Wednesday September 16, 2026 15:15 - 16:15 MDT
Willow Lake 3/4/5

15:15 MDT

Our Journey Toward a Fully Backward-Compatible, UB-Safe, ISO C++
Wednesday September 16, 2026 15:15 - 16:15 MDT
Today's world runs on C++. That's because, in domains requiring scale, performance, low latency, and fine-grained control over concurrency, C++ is second to none! Yet in recent years, a growing concern has emerged: C++ programs are often considered unsafe — not because of programmer negligence, but because the language itself provides insufficient mechanisms to prevent or reliably detect undefined behavior (UB).

For those financially and technically invested in C++, its current lack of language safety raises a fundamental question: How can we evolve ISO C++ to be UB-safe without necessarily sacrificing runtime performance, and without breaking backward compatibility with existing, valid C++ code?

In this talk, we begin by motivating an overall approach to UB-safety that starts from a simple but uncompromising premise: each individual potential source of UB must be able to be detected via runtime checking. Crucially, this approach eliminates the notion of "safe" and "unsafe" regions of a program — there is no place where UB can hide, and no need to switch languages, subsets, or tools to achieve comprehensive coverage.

We then examine how the C++26 contracts facility provides the essential foundation for transforming optional runtime checks into the practical, scalable mechanisms to eliminate UB bugs in production software. Contracts give developers fine-grained control over where and when checking occurs, allowing runtime overhead to be spent where it is affordable or most valuable — such as in new, rarely executed, or security-critical code. These decisions naturally evolve over time, as long-running checks that never fire may no longer justify their cost.

Finally, we outline the concrete steps of an incremental journey toward reducing undefined behavior in ISO C++. The result is a model of UB-safety — rooted in C++26 contracts and optional runtime checking — that is competitive with, and in key respects stronger than, approaches taken by other high-performance languages. Most importantly, this model applies not only to new code, but to the vast body of existing C++ software already in the wild.

Presenters
JL

John Lakos

John Lakos, author of Large-Scale C++ Software Design (Pearson, 1996), is currently exploring the application of AI to large-scale C++ software design. From 2001 to 2026, he served at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development worldwide... Read More →
Wednesday September 16, 2026 15:15 - 16:15 MDT
Red Rock 8/9

15:15 MDT

Readable Async Workflows in Modern C++: Coroutines Meet std::expected
Wednesday September 16, 2026 15:15 - 16:15 MDT
What makes an async workflow readable? Not just linear control flow — you also need to see where errors go, what each step depends on, and how failures compose. This talk takes a single production workflow — multiple async RPC calls with conditional branching, parallel fan-out, and partial-failure handling — and shows it implemented in three paradigms: callbacks with thread pools, a workflow orchestration graph over futures, and coroutines with std::expected. We evaluate each through four questions: where does the control flow live, the error flow, the coupling, and the migration risk?

Coroutines restore linear control flow, but without structured error composition, the workflow drowns in manual failure checks at every step, that is more error-handling code than business logic. Task
Presenters
avatar for Futong Liu

Futong Liu

Software Engineer, Bloomberg
Futong Liu is a software engineer at Bloomberg, where he works on distributed back-end systems for financial infrastructure, with a focus on trading systems built in modern C++. His work spans asynchronous programming, service orchestration, and event-driven workflows in production... Read More →
Wednesday September 16, 2026 15:15 - 16:15 MDT
Homestead 3/4

15:15 MDT

You Shall Not Pass*!
Wednesday September 16, 2026 15:15 - 16:15 MDT
Sean Parent's "no raw pointers" guideline is often misunderstood as "avoid T* , use smart pointers instead", even though Sean explicitly included smart pointers in his definition of a raw pointer: "anything with implied ownership and reference semantics".

This talk presents a refinement of that guideline:

Pointers - smart or not - shall not appear in function signatures, neither as argument nor as return type.

The focus of this talk is how to implement classes as regular types while still supporting dynamic allocation, polymorphism, and sharing internally.

It shows how such value types can be implemented manually, without dedicated library support. It then follows the evolution of the language and library in gradually simplifying these abstractions: C++11 smart pointers ( unique_ptr and shared_ptr ), C++26 vocabulary types ( indirect and polymorphic ), as well as in-progress proposals ( copy_on_write and protocol ) are presented as tools to simplify writing safe abstractions, not as safe abstractions themselves.

Along the way, the talk revisits the Rules of 3/5/0, exception safety guidelines, const propagation, aliasing, and local reasoning.

The talk aims to make you stop passing pointers around.

Presenters
avatar for Daniel Pfeifer

Daniel Pfeifer

Senior Software Engineer
Wednesday September 16, 2026 15:15 - 16:15 MDT
Red Rock 6/7

15:15 MDT

Queue Discipline: A Deep Dive into Lock-Free SPSC, MPSC, SPMC, and MPMC Queues in Modern C++
Wednesday September 16, 2026 15:15 - 16:15 MDT
Queues are the backbone of concurrent systems — yet most C++ developers treat them as a black box. Pick the wrong queue topology, misplace an alignas, or use the wrong memory order, and you pay for it in microseconds of latency, invisible cache thrashing, or subtle correctness bugs that only manifest under load. This talk is a rigorous, bottom-up treatment of the four canonical concurrent queue topologies: SPSC, MPSC, SPMC, and MPMC. We start with the hardware reality — how cache coherence protocols turn innocent struct layout into a performance disaster through false sharing — and build upward through the C++ memory model, atomic operations, and queue algorithm design. For each topology, we derive the minimal set of memory ordering guarantees required for correctness, show how to exploit producer/consumer asymmetry to eliminate unnecessary synchronization, and demonstrate how alignas(std::hardware destructive interference size) and deliberate padding can be the difference between 100ns and 10ns throughput. We dissect Dmitry Vyukov's MPMC ring buffer, the intrusive MPSC queue, and Michael-Scott's linked-list queue — not just their interfaces, but the why behind every memory order acquire and every phantom cache line. We then go beyond correctness into the practical engineering tradeoffs: bounded vs unbounded, throughput vs latency, contention vs coordination overhead. Real benchmark data shows how these decisions interact non-obviously — an MPMC queue can outperform MPSC under certain producer counts, and seq cst where you don't need it can quietly halve your throughput. Attendees will leave with a clear mental model for choosing and implementing the right queue for their threading topology, a checklist for false sharing audits, and battle-tested code patterns suitable for low-latency production systems.

Presenters
avatar for Anmol Singhal

Anmol Singhal

Gardening, My garden
Anmol has spent 5 years working as a quantitative developer at Goldman Sachs and IMC trading. Previously he completed his education from NYU and BITS Pilani. Most recently he developed multi threaded applications for trading application and improved software performance. He errs on... Read More →
Wednesday September 16, 2026 15:15 - 16:15 MDT
Colorado A

16:45 MDT

Graphics Programming with SDL 3 Part 2
Wednesday September 16, 2026 16:45 - 17:45 MDT
Last year I introduced the SDL3 library which provides a solution for building games and graphical applications on multiple platforms. In this talk, we will continue our journey into SDL3, which newly includes the ability to write shaders within the built-in 2D API. My goal is to get you up and running fast by building out a small game application. Throughout the talk I will show how to build a small 2D framework, discussing design decisions and which C++ features can be used to help organize our code. Attendees will leave this talk ready to build multimedia / game applications and with an understanding on if SDL3 is the right tool for them.

Presenters
avatar for Mike Shah

Mike Shah

Professor / (occasional) 3D Graphics Engineer
Mike Shah is currently a teaching faculty at Yale University with primary teaching interests  in computer systems, computer graphics, and game engines. Mike's research interests are related to performance engineering (dynamic analysis), software visualization, and computer graphics... Read More →
Wednesday September 16, 2026 16:45 - 17:45 MDT
Homestead 3/4

16:45 MDT

Modern C++ Techniques to Reduce Boilerplate Without Sacrificing Performance
Wednesday September 16, 2026 16:45 - 17:45 MDT
Modern C++ gives developers powerful tools to write cleaner, safer, and more expressive code — but many production codebases still suffer from excessive boilerplate, repetitive patterns, and verbose implementations inherited from older C++ styles.

This talk explores practical modern C++ techniques that significantly reduce lines of code while preserving readability, maintainability, and runtime performance.

Through real-world examples, we will refactor traditional C++ implementations using features such as ranges, structured bindings, constexpr, concepts, CTAD, lambdas, std::optional, std::variant, and std::expected. We will examine where these features genuinely improve code quality — and where they can accidentally hurt clarity or performance if misused.

The session also goes beyond syntax improvements by analyzing generated assembly, compiler optimizations, allocations, and benchmark results to validate whether “shorter” code truly remains zero-cost.

Attendees will leave with practical patterns they can immediately apply to modernize existing codebases, reduce unnecessary complexity, and write more expressive C++ without sacrificing performance.

Presenters
avatar for VISHNU G NATH

VISHNU G NATH

Software Technical Lead, Applied Materials
Seasoned software developer with over 8 years of experience specializing in modern C++ development across industrial automation, semiconductor manufacturing, and enterprise systems. He currently works as a Technical Lead Software at Applied Materials, where he architects and implements... Read More →
Wednesday September 16, 2026 16:45 - 17:45 MDT
Colorado A

16:45 MDT

Prioritizing Pretty-printers
Wednesday September 16, 2026 16:45 - 17:45 MDT
Working with C++ code can be difficult, and it's made even more difficult when the code isn't your own. Everyone agrees that documentation is necessary when sharing a library. But, as a user of a library, the documentation may not help when you want to know the current state of your program. If you're a veteran C++ programmer then you may easily find your way around memory readouts, putting print statements in exactly the right spots, or reading "between the lines" of the documentation. Some of us are not very experienced, or we aren't able to recompile the code with print statements, or the documentation may not help with the problem.

Hopefully, the author had written a GDB extension to pretty-print their data types. But odds are, they didn't. As library writers, or as people writing classes for others to use and reuse, we can and should be writing debugger visualizers. We can empower our users by lowering the barrier to using the library successfully. Let's make our libraries more accessible. Software is about more than just the source code.

This talk will help you make the most of GDB extensions. After briefly discussing how to get started with GDB assuming zero prior knowledge, we will discuss how to write a GDB pretty-printer, how to set up your system to use the pretty-printer, how to embed it into your compiled binary, and how to distribute it with auto-loading scripts. By the end of the talk, the user will not only know the basics of writing a simple "to_string()", but will also understand how to effectively display containers and how to implement custom debugger-side user-facing extension methods. Let's get excited about debuggers!

Presenters
avatar for Braden Ganetsky

Braden Ganetsky

Braden Ganetsky graduated from the University of Manitoba with a degree in mechanical engineering, fueled by his passion for mechanical puzzles. During his final year of school, when all classes and activities were remote, he discovered C++ and has been hooked ever since. He interned... Read More →
Wednesday September 16, 2026 16:45 - 17:45 MDT
Red Rock 8/9

16:45 MDT

Processor Design and C++ Memory Models
Wednesday September 16, 2026 16:45 - 17:45 MDT
std::atomic and std::memory_order are utterly opaque abstractions. It feels like they were put in place to hide some monstrosity that is too complex for mortals to comprehend, and inevitably when trying to understand the underlying reality, the explanations end with 'the processor does weird things' and 'think about it as if...'.

Well, 'think about it as if' no more. In this talk we'll present the gory and wonderful mechanics of cache coherence protocols, store buffers, cache invalidation queues and the in-processor load-store-queue. We'll explain how modern hardware design makes different cores have different views of memory, and what fences and read-modify-write instructions do exactly - for both x86/64 and ARM/RISC-V (which are sometimes dramatically different).

This is an advanced low-level talk located at the borderline of software development and electrical engineering, discussing topics rarely - if ever - discussed at C++ conference talks.

Presenters
avatar for Ofek Shilon

Ofek Shilon

Senior Developer, Speedata
A Mathematics MA by training, but a 20Y C++ developer, writer and speaker in both the Linux and MS universes. Member of the maintainers team of Compiler-Explorer (==godbolt). Fascinated by compilers, debuggers and pretty much anything low level. Fiercely hated by his cat for no apparent... Read More →
Wednesday September 16, 2026 16:45 - 17:45 MDT
Colorado B

16:45 MDT

The Clocks of C++: Knowing When (and Why) to Use Each One
Wednesday September 16, 2026 16:45 - 17:45 MDT
Time handling in C++ looks simple — but it has some caveats. Between system_clock , steady_clock , high_resolution_clock , and a few new friends from C++20, it’s easy to pick the wrong one and end up with flaky tests, wrong timestamps, or confusing results.

This talk demystifies how time works in C++. We’ll explore what a "clock" really is, how std::chrono models it, and why not all clocks tick the same way. You'll learn when to use each standard clock, how to reason about monotonicity and precision, and how to build your own custom or fake clocks to make testing reliable.

By the end, you'll not only understand the difference between wall time and steady time — you'll know how to use them confidently in your production and test code.

Presenters
avatar for Sandor Dargo

Sandor Dargo

Software Developer, Spotify
Sandor is a passionate software developer focusing on reducing the maintenance costs by developing, applying and enforcing clean code standards. His other core activity is knowledge sharing both oral and written, within and outside of his employer. When not reading or writing, he... Read More →
Wednesday September 16, 2026 16:45 - 17:45 MDT
Willow Lake 3/4/5

16:45 MDT

My DAG Ate All My Cores: Identifying and Resolving Build Graph Bottlenecks
Wednesday September 16, 2026 16:45 - 17:45 MDT
Every C++ developer runs their build system dozens of times a day, yet few think about what it actually computes. Underneath every cmake --build or ninja invocation lies a directed acyclic graph, a DAG of dependencies that determines what gets rebuilt, in what order, and how much parallelism is available. When builds are slow, when incremental rebuilds trigger more work than expected, or when CI bottlenecks in surprising places, the root cause is almost always a structural property of this graph. Most developers never look at it.

This talk makes the build graph visible and actionable. Through curated examples, we will visualize dependency graphs and expose the common pathologies: overly connected "hub" headers that invalidate half the build when touched, deep critical paths that starve parallelism even on a 128-core machine, and accidental edges introduced by includes that no one questioned. These are not just build performance issues: they are architectural issues wearing a different hat. Your build graph is the ground truth of your codebase's structure, whether or not it matches the diagram in your team's documentation.

Armed with this mental model, we will walk through practical techniques for reshaping the graph: measuring critical path length from .ninja_log , identifying high-fan-in nodes, breaking costly edges with forward declarations and interface segregation, and using graph analysis as an automated architectural fitness function in CI. Worked examples will show concrete before-and-after measurements. You will leave with a new way of seeing your codebase, not as files in folders, but as a graph you can visualize, measure, and deliberately reshape.

Tooling Track sessions are sponsored by Optiver.
Presenters
avatar for Florent Castelli

Florent Castelli

Software Engineer, EngFlow
Wednesday September 16, 2026 16:45 - 17:45 MDT
Red Rock 6/7

18:15 MDT

Boost.Documentary (Audience Preview Screening)
Wednesday September 16, 2026 18:15 - 21:00 MDT
Boost has always been run by its community. Nothing got in without review, nobody's library was above being argued. The Boost.Documentary filmmakers want their film held to the same standard. Join the test screening and ensure your thoughts are reflected in the general release cut!

The True Stories team will be on site during this Audience Preview Screening.

True Stories is the two-time Image Award-nominated production company of Collier Landry and Ray Nowosielski. They met on the production of A Murder in Mansfield, bringing to life Landry’s personal story for Warner Discovery, and have since together and solo led the productions of Emmy- and awards-nominated documentaries, including 1946: The Mistranslation that Shifted Culture, Desert One (HISTORY), Gumbo Coalition (HBO Max), Reservation Redemption, The Super Models (AppleTV), and Tricky Dick and the Man in Black (Netflix), and podcasts, including After the Uprising (iHeartMedia), The Collier Landry Show (YouTube), Finding Mom’s Killer (Sony/The Binge) and Moving Past Murder (YouTube).



Wednesday September 16, 2026 18:15 - 21:00 MDT
Colorado A

21:00 MDT

Lightning Talks
Wednesday September 16, 2026 21:00 - 22:00 MDT
Lightning talks are your five minutes of stardom. The format encourages a focused and often high-energy presentation about nearly anything (subject to approval by the conference) that might be interesting to the C++ community, including proprietary technologies. They can be of a lighter or humorous nature, but they need not be.

Submit your talk here
Wednesday September 16, 2026 21:00 - 22:00 MDT
Colorado B
 
Share Modal

Share this link via

Or copy link

Filter sessions
Apply filters to sessions.
Filtered by Date -