CppCon 2026

Profiles for simplicity and guarantees 08:30 - 10:15

Conference Group P...

C++26: A Curated Tour of What's New 11:00 - 12:00

Familiar C++ Patterns That Fail at Scale and the Design Shifts T... 14:00 - 15:00

The Latency Slippage: Understanding the Hidden Costs of Caching... 15:15 - 16:15

Back to Basics: const, constexpr, consteval 16:45 - 17:45

Committee Fireside Chat 20:30 - 22:00

Are You Smarter Than A Branch Predictor? 11:00 - 12:00

Towards a complete contract-assertion facility for C++ 14:00 - 15:00

std::simd Without Compromise: SIMD in C++26 and Beyond, as Fast... 15:15 - 16:15

Why Great C++ Libraries Fail (And How to Fix That) 16:45 - 17:45

Registration 08:00 - 08:30

Same Bits Without Losing MIPS: Reproducible Numerics at Full Har... 11:00 - 12:00

Pointers to Power: Navigating Organizational Influence 14:00 - 15:00

Capability Routing Grid: From Decoupled Plugins to the Hardware... 15:15 - 16:15

AEMBER: Modern Embedded C++ Without the Chaos 16:45 - 17:45

HRT Happy Hour 19:00 - 22:00

From 20 Nanoseconds to One: Optimizing Bishop, Rook, and Queen M... 11:00 - 12:00

[Open Content] C++26 Reflection on Windows with Visual Studio Co... 12:30 - 13:30

Component based or monolithic development for large C and C++ pr... 14:00 - 15:00

Back to Basics: Code Analysis 15:15 - 16:15

C++ in the Age of AI: How Visual Studio Is Evolving 16:45 - 17:45

From Firmware to Screen: Real-Time Control, Simulation, and Visu... 11:00 - 12:00

Beyond the Scheduler: Designing Predictable Embedded Systems in... 14:00 - 15:00

The journey to "/W4 /WX": How hard could it be? 15:15 - 16:15

Works on My Machine, Works in CI: Treating Your Build Toolchain... 16:45 - 17:45

Back to Basics: Move Semantics 11:00 - 12:00

Back to Basics: Templates 14:00 - 15:00

Catching Leaks: How to stop a C++ program at the exact instructi... 15:15 - 16:15

Zero Cost Scripting Languages for Game Engines With C++26 Static... 16:45 - 17:45

Interesting Upcoming Low-Latency, Networking, Concurrency, and P... 09:00 - 10:00

Language Designers Panel 10:30 - 12:00

Running Compiler Explorer in 2026: Sandboxes, Storage, and Stran... 14:00 - 15:00

Lock-Free Timer Scheduling With C++ Atomics 15:15 - 16:15

Ensuring Code Quality in the Age of AI : More Code, Less Enginee... 16:45 - 17:45

C++: The Documentary 20:30 - 22:00

What's New for C++ in Visual Studio Code: C++ and AI Tooling for... 09:00 - 10:00

C++ at Scale 14:00 - 15:00

C++ in an AI World 15:15 - 16:15

You’re absolutely wrong! How to get agents to solve complex prob... 16:45 - 17:45

Seven Research Women++ Networking Breakfast 07:00 - 09:00

Poster Presenter sessions 13:00 - 13:55

Scaling Robotics to 200 Developers: Flexible C++ Architectures f... 09:00 - 10:00

Back to Basics: Loops in C++ 14:00 - 15:00

Compile-Time Polymorphism for Runtime-Flexible Systems: Lessons... 15:15 - 16:15

Using Type Erasure to Extend APIs You Don't Own: A Case Study Fr... 16:45 - 17:45

[Open Content] Tower Research Capital - Ask Me A... 08:00 - 08:45

Can I memcpy This Type Across a Boundary? Verifying Object Repre... 09:00 - 10:00

[Open Content] The Death of Flow? How AI Changed Programming — a... 12:30 - 13:30

Inside a Small Game Engine: An Architecture Tour in Modern C++ 14:00 - 15:00

Hacking and Securing C++ 15:15 - 16:15

Back to Basics: std::unordered_map 16:45 - 17:45

[Open Content] One C++26 App Three Ways: By Hand, By AI, and Together 18:30 - 20:00

Death by a Thousand Tape Entries: Low-Overhead Automatic Differe... 09:00 - 10:00

[Open Content] Meet the Recruiters (Bloomberg edition) 12:30 - 13:30

Using Modules in a Real Project 14:00 - 15:00

C++ Core Guidelines Enforcement in Practice 15:15 - 16:15

From User to Contributor: Fixing Bugs and Adding Features in Cla... 16:45 - 17:45

The State of Boost: Boost Is Where You Become the Engineer You W... 09:00 - 10:00

What Are We Synchronizing? 14:00 - 15:00

Good boss, bad boss: how to be a good manager, and how to manage... 15:15 - 16:15

Practical HPC — Forcing the Compiler's Hand with Modern C++ 16:45 - 17:45

Awaiters and Awaitables 09:00 - 10:00

How C++26 changes the way we write code 10:30 - 12:00

Rule of 0,1,2,5,6,7,8,9,10? 14:00 - 15:00

Queue Discipline: A Deep Dive into Lock-Free SPSC, MPSC, SPMC, a... 15:15 - 16:15

Modern C++ Techniques to Reduce Boilerplate Without Sacrificing... 16:45 - 17:45

Boost.Documentary (Audience Preview Screening) 18:15 - 21:00

AI is UB with Better PR 09:00 - 10:00

Refactoring Techniques and Strategies (a Tale in Three Acts) 14:00 - 15:00

Back to Basics: Memory Alignment 15:15 - 16:15

Processor Design and C++ Memory Models 16:45 - 17:45

Lightning Talks 21:00 - 22:00

QRT Community Lunch 12:00 - 14:00

Automatic Splitting of Translation Units: Compiler-Agnostic Comp... 14:00 - 15:00

Readable Async Workflows in Modern C++: Coroutines Meet std::exp... 15:15 - 16:15

Graphics Programming with SDL 3 Part 2 16:45 - 17:45

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

CUDA Tile C++: Practical Automatic Parallelization for the GPU 09:00 - 10:00

[Open Content] C++23: Ask Me Anything and Book Signing 12:30 - 13:30

The Ghost in the Heap: Defeating a Memory Thief 14:00 - 15:00

You Shall Not Pass*! 15:15 - 16:15

My DAG Ate All My Cores: Identifying and Resolving Build Graph B... 16:45 - 17:45

Breaking the Speed Limit: Building a High-Throughput Hashing Eng... 09:00 - 10:00

Embedded-Friendly C++: Modern Features That Make a Difference 14:00 - 15:00

Our Journey Toward a Fully Backward-Compatible, UB-Safe, ISO C++ 15:15 - 16:15

Prioritizing Pretty-printers 16:45 - 17:45

Escaping the AST: A Data-Oriented, Lock-Free Parallel Compiler A... 09:00 - 10:00

Turbocharging Native Code Performance: Compiler Optimizations, P... 14:00 - 15:00

C++ Views and Pipelines 15:15 - 16:15

The Clocks of C++: Knowing When (and Why) to Use Each One 16:45 - 17:45

Writing Low-Latency C++: Predictability, Cache, and the Architec... 09:00 - 10:00

The Address is Not The Place: Object Residency in C++26 10:30 - 12:00

When Zero-Cost Abstractions Aren’t Zero-Cost 14:00 - 15:00

Modernizing Legacy Codebases without Stopping the World 15:15 - 16:15

Writing High Performance Parsers Using State Machines 16:45 - 17:45

Composing the Future: Async Workflows with std::execution 09:00 - 10:00

Generating Language Bindings using C++ Reflection 14:00 - 15:00

Ranges Without Compromises: Designing for Simplicity, Performanc... 15:15 - 16:15

Meet Guy Davidson 16:45 - 17:45

Lightning Talks 20:30 - 22:00

Meet the Presenters Banquet (Susquehanna) 18:30 - 20:30

Tying up Loose Threads: Making Y... 09:00 - 09:30

[[musttail]]-ling Our Way to a F... 09:35 - 10:05

What Is Your Algorithmic Core? 14:00 - 15:00

Leveraging LLM to Generate Unittests for Notifiers in Taskflow 15:15 - 16:15

Extending Google Test for Statis... 16:45 - 17:15

API Design is Language Design: L... 17:20 - 17:50

Beyond Monads: Pattern Matching Alternatives for Result Types 09:00 - 10:00

[Open Content ] The Barrier Is a Myth: Becoming a Boost Maintain... 12:30 - 13:30

Back to Basics: Containers 1/2 14:00 - 15:00

Back to Basics: Containers 2/2 15:15 - 16:15

A Duck Does More Than Quack: Synthesizing VTables with C++26 Ref... 16:45 - 17:45

Building C++20 Modules: The Rest of the Story 09:00 - 10:00

Type Punning: the joke is on you, pun intended. Fixing UB of rei... 14:00 - 15:00

The C++ safety issues your tools can't see 15:15 - 16:15

Back to Basics: Computer Systems 16:45 - 17:45

Back to Basics: Lambdas, Function Objects, and std::function 09:00 - 10:00

MrDocs: Reliable Reference Documentation for C++ Using the Clang... 14:00 - 15:00

The Biggest Misconception of Computer Science 15:15 - 16:15

Who Is #include-ing You? Measuring the Impact of C++ Libraries 16:45 - 17:45

“If You Can’t Measure It, You Can’t Improve It”: From Profiling... 09:00 - 10:00

What can C++26 reflection do for you?: A practical experiment in... 10:30 - 11:30

Thinking Low Level, Writing High Level 13:30 - 14:30

What 25 Days of Optimisations Taught Me About Compilers 14:45 - 15:45

C++: Growing in a world of efficiency, safety, and AI 16:15 - 18:00

The Next 20 Weeks of Systems Engineering 09:00 - 10:00

Mock Any Function in C++ Without Changing a Single Line of Code 10:30 - 11:30

Code You Didn't Write: Understanding Large and Unfamiliar Codeba... 13:30 - 14:30

Concurrency for Modern CPUs - Lock-Free or Lock-based? 14:45 - 15:45

Back to Basics: Text Formatting 09:00 - 10:00

Memory Safety on a Microcontroller: What Embedded C++ Teams Can... 10:30 - 11:30

When Air Gaps Learn: AI, Data, and the New C++ Attack Surface 13:30 - 14:30

Escaping 1996: Meta-Modern C++ Techniques for Embedded Systems 14:45 - 15:45

CMake: Making Hard Things Easy 09:00 - 10:00

Senders, Receivers, and Robots: Structured Concurrency for Auton... 10:30 - 11:30

[Open Content] Refactoring C++ : Techniques, Smells, and Discuss... 12:00 - 13:00

The Real Story of C++26: Beyond the Headline Features 13:30 - 14:30

The Value of Idiomatic Code 14:45 - 15:45

Safety in Numbers 09:00 - 10:00

IEEE 754 Decimals for C++: The Boost.Decimal Library 10:30 - 11:30

Back to Basics: Function Overloading 13:30 - 14:30

In Pursuit of a 6,000 FPS Game Boy Emulator 14:45 - 15:45

Code Like a Library Author: How to Write Better C++ Application... 09:00 - 10:00

Incremental Modernization: Refactoring Legacy OOP Application Co... 10:30 - 11:30

Implementing Async RAII 13:30 - 14:30

Back to Basics: C++20 Concepts 14:45 - 15:45

AI++ 201: Building High Quality C++ Infrastructure with AI 09:00 - 17:15

Function and Class Design with C++2x 09:00 - 17:15

High-performance Concurrency in C++ 09:00 - 17:15

AI++ 201: Building High Quality C++ Infrastructure with AI 09:00 - 17:15

Function and Class Design with C++2x 09:00 - 17:15

High-performance Concurrency in C++ 09:00 - 17:15