CppCon 2025

Tee Shirt Night 17:30 - 20:00

Field Trip: Wings Over the Rockies Air Museum 10:30 - 16:00

Registration Reception 20:00 - 22:00

European Networking Dinner by think-cell 18:15 - 20:15

Concept-based Generic Programming 08:45 - 10:30

Conference Group P...

Committee Fireside Chat 20:30 - 22:00

The joy of C++26 contracts (and some myth-conceptions) 11:00 - 12:00

Building Robust Inter-Process Queues in C++ 14:00 - 15:00

Inherently Unsafe: Practical Approaches for Writing Safer C++ 15:15 - 16:15

Implementing Your Own Atomics 16:45 - 17:45

HRT Networking Social 18:00 - 20:30

Zero-Overhead Abstractions: Building Flexible Vector Math Librar... 11:00 - 12:00

From Bayesian Inference to LLMs: Modern C++ Optimizations for Re... 14:00 - 15:00

Changing /std:c++14 to /std:c++20 – How Hard Could It Be? 15:15 - 16:15

From Theory to Practice: A Student Journey Building a C++ Game E... 16:45 - 17:45

Performance Is Not a Number: Avoiding Microbenchmarking Pitfalls 11:00 - 12:00

Understanding Bitcoin for Investors 12:30 - 13:30

Practical Reflection 14:00 - 15:00

Where'd all that RAM Go? Measuring Objects with Ownership-Aware... 15:15 - 16:15

Building Secure C++ Applications: A Practical End-to-End Approac... 16:45 - 17:45

Cutting C++ Exception time by 93.4% 11:00 - 12:00

Emulating a BBC Micro in Javascript 12:30 - 13:30

Implement Standard Library: Design Decisions, Optimisations and... 14:00 - 15:00

Enhancing Exception Handling and Debugging using C++23 std::stac... 15:15 - 16:15

Declarative Refactoring for the Masses 16:45 - 17:45

Agentic Debugging: From Guesswork to Root Cause with AI 18:30 - 20:00

Back to Basics: Strings and Character Sequences 11:00 - 12:00

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

Could We Handle an ABI Break Today? 15:15 - 16:15

How to Affect the Future of C++ Standard in 60 Minutes 16:45 - 17:45

Registration 08:00 - 08:45

QRT Global Networking Lunch 12:00 - 14:00

Crafting the Code You Don’t Write: Sculpting Software in an AI World 10:30 - 12:00

Panel: What We Learned About AI Tools For C++ Engineers 20:30 - 22:00

The Missing Step: Making Data Oriented Design One Million Times... 09:00 - 10:00

Refactoring at Scale: LLM‑Powered Pipelines for Detecting Code S... 14:00 - 15:00

Building a High-Performance Binary Serialization Format with In-... 15:15 - 16:15

Cache-Friendly C++ 16:45 - 17:45

Author Signing: Nicolai Josuttis 12:00 - 12:30

Creating a Declarative UI Library in C++ 09:00 - 10:00

Using Floating-point: What Works, What Breaks, and Why 14:00 - 15:00

Performance of std::expected With Monadic Operations 15:15 - 16:15

C++ ♥ Python 16:45 - 17:45

Alex Stepanov, Generic Programming, and the STL 07:15 - 08:45

Back to Basics: Refactoring 09:00 - 10:00

Interesting Upcoming Low-Latency, Concurrency, and Parallelism F... 14:00 - 15:00

std::optional＜T&＞ --- Optional over References 15:15 - 16:15

API Structure and Technique: Learnings from Code Review 16:45 - 17:45

r/AskTowerAnything 08:00 - 08:45

What's New for Visual Studio Code: CMake Improvements and GitHub... 09:00 - 10:00

Time Travel is Real: Debugging C++ Problems in Network Operating... 12:30 - 13:30

Back to Basics: Code Review 14:00 - 15:00

Engineers Are Users Too: A Case Study in Design Thinking for Inf... 15:15 - 16:15

How to Tame Packs, std::tuple, and the Wily std::integer_sequenc... 16:45 - 17:45

Modern C++ for Robust Bundle Adjustment: From Outliers to Optimi... 09:00 - 10:00

What’s New in Visual Studio for C++ Developers in 2025 14:00 - 15:00

Debugging C++ Coroutines in GDB 15:15 - 16:15

15 Years Doing C++ Standardization Work: A Personal Retrospectiv... 16:45 - 17:45

Community Dinner 18:15 - 20:30

Reflection: C++’s Decade-Defining Rocket Engine 10:30 - 12:00

Best Practices for AI Tool Use 09:00 - 10:00

Lazy and Fast: Ranges Meet Parallelism in C++ 14:00 - 15:00

C++ Performance Tips: Cutting Down on Unnecessary Objects 15:15 - 16:15

Compiler Explorer: The Features You Never Knew Existed 16:45 - 17:45

Lightning Talks 20:30 - 22:00

Author Signing: Andreas Fertig 12:00 - 12:30

Poster Presentations 12:30 - 13:30

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

Back to Basics: Ranges 09:00 - 10:00

LLMs in the Trenches: Boosting System Programming with AI 14:00 - 15:00

To Err is Human: Robust Error Handling in C++26 15:15 - 16:15

The Programmer CEO 16:45 - 17:45

What C++ Needs to be Safe 09:00 - 10:00

Modern CMake: Past, Present, and Future 14:00 - 15:00

Mastering the Code Review Process 15:15 - 16:15

Pragmatic CMake 16:45 - 17:45

Beman Project Meetup 08:00 - 08:45

C++26 - What's In It For You? 09:00 - 10:00

DepC: Like C++ but with Dependent Types 12:30 - 13:30

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

Networks in C++ 15:15 - 16:15

Parallel Range Algorithms: The Evolution of Parallelism in C++ 16:45 - 17:45

Rust Traits in Style for C++: How We Unlocked Their Big Benefits... 09:00 - 10:00

Engineering the Software, from DevEx to Delivery 14:00 - 15:00

Cross-platform Package Managemen... 15:15 - 15:45

Connecting C++ Tools to AI Agent... 15:50 - 16:20

Welcome to v1.0 of the meta::[[verse]]! 16:45 - 17:45

Full Reg Reception 17:45 - 18:30

Meet the Presenters Banquet 18:30 - 20:30

More Speed & Simplicity: Practical Data-Oriented Design in C++ 10:30 - 12:00

The Evolution of a Logging Library 07:45 - 08:45

Back to Basics: static, inline, const, and constexpr 09:00 - 10:00

Back to Basics: Custom Allocators 14:00 - 15:00

Threads vs Coroutines: Understanding the Concurrency Models of C... 15:15 - 16:15

Cache Me Maybe: Using Caches to Improve Performance in Productio... 16:45 - 17:45

Lightning Talks 20:30 - 22:00

Author Signing: Jason Turner 12:00 - 12:30

Open Source Graphics Technologies at Pixar 09:00 - 10:00

View from the trenches - First principles while using C++ in cri... 14:00 - 15:00

From pure ISO C++20 to compute shaders 15:15 - 16:15

It’s Dangerous to Go Alone: A Game Developer Tutorial 16:45 - 17:45

std::execution in Asio Codebases: Adopting Senders Without a Rew... 09:00 - 10:00

Agentic debugging live - without a safety net 12:30 - 13:30

C++ Parallel Programming Models 14:00 - 15:00

Catching Bugs Early: Validating C++ Contracts with Static Analys... 15:15 - 16:15

Knockin' on Header's Door: An Overview of C++ Modules 16:45 - 17:45

Shadow Stack, Or: How to Submerge Beneath C++ and Fix Memory Cor... 09:00 - 10:00

Achieving Peak Performance for Matrix Multiplication 14:00 - 15:00

Using Distributed Trace for End-to-end Latency Metrics 15:15 - 16:15

Modern C++ for Embedded Systems: From Fundamentals to Real-Time... 16:45 - 17:45

A Case-study in Rewriting a Legacy Gui Library for Real-time Aud... 09:00 - 10:00

MSVC C++ Dynamic Debugging: How... 14:00 - 14:30

Instrumenting the Stack: Strateg... 14:35 - 15:05

Wait is it POSIX? Investigating Different OS and Library Impleme... 15:15 - 16:15

Seamless Static Analysis with Cp... 16:45 - 17:15

Sanitize It Before You Ship It:... 17:20 - 17:50

C++: Some Assembly Required 16:15 - 18:00

Duck Typing, the C++ Way: How Type Erasure Bends the Rules 09:00 - 10:00

Back to Basics: Move Semantics 10:30 - 11:30

Implicit Conversions Considered Harmful? 12:00 - 13:00

Work Contracts in Action: Advancing High-performance, Low-latenc... 13:30 - 14:30

Clean code! Horrible performance? 14:45 - 15:45

Building a career off-road 09:00 - 10:00

The Wonderful World of Designing a USB Stack Using Modern C++ 10:30 - 11:30

Graphics Programming with SDL 3 13:30 - 14:30

Beyond the Big Green Button: Demystifying the Embedded Build Pro... 14:45 - 15:45

Reflection-based JSON in C++ at Gigabytes per Second 09:00 - 10:00

Beyond Sequential Consistency 10:30 - 11:30

Duck-Tape Chronicles: Rust/C++ Interop 13:30 - 14:30

CTRACK: Lightweight C++ Performance Tracking for Bottleneck Disc... 14:45 - 15:45

In search of meta data for compile time reflecti... 08:00 - 08:45

Back to the Standard: From CUDA and Pragmas to GPU-Accelerated P... 09:00 - 10:00

Dynamic Asynchronous Tasking with Dependencies 10:30 - 11:30

groov: Asynchronous Handling of Special Function Registers 13:30 - 14:30

From C+ to C++: Modernizing a GameBoy Emulator 14:45 - 15:45

The Pattern Matching We Already Have 09:00 - 10:00

Type Traits without Compiler Intrinsics – The Promise of Static... 10:30 - 11:30

Constexpr STL Containers: Challenges and a Limitless Allocator I... 13:30 - 14:30

Persistence squared: persisting persistent data structures 14:45 - 15:45