BEGIN:VCALENDAR
VERSION:2.0
X-WR-CALNAME:cppcon2026
X-WR-CALDESC:Event Calendar
METHOD:PUBLISH
CALSCALE:GREGORIAN
PRODID:-//Sched.com CppCon 2026//EN
X-WR-TIMEZONE:UTC
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260909T150000Z
DTEND:20260909T210000Z
SUMMARY:System Architecture and Design Using Modern C++
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nC++ developers confront daunting responsibilities: to be familiar with the guarantees and idioms for the C++ language\; know data structures and algorithms with intrinsic benefits and constraints explored by Computer Science\; and understand the application domain in which the practicing professional is expected to make implementation decisions that manage complexity and resolve edge-cases to effectively solve real-world problems.\nAnd yet\, none of these directly address the meta-patterns and system-wide concerns defined by “architecture”\, nor the reasoned tradeoffs of “design” that divide responsibilities and ultimately define subsystems and APIs. Often\, these higher-order concerns are relegated to senior and experienced engineers charged with balancing business constraints with technical tradeoffs to establish a Theory of Operation for individual systems\, and for product families.\nThis course is intended for intermediate and advanced C++ engineers with experience making architectural and design decisions\, or who are evolving into roles that demand proficiency in system-level analysis and decision making. We will focus on Modern C++ and deeply explore successes and failures in projects and systems from a variety of industries. And\, we will discover that some crossroads are universal\, despite the unique concerns that may present pragmatic challenges and cause technical implications to be ranked differently based on the specific domain to which the solution is applied.\n\n
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:21d88ddb72a3f5c4459657031854bfa4
URL:http://cppcon2026.sched.com/event/21d88ddb72a3f5c4459657031854bfa4
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260910T150000Z
DTEND:20260910T210000Z
SUMMARY:System Architecture and Design Using Modern C++
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nC++ developers confront daunting responsibilities: to be familiar with the guarantees and idioms for the C++ language\; know data structures and algorithms with intrinsic benefits and constraints explored by Computer Science\; and understand the application domain in which the practicing professional is expected to make implementation decisions that manage complexity and resolve edge-cases to effectively solve real-world problems.\nAnd yet\, none of these directly address the meta-patterns and system-wide concerns defined by “architecture”\, nor the reasoned tradeoffs of “design” that divide responsibilities and ultimately define subsystems and APIs. Often\, these higher-order concerns are relegated to senior and experienced engineers charged with balancing business constraints with technical tradeoffs to establish a Theory of Operation for individual systems\, and for product families.\nThis course is intended for intermediate and advanced C++ engineers with experience making architectural and design decisions\, or who are evolving into roles that demand proficiency in system-level analysis and decision making. We will focus on Modern C++ and deeply explore successes and failures in projects and systems from a variety of industries. And\, we will discover that some crossroads are universal\, despite the unique concerns that may present pragmatic challenges and cause technical implications to be ranked differently based on the specific domain to which the solution is applied.\n\n
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:cd2ba3c46e402dde56451916451f1e7c
URL:http://cppcon2026.sched.com/event/cd2ba3c46e402dde56451916451f1e7c
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260911T150000Z
DTEND:20260911T210000Z
SUMMARY:System Architecture and Design Using Modern C++
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass PageC++ developers confront daunting responsibilities: to be familiar with the guarantees and idioms for the C++ language\; know data structures and algorithms with intrinsic benefits and constraints explored by Computer Science\; and understand the application domain in which the practicing professional is expected to make implementation decisions that manage complexity and resolve edge-cases to effectively solve real-world problems.\nAnd yet\, none of these directly address the meta-patterns and system-wide concerns defined by “architecture”\, nor the reasoned tradeoffs of “design” that divide responsibilities and ultimately define subsystems and APIs. Often\, these higher-order concerns are relegated to senior and experienced engineers charged with balancing business constraints with technical tradeoffs to establish a Theory of Operation for individual systems\, and for product families.\nThis course is intended for intermediate and advanced C++ engineers with experience making architectural and design decisions\, or who are evolving into roles that demand proficiency in system-level analysis and decision making. We will focus on Modern C++ and deeply explore successes and failures in projects and systems from a variety of industries. And\, we will discover that some crossroads are universal\, despite the unique concerns that may present pragmatic challenges and cause technical implications to be ranked differently based on the specific domain to which the solution is applied.\n\n
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:e4c43adda03ba6135d9d43a8f43ca9e1
URL:http://cppcon2026.sched.com/event/e4c43adda03ba6135d9d43a8f43ca9e1
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260912T150000Z
DTEND:20260912T231500Z
SUMMARY:Advanced and Modern C++ Programming: The Tricky Parts
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nWhenever I give C++ trainings I run into the same topics of “half knowledge” even for expreienced programmers. We use a lot of features\, for which looking into details opens a deep level of surprises and unexpected behavior. Even strings and vectors cause surprises (e.g.\, to understand when and how memory is allocated). Most of the time\, day-to-day programmingthis works fine without full understanding\, but once you hit corner cases (and it starts with error messages) good knowledge about what really goes on is key. \n \n This tutorial will discuss all the common “tricky fundamentals” of C++\, which application programmers see and use day by day. We will motivate them\, understand them\, and see how they should be used in practice. As a result\, you will understand C++ way better and advance to the next level of an experienced C++ programmer. \n \n As a long-time member of the C++ standards committee and experienced trainer\, Nicolai will teach the essence spiced with useful background information about key design decisions.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Homestead 1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:d27aa1f0e0018edae247e24b0e330127
URL:http://cppcon2026.sched.com/event/d27aa1f0e0018edae247e24b0e330127
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260912T150000Z
DTEND:20260912T231500Z
SUMMARY:C++ Best Practices
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\n“C++ Best Practices” is designed to help programmers elevate the quality of their C++ code. This course is intended for developers who have a beginner to intermediate knowledge of C++. You will learn how to write programs that perform well by default\, are easier to maintain\, memory safe\, and have better compile times. We will cover best practices for new features added in C++17/20/23 and how to use the tools available to maintain code quality. Come prepared to interact and discuss.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Willow Lake 3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:1eb28aea43603465450394e0abcceb3f
URL:http://cppcon2026.sched.com/event/1eb28aea43603465450394e0abcceb3f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260912T150000Z
DTEND:20260912T231500Z
SUMMARY:Performance and Efficiency in C++ for Experts\, Future Experts\, and Everyone Else
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nYour compiler is smart\, but it is not a magician. It cannot fix a design that fights the hardware\, nor can it optimize code that hides its intent. To achieve the peak performance C++ is capable of\, you must master the deep interplay between the language\, the compiler\, and the physical machine. Most C++ developers know how to write code that is correct. Fewer know the actual cost of the abstractions they use. And only a small fraction understand how the compiler translates those abstractions into physical execution. \n \n This class reveals the “secret life” of your application. We move beyond standard optimization advice to explore the mechanical sympathy required to squeeze every cycle out of modern systems. We will examine code from three perspectives: the hardware that executes it\, the compiler that generates it\, and the language rules that constrain it. We will demonstrate that performance is not an afterthought but a fundamental part of the design specification. You will learn how to validate that specification early—running “estimation benchmarks” on mock-ups to predict performance before writing a single line of production code. \n \n We will unlock the specific behaviors that dictate speed across three critical layers: \n \n The Hardware Reality: Moving beyond “cache friendly” to understand the physics of the memory hierarchy\, pipeline hazards\, and why data layout often matters more than instruction count. The Compiler Partnership: How to read assembly to verify optimizations\, how to structure code so the compiler can vectorize it\, and understanding the critical (and often misunderstood) role of Undefined Behavior in generating efficient code. Design for Performance: How to integrate performance constraints into your architecture from day one\, using estimation techniques to distinguish feasible designs from dead ends. Crucially\, we will challenge the myth that efficient code must be unreadable. We will point out concrete examples of how modern design practices and clean coding styles often align perfectly with hardware requirements\, allowing you to write software that is maintainable\, robust\, and ruthlessly efficient. \n \n This class is about performance and efficiency\, spanning the entire range from the fundamentals of the hardware to the peculiarities of compiler optimizations. You will learn\, on practical examples extracted from real-life programs\, how to measure\, analyze\, and improve the performance of your programs. But most importantly\, you will learn how to understand why your programs\, compilers\, and hardware behave the way they do. Some of the material will be basic and fundamental\, some cutting-edge and esoteric\, and the rest somewhere in between. All explanations will be reinforced with hands-on exercises\, which you get to do in the classroom and can explore later in detail if you want to learn more.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Willow Lake 4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:c55f0cee179e9a284af7e4cb4e5de444
URL:http://cppcon2026.sched.com/event/c55f0cee179e9a284af7e4cb4e5de444
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260912T150000Z
DTEND:20260912T231500Z
SUMMARY:Talking Tech
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nA good technical talk needs a compelling narrative as much as it needs absorbing information. At best\, it is a shared experience between speaker and audience sparking questions\, and conversations that go on throughout the hallway track. When done well\, a good talk becomes a great one and leaves everyone\, including the speakers\, with more: more understanding\, more curiosity\, more interest. \n \n We can help you discover what makes a great technical story. We can show you how even small small tweaks to existing presentations can make a huge difference. Learn clarity\, the best use of detail\, slides that illustrate rather than distract and how to be truly comfortable on stage. \n \n We will also go over where AI can play a role in helping develop a talk. Like good code\, a good talk is never written with an LLM taking the lead. However\, LLMs can be trained to ask questions\, make suggestions and help wade through piles of material\, freeing you to craft\, think\, and share experiences. Be aware that we come with the strong opinion that AI art is vastly overused and is often awful.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Willow Lake 5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:d9623665e1d3886ce8bb033233a01157
URL:http://cppcon2026.sched.com/event/d9623665e1d3886ce8bb033233a01157
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260913T150000Z
DTEND:20260913T231500Z
SUMMARY:Advanced and Modern C++ Programming: The Tricky Parts
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nWhenever I give C++ trainings I run into the same topics of “half knowledge” even for expreienced programmers. We use a lot of features\, for which looking into details opens a deep level of surprises and unexpected behavior. Even strings and vectors cause surprises (e.g.\, to understand when and how memory is allocated). Most of the time\, day-to-day programmingthis works fine without full understanding\, but once you hit corner cases (and it starts with error messages) good knowledge about what really goes on is key. \n \n This tutorial will discuss all the common “tricky fundamentals” of C++\, which application programmers see and use day by day. We will motivate them\, understand them\, and see how they should be used in practice. As a result\, you will understand C++ way better and advance to the next level of an experienced C++ programmer. \n \n As a long-time member of the C++ standards committee and experienced trainer\, Nicolai will teach the essence spiced with useful background information about key design decisions.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Homestead 1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:9ce2fe6037a1b26ca1f74917f9877bf5
URL:http://cppcon2026.sched.com/event/9ce2fe6037a1b26ca1f74917f9877bf5
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260913T150000Z
DTEND:20260913T231500Z
SUMMARY:AI++ 101: Build a C++ Coding Agent from Scratch
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nRemember writing a compiler in university? Not a real compiler\, but something that handled a subset of a language and generated naive code. You’d never ship it. But decades later\, you still understand how compilers work because you built one. \n \n That’s what we’re doing here. In one intensive day\, you will build a working AI coding agent in C++. \n Not Claude Code. Not Cursor. A simple thing you fully understand\, that talks to an LLM\, defines tools\, executes them\, and runs the same agentic loop that powers every AI coding assistant on the market. \n \n This workshop emerged from my own AI/C++ journey. I watched AI stumble through C++ like a freshman who skipped the first three weeks of class\, until I discovered the problem wasn’t the models\, it was me. The breakthrough came from understanding what’s actually happening under the hood. \n \n In this workshop\, you will write a fully functioning agent harness in C++. Like those university compilers\, it will not be production ready\, but will serve as a laboratory for learning how generative AI large language models can be used as C++ programmers. \n \n By end of day\, your agent will read code\, write code\, compile it\, fix its own errors\, and even modify its own source code to add new capabilities. \n \n You won’t ship this agent. But you’ll understand what Claude Code and Cursor are actually doing. When they break\, you’ll know why. When new tools emerge\, you’ll evaluate them with comprehension instead of hype. \n \n What You’ll Build: \n \n A C++ program that talks to an LLM API \n System prompts that shape model behavior \n Tool definitions (read_file\, write_file\, run_command) \n A working agentic loop \n An agent capable of modifying its own source \n \n What You’ll Understand: \n \n Why the same model acts completely different with different prompts \n What “tool calling” actually means (spoiler: you do all the work) \n How context windows work and why you send the whole conversation every time \n What “turns” are and how the conversation builds up \n Why agents sometimes go off the rails and how to prevent it \n \n Format: Lab-heavy. Students build\; instructor guides. Starter code provided for API plumbing.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Homestead 2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:f812c1f7e0d31a744753ca8f98a16142
URL:http://cppcon2026.sched.com/event/f812c1f7e0d31a744753ca8f98a16142
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260913T150000Z
DTEND:20260913T231500Z
SUMMARY:C++ Best Practices
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\n“C++ Best Practices” is designed to help programmers elevate the quality of their C++ code. This course is intended for developers who have a beginner to intermediate knowledge of C++. You will learn how to write programs that perform well by default\, are easier to maintain\, memory safe\, and have better compile times. We will cover best practices for new features added in C++17/20/23 and how to use the tools available to maintain code quality. Come prepared to interact and discuss.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Willow Lake 3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:1f915b389503da9f9d3d1dcf05ad2a76
URL:http://cppcon2026.sched.com/event/1f915b389503da9f9d3d1dcf05ad2a76
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260913T150000Z
DTEND:20260913T231500Z
SUMMARY:Performance and Efficiency in C++ for Experts\, Future Experts\, and Everyone Else
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nYour compiler is smart\, but it is not a magician. It cannot fix a design that fights the hardware\, nor can it optimize code that hides its intent. To achieve the peak performance C++ is capable of\, you must master the deep interplay between the language\, the compiler\, and the physical machine. Most C++ developers know how to write code that is correct. Fewer know the actual cost of the abstractions they use. And only a small fraction understand how the compiler translates those abstractions into physical execution. \n \n This class reveals the “secret life” of your application. We move beyond standard optimization advice to explore the mechanical sympathy required to squeeze every cycle out of modern systems. We will examine code from three perspectives: the hardware that executes it\, the compiler that generates it\, and the language rules that constrain it. We will demonstrate that performance is not an afterthought but a fundamental part of the design specification. You will learn how to validate that specification early—running “estimation benchmarks” on mock-ups to predict performance before writing a single line of production code. \n \n We will unlock the specific behaviors that dictate speed across three critical layers: \n \n The Hardware Reality: Moving beyond “cache friendly” to understand the physics of the memory hierarchy\, pipeline hazards\, and why data layout often matters more than instruction count. The Compiler Partnership: How to read assembly to verify optimizations\, how to structure code so the compiler can vectorize it\, and understanding the critical (and often misunderstood) role of Undefined Behavior in generating efficient code. Design for Performance: How to integrate performance constraints into your architecture from day one\, using estimation techniques to distinguish feasible designs from dead ends. Crucially\, we will challenge the myth that efficient code must be unreadable. We will point out concrete examples of how modern design practices and clean coding styles often align perfectly with hardware requirements\, allowing you to write software that is maintainable\, robust\, and ruthlessly efficient. \n \n This class is about performance and efficiency\, spanning the entire range from the fundamentals of the hardware to the peculiarities of compiler optimizations. You will learn\, on practical examples extracted from real-life programs\, how to measure\, analyze\, and improve the performance of your programs. But most importantly\, you will learn how to understand why your programs\, compilers\, and hardware behave the way they do. Some of the material will be basic and fundamental\, some cutting-edge and esoteric\, and the rest somewhere in between. All explanations will be reinforced with hands-on exercises\, which you get to do in the classroom and can explore later in detail if you want to learn more.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Willow Lake 4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:8c89216bed76b0909cd5e36be0dc95de
URL:http://cppcon2026.sched.com/event/8c89216bed76b0909cd5e36be0dc95de
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260913T150000Z
DTEND:20260913T231500Z
SUMMARY:Talking Tech
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nA good technical talk needs a compelling narrative as much as it needs absorbing information. At best\, it is a shared experience between speaker and audience sparking questions\, and conversations that go on throughout the hallway track. When done well\, a good talk becomes a great one and leaves everyone\, including the speakers\, with more: more understanding\, more curiosity\, more interest. \n \n We can help you discover what makes a great technical story. We can show you how even small small tweaks to existing presentations can make a huge difference. Learn clarity\, the best use of detail\, slides that illustrate rather than distract and how to be truly comfortable on stage. \n \n We will also go over where AI can play a role in helping develop a talk. Like good code\, a good talk is never written with an LLM taking the lead. However\, LLMs can be trained to ask questions\, make suggestions and help wade through piles of material\, freeing you to craft\, think\, and share experiences. Be aware that we come with the strong opinion that AI art is vastly overused and is often awful.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Willow Lake 5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:694a7366f30bb6bd64f82a7735f4494d
URL:http://cppcon2026.sched.com/event/694a7366f30bb6bd64f82a7735f4494d
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260913T163000Z
DTEND:20260913T220000Z
SUMMARY:Field Trip: Red Rocks & Dinosaur Ridge
DESCRIPTION:The Red Rocks & Dinosaur Ridge Museum Field Trip.\n Details are here.\n A separate registration is required for this event.\n\n For those who've registered for this year's Field Trip\, let's meet up in Rockies Square.\n\n Rockies Square is behind the Convention Coffee shop "the Cocoa Bean"\, convention center level 2. \n\n The tour bus will meet us outside of this area 11:15 - 11:30. Don't be late!\n\n We should return to the hotel around 17:00.
CATEGORIES:SOCIAL
LOCATION:Rockies Square\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:be1b0e433fc4643b052334c9e9f708f9
URL:http://cppcon2026.sched.com/event/be1b0e433fc4643b052334c9e9f708f9
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260913T233000Z
DTEND:20260914T020000Z
SUMMARY:Tee Shirt Night
DESCRIPTION:Tee Shirt Night is our way to helping you get to know other conference attendees even before the conference has officially started. It works best if you brought a C++ (or CppCon) shirt with you. But even if you didn't you can join the fun.\n\n Here is how: Put on your C++ or CppCon shirt (or don't\, if you didn't bring one). Go to any of the Gaylord Rockies eateries (except Hickory H Look for others wearing a C++ or CppCon shirt. Ask to join their group. Enjoy getting to know other attendees before the conference starts! Get a special offer from the restaurant!
CATEGORIES:SOCIAL
LOCATION:Gaylord Rockies\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:92b87c05a1ca24510d3235d207749ca0
URL:http://cppcon2026.sched.com/event/92b87c05a1ca24510d3235d207749ca0
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T020000Z
DTEND:20260914T040000Z
SUMMARY:Registration Reception
DESCRIPTION:Come for the registration and stay for the reception.\n \nGet your badge.\n\n Stick around and get acquainted with new friends and reacquainted with old friends.\n\n
CATEGORIES:BUSINESS
LOCATION:Colorado Pre-function\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:6dba0d03bd25bb05bfc7f1ad45de6066
URL:http://cppcon2026.sched.com/event/6dba0d03bd25bb05bfc7f1ad45de6066
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T140000Z
DTEND:20260914T143000Z
SUMMARY:Registration
DESCRIPTION:
CATEGORIES:BUSINESS
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:bf0b540089dd41667bbc5e3c56f0fdb9
URL:http://cppcon2026.sched.com/event/bf0b540089dd41667bbc5e3c56f0fdb9
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T143000Z
DTEND:20260914T161500Z
SUMMARY:Profiles for simplicity and guarantees
DESCRIPTION:The C++ community is growing fast. C++ is being used in critical applications. C++ can be used in ways that ensures correctness\, simplicity\, performance\, and maintainability. How can we ensure that it is used is such desirable ways? How can we teach new and old C++ developers to do so?\nThe general strategy is called “subset of superset” and is based on the idea that by extending (“supersetting”) by adding libraries\, we can simplify static analysis to where we can remove undesirable uses (“subsetting”) without damaging expressiveness or efficiency. Where run-time checks are necessary\, such as to catch out-of-range accesses in hardened libraries\, static analysis can be used to minimize the number of checks.\nThe strategy is supported by the “Profiles” framework\, that allows us to require or suppress specific sets of guarantees\, called profiles.\nAs examples\, I show how to eliminate uninitialized-object errors and container-invalidation errors (a kind of dangling pointer errors) using the profiles framework and implementations of the “Initialization” and “invalidation” profiles. Both with zero run-time cost.\n\n
CATEGORIES:PLENARY
LOCATION:Colorado A\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:7626a22d77eb36fadf65596077690883
URL:http://cppcon2026.sched.com/event/7626a22d77eb36fadf65596077690883
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T161500Z
DTEND:20260914T163000Z
SUMMARY:Conference Group Photo
DESCRIPTION:Meet outside of Aurora BCD immediately after the opening keynote to be in the conference photo. Be part of conference history!\n\n Photo will be taken by CppCon's official conference photographer\, Jonathan Phillips.
CATEGORIES:SOCIAL
LOCATION:Colorado A\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:c296a848f20d67274ac9b95083d47c0a
URL:http://cppcon2026.sched.com/event/c296a848f20d67274ac9b95083d47c0a
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T170000Z
DTEND:20260914T180000Z
SUMMARY:Back to Basics: Move Semantics
DESCRIPTION:Move semantics and perfect forwarding\, introduced in C++11\, are quite impactful features that still remain a source of confusion even for some experienced developers. This talk builds understanding from the ground up: what problem move semantics solves\, how rvalue references enable it\, and why the rules work the way they do. \n \n We start with the cost of unnecessary copies and how move constructors and move assignment operators let us transfer resources instead of duplicating them. We then look at how std::move doesn't actually move anything — and what it really does. From there we tackle the forwarding problem: why writing a single function that preserves the value category of its arguments is necessary\, how forwarding references (also known as "universal reference" in the past) solve it\, and what std::forward does under the hood. \n \n Along the way we cover the practical details that trip people up: reference collapsing rules\, the interaction between overload resolution and reference binding\, when the compiler generates move operations and when it doesn't\, and the cases where std::move can actually pessimize your code. We also discuss trade-offs in parameter passing — by value\, by const reference\, or by forwarding reference — so attendees should have a clearer model for making these decisions in their own code. \n \n At the end we will look into std::forward_like and explore how it is different from std::forward . \n \n No prior knowledge of rvalue references is assumed. Familiarity with copy constructors\, destructors\, and basic templates is helpful. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:a9bd3e9d51d5e12fbb49ba47020f8302
URL:http://cppcon2026.sched.com/event/a9bd3e9d51d5e12fbb49ba47020f8302
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T170000Z
DTEND:20260914T180000Z
SUMMARY:From 20 Nanoseconds to One: Optimizing Bishop\, Rook\, and Queen Move Generation in a Chess Engine
DESCRIPTION:A chess engine must search millions of positions per second. Move generation is often a bottleneck. Generating moves for knights\, kings\, and pawns are computationally cheap (~1 nanosecond). However\, rooks\, bishops\, and queens (aka "sliding pieces") present a unique challenge: their movement depends on the placement of other pieces. This makes on-demand generation too slow (20+ nanoseconds) and naively-implemented lookup tables impractical (requiring zettabytes of RAM). \n \n We will start by reviewing the core data structures in a chess engine and the logic behind move generation. Then\, we will explore "magic bitboards"\, a perfect hashing technique that enables sliding piece move generation in ~1 nanosecond. We will look at how to implement this in modern C++\, comparing hardware-specific instructions like PEXT (Parallel Bits Extract) against a portable software approach. Finally\, we will discuss the practical challenges of generating the data structures required for magic bitboards\, including the limitations of consteval and how to integrate build-time table generation into the build process using Bazel. \n \n To ground these concepts\, we will be referencing implementation details and code from my C++ chess engine\, FollyChess. \n \n
CATEGORIES:GAMEDEV
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:878930017d75bac3d067534a72719bbf
URL:http://cppcon2026.sched.com/event/878930017d75bac3d067534a72719bbf
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T170000Z
DTEND:20260914T180000Z
SUMMARY:Are You Smarter Than A Branch Predictor?
DESCRIPTION:Are you smarter than a branch predictor? In this interactive\, game-show-themed session\, the audience becomes the branch predictor: participants vote on which of two C++ snippets will run faster before we examine what actually happens on real hardware. The snippets are drawn from real-world production code\, and correct answers are rewarded with unique specialty erasers (no two are the same!). Through these examples\, we build a practical mental model of how modern CPUs handle control flow and why even small branching decisions can have a significant impact on performance. Using annotated assembly\, performance-counter data\, and cross-platform comparisons\, this talk explores branch prediction\, misprediction costs\, indirect calls and virtual dispatch\, and the trade-offs between branches and conditional moves. We examine how different compilers (GCC\, Clang\, and MSVC) transform code and highlight non-obvious cases where “branchless” code performs worse or behaves differently across architectures. The examples are intentionally small microbenchmarks\, but each exposes patterns that appear in real-world systems when control flow becomes the bottleneck. Whether you're a systems engineer or just curious about what your branch predictor is doing behind your back\, this session will give you a concrete mental model of control flow. You'll leave with the tools to profile your code\, interpret assembly\, and make informed decisions about when to rely on compiler heuristics versus manual optimization. \n \n
CATEGORIES:GENERAL
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:5b58445ed90c30cab0b05a154f5c7b9f
URL:http://cppcon2026.sched.com/event/5b58445ed90c30cab0b05a154f5c7b9f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T170000Z
DTEND:20260914T180000Z
SUMMARY:C++26: A Curated Tour of What's New
DESCRIPTION:The next evolution of C++ has officially arrived\, bringing a massive wave of enhancements to both the core language and the Standard Library. But with hundreds of committee proposals officially baked into the standard\, where do you start? Continuing the tradition from previous releases\, this fast-paced session delivers a comprehensive look at the new and updated features that define C++26. \n \n We won’t get bogged down in the minutiae of every single ISO proposal—covering everything in detail is impossible in just one hour. Instead\, you'll get a high-level\, curated overview of the most impactful changes\, from the major game-changers down to the small quality-of-life gems. If you want to get up to speed with the new standard and see how it will shape your codebase\, this session is for you. \n \n The session will touch on the following core language and Standard Library topics. \n \n C++26 core language changes include - Reflection - Contracts - Unnamed placeholder variables - = delete("reason")\; - Pack indexing - #embed - constexpr exceptions\, constexpr placement new - Variadic friends - ... \n \n C++26 Standard Library changes include - Execution control library - New libraries such as \, \, \, \, \, and more - std::inplace vector: dynamically-resizable vector with fixed capacity - std::philox engine: counter-based random number engine - std::text_encoding: text encodings identification - More constexpr for containers and container adaptors - Saturation arithmetic - New SI prefixes - Printing Blank Lines with std::println() - ... \n \n Where applicable\, I’ll point you toward other specialized CppCon sessions for those ready to dive even deeper into specific topics. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:acda079ee7c6398f88a7d2a22000990f
URL:http://cppcon2026.sched.com/event/acda079ee7c6398f88a7d2a22000990f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T170000Z
DTEND:20260914T180000Z
SUMMARY:From Firmware to Screen: Real-Time Control\, Simulation\, and Visualization in C++23 With CUDA and Unreal Engine
DESCRIPTION:What does it take to build a real-time embedded control system in modern C++\, simulate its environment\, command it from a browser\, and watch it fly in 3D — all from the same open source ecosystem? This talk follows that pipeline end-to-end: from a C++23 real-time framework that schedules deterministic control loops across POSIX hosts and bare-metal microcontrollers\, to GPU-accelerated simulation with CUDA\, to web-based operations and telemetry\, to live 3D visualization in Unreal Engine. \n \n Attendees will see how a unified runtime architecture can span embedded control\, simulation\, diagnostics\, operations\, and visualization without fragmenting into separate software stacks. The talk explores deterministic scheduling\, zero-allocation real-time design\, cross-platform deployment\, and integrating CUDA compute kernels directly into scheduled control loops without blocking execution. It also covers tooling for validating deterministic real-time behavior\, along with techniques for streaming telemetry and sensor data between simulation and visualization layers in real time. \n \n The presentation includes live demonstrations of a quadcopter simulation flying a programmed trajectory with lidar feedback\, and a full-fidelity aircraft simulation with closed-loop autopilot\, engine dynamics\, and atmospheric turbulence — both running through the same real-time framework and rendered live in Unreal Engine. Whether you build flight software\, robotics systems\, industrial controllers\, or simulation infrastructure\, this talk presents practical architectural patterns for modern real-time systems in C++ that bridge embedded devices\, GPU compute\, and interactive visualization. \n \n
CATEGORIES:ROBOTICS & AI
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:7369c6b68f00c7e8501060c8efd5331a
URL:http://cppcon2026.sched.com/event/7369c6b68f00c7e8501060c8efd5331a
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T170000Z
DTEND:20260914T180000Z
SUMMARY:Same Bits Without Losing MIPS: Reproducible Numerics at Full Hardware Speed
DESCRIPTION:Floating point has a reputation for betrayal. Change the thread count\, vector width\, compiler flags\, reduction tree\, or target architecture\, and the low bits can move. Parallel algorithms make this worse: the standard often specifies the operation\, but not the numerical expression whose result must be reproduced. This talk asks a provocative question: what if reproducible numerics did not have to be slow? \n \n We will show reproducible\, deterministic implementations of reduce and scan that exhibit better error behavior on hostile floating-point workloads and can match or beat conventional standard-library implementations on realistic workloads. The trick is not to freeze the execution schedule. It is to specify the expression being computed\, then let the implementation use SIMD\, threading\, blocking\, tiling\, and platform-specific strategies to compute that expression efficiently. \n \n The key idea\, developed through C++ standardization work such as P4016R0 and P4229R0\, is reproducibility by reproducing the computation. Instead of asking the implementation to promise a particular schedule\, we give the calculation a named expression. Once that expression is chosen\, changing the thread count\, vector width\, chunking\, or blocking strategy does not silently change the answer. \n \n A reproducible scan makes this harder than reduce because it does not expose only one final value. It exposes every prefix. A reproducible final sum is not enough if the intermediate results still drift. We will show how expression and observation contracts make those prefixes reproducible without forcing the computation back into a slow sequential order. \n \n Then we go below the algorithm layer\, to the places where bits usually escape: FMA contraction\, denormals\, floating-point environment choices\, math-library approximations\, and vectorized transcendental functions. The goal is not to get the same answer by turning off the hardware. We will show reproducible vectorized primitives\, including transcendental functions\, running at speeds comparable to established vector math libraries while preserving a cross-platform numerical contract. \n \n Finally\, we put the whole stack under stress: a heterogeneous numerical pipeline across x86-64\, Apple Silicon\, and CUDA. The data is deliberately hostile\, with high cancellation rates and fragile intermediate states. The aim is not to pass friendly benchmark cases\, but to reproduce the specified computation\, including the same intermediate failures\, not just the same final answer\, bit for bit\, across CPUs\, GPUs\, and toolchains. \n \n
CATEGORIES:SCIENTIFIC COMPUTING
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:c1fcc73fcde28ad26f9aadc3f2320428
URL:http://cppcon2026.sched.com/event/c1fcc73fcde28ad26f9aadc3f2320428
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T200000Z
DTEND:20260914T210000Z
SUMMARY:Back to Basics: Templates
DESCRIPTION:C++ templates are one of the language’s most powerful yet often misunderstood features. This talk walks the audience through the entire template landscape\, starting with the basic syntax and definition\, moving through function and class templates\, and culminating in advanced techniques. \n \n Attendees will learn how template argument deduction works\, why implicit requirements matter\, and how explicit specialization can replace error-prone macro tricks. Real-world examples\, including a flexible register abstraction used in production code\, show how generic programming can deliver type-safe\, high-performance solutions without sacrificing readability and performance (zero cost abstraction). \n \n By the end of the session\, participants will feel confident writing their own generic components\, understand the trade-offs of different template features\, and have a toolbox of best-practice patterns they can apply immediately to their projects. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:be6f84c5423d39b4e85f59f7ac716522
URL:http://cppcon2026.sched.com/event/be6f84c5423d39b4e85f59f7ac716522
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T200000Z
DTEND:20260914T210000Z
SUMMARY:Pointers to Power: Navigating Organizational Influence
DESCRIPTION:Getting a project approved\, or killed\, often has less to do with technical merit than with who actually holds the keys and what they need to hear. This talk draws on real case studies from library design fights\, cross-functional infrastructure rewrites\, and a couple of notable failures to show practical techniques: how to find the real decision-maker\, how to break expert deadlock with a position paper\, and how to build toward an audacious goal through incremental wins and a well timed crisis. \n \n
CATEGORIES:BUSINESS & CAREER
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:af8566d61d7a148f6ce9f70245c8c251
URL:http://cppcon2026.sched.com/event/af8566d61d7a148f6ce9f70245c8c251
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T200000Z
DTEND:20260914T210000Z
SUMMARY:Thinking Low Level\, Writing High Level
DESCRIPTION:An overview of contemporary hardware platforms and how software engineering and design practices and methodologies could help in building performant systems\, with a particular focus on low level optimizations. Contrary to attempting direct low level software engineering for addressing performance specifics\, this talk would focus on how higher level abstractions could and should be used\, and how a software engineer could help the compiler to “do the right thing”. The trend of moving software engineering focus upward to constructs that have a tendency of hiding the specific of the underlying platform is quite clear – and there certainly are very good reasons for such a paradigm change. \n \n Performance matters. Premature optimization is evil. Is there anything in between those two extremes? How feasible is it to rely on the abstraction of the platform as hidden by the compiler and the corresponding libraries and language constructs\, expecting that it will be able to realize the intended lower level optimizations? How much of hints and specifics would one need to expose for the compiler to be able to get the equivalent of direct low level approach? What is the right balance between expressing application logic via higher level construct yet still being able to gain the performance benefits compared relying on the low level specifics? \n \n Looking from the practical applicability of lambdas\, iterators\, ranges\, coroutines\, error handling\, and safe(r) memory access\, the talk would attempt to cover a set of use cases with a focus on analysis of what could be done for focusing on performance. \n \n The overall goal of the talk is not to go deep into low level aspects\; the goal is to explain that one needs to be aware of such low level details while operating on the higher level constructs. \n \n
CATEGORIES:EMBEDDED
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:1b7a6ecb136259314490364675400e64
URL:http://cppcon2026.sched.com/event/1b7a6ecb136259314490364675400e64
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T200000Z
DTEND:20260914T210000Z
SUMMARY:Component based or monolithic development for large C and C++ projects: Why not both?
DESCRIPTION:Developers of large C and C++ projects have to choose between two main development paradigms: component based development and monolith based development\, each one with its own advantages and disadvantages. \n \n In component based development\, projects can be split in multiple repositories that allow to do decouple development and releasing\, which suits well for many organizations that split the work in different teams with different development speeds. But this approach requires efficient dependency management\, complicates working simultaneously in multiple components and it adds extra challenges to implement Continuous Integration at scale. \n \n On the other hand\, in monolithic/monorepo base development\, the build system tool manages the whole project efficiently\, simplifying some development and integration flows. But it can be resource-intensive on the CI side and it also push the whole organization to move at the same speed\, often with little or almost no versioning: the “live at head” paradigm \n \n It is said that by Conway's law\, organizations are forced in practice to choose between them. But what if modern C and C++ tooling allowed us to have the best of both worlds? \n \n This talk will present the novel Conan2 “Workspaces”\, a monolithic view of multiple independent components that can be dynamically added and removed from the monolithic build\, and how leveraging CMake FetchContent\, such a single monolithic build can be implemented. \n \n Also\, for the cases where not only CMake is involved\, a quick overview of the orchestration of workspace incremental builds for heterogenous build systems and CI at scale will also be introduced. \n \n The talk will describe the basics\, tools\, design and architecture of the solutions\, and it will also show full working demonstrations for them. \n \n
CATEGORIES:GENERAL
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:2acce234336e3d54b7a42d4435e4cbff
URL:http://cppcon2026.sched.com/event/2acce234336e3d54b7a42d4435e4cbff
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T200000Z
DTEND:20260914T210000Z
SUMMARY:Towards a complete contract-assertion facility for C++
DESCRIPTION:C++26 introduces contract assertions: language-level constructs for expressing expectations about program correctness\, optionally checking them at runtime\, and configuring how violations are handled. However\, what ships in C++26 is intentionally minimal — not the final destination\, but a carefully designed foundation for a much more capable facility. \n \n In this talk\, we begin with a brief overview of contract assertions as they exist in C++26\, including the three kinds of assertions ( pre \, post \, and contract_assert )\, the four evaluation semantics ( ignore \, observe \, enforce \, and quick-enforce )\, and the user-replaceable contract-violation handler. The focus of the talk\, however\, is the next stage of evolution already underway. \n \n We will explore the major extensions currently planned for C++29 and beyond\, and the problems they are intended to address\, and how they build upon the extensibility intentionally designed into the C++26 facility. Many of the concerns raised during standardisation — particularly around scalability\, configurability\, and expressiveness — are already being addressed by these extensions. We will discuss contract assertions on virtual functions\; grouping contract assertions and configuring evaluation semantics by group\; constraining evaluation semantics (for example\, assertions that must always or never be enforced)\; postconditions that refer to earlier program state\; user-defined diagnostic messages\; and finally\, compiler-generated\, implicit contract assertions guarding against core-language undefined behavior. We then look even further ahead at more ambitious ideas still in earlier stages of exploration: class invariants\, contracts on function pointers\, and procedural interfaces. \n \n Rather than just listing the proposed extensions\, we will examine the design considerations behind them and show how the new functionality fits into the broader model of contract assertions in C++. What does it mean for contracts to participate in virtual dispatch? When can contract assertions support optimisation? How can evaluation semantics remain both predictable and configurable across large codebases? Understanding these questions is essential to understanding where contract assertions in C++ are heading next. \n \n This talk is intended for anyone interested not only in how contract assertions work in C++\, but also in the principles shaping their future evolution — and what a complete contract facility for C++ might ultimately look like. \n \n
CATEGORIES:GENERAL
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:c6d3c30516183cf32278c0b94b8b75f8
URL:http://cppcon2026.sched.com/event/c6d3c30516183cf32278c0b94b8b75f8
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T200000Z
DTEND:20260914T210000Z
SUMMARY:Familiar C++ Patterns That Fail at Scale and the Design Shifts That Prevent Them
DESCRIPTION:Some of the most expensive C++ bugs are not caused by obscure language features. Instead\, they emerge from code that looks reasonable: shared ownership that quietly extends lifetimes\, singletons that become invisible dependencies\, and performance-driven decisions that harden into architecture. \n \n This talk examines these common design-level failure patterns in large-scale C++ systems. We cover three concrete design shifts: \n \n Lifetimes: Shifting from shared ownership to explicit lifetime boundaries. Coupling: Shifting from implicit global coupling to injected dependencies. Interfaces: Replacing permissive APIs with constrained interfaces using std::span\, std::optional\, std::variant\, and strong types. \n \n Each shift is presented with the failure pattern it addresses\, the solution\, and the design rule it yields. Attendees will leave with practical heuristics for designing systems that are easier to reason about\, test\, and evolve: all grounded in real-world failures and the redesigns that fixed them. \n \n
CATEGORIES:SOFTWARE DESIGN
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:15822dc7418c0a5555c2b54518bf72e1
URL:http://cppcon2026.sched.com/event/15822dc7418c0a5555c2b54518bf72e1
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T211500Z
DTEND:20260914T221500Z
SUMMARY:Back to Basics: Code Analysis
DESCRIPTION:In the C++ ecosystem\, we have powerful tools for understanding our programs before\, during\, and after they run. But compiler warnings\, clang-tidy\, cppcheck\, sanitizers\, debuggers\, profilers\, and coverage tools all answer different questions\, and using them well starts with knowing which question you are asking. \n \n This talk introduces code analysis from first principles. We will compare static techniques such as compiler diagnostics\, linting\, and include analysis with runtime techniques such as sanitizers\, coverage instrumentation\, and profiling. We will also briefly connect these tools to the direction of modern C++\, including C++26 contracts and standard library hardening\, where some assumptions that used to live only in comments\, documentation\, or debug modes become part of the program's checkable structure. Through small C++ examples\, we will see what each category of tool can reveal\, what it cannot prove\, and how the tools complement each other. \n \n Attendees will leave with a practical mental model for choosing the right analysis tool for the task at hand\, interpreting its output\, introducing analysis into an existing C++ codebase\, and writing code that is easier for both humans and tools to understand. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:d31b36e079b80666ad35ea18cd6767d4
URL:http://cppcon2026.sched.com/event/d31b36e079b80666ad35ea18cd6767d4
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T211500Z
DTEND:20260914T221500Z
SUMMARY:The journey to "/W4 /WX": How hard could it be?
DESCRIPTION:Building on the recent work of improving the quality of Sea of Thieves' codebase by upgrading from C++14 to C++20\, this talk will focus on the work that has went into enabling warnings as errors on the game\, and more. \n \n Rare will discuss the motivations behind wanting to crank up the warning level\, and to flick the "warnings as errors" switch after 10 years of development in their multi-million line Unreal Engine code base. \n \n What were the challenges? How much effort did it take? Was it worth it? Did we find any bugs? Did we stop at just "/W4 /WX"? What warnings did we find the most useful? What warnings were deemed unhelpful? All of these questions and probably more will be answered throughout this session. \n \n
CATEGORIES:GAMEDEV
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:b70a1639035db17371f822c03eba32a9
URL:http://cppcon2026.sched.com/event/b70a1639035db17371f822c03eba32a9
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T211500Z
DTEND:20260914T221500Z
SUMMARY:std::simd Without Compromise: Making SIMD in C++26 and Beyond as Fast as Silicon Allows
DESCRIPTION:For thirty years\, SIMD has been the preserve of experts. Writing the fastest C++ has meant hand-written intrinsics\, locking code to one architecture\, and parallel implementations maintained across every instruction set you ship to. Auto-vectorization can help\, but optimizers may give up in complex scenarios where iteration independence isn't obvious. C++26 changes that by putting SIMD in the hands of every C++ programmer\, bringing portable\, expressive data parallelism into the standard library. \n \n For the engineers who have spent decades writing intrinsics in telecoms\, finance\, HPC\, and embedded systems\, migration to std::simd is only worthwhile if it preserves the performance they have fought to achieve. Every cycle counts when code runs tens of thousands of times per second\, for years on end\, and a portable abstraction that costs ten percent is not a win. The bar for adoption is therefore high: the abstraction must be measurably cheap\, the generated code must match hand-written intrinsics\, and the tricks and techniques those engineers rely on must all be expressible in the library\, not lost in translation. \n \n This talk takes the practitioner's view\, aimed squarely at the engineers who write real intrinsics code today and need to know whether std::simd can replace it. It starts with what modern SIMD hardware actually offers\, grounding std::simd in real silicon. It then works through the main features of C++26's std::simd with worked examples drawn from the patterns that recur in production intrinsics code\, accessible to programmers new to the library and detailed enough for intrinsics veterans to map against their own kernels with all their accumulated tricks and techniques. A look under the hood at our implementation shows how careful API design and aggressive use of hardware features make the abstraction as cheap as the target architecture allows\, and how the library fills the gaps on weaker targets with implementations that an expert library author can write once on behalf of every user. The talk closes with a preview of the C++29 proposals being written now to close the remaining gaps\, so that std::simd becomes a clear win even for the most performance-critical code. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:5e969999417ee382bb684298e196d703
URL:http://cppcon2026.sched.com/event/5e969999417ee382bb684298e196d703
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T211500Z
DTEND:20260914T221500Z
SUMMARY:The Latency Slippage: Understanding the Hidden Costs of Caching for Low Latency C++
DESCRIPTION:Choosing cache-friendly data structures is a well-known optimization\, but it's rarely the whole story. This talk goes deeper\, exploring the hardware mechanics that dictate real-world performance and showing where significant gains are still left on the table. \n \n We'll start from the ground up: what actually happens inside the cache hierarchy when your code issues a memory read or a software prefetch? Understanding the hardware lets us answer\, when you should prefetch manually\, and when you should trust the hardware prefetcher. \n \n From there\, we'll examine the invisible cost of multi-core C++. Cache coherency protocols (MESI/MOESI) can silently degrade performance through false sharing\, RFO stalls\, and coherency storms. We'll walk through how to diagnose these issues using hardware performance counters and how to eliminate them. \n \n Additionally\, we will contrast these behaviors across the data cache (DCache) and instruction cache (ICache)\, and analyze how Translation Lookaside Buffers (TLBs) impact overall memory read latency. \n \n Finally\, we'll tie it all together by combining hardware insight with application profiling data to arrive at practical strategies for low latency C++\, packaged as an application-aware memory allocator. \n \n
CATEGORIES:GENERAL
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:86d1de6dd518b8c762d776fcec0f7f00
URL:http://cppcon2026.sched.com/event/86d1de6dd518b8c762d776fcec0f7f00
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T211500Z
DTEND:20260914T221500Z
SUMMARY:Capability Routing Grid: From Decoupled Plugins to the Hardware Ceiling
DESCRIPTION:For C++ developers building modular applications or performance-critical loops\, modern architecture often forces a painful compromise: you either build heavily decoupled systems that thrash the CPU cache\, or you write rigid\, tightly coupled code. Distributed builds mask the compile-time symptom — but the underlying coupling bleeds into the runtime hot path. \n \n This talk presents the Capability Routing Grid (CRG)\, an architecture that refuses this compromise. CRG enables a zero-registry plugin system where modules self-register at link time\, and polymorphic dispatch is reduced to an O(1) branchless array lookup — with no central registry\, no Init() function\, and no runtime search. \n \n Three independent pillars\, each usable standalone: \n \n Pillar 1 — Linker-Driven Discovery: Build a fully decoupled plugin system without central registries or Init() boilerplate. Modules self-register via standard C++ static initialization — entirely automatic in monolithic builds\, and requiring a single explicit sync-point call at DLL load time. \n \n Pillar 2 — State and Behavior Separation: Enforce a strict architectural boundary between pure data structs and stateless capability objects. This separation — not a framework — is what keeps the hot path flat. Type erasure is available as an optional cold-path utility for cross-boundary routing\, but is never required for performance. \n \n Pillar 3 — O(1) Branchless Dispatch: Map multi-dimensional contextual states into a single flat lookup table using basic polynomial math. Because this layout never changes\, the CPU branch predictor and hardware prefetcher maintain peak efficiency. \n \n The final payoff: by collapsing capabilities into raw function pointers\, the system hits the memory bandwidth ceiling — 33 GiB/s sustained throughput\, with a per-dispatch tax of approximately 1.5 nanoseconds. \n \n Data-Oriented Design is defined from scratch. A brief hardware cache primer precedes every performance claim. The entire architecture compiles on C++17 — no language extensions\, no experimental flags\, on any mainstream toolchain. The audience will leave thinking\, "I could have written this" — because they can. \n \n Attendees will learn how to: - Build self-registering plugins with zero shared headers\, using standard static initialization across both monolithic and DLL builds - Apply state/behavior separation as an architectural discipline — keeping capabilities stateless and the hot path free of virtual overhead - Replace vtable dispatch with a flat array lookup across N behavioral dimensions — O(1) regardless of dimensionality - Cache resolved logic as raw function pointers and call them directly\, reaching memory-bound throughput \n \n
CATEGORIES:SOFTWARE DESIGN
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:1891758261c75e93f788a95f4cac148e
URL:http://cppcon2026.sched.com/event/1891758261c75e93f788a95f4cac148e
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T211500Z
DTEND:20260914T221500Z
SUMMARY:Catching Leaks: How to stop a C++ program at the exact instruction that leaks memory
DESCRIPTION:Memory leaks are very hard to treat. We have reliable tools like valgrind or AddressSanitizer to tell us whether or not an application has leaked memory\, but current tools cannot tell us where the leak happens (they can tell us where the allocation happened\,which is not the same). \n \n I show that it is possible to run an analysis that is equivalent to running a garbage detection pass after every instruction and use that to find the actual cause of memory leaks in open source applications. \n \n Using a garbage detection algorithm on record-and-replay recording\, one can overcome the most obvious obstacle: stopping a program a program after every instruction or running garbage detection algorithms is very slow\, but we can effectively run a bisection search on the recorded timeline to avoid having to evaluate after every instruction. \n \n The goal is attribution to source code. Are we limited to reporting the instruction that overwrites the last reference to allocated memory or can we actually diagnose a specific error for a concrete function? \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:0d8ba99bae6ac539d97d9efee660b6fb
URL:http://cppcon2026.sched.com/event/0d8ba99bae6ac539d97d9efee660b6fb
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T224500Z
DTEND:20260914T234500Z
SUMMARY:Back to Basics: const\, constexpr\, consteval
DESCRIPTION:const is one of the oldest and most widely used features in C++\, yet many developers still struggle with the subtle differences between const \, constant expressions\, constexpr \, and consteval . \n \n In this talk\, you will learn how compile-time constants evolved in modern C++\, starting with const and continuing through the features introduced since C++11. You will see what constant evaluation really means\, what the compiler is allowed to execute during compilation\, and where the limits still are today. \n \n Using practical examples\, we will explore when const is enough\, when constexpr is needed\, and how compile-time and runtime execution interact in modern C++. We will also look at common pitfalls\, surprising behavior\, and cases where compile-time programming can either improve code or make it harder to understand. \n \n Finally\, you will see how features such as consteval and std::is_constant_evaluated influence correctness\, testing\, and maintainability. \n \n By the end of this talk\, you will have a deeper understanding of constant evaluation and know how to use modern compile-time features more effectively in your code. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:7847490d080632b349abcaa62f16aff0
URL:http://cppcon2026.sched.com/event/7847490d080632b349abcaa62f16aff0
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T224500Z
DTEND:20260914T234500Z
SUMMARY:AEMBER: Modern Embedded C++ Without the Chaos
DESCRIPTION:Building embedded systems wastes time on infrastructure instead of features. Before running application logic\, developers lose hours bootstrapping init systems\, wiring services\, debugging startup failures\, and fighting tooling never designed for constrained or early-boot environments. AEMBER is a developer-first PID1 (init system) that eliminates this overhead by providing a modern C++ runtime for process supervision\, container orchestration\, and service management - letting you focus on your application\, not your plumbing. \n \n This talk demonstrates how C++23 enables robust embedded systems without sacrificing performance. We'll explore std::expected for exception-free error handling\, if consteval for compile-time optimization paths\, and deducing this for zero-overhead policy classes. You'll see how monadic operations compose system calls into clean pipelines\, and how modern C++ features build type-safe APIs for namespaces\, cgroups\, and process management. \n \n Starting from main()\, we'll trace AEMBER's architecture: how components compose\, how errors propagate through std::expected chains\, and how C++23 patterns enable embedded systems to be both safe and fast. We'll wrap up with a live demo showing AEMBER managing containers and services in real-time. You'll leave with concrete techniques for building maintainable embedded infrastructure using cutting-edge C++. \n \n
CATEGORIES:EMBEDDED
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:e284cef317c73418f20d71a2ee825469
URL:http://cppcon2026.sched.com/event/e284cef317c73418f20d71a2ee825469
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T224500Z
DTEND:20260914T234500Z
SUMMARY:Graphics Programming with SDL 3 Part 2
DESCRIPTION: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. \n \n
CATEGORIES:GAMEDEV
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:5c47eeace9cf0463c9d19b76e2b7ed4c
URL:http://cppcon2026.sched.com/event/5c47eeace9cf0463c9d19b76e2b7ed4c
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T224500Z
DTEND:20260914T234500Z
SUMMARY:C++ in the Age of AI: How Visual Studio Is Evolving
DESCRIPTION:For almost 30 years\, Visual Studio has been a core part of the C++ developer's toolkit on Windows. This year\, we're building on that foundation with investments across three themes: making the IDE faster and more responsive for large codebases\, advancing compiler conformance and runtime performance\, and integrating AI-powered workflows that help you debug\, refactor\, and optimize more effectively. Beyond the IDE\, we'll show you how AI-powered command-line tools can become a natural part of your development process. This session combines demos and practical guidance so you can get the most out of these tools right away. Come with curiosity\, leave with new techniques you can apply immediately. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:6aeb9a493505691bf7b37a91f1fc3aa5
URL:http://cppcon2026.sched.com/event/6aeb9a493505691bf7b37a91f1fc3aa5
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T224500Z
DTEND:20260914T234500Z
SUMMARY:Why Great C++ Libraries Fail (And How to Fix That)
DESCRIPTION:You found the perfect C++ library. But you cannot integrate it with your CMake build without reading three pages of bespoke instructions. The documentation (if any) is a Doxygen-generated API dump. You file a bug\, get "read the source\," and move on. You never adopted it—and you had every intention of doing so. \n \n Or you are the author of that library. Technically brilliant. Six months after release: three users\, no contributors\, two support tickets\, you are not sure how to answer. Drawing on years of experience as both a maintainer of mp-units — a high-visibility\, standards-track C++ library — and as a developer who regularly evaluates and contributes to third-party C++ projects\, I have watched this pattern repeat across dozens of technically excellent libraries. The barriers that drive users away\, frustrate potential contributors\, and quietly kill great projects are predictable. More importantly\, they are fixable. \n \n This talk traces the five stages every C++ library must survive — Discovery\, Evaluation\, Integration\, Contribution\, and Community — and examines the concrete engineering decisions at each. We will look at how naming\, README structure\, and CI signals communicate trust to a user who found you three seconds ago\; how a properly fuzzed build matrix gives users real confidence across their compiler\, their C++ standard\, and their platform\; how DevContainers and Compiler Explorer eliminate the local setup barrier for both users and contributors\; how the Diátaxis framework turns a documentation site from a reference graveyard into a system that serves newcomers\, practitioners\, and design-curious contributors\; and how to craft an AI contribution policy that manages the rising volume of LLM-generated PRs without sacrificing the architectural integrity that makes a library worth contributing to in the first place. \n \n Whether you are a user evaluating libraries\, a developer looking for a C++ project worth your time\, or an author trying to build one\, you will leave with a concrete\, field-tested checklist. \n \n
CATEGORIES:GENERAL
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:57d0f511f4a9692fca7151ed6f6f8792
URL:http://cppcon2026.sched.com/event/57d0f511f4a9692fca7151ed6f6f8792
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260914T224500Z
DTEND:20260914T234500Z
SUMMARY:My DAG Ate All My Cores: Identifying and Resolving Build Graph Bottlenecks
DESCRIPTION: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. \n \n 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. \n \n 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. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:d70ea8f61e45c959adb8f1246d42355e
URL:http://cppcon2026.sched.com/event/d70ea8f61e45c959adb8f1246d42355e
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T003000Z
DTEND:20260915T023000Z
SUMMARY:HRT Happy Hour
DESCRIPTION:HRT is excited to be back at CppCon again this year! We invite you to attend our&nbsp\;Networking Social.
CATEGORIES:SOCIAL
LOCATION:Mountain Pass Sports Bar\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:ba9d35426723a0f073e077fc770a1d74
URL:http://cppcon2026.sched.com/event/ba9d35426723a0f073e077fc770a1d74
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T023000Z
DTEND:20260915T040000Z
SUMMARY:Committee Fireside Chat
DESCRIPTION:\n
CATEGORIES:ISO / WG21
LOCATION:Colorado A\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:482709dc67beba003e3e51d8eb1465ad
URL:http://cppcon2026.sched.com/event/482709dc67beba003e3e51d8eb1465ad
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T130000Z
DTEND:20260915T150000Z
SUMMARY:Seven Research Women++ Networking Breakfast
DESCRIPTION:Join us for the Women++ Networking Breakfast!\n\nKick off CppCon with a relaxed breakfast for women and LGBTQIA+ professionals on Tuesday\,\nSeptember 15\, from 07:00–09:00.\n\nMeet fellow C++ engineers over coffee\, breakfast\, swag\, and light activities designed to spark\nmeaningful conversation before the conference begins.\n\nSponsored by Seven Research\, the event will also offer a chance to learn how C++ expertise\ncan make an impact in quantitative finance.\n\nPlease RSVP early so we can plan breakfast and swag for everyone.\n\nRegister here to join us\n\nAbout Seven Research\n\nSeven Research is a quantitative research and technology company developing\nadvanced systems for the global markets. We bring together quants\, strategists\, and\n\ntechnologists to design scalable models\, systematic strategies\, and high-performance\ninfrastructure built for speed\, precision\, and robustness.\n\nOur quants work on complex market problems\, developing models\, signals\, simulations\,\nand strategies that translate research into real-world trading systems. Our developers\nbuild the technology that powers that research and execution\, from low-latency C++\nsystems to simulation platforms\, high-performance computing\, and tools that accelerate\nthe entire research process.\n\nIf you’re interested in solving hard problems alongside a close-knit technical team in a\nflat\, collaborative environment\, visit our careers page to learn more about our open\nroles.\n\n
CATEGORIES:SOCIAL
LOCATION:TBA\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:f70bd36910e7b1f2fd499657d45f1a05
URL:http://cppcon2026.sched.com/event/f70bd36910e7b1f2fd499657d45f1a05
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T150000Z
DTEND:20260915T160000Z
SUMMARY:Can I memcpy This Type Across a Boundary? Verifying Object Representation at Compile Time With C++26 Reflection
DESCRIPTION:Native C++ types often become the format for bytes that cross a boundary: shared-memory IPC\, plugin interfaces\, persistent storage\, or software built for more than one ABI. At that point the type is no longer just an implementation detail\; it is part of a binary contract. trivially_copyable \, sizeof \, and code review help\, but they do not answer the two questions that matter: may this type be transported as bytes at all\, and do all supported ABIs give it the same object representation? \n \n C++26 reflection can derive that evidence from the type itself. The technique builds a compile-time layout signature from ordinary C++ types\, without IDL\, generated stubs\, or runtime inspection. The signature records the representation facts needed for byte transfer: architecture and endianness\, leaf type tokens\, sizes\, alignments\, absolute offsets\, bit-fields\, and pointer-like markers. It deliberately leaves out field names and source-level meaning. \n \n With those signatures in hand\, the build can enforce a gate for memcpy-style transfer. You name the boundary types and supported ABIs. Each target exports signatures\, and a verification build permits direct byte transfer only when the type is byte-copy safe and the signature matches across the set. We'll walk through the workflow with static_assert checks and CI diagnostics: a fixed-width type that passes\, a pointer-containing type rejected by admission\, and a platform-divergent type rejected by signature comparison. The claim is intentionally narrow: representation compatibility\, not semantic compatibility or schema evolution. \n \n
CATEGORIES:GENERAL
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:06e3fcf49efb1bc47730eb5645c57618
URL:http://cppcon2026.sched.com/event/06e3fcf49efb1bc47730eb5645c57618
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T150000Z
DTEND:20260915T160000Z
SUMMARY:Interesting Upcoming Low-Latency\, Networking\, Concurrency\, and Parallelism Features from Kona 2025\, Croydon 2026\, and Brno 2026
DESCRIPTION:This talk is the 2026 edition of our series that highlights low-latency\, networking\, parallelism\, and concurrency proposals to the C++ Standards Committee\, especially those discussed in the Kona 2025\, Croydon 2026\, and Brno 2026 meetings. This talk from the Concurrency TS2 Editors\, DG and SG14/19 chair will describe the following features and show how they can be used. It will also give their motivation\, background\, and their place within the overall framework of C++ low latency\, networking\, parallelism and concurrency: \n \n Atomic Compare and Hazard Pointers Reclamation Control \n \n We discuss a proposal for atomic compare operations that clarify programmer intent and simplify static analysis by avoiding the unnecessary leakage of atomic values. We also explore how these operations complement recent proposals to enhance the expressiveness of atomics\, such as the use of tagged pointers. We examine techniques for controlling C++26 hazard pointer reclamation\, demonstrating how to offload retirement overhead to asynchronous executors to ensure predictable thread latency. We show how this capability can prevent specific deadlock scenarios and assess whether such controllers should be standardized or remain user-space patterns. Twenty-One Years Without Sockets\, The History of Networking in C++ and What We Learned Along the Way \n \n Go has standard networking. Rust has standard networking. C++ has been trying since 2005. This talk tells the twenty-one-year story in seventeen minutes: the library that shipped but never standardized\, the dependency that blocked it\, the coroutine revolution that changed the assumptions\, the technical discovery that explains why I/O doesn’t fit the three-channel model cleanly\, and the bridge that lets both models win. Three decision points\, three lessons\, one live question: how should coroutines and senders coexist for C++29? No villains. Just the story and the engineering. Networking is now finally a C++29 priority\, so said the Direction Group’s P5000. Out-of-Thin-Air (OOTA) Values. \n \n The memory models for high-level languages\, including C++\, C\, Rust\, and even Java\, have been prone to out-of-thin-air values. For example\, given two atomic integers X and Y\, both initially zero\, if one thread does a relaxed assignment from X to Y and the other does a relaxed assignment from Y to X\, the mathematical C++ memory model does not rule out the outcome where both X and Y have the value 42. However\, both communication and computation take time\, and so we have proven that OOTA values cannot happen on real-world production-quality computer systems. This result makes compiler-writers’ lives easier\, and also eases the jobs of those brave individuals pursuing the full mathematical OOTA problem by relieving them of the need to live within CPU and memory constraints of production-quality compilers. Discussion \n \n There are other features under discussion\, but the features we will present seem close to approval\, are particularly interesting\, and/or are relatively non-controversial. We will show use cases for each and prognosticate their journeys to C++26 and beyond. This will help programmers in concurrency\, lock-free programming\, and low-latency applications understand how best to take advantage of each of these important facilities. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:4af4b89b2332cb1a3664fb4956617779
URL:http://cppcon2026.sched.com/event/4af4b89b2332cb1a3664fb4956617779
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T150000Z
DTEND:20260915T160000Z
SUMMARY:The State of Boost: Boost Is Where You Become the Engineer You Want to Be
DESCRIPTION:Every Boost library that graduated to the C++ Standard became invisible. shared_ptr doesn't say "Boost" anywhere in . Boost's greatest successes carry no signature — and that invisibility is killing recruitment. This talk is not a status report. It is an answer to the question: why would I give my best work to a project that erases my name? \n \n We begin with the people. Peter Dimov. Beman Dawes. Howard Hinnant. Marshall Clow. These engineers didn't just write libraries — they defined what production-quality C++ means. We will say their names\, show their faces\, and then ask the only question that matters for Boost's future: who replaces them? Every technical detail in this talk serves that question. \n \n The answer starts with the peer review process — not as a quality gate\, but as an apprenticeship. Boost review doesn't just catch bugs\; it forges people. It is the mechanism by which a competent developer becomes a Dimov-class designer\, and we will show how that pipeline works today. \n \n Then the technical core. Boost.Unordered's unordered flat map — not as a benchmark\, but as a character study. Joaquín López Muñoz sat down\, studied SIMD probing\, and built something faster than a team at Google. We won't just show a bar chart\; we'll show the design decisions — the one that made it fast and the one that almost kept it from shipping. Boost.Intrusive — presented as a magic trick before an explanation. One object. Three containers. Zero allocations. We'll let the audience sit in "wait\, that can't work" for ten seconds before we reveal the mechanism. Boost.Decimal — IEEE 754 decimal floating-point that feels like a native type\, with portable performance rivaling GCC's non-portable _Decimal extensions. We will also cover Boost.JSON\, Boost.URL\, Boost.Scope\, Boost.Cobalt\, and the design thinking behind each. \n \n Networking gets its own act. Beast\, Corosio\, Capy — presented as a list\, they're alphabet soup. Presented as what they are\, they become a statement of intent: Boost is building the networking layer the committee has been unable to standardize for fifteen years\, and we believe we can ship it. We will show how buffer sequences\, stream concepts\, and type-erased I/O deliver ABI-stable networking compiled once against an abstract transport\, and how this connects to active WG21 proposals for C++29. \n \n We close not with a mailing list URL but with a name. One person — a contributor who submitted their first Boost PR this year\, went through review\, and is now preparing a library for formal consideration. A person is a door\; a URL is a wall. The thesis of this talk is not "Boost is alive." The thesis is that Boost is where you become the engineer you want to be — and every section\, from the review process to the mentorship lineage to the fact that one person can build the fastest hash map in the industry\, is proof. \n \n
CATEGORIES:GENERAL
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:80b5c6d367729ba5e0b67bc907b89784
URL:http://cppcon2026.sched.com/event/80b5c6d367729ba5e0b67bc907b89784
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T150000Z
DTEND:20260915T160000Z
SUMMARY:Scaling Robotics to 200 Developers: Flexible C++ Architectures for Kinematics\, Dynamics\, Simulation & Control
DESCRIPTION:Large-scale robotics organizations operate diverse fleets of manipulators — 4-DOF arms on rails\, 6-DOF standard manipulators on pedestals and fully mobile manipulators — each with different kinematics\, hardware vendors\, and software teams and researchers. \n \n And engineers and researchers are opinionated. \n \n As a team eventually you have one goal. Re-use as many abstractions\; ideas and algorithms as you can while still allowing you the flexibility to explore new algorithms\; ideas and approaches. \n \n This talk presents a layered C++ architecture that solves this at scale. We present our core abstrcactions\; a header-only Lie group library provides shared spatial math types (SE(3) poses\, twists\, wrenches)\; a trajectory library for motion planners and controllers\; and a collision detection library from the same. \n \n We will discuss how we moved from virtual functions to C++ concepts with zero overhead and the learnings along the way that allow us to write planning and control algorithms for various robots morphologies and sensing paradigms. \n \n Critically\, this architecture balances the needs of production at scale while enabling experimentation: researchers can prototype new collision algorithms\, try a new physics engine\, or test a novel trajectory representation — all without disrupting production code. The backend boundaries are where new ideas enter the system. You'll leave with three distinct C++ patterns for backend abstraction — compile-time traits\, runtime interfaces\, and type erasure — and an understanding of when to use each based on performance requirements and the need for experimentation. \n \n
CATEGORIES:ROBOTICS & AI
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:b9402138927600165faedea2e2950a66
URL:http://cppcon2026.sched.com/event/b9402138927600165faedea2e2950a66
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T150000Z
DTEND:20260915T160000Z
SUMMARY:Death by a Thousand Tape Entries: Low-Overhead Automatic Differentiation for Scientific and Financial C++
DESCRIPTION: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. \n \n 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. \n \n 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. \n \n 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. \n \n
CATEGORIES:SCIENTIFIC COMPUTING
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:23b69cec2c8b5857149e22dab329c461
URL:http://cppcon2026.sched.com/event/23b69cec2c8b5857149e22dab329c461
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T150000Z
DTEND:20260915T160000Z
SUMMARY:What's New for C++ in Visual Studio Code: C++ and AI Tooling for Your Build\, Your Code\, Your Workflow
DESCRIPTION:Modern C++ development spans platforms\, build systems\, and increasingly complex project structures. In this landscape\, Visual Studio Code has carved out its distinct position as a lightweight\, extensible editor that works where you do\, with first-class extensions built on decades of C++ language services and build system integration. This year's update deepens both of those foundations and opens them up to AI-driven workflows powered by GitHub Copilot. \n \n This session walks through what's new across three dimensions of C++ development in Visual Studio Code. For the inner loop\, we'll cover practical improvements to everyday compile-test workflows\, including CMake target bookmarks and Run Without Debugging. For writing and understanding code\, we'll show how the C/C++ extension's language services now surface rich project understanding to GitHub Copilot\, giving AI assistance real awareness of your code structure instead of relying on generic pattern matching. For your workflow\, we'll demonstrate how AI capabilities compose across different modes of working: inline suggestions for hands-on editing\, agent coordination for multi-file refactoring\, and CLI sessions for long-running tasks and deeper codebase analysis you can revisit on your own schedule. \n \n Throughout the session\, we’ll use real-world C++ problems to demonstrate where these tools meaningfully improve productivity and where they intentionally stay out of your way. Finally\, we’ll show you how to inform GitHub Copilot about your team's best practices and scale them across your code through extensibility points like skills\, custom instructions\, and custom agents. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:efa7aa7b144217fdd422ba00dcc55b7f
URL:http://cppcon2026.sched.com/event/efa7aa7b144217fdd422ba00dcc55b7f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T163000Z
DTEND:20260915T180000Z
SUMMARY:Language Designers Panel
DESCRIPTION:This Language Designers Panel features three of the people who decide what the languages you use every day actually become:\nBjarne Stroustrup\, the creator of C++ (who will have just given his own Monday conference kickoff keynote the day before)Guido van Rossum\, the creator of PythonMads Torgersen\, the lead designer of C# and Anders Hejlsberg’s successor in that roleModerator:&nbsp\;Emma Tracey\, founder of CultRepo and producer of its new feature film&nbsp\;C++: The Documentary and&nbsp\;Python: The DocumentaryThree living and growing languages used by millions of developers\, three design philosophies\, one stage\, one conversation.\nBjarne and Guido have never been on stage together anywhere and may never be again\; add Mads to the stage\, and we expect this special moment to be watched\, cited\, and argued over for years. You can be in the room when it happens.\nWhy should a C++ audience care about a panel that is two-thirds “other languages”? The answer is that these languages are two of C++’s closest neighbors and are used together all the time.\nPython&nbsp\;is\, by the numbers\, C++’s truest sister language. In the Standard C++ Foundation’s annual C++ developer survey\, when we ask which other languages C++ programmers use\, Python always comes first\, consistently around 70 percent — ahead even of C\, which you might expect to win and is consistently around 45 percent. If you write C++\, the odds are very good that you also write Python\; the two have grown up side by side\, gluing and being glued\, and the relationship only deepens each year.C#&nbsp\;and C++ are the two dominant languages on Windows\, and the two are constantly used together — native performance underneath\, managed productivity on top — so the person designing C# is designing part of the world that a great many C++ developers ship into.So this is a conversation among the architects of the three languages most of us actually live in. What do they envy in one another’s designs? Where do they think they got it right\, and where would they start over? How do you steer a language with millions of users and decades of existing code without breaking the people who depend on you? And the lessons to learn from their shared experience reach well beyond language design — the same instincts that shape a language will sharpen how you design your own libraries and products. Bring your own questions\, too — you will not get a chance like this often.\n
CATEGORIES:PLENARY
LOCATION:Colorado A\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:31706adc7b7acd6cb30984ad05470b6e
URL:http://cppcon2026.sched.com/event/31706adc7b7acd6cb30984ad05470b6e
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T190000Z
DTEND:20260915T195500Z
SUMMARY:Poster Presenter sessions
DESCRIPTION:Poster presenters will be available for an additional Q&A at their posters\, in case you weren't able to make the session Sunday night\, or if you would like to discuss the presented topics in more detail.
CATEGORIES:OPEN CONTENT
LOCATION:Exhibit Hall\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:21872eecee9b21baa94b22ae74a329ee
URL:http://cppcon2026.sched.com/event/21872eecee9b21baa94b22ae74a329ee
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T200000Z
DTEND:20260915T210000Z
SUMMARY:Back to Basics: Loops in C++
DESCRIPTION:A fundamental control structure of each programming language are loops. And we all expect them to be simple and self explanatory. However\, C++ would not be C++\, if there would be no tricky details to learn and respect about loops in C++. \n \n This talk takes its time to discuss the various ways and approaches to program loops in C++. Beside basic while and for loops\, we talk about the range-based for loop\, and all the extensions recently added to these control structures. \n \n In addition\, we will look at other ways to program loops in C++\, such as using algorithms and how to deal with parallel computing in a loop. \n \n As a result you get a deeper understanding of the various ways loops can be programmed in Modern C++ so that you know better how to use them in practice. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:7b01b1aca568e3badc0d1355a187735b
URL:http://cppcon2026.sched.com/event/7b01b1aca568e3badc0d1355a187735b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T200000Z
DTEND:20260915T210000Z
SUMMARY:What Are We Synchronizing?
DESCRIPTION:Atomic memory ordering is often taught operationally: Use acquire here\, release there\, and perhaps add a fence “to be safe.” This approach tends to produce cargo-cult synchronization\, where atomic operations are selected mechanically without a clear understanding of what information is actually being propagated between threads. In practice\, memory ordering is not about memorizing enum values\, but about establishing which facts become visible to which observers\, and when. \n \n This talk approaches atomic synchronization from first principles. Beginning with the fundamental ideas of publication\, visibility\, ownership transfer\, and synchronization edges\, the talk incrementally develops several concurrent structures drawn from real asynchronous systems. Case studies include outstanding-work reference counting\, a multi-producer singly-linked publication structure\, a concurrently-mutated doubly-linked intrusive list\, and the coordination machinery underlying a concurrent operation with multiple concurrent completion modalities. Each structure is used to derive the synchronization requirements imposed by its invariants\, rather than selecting memory orderings mechanically. \n \n Along the way\, the talk explores the practical meaning of relaxed operations\, acquire/release synchronization\, and atomic thread fences. Particular attention is paid to understanding what each actually does\, when it is necessary\, and when it has become a decorative synchronization cargo cult. The goal is not simply to present lock-free algorithms\, but to develop a principled way of reasoning about memory visibility and synchronization in real concurrent systems. \n \n
CATEGORIES:EMBEDDED
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:1c64b5ac9e21b7dcc4ddc6b54267d95d
URL:http://cppcon2026.sched.com/event/1c64b5ac9e21b7dcc4ddc6b54267d95d
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T200000Z
DTEND:20260915T210000Z
SUMMARY:Inside a Small Game Engine: An Architecture Tour in Modern C++
DESCRIPTION:According to VGInsights\, about 10% of games released on Steam in 2024 used a custom engine\, but those games represent 41% of units sold. Most "how an engine works" talks come from the AAA end of that distribution. This one comes from the other end of that distribution: a teaching-scale engine\, where every system has to be small enough to understand from first principles. The problems are the same as in a big engine\, but the smaller surface is what makes the architecture legible. \n \n In this talk\, we'll walk the spine of the engine in modern C++: allocators and handles in the core\, the job system\, the graphics abstraction question\, the asset pipeline split between pipeline-time and runtime\, and scene representation including ECS. We finish on serialization\, where C++26 reflection (P2996) offers a path past today's reliance on macros and external code generators. \n \n
CATEGORIES:GAMEDEV
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:6571f96504626e2242f46d4ff002bc28
URL:http://cppcon2026.sched.com/event/6571f96504626e2242f46d4ff002bc28
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T200000Z
DTEND:20260915T210000Z
SUMMARY:Running Compiler Explorer in 2026: Sandboxes\, Storage\, and Strangers' Code
DESCRIPTION:Compiler Explorer looks simple: type code\, get assembly. Underneath: a fleet of sandboxed machines running hundreds of compilers across dozens of languages\, terabytes of binaries to keep current\, and the ongoing problem of executing arbitrary code from internet strangers. \n \n A lot has changed in the 14 years that the site has been around: The sandboxing layers that let it run other people's code without losing sleep. The storage situation that very nearly broke it\, and the content-addressable filesystem that quietly rescued everything. The operational war stories\, the migration sagas\, and the bits that are far more boring than they look from the outside. Along the way you'll see some of CE's recent features in their natural habitat\, and get a peek at what's coming next. \n \n You'll come away with a working mental model of how to run untrusted compilation at scale - and why the parts that look easy are almost always the hard ones. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:72f5c254787c26d165a2e7986a7cb9ef
URL:http://cppcon2026.sched.com/event/72f5c254787c26d165a2e7986a7cb9ef
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T200000Z
DTEND:20260915T210000Z
SUMMARY:Using Modules in a Real Project
DESCRIPTION: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. \n \n
CATEGORIES:GENERAL
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:613e4956a76f4105d5829cbafdb1fd22
URL:http://cppcon2026.sched.com/event/613e4956a76f4105d5829cbafdb1fd22
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T200000Z
DTEND:20260915T210000Z
SUMMARY:C++ at Scale
DESCRIPTION:At scale\, writing C++ becomes a different engineering discipline. Problems that appear secondary in smaller systems — dependency boundaries\, build graph stability\, toolchain inconsistencies\, integration latency\, ownership\, and deployability — become first-order constraints. \n \n In production HFT\, a single core infrastructure repository may contain 26+ million lines of C++ across 100K files\, organized into 250+ distinct subprojects: exchange gateways\, feed handlers\, protocol codecs\, shared risk libraries\, replay frameworks\, and strategy infrastructure. That shared foundation is continuously modified\, rebuilt\, tested\, and deployed by engineering teams across five time zones and more than 40 trading teams\, each maintaining their own siloed multi-million-line client systems in C++\, Rust\, and Python. \n \n Under these conditions\, many accepted “best practices” simply do not survive contact with reality. Systems must instead evolve toward what might be called a ground state: components reduced to their essential boundaries and responsibilities\, abstract enough to support radically different workloads\, but precise enough to compose into a coherent whole. \n \n The challenge is not merely writing fast code. It is building systems that remain correct\, flexible\, and evolvable while operating under constant latency and operational pressure. \n \n This is not a talk about “perfect architecture\,” but about the tradeoffs\, hard-earned lessons\, constraints\, and occasional failures through which generations of engineers — myself included — have kept large systems moving forward without stopping the business behind them. \n \n
CATEGORIES:SOFTWARE DESIGN
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:bf7518ae9cbaeb638f80cc192be8219c
URL:http://cppcon2026.sched.com/event/bf7518ae9cbaeb638f80cc192be8219c
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T211500Z
DTEND:20260915T221500Z
SUMMARY:Back to Basics: C++20 Concepts
DESCRIPTION:In this talk we will explore "Concepts\," a powerful feature for expressing template requirements added in C++20. Participants will learn how concepts improve code readability\, provide clearer compiler diagnostics\, and help enforce correct usage of templates and function overloading. Through simple\, hands-on examples\, we will explore the syntax\, common use cases\, and best practices for integrating concepts into modern C++ code. By the end of the session\, attendees will understand how to write safer\, more maintainable template code and leverage concepts to communicate intent clearly. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:143de37214db907b041635ffe2e113fd
URL:http://cppcon2026.sched.com/event/143de37214db907b041635ffe2e113fd
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T211500Z
DTEND:20260915T221500Z
SUMMARY:Good boss\, bad boss: how to be a good manager\, and how to manage a bad one.
DESCRIPTION:Most bosses aren’t stupid\, they just seem like it sometimes! This can be especially so when a great programmer first becomes a manager – suddenly the very attributes that made them good at their job become a problem. Whether you’ve just been ‘promoted’ to a management position\, you hope to be some day\, or you want to know how to deal with a difficult manager – it’s very useful to understand the world from a boss’s perspective. Not all leaders are bosses (and not all bosses are truly leaders): if you want to get something meaningful done then you’ll need to influence other people. \n \n Whether or not you're a boss\, leadership is important. To do meaningful/large things\, we need to work with other people. Encouraging and persuading peers in the right way will make your and your peers' working lives better. \n \n Lots of war stories (anonymised to protect the guilty) and tips and tricks\, this talk is basically 'how to win friends and influence people' for programmers. \n \n
CATEGORIES:BUSINESS & CAREER
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:c764650f1cc4839281fd2b668d4d7469
URL:http://cppcon2026.sched.com/event/c764650f1cc4839281fd2b668d4d7469
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T211500Z
DTEND:20260915T221500Z
SUMMARY:Hacking and Securing C++
DESCRIPTION:This session dives deep into the world of vulnerabilities from a C++ developer's perspective. Using a simple embedded device as the playground\, where the memory model is stripped to the bare essentials\, attendees will explore how classic attacks like buffer overflows can be used to hijack control flow\, inject code\, and manipulate the stack. \n \n Everyone has heard the warnings about buffer overflows\, use-after-free\, memory corruption\, and other infamous vulnerabilities lurking in low-level code. But many developers accept that these traps should be avoided without truly understanding how the exploits work. In this talk\, attendees will see hands-on examples of how memory vulnerabilities arise\, how they’re exploited\, and why they’re dangerous. \n \n But this session is not just about breaking things\, it is about building them right. We will explore how modern C++ techniques like smart pointers\, bounded containers\, and RAII can prevent these issues altogether. By the end of the talk\, developers will not only understand the risks but feel confident applying C++ best practices to write safer\, more robust code. \n \n Whether you are a systems programmer\, embedded developer\, or security-minded engineer\, this session will deepen your understanding of C++\, not just as a powerful language\, but as a tool for writing secure\, reliable software. \n \n
CATEGORIES:EMBEDDED
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:7607345579e3e79c0cf501a6c58ebda3
URL:http://cppcon2026.sched.com/event/7607345579e3e79c0cf501a6c58ebda3
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T211500Z
DTEND:20260915T221500Z
SUMMARY:Lock-Free Timer Scheduling With C++ Atomics
DESCRIPTION:Applications that present rapidly changing market data to human users face a practical challenge: updates may arrive thousands of times per second\, but humans only benefit from periodic refreshes. Efficiently coalescing and scheduling that work without overwhelming CPU resources becomes a concurrency problem rather than simply a rendering problem. \n \n This talk demonstrates how modern C++ atomics can be used to build a lock-free timer scheduler optimized for extremely high update rates. The scheduler follows a single-producer\, multiple-consumer design in which work items represent recurring tasks that must execute periodically. Consumers process scheduled work and re-schedule it for future execution without relying on traditional locks or centralized coordination. \n \n The most unusual aspect of the design is its “reverse work stealing” behavior: consumers can proactively give away work to other consumers and become idle themselves. Rather than distributing work evenly across all threads\, the scheduler attempts to pack work onto as few cores as possible\, reducing idle spinning\, lowering CPU utilization\, and improving cache locality. Because tasks may have highly variable execution times\, the scheduler must also prevent pathological cases where work is endlessly redistributed between consumers. \n \n Attendees will learn how atomics\, lock-free forward lists\, and memory ordering can be combined to implement high-throughput schedulers with predictable latency characteristics. The talk also discusses practical tradeoffs\, implementation challenges\, and performance measurements from production-inspired workloads\, including producer throughput of approximately 50 million scheduled tasks per second and consumer processing throughput approaching 700 million tasks per second\, while keeping migrated work items below 1% in typical workloads. \n \n
CATEGORIES:GENERAL
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:82d31b680dea36f6f1be63af84c635b5
URL:http://cppcon2026.sched.com/event/82d31b680dea36f6f1be63af84c635b5
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T211500Z
DTEND:20260915T221500Z
SUMMARY:Compile-Time Polymorphism for Runtime-Flexible Systems: Lessons from OpenJDK
DESCRIPTION:Your system supports multiple strategies\, with the user selecting one at startup\, but each strategy must handle different semantics. Traditional runtime polymorphism can require a virtual override for every combination\, making code harder to extend and easier to get wrong \n \n This talk shows how OpenJDK solves this problem by using a layered architecture of compile-time patterns with a runtime trampoline. We'll build them up through OpenJDK's GC barrier system\, where a single templated API stands in for dozens of differently-shaped memory accesses across the runtime: plain stores\, raw/unsafe access\, native calls\, weak references\, and more\, each needing different treatment depending on the semantics and which garbage collector was chosen by the user. \n \n We'll also discuss trade-offs against std::variant\, function pointers\, and plain virtual dispatch. No JVM knowledge required. \n \n
CATEGORIES:SOFTWARE DESIGN
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:e79f213e1256279d8915581f6166a32b
URL:http://cppcon2026.sched.com/event/e79f213e1256279d8915581f6166a32b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T211500Z
DTEND:20260915T221500Z
SUMMARY:Mock Any Function in C++ Without Changing a Single Line of Code
DESCRIPTION:In many languages\, you can mock almost anything. Python has unittest.mock\, Java has Mockito and PowerMock\, and C# has Moq. In C++\, you can usually mock only what was designed to be mockable — and little else. Want to mock a free function? Wrap it in an interface. A static method? Refactor to a template. A non-virtual member? Redesign the class hierarchy. The cost is real: developers either shape production code around testing-tool constraints instead of domain needs\, or they simply leave hard-to-mock code untested. \n \n This talk introduces [LibraryName]\, a new C++ mocking library we developed (and plan to publish soon as open source) that can mock almost any C++ callable — free functions\, static methods\, non-virtual members\, private members\, templates\, lambdas\, and even extern "C" routines — without modifying the code under test. Developed and battle-tested at [CompanyName] for three years across a very large C++/C codebase\, it aims to deliver a first-class testing experience for C++. Under the hood it uses runtime binary patching — replacing function prologues with redirections at test time\, restoring them on scope exit — all surfaced through familiar Google Mock syntax. \n \n We'll show [LibraryName] in action\, walk through the patching mechanism\, and share how to get started -- you'll walk away ready to test almost any function\, regardless of how it was designed. Strong test coverage has always been essential\, and AI-assisted code generation only increases the need for reliable testing backpressure. C++ deserves mocking tooling that matches. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:55ac03b29439caab2d8e2a6a37d288dd
URL:http://cppcon2026.sched.com/event/55ac03b29439caab2d8e2a6a37d288dd
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T224500Z
DTEND:20260915T234500Z
SUMMARY:Back to Basics: Function Overloading
DESCRIPTION:Modern programming languages offer powerful tools for creating intuitive\, expressive code\, but few are as frequently debated as function and operator overloading. While these features allow developers to write code that mimics natural mathematical notation\, such as A+B for complex numbers or vectors\, they also introduce significant risks of ambiguity\, hidden performance costs\, and unintuitive behavior if misused. \n \n This talk explores the balance between expressive power and code maintainability. We will dive into the mechanics of compile-time polymorphism\, examining how compilers resolve overloaded calls and the strict rules governing arity\, precedence\, and associativity. Beyond the what and the how\, we will talk about the when and the why with examples. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:6d99bfa541751f723c03e8367412dcea
URL:http://cppcon2026.sched.com/event/6d99bfa541751f723c03e8367412dcea
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T224500Z
DTEND:20260915T234500Z
SUMMARY:The Value of Idiomatic Code
DESCRIPTION:Many of the problems you encounter in C++ have already been solved\, just not by anyone you talk to regularly. Idioms encode best practices into recognizable patterns that help reduce cognitive load\, convey intent\, and eliminate entire categories of bugs. However\, C++ isn’t a single community. It is a language spoken across many industries\, including\, but not limited to: scientific computing\, games\, embedded systems\, and finance. Each of these domains has developed its own idioms\, patterns that are shaped by the specific constraints they face. \n \n While our vernacular evolves independently\, the problems they solve often overlap. Consider the convergence around the Curiously Recurring Template Pattern (CRTP) and variant-based dispatch. Embedded systems engineers\, working without a heap\, paired CRTP with tagged unions to achieve polymorphic behavior over a closed set of types in static storage. Independent of this\, high frequency trading firms\, driven by latency rather than memory constraints\, adopted the same combination to avoid indirect branches and allocator contention. Two communities\, two different constraints\, but the same pattern. Unfortunately\, since each community was solving the problem in isolation\, it had to be discovered twice. \n \n This is not a new phenomenon. C++ idioms have been crossing boundaries since at least Coplien’s 1992 work on advanced programming styles. Data-oriented design is making a similar journey today\, moving from game engines\, where cache-friendly layouts are basically required\, to financial systems\, where the same CPU architecture imposes the same penalties. \n \n Like a spoken language\, C++ evolves not just through formal specification but through usage. New idioms emerge as communities discover better ways to express intent with new or existing features. They grow and spread via conferences\, open source libraries\, and cross-industry hiring. The C++ Core Guidelines capture some of this evolution\, but much of it lives within codebases and communities that you may never find if you don’t look. \n \n This is a call to look for them. We will trace how specific idioms have traveled between industries\, examine what made them transferable\, and argue that the next improvement to your codebase may already exist\, written in a usage of C++ you haven’t learned about yet. While you are at this conference\, attend the talks from industries other than your own. You may find a solution in a session that you may otherwise skip. \n \n
CATEGORIES:BUSINESS & CAREER
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:d3e39cea0cc6b1361c02d1fc40804af3
URL:http://cppcon2026.sched.com/event/d3e39cea0cc6b1361c02d1fc40804af3
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T224500Z
DTEND:20260915T234500Z
SUMMARY:You’re absolutely wrong! How to get agents to solve complex problems with complex code.
DESCRIPTION:Modern coding agents are incredible\, but they still struggle with the kind of large\, unstructured codebases that are common in C++. There are several techniques and tools that can make them perform much better. Here we show examples and demos of how to get your agent to work better with complex code. The focus is on providing an overview on current techniques and how we’ve found they work best. - Skills\, memory and MCP - these have all been hyped hard\, we’ll sort through where they are actually useful. - All agents (Claude\, Copilot\, Codex\, Gemini) support these - some better than others. - What a skill is and what it isn’t - How to use persistent memory - Why MCP servers are still needed (but not always) - Context engineering. - Context management keeps changing - we’ve got autocompaction and 1M token windows now\, why should we care anymore? - When to “manage” your agent’s context window and when it’s a bad idea - How to understand where context is being spent. - How and why to use subagents - these are almost always available but the capabilities in different frontends are exposed in different ways. - Spec Oriented Development: buzzword\, euphemism for vibe coding or the future of programming? - What is it? - What tools exist? Covering options such as SpecKit\, Kiro\, etc. - Working in parallel with agent teams! - How to get started without having to learn anything (almost)! - Runtime context. - How to give your agent the best possible feedback path so you can stop micromanaging it and leave it to complete longer\, more complex tasks. - Techniques including testing\, CI integration and recording-based technology \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:296a9ef966008b5df99d6f4d498548fc
URL:http://cppcon2026.sched.com/event/296a9ef966008b5df99d6f4d498548fc
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T224500Z
DTEND:20260915T234500Z
SUMMARY:Practical HPC — Forcing the Compiler's Hand with Modern C++
DESCRIPTION:Practical HPC — Forcing the Compiler's Hand with Modern C++ \n \n Achieving near-peak FLOPs on modern CPUs requires exploiting SIMD\, register files\, and cache hierarchies — yet the levers that matter most (loop unrolling\, vectorization width\, tile sizes\, register tiling) are largely outside the programmer's direct control. Autovectorization is fragile\, #pragma unroll is advisory and non-portable\, and the information the compiler needs most — loop bounds\, problem shapes\, working-set sizes — is typically only available at runtime. The result is a familiar gap between theoretical peak and delivered performance\, bridged in practice only by hand-written intrinsics or inline assembly\, fragile macro forests\, or external code generators that sacrifice maintainability and type safety. \n \n Modern C++ is\, sometimes surprisingly\, an excellent language for closing that gap without leaving the host language. We walk through the concrete features that make this possible and how to use them in practice — templates and constexpr to promote runtime values into compile-time constants\, if constexpr and parameter packs for shape-specialized kernels\, generic and template lambdas for loop bodies that are unrolled and inlined by construction\, and concepts to turn silent performance cliffs into compile-time errors. Together\, these give the programmer precise control over what the compiler emits: compile-time dispatch that specializes kernels per shape and target\, guaranteed static unrolling that unlocks ILP and register tiling without relying on optimizer heuristics\, and hardware-aware specialization parameterized on register count\, SIMD width\, and cache sizes. \n \n Looking forward\, C++26 and static reflection push this approach considerably further\, turning today's disciplined metaprogramming into something closer to first-class\, in-language code generation — and squarely aligning the language with the goal of making inline assembly unnecessary\, even at the highest performance tiers. \n \n These patterns are powerful but verbose and reappear across kernels\, so we briefly introduce POET (Performance Optimized Excessive Templates)\, a header-only library usable from C++17 onward that packages the most common cases as ready-to-use building blocks\, alongside xsimd for portable SIMD. \n \n As a concrete case study\, we walk through a real scientific-computing kernel — a workload of the kind that has historically demanded hand-tuned assembly — and show how these abstractions get within a small fraction of theoretical peak throughput while keeping the source readable\, portable\, and maintainable\, with no inline assembly\, no compiler builtins\, and no external code-generation step. Scientific computing does not have to choose between performance and engineering quality\, and with the right abstractions\, development becomes dramatically more effective. \n \n
CATEGORIES:SCIENTIFIC COMPUTING
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:1a3012f241ff02893e02bf2bf5b0dc8f
URL:http://cppcon2026.sched.com/event/1a3012f241ff02893e02bf2bf5b0dc8f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T224500Z
DTEND:20260915T234500Z
SUMMARY:Using Type Erasure to Extend APIs You Don't Own: A Case Study From Audio Plugin Development
DESCRIPTION:Application developers sometimes hit a limitation of a 3rd-party library or framework. The Type Erasure design pattern can help us overcome such limitations without the need to change the 3rd-party API. \n \n Type Erasure is a relatively complex design pattern that allows us to treat a set of unrelated classes as if they shared a common base class\, while preserving value semantics. The downside is increased code bloat and code complexity as the pattern requires a significant amount of additional code. \n \n There have been quite a few talks explaining HOW to implement Type Erasure\, while the topic of WHEN has been rarely discussed. Should we always use type erasure instead of virtual polymorphism? And if not\, then what are the criteria? \n \n This talk will show a concrete example from the audio programming industry of how Type Erasure allowed adding new functionalities to the parameter class system of the JUCE C++ framework without changing its API. As such\, the talk will be useful for application and library developers who use 3rd party libraries but need an extra degree of flexibility. \n \n You will come out of the talk understanding \n \n what Type Erasure is\, when to use it\, and how to implement it. You don't need to understand Type Erasure\, audio development\, or JUCE to attend the talk\; the necessary minimum will be explained during the talk. \n \n
CATEGORIES:SOFTWARE DESIGN
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:f17de4ebdbd23a7fa24ee2c4f4d51257
URL:http://cppcon2026.sched.com/event/f17de4ebdbd23a7fa24ee2c4f4d51257
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260915T224500Z
DTEND:20260915T234500Z
SUMMARY:From User to Contributor: Fixing Bugs and Adding Features in Clang
DESCRIPTION: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. \n \n 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. \n \n 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. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:a7bd5d9de1ca9f9b422eafd1f40970ce
URL:http://cppcon2026.sched.com/event/a7bd5d9de1ca9f9b422eafd1f40970ce
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T003000Z
DTEND:20260916T023000Z
SUMMARY:Citadel Reception
DESCRIPTION:
CATEGORIES:SOCIAL
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:65502e601d0650f33d7b1b56da8650d1
URL:http://cppcon2026.sched.com/event/65502e601d0650f33d7b1b56da8650d1
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T023000Z
DTEND:20260916T040000Z
SUMMARY:C++: The Documentary
DESCRIPTION:
CATEGORIES:SOCIAL
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:cbc9af370f4a779bd0ad3f75e377e1d3
URL:http://cppcon2026.sched.com/event/cbc9af370f4a779bd0ad3f75e377e1d3
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T150000Z
DTEND:20260916T160000Z
SUMMARY:Beyond the Scheduler: Designing Predictable Embedded Systems in Modern C++
DESCRIPTION:Embedded systems live in a world where timing\, memory\, and reliability are not “nice to have” properties—they are the system. And yet\, storage is often treated as if it exists outside those constraints: you write a file\, you call an API\, and you assume the system will “get around to it.” In most applications\, that assumption is fine. In real-time systems\, it quietly becomes a risk. \n \n This talk starts from a simple but uncomfortable question: what if storage had to be as predictable as the rest of your real-time system? \n \n We will explore what changes when predictability is no longer an optimization\, but a design requirement for an embedded file system. Using a deterministic file system written in modern C++ as a concrete case study\, we will walk from system-level requirements all the way down to implementation details that make storage behavior measurable\, bounded\, and reasoned about. \n \n Along the way\, we will look at design choices that are often avoided in general-purpose file systems: fixed-block allocation instead of dynamic growth\, metadata-first layouts that make state explicit\, strictly bounded operations with worst-case guarantees\, and explicit ownership models that eliminate ambiguity around lifetime and responsibility. We will also examine how storage operations interact with real-time scheduling\, and what happens when file I/O is no longer “background work\,” but part of the timing budget. \n \n Modern C++20 plays a central role—not as a performance trick\, but as a way to encode intent. Strong types prevent invalid configurations from compiling. RAII makes resource ownership explicit and deterministic. Compile-time configuration moves entire classes of errors out of runtime. And carefully constrained abstractions allow us to build systems that remain suitable for deeply resource-limited microcontrollers without sacrificing clarity. \n \n But determinism always comes with a cost. Once you commit to predictable behavior\, you give up some flexibility: storage efficiency may decrease\, allocation strategies become more rigid\, and you may lose features that depend on dynamic behavior. This talk does not hide those tradeoffs—it makes them visible\, measurable\, and intentional. We will discuss when deterministic storage is the right answer\, and just as importantly\, when it is not. \n \n Finally\, we will step back from the implementation and look at portability. The same architectural ideas will be mapped across multiple environments: file-backed storage used for testing\, SPI flash on microcontrollers\, and block devices under embedded Linux. The goal is not a single file system\, but a reusable way of thinking about storage in constrained systems. \n \n By the end of this talk\, attendees will not just understand a file system design—they will have a practical framework for reasoning about timing guarantees\, resource ownership\, failure modes\, and architectural tradeoffs in embedded C++ systems where predictability matters more than peak throughput. \n \n
CATEGORIES:EMBEDDED
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:fe50f6453737587d6b20b48f1c581c48
URL:http://cppcon2026.sched.com/event/fe50f6453737587d6b20b48f1c581c48
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T150000Z
DTEND:20260916T160000Z
SUMMARY:Turbocharging Native Code Performance: Compiler Optimizations\, Profile-guided Optimizations\, and Beyond
DESCRIPTION: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. \n \n 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. \n \n 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. \n \n 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. \n \n
CATEGORIES:GAMEDEV
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:ecb74f84fe7c7291356215a3721b3acc
URL:http://cppcon2026.sched.com/event/ecb74f84fe7c7291356215a3721b3acc
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T150000Z
DTEND:20260916T160000Z
SUMMARY:Awaiters and Awaitables
DESCRIPTION: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. \n \n 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. \n \n 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. \n \n 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. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:f5ceb7ac1676b3bffce481a14be9215f
URL:http://cppcon2026.sched.com/event/f5ceb7ac1676b3bffce481a14be9215f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T150000Z
DTEND:20260916T160000Z
SUMMARY:AI is UB with Better PR
DESCRIPTION: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. \n \n
CATEGORIES:ROBOTICS & AI
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:3c9b53507378811322dd8c10d6c9be5a
URL:http://cppcon2026.sched.com/event/3c9b53507378811322dd8c10d6c9be5a
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T150000Z
DTEND:20260916T160000Z
SUMMARY:CUDA Tile C++: Practical Automatic Parallelization for the GPU
DESCRIPTION: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. \n \n 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. \n \n The tile programming model introduces three key abstractions: \n \n 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. \n \n
CATEGORIES:SCIENTIFIC COMPUTING
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:62e6dfc715d2f4ce5e0d8dc1bf743274
URL:http://cppcon2026.sched.com/event/62e6dfc715d2f4ce5e0d8dc1bf743274
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T150000Z
DTEND:20260916T160000Z
SUMMARY:Ranges Without Compromises: Designing for Simplicity\, Performance\, and Composability
DESCRIPTION:Range views enable a "no raw loops" style of programming — not as a matter of taste\, but as a pragmatic way to reuse well-tested algorithms to write code faster\, express intent clearly\, and avoid common bugs. In practice\, however\, developers often run into issues that may lead them to abandon ranges altogether: - unintuitive behavior and surprising limitations - slower compilation and runtime performance compared to raw loops - high complexity when implementing custom views \n \n In this talk\, we'll distill the core design choices behind these problems — and the alternatives that avoid them. In particular\, we'll compare: - iterators and indices - external and internal iteration - transformations of nested views that overcome limitations of internal iteration \n \n Attendees will leave with practical insights for designing and using range abstractions\, along with examples of libraries that embody these ideas. \n \n
CATEGORIES:SOFTWARE DESIGN
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:a0c13dd017712fcee3cfaf8288935e57
URL:http://cppcon2026.sched.com/event/a0c13dd017712fcee3cfaf8288935e57
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T163000Z
DTEND:20260916T180000Z
SUMMARY:How C++26 changes the way we write code
DESCRIPTION:The upcoming C++26 Standard is a major update of the language and one of the most impactful releases in the history of C++.\nstd::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.\nThis 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.\n\n
CATEGORIES:PLENARY
LOCATION:Colorado A\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:238dc161fd572d885681965e5d1b7035
URL:http://cppcon2026.sched.com/event/238dc161fd572d885681965e5d1b7035
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T190000Z
DTEND:20260916T223000Z
SUMMARY:Official ISO C++ WG21 SG meeting of low latency/embedded/games/finance and Machine Learning
DESCRIPTION:\n
CATEGORIES:ISO / WG21
LOCATION:Red Rock 1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:eedae5bfdb404c262d02e8632d4ab671
URL:http://cppcon2026.sched.com/event/eedae5bfdb404c262d02e8632d4ab671
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T200000Z
DTEND:20260916T210000Z
SUMMARY:Embedded-Friendly C++: Modern Features That Make a Difference
DESCRIPTION: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. \n \n 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? \n \n In this talk\, I will present various library elements as well as language improvements that make writing embedded software better. \n \n 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 . \n \n 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. \n \n 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. \n \n By the end of this talk\, you know the most important improvements in C++ for embedded or similar environments. \n \n
CATEGORIES:EMBEDDED
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:62cfd16dcd456e69e56a9b0012a3ecb1
URL:http://cppcon2026.sched.com/event/62cfd16dcd456e69e56a9b0012a3ecb1
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T200000Z
DTEND:20260916T210000Z
SUMMARY:In Pursuit of a 6\,000 FPS Game Boy Emulator
DESCRIPTION:How far can modern C++ push an emulator before performance stops being a C++ problem and becomes a systems problem? This talk is the final part of a CppCon trilogy about building an extremely fast Game Boy emulator in modern C++\, moving from high-performance emulation techniques to the limits imposed by hardware\, compilers\, and CPU architecture. \n \n The target is intentionally absurd but not arbitrary: a Game Boy emulator running Tetris at roughly 100 times original speed\, about 6\,000 frames per second. However\, the goal is not to support every Game Boy cartridge ever made. This project deliberately specializes for one iconic game first\, using the code paths Tetris actually exercises as a guide\, while keeping enough design discipline to test other games later. That means questioning the architecture of the emulator itself: instruction dispatch\, memory access\, generated code size\, cache behavior\, branch prediction\, compile-time computation\, benchmarking methodology\, and the tension between accuracy\, maintainability\, flexibility\, and raw throughput. \n \n This is not a victory-lap performance talk. It is a measurement-driven engineering investigation. Rather than treating 6\,000 FPS as just a headline number\, this talk treats it as a stress test: a way to force difficult design decisions into the open. Attendees will leave with concrete lessons about performance-oriented C++: how to measure methodically\, how to specialize without losing control\, how to reason about modern CPU behavior\, and how to decide when an optimization is worth its cost. \n \n
CATEGORIES:GAMEDEV
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:ae1af7f2979984ffae75bd1fb7f0bb2f
URL:http://cppcon2026.sched.com/event/ae1af7f2979984ffae75bd1fb7f0bb2f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T200000Z
DTEND:20260916T210000Z
SUMMARY:Rule of 0\,1\,2\,5\,6\,7\,8\,9\,10?
DESCRIPTION: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. \n \n But there are many other member functions\, in the form of comparison operators\, that we can =default explicitly \n \n Which of these should we =default? How do we help the compiler\, or stay out of its way? \n \n How many do we need to implement? When can you trust the compiler or not?A \n \n
CATEGORIES:GENERAL
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:fca8e03337ec84d66bc9346abdc4b2db
URL:http://cppcon2026.sched.com/event/fca8e03337ec84d66bc9346abdc4b2db
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T200000Z
DTEND:20260916T210000Z
SUMMARY:The Ghost in the Heap: Defeating a Memory Thief
DESCRIPTION: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. \n \n 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. \n \n 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. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:684e86e192803be36567ec0c978a9723
URL:http://cppcon2026.sched.com/event/684e86e192803be36567ec0c978a9723
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T200000Z
DTEND:20260916T210000Z
SUMMARY:Refactoring Techniques and Strategies (a Tale in Three Acts)
DESCRIPTION: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". \n \n 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. \n \n 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. \n \n 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. \n \n
CATEGORIES:SOFTWARE DESIGN
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:489ba815be5cc9e0eadc0ecbdd9055fb
URL:http://cppcon2026.sched.com/event/489ba815be5cc9e0eadc0ecbdd9055fb
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T200000Z
DTEND:20260916T210000Z
SUMMARY:Automatic Splitting of Translation Units: Compiler-Agnostic Compiler Frontend Parallelization
DESCRIPTION: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. \n \n 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. \n \n 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. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:437d7f735ac37726377aa6696b42a706
URL:http://cppcon2026.sched.com/event/437d7f735ac37726377aa6696b42a706
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T211500Z
DTEND:20260916T221500Z
SUMMARY:Back to Basics: Memory Alignment
DESCRIPTION: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. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:84ad3dc15c0282e11f2dcd0700e903cc
URL:http://cppcon2026.sched.com/event/84ad3dc15c0282e11f2dcd0700e903cc
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T211500Z
DTEND:20260916T221500Z
SUMMARY:C++ Views and Pipelines
DESCRIPTION: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. \n \n 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 \n \n This talk gives an overview about both the technology and where to pay special attention. \n \n
CATEGORIES:GENERAL
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:0ebed2252b02d1374e4ee0384baf1446
URL:http://cppcon2026.sched.com/event/0ebed2252b02d1374e4ee0384baf1446
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T211500Z
DTEND:20260916T221500Z
SUMMARY:Our Journey Toward a Fully Backward-Compatible\, UB-Safe\, ISO C++
DESCRIPTION: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). \n \n 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? \n \n 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. \n \n 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. \n \n 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. \n \n
CATEGORIES:GENERAL
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:1514672429623b4e05d05b1995d62779
URL:http://cppcon2026.sched.com/event/1514672429623b4e05d05b1995d62779
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T211500Z
DTEND:20260916T221500Z
SUMMARY:Readable Async Workflows in Modern C++: Coroutines Meet std::expected
DESCRIPTION: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? \n \n 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
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:2db8e37b50942b1cdf67b6a101f545e0
URL:http://cppcon2026.sched.com/event/2db8e37b50942b1cdf67b6a101f545e0
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T211500Z
DTEND:20260916T221500Z
SUMMARY:Writing High Performance Parsers Using State Machines
DESCRIPTION:Starting from the simple objective of writing an optimized lexer we will grapple with their fundamental performance factor: branch prediction. We will investigate how lookup tables can improve (or hurt) the CPUs prediction capabilities with some unexpected results. Over time our design evolves by combining parsing and lexing into a single step in a way that is as fast as just a standalone lexer. A central aspect of the design will be a primitive parsing state machine from which the parser source code is generated. \n \n After the talk attendees will have a better understanding of some advanced branch prediction techniques and should have some new ideas for their present or future parsing endeavors. \n \n
CATEGORIES:GENERAL
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:5749910d6d81b2f5214bb8c97c1d2ca7
URL:http://cppcon2026.sched.com/event/5749910d6d81b2f5214bb8c97c1d2ca7
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T211500Z
DTEND:20260916T221500Z
SUMMARY:You Shall Not Pass*!
DESCRIPTION: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". \n \n This talk presents a refinement of that guideline: \n \n Pointers - smart or not - shall not appear in function signatures\, neither as argument nor as return type. \n \n The focus of this talk is how to implement classes as regular types while still supporting dynamic allocation\, polymorphism\, and sharing internally. \n \n 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. \n \n Along the way\, the talk revisits the Rules of 3/5/0\, exception safety guidelines\, const propagation\, aliasing\, and local reasoning. \n \n The talk aims to make you stop passing pointers around. \n \n
CATEGORIES:GENERAL
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:45b45a0684e27956bedb257f80cf9c6c
URL:http://cppcon2026.sched.com/event/45b45a0684e27956bedb257f80cf9c6c
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T224500Z
DTEND:20260916T234500Z
SUMMARY:Meet Guy Davidson
DESCRIPTION:For the first time in a generation\, the C++ Standards Committee has a new convenor. Meet Guy Davidson. \n \n In the decade since joining the Committee\, Guy has not personally authored wording that made it into the Standard. Yet\, he exemplifies what the role demands: the ability to work intently\, iterate relentlessly\, absorb setbacks\, adapt\, and return stronger. He pairs that with a deep commitment to guiding the evolution of a language that underpins much of the modern world – and a rare talent for setting aside ego to build consensus. Sometimes\, he even does it in iambic pentameter\; at others\, in the rhythm of a sea shanty. \n \n In this fireside chat\, Guy will reflect on what it means to inherit an institution\, his first months in the role\, and the moment 118 hands rose in support of C++26 – while Bjarne Stroustrup’s did not. He’ll also share his own work: projects aimed at expanding C++’s capabilities\, including an idea inspired by game engine design that has caught the attention of leading climate scientists. \n \n
CATEGORIES:BUSINESS & CAREER
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:3bcb1b7b6f4888d0c5e18e84db7e2f92
URL:http://cppcon2026.sched.com/event/3bcb1b7b6f4888d0c5e18e84db7e2f92
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T224500Z
DTEND:20260916T234500Z
SUMMARY:Zero Cost Scripting Languages for Game Engines With C++26 Static Reflection
DESCRIPTION:Scripting in a C++ game engine should not cost you the engine's native performance. This talk shows how C++26 static reflection and std::meta::substitute in particular can lift a scripting language's bytecode into C++ template structures that the compiler optimizes away entirely\, collapsing the interpreter dispatch loop into the same machine code you'd write by hand. Scripting languages like AngelScript and Lua are invaluable in C++ engines: they give designers a fast iteration loop without rebuilding the engine. But they come with a paradox. The engine you chose for raw performance now spends cycles on every frame interpreting a slower language\, juggling a software stack and checking types at runtime. We will walk through the technique step by step\, starting from a plain bytecode interpreter and ending at a fully reflected program where a scripted sum(0..10) compiles to mov eax\, 45\; ret. Along the way you'll learn the core C++26 reflection primitives (^^\, [: :]\, std::meta::substitute)\, how to assemble bytecode into structural templates like block&lt\;&gt\; and loop&lt\;&gt\;\, and how these techniques generalize to embedding any stack or register based scripting language in your engine with zero runtime overhead. \n \n
CATEGORIES:GAMEDEV
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:9c4f3274c602d51cf32cbfa1d912d245
URL:http://cppcon2026.sched.com/event/9c4f3274c602d51cf32cbfa1d912d245
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T224500Z
DTEND:20260916T234500Z
SUMMARY:Modern C++ Techniques to Reduce Boilerplate Without Sacrificing Performance
DESCRIPTION: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. \n \n This talk explores practical modern C++ techniques that significantly reduce lines of code while preserving readability\, maintainability\, and runtime performance. \n \n 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. \n \n 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. \n \n 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. \n \n
CATEGORIES:GENERAL
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:705b01fd5bea90c3801c3065c66c8599
URL:http://cppcon2026.sched.com/event/705b01fd5bea90c3801c3065c66c8599
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T224500Z
DTEND:20260916T234500Z
SUMMARY:Processor Design and C++ Memory Models
DESCRIPTION: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...'. \n \n 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). \n \n 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. \n \n
CATEGORIES:GENERAL
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:781e28603b78f9fdbca07c01b3f2a464
URL:http://cppcon2026.sched.com/event/781e28603b78f9fdbca07c01b3f2a464
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T224500Z
DTEND:20260916T234500Z
SUMMARY:The Clocks of C++: Knowing When (and Why) to Use Each One
DESCRIPTION: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. \n \n 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. \n \n 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. \n \n
CATEGORIES:GENERAL
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:e1658b77eb2ba72597f95897d7616ac3
URL:http://cppcon2026.sched.com/event/e1658b77eb2ba72597f95897d7616ac3
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260916T224500Z
DTEND:20260916T234500Z
SUMMARY:C++ Core Guidelines Enforcement in Practice
DESCRIPTION: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." \n \n 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. \n \n 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. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:0460c4cf82029d6892f5d3667432db89
URL:http://cppcon2026.sched.com/event/0460c4cf82029d6892f5d3667432db89
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T001500Z
DTEND:20260917T030000Z
SUMMARY:Boost.Documentary (Audience Preview)
DESCRIPTION:\nThe True Stories team will be on site during this Audience Preview.\n\nTrue 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).\n
CATEGORIES:OPEN CONTENT
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:ec03d3375af4e1d0b5f16b8c5f21ed61
URL:http://cppcon2026.sched.com/event/ec03d3375af4e1d0b5f16b8c5f21ed61
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T030000Z
DTEND:20260917T040000Z
SUMMARY:Lightning Talks
DESCRIPTION: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. \n\n Submit your talk here
CATEGORIES:OPEN CONTENT
LOCATION:Colorado B\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:be516c848f90279967c47e82ae816d0a
URL:http://cppcon2026.sched.com/event/be516c848f90279967c47e82ae816d0a
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T150000Z
DTEND:20260917T160000Z
SUMMARY:Back to Basics: Lambdas\, Function Objects\, and std::function
DESCRIPTION:C++ gives us at least four different ways to pass "a thing that can be called" from one piece of code to another: function pointers\, function objects\, lambdas\, and type-erased wrappers like std::function . Modern C++ has added more — generic lambdas\, deducing-this lambdas\, std::move_only_function \, and a healthy ecosystem of concept-constrained callable parameters. Each of these has a job it is good at and several jobs it is bad at\, but they are often used interchangeably until something breaks. \n \n We will start with the basics: what a callable actually is\, how function pointers\, function objects\, and lambdas relate to one another\, and how the compiler thinks about each of them. We will look at lambda capture rules in detail — by-value\, by-reference\, init captures\, dangling captures\, and the cases where well-meaning developers reach for [=] or [&] and ship a bug — and we will see how generic lambdas (C++14) and deducing-this lambdas (C++23) extend the model without giving up clarity. \n \n From there we will turn to the question of how to store and pass callables. We will compare function pointers\, std::function \, std::move_only_function (C++23)\, and concept-templated callable parameters along the axes that actually matter: ownership\, allocation\, move-only support\, performance\, and what the API tells the reader. Examples will be drawn from issues that have come up writing production code and mentoring developers — including the kind of subtle ABI and lifetime bugs that hide behind a perfectly reasonable-looking std::function&lt\;void()&gt\; parameter. \n \n We will conclude with recommendations for which tool to reach for in which situation\, with reference to the C++ Core Guidelines where useful. Attendees will leave with a clearer mental model of callables in modern C++ and a defensible default for the next time they write a function that takes one. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:938c30c81974c4af29e0a1eadb886b06
URL:http://cppcon2026.sched.com/event/938c30c81974c4af29e0a1eadb886b06
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T150000Z
DTEND:20260917T160000Z
SUMMARY:Beyond Monads: Pattern Matching Alternatives for Result Types
DESCRIPTION:In C++\, monadic operations are a commonly utilized API for interacting with result types like std::optional and std::expected. By chaining the computations\, these abstractions allow you to manipulate the underlying values using less boilerplate code. Monadic operations are a powerful tool suitable for a variety of usage scenarios. They enhance code robustness and significantly lower the risk of accidental errors. \n \n Despite its benefits\, many users consider the syntax of monadic operations to be overly verbose\, and the underlying concept often seems complicated. There are also the cases where the restrictions placed on functions require using extra statements\, specific return and arguments types\, and reduce code readability. However\, are there other options available? Do we have promising alternatives? The short answer is: yes. While C++ does not yet include pattern matching as a native language feature\, the standard library still offers tools for achieving many useful pattern-matching-like functionalities. We will explore how to apply std::visit to this problem and evaluate if an abstraction\, which we might call std::match\, could serve as an effective substitute for monadic operations in various situations. \n \n Based on several years of practical production experience\, this talk will explore the use of monadic result type interfaces and comparable alternatives. This information will benefit practicing software engineers looking to deepen their understanding of these features and integrate them into their codebases. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:7a55905e11130a44f3ea0ad98ca8fc09
URL:http://cppcon2026.sched.com/event/7a55905e11130a44f3ea0ad98ca8fc09
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T150000Z
DTEND:20260917T160000Z
SUMMARY:Building C++20 Modules: The Rest of the Story
DESCRIPTION:There is no classical treatise on the design and implementation build systems\; no faithful textbook every toolchain engineer has on their bookshelf. If there were we would need to throw it out anyway\, because C++20 modules required a significant rethink of how build systems orchestrate compilation of C++ software. \n \n It's been said over and over again that C++20 modules complicate the classic compile and link steps for C++. However\, few have dived into how exactly build systems are dealing with this step-change in complexity. Talks will demo a few raw compiler invocations and say no more about the subject. This leaves engineers unequipped to deal with problems that arise in their builds\; frustrated by opaque error messages and baffling build logs. \n \n In this talk\, we're going to fill in the rest of the blanks and explore exactly how build systems are tackling modules. \n \n
CATEGORIES:GENERAL
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:4ddb17110826d91e37adbd94b0a5496b
URL:http://cppcon2026.sched.com/event/4ddb17110826d91e37adbd94b0a5496b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T150000Z
DTEND:20260917T160000Z
SUMMARY:Composing the Future: Async Workflows with std::execution
DESCRIPTION:Software development has now shifted decisively to a distributed\, asynchronous paradigm\, in which engineers must manage code that may be executing on parallel threads\, or on a different machine. Many mainstream programming languages have adapted themselves to this new world. For example\, JavaScript has promises and async/await\, Python has asyncio\, Rust offers zero-cost async/await with compile-time safety\, and Go built goroutines and channels as first-class primitives. \n \n C++ developers face the same challenge but have been left without a standard solution. As a result\, much production code remains stuck in “callback hell\,” where control flow is inverted\, error handling is duplicated at every level\, and common patterns like "run A and B in parallel\, and then combine results" must be hand-rolled every time. \n \n This is not simply a matter of bolting async/await onto C++. Deterministic destruction\, zero-overhead abstraction\, and precise control over memory and lifetimes\, these very properties making C++ powerful dictate that an async framework cannot rely on a garbage collector or managed runtime to paper over complexity. It must earn its place by working with the language's ownership model\, not around it. \n \n std::execution is C++’s answer to this problem. Introduced as part of C++ 26\, it solves this through composable senders: lazy\, type-safe descriptions of work that can be chained\, branched\, and parallelized before being submitted to an execution context. Like Swift's structured concurrency\, std::execution enforces structured lifetimes so that async work cannot silently outlive its scope. \n \n This talk aims to provide application developers with an introduction to the current proposal and give them a grounding in the fundamentals that can be applied in real-world applications. We will walk through several worked examples: from simple chains to parallel fan-out with error propagation\, showing side-by-side comparisons with callback-based equivalents to make the advantages more concrete and relatable. \n \n This talk assumes no knowledge of the std::execution framework and no expertise in async programming\, though practical\, real-world experience will certainly help ground the examples. Attendees will leave with a working understanding of the sender/receiver model\, practical patterns they can use\, and a clear picture of what structured concurrency means for C++. \n \n
CATEGORIES:GENERAL
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:93e9f8be54247a9cb45bad17521d591b
URL:http://cppcon2026.sched.com/event/93e9f8be54247a9cb45bad17521d591b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T150000Z
DTEND:20260917T160000Z
SUMMARY:Writing Low-Latency C++: Predictability\, Cache\, and the Architectures Underneath
DESCRIPTION:In low-latency C++\, correctness is table stakes. What separates good systems from great ones is predictability — the ability to hit your deadline not just on average\, but at the 99th and 99.9th percentile\, where real workloads live. Latency is a feature\, and if you don't design for it explicitly\, you lose it accidentally. \n \n This talk is a practitioner's guide to writing C++ that behaves predictably under load\, drawn from experience building and tuning low-latency systems on Microsoft's Azure Core platform. We start from the mental models that matter most — CPU-centric thinking\, the latency stack from L1 to DRAM\, and why minimizing work\, unpredictability\, and memory movement is the foundation of everything else — and then work through the layers of the stack where latency is won or lost in practice. \n \n Through live demos and benchmark data on both x86 and ARM\, we'll cover: \n \n STL containers as latency contracts — why most latency bugs start with the wrong container\, the real cost of dynamic reallocation\, and the measurable wins from reserve() and custom allocators. \n \n Memory layout and cache behavior — struct layout and alignment (and how it differs on x86-64 vs. ARM64)\, AoS vs. SoA trade-offs\, hot/cold data separation\, false sharing\, NUMA\, and TLB pressure. \n \n Atomics vs. mutexes — when atomics actually lose to mutexes\, why architecture and memory model dictate the answer\, and how to choose between them in real code. \n \n Threading and scheduling — fixed vs. dynamic thread pools\, context-switch and migration costs\, and why understanding the OS is half the battle. \n \n Benchmarking and observability — why microbenchmarks lie\, how to avoid measurement bias and jitter\, why latency histograms beat averages\, and why "absolute benchmark" is a myth. \n \n You'll leave with a practical playbook for designing and measuring low-latency C++ systems\, an honest understanding of why benchmarks from one machine rarely generalize to another\, and a sharper instinct for the silent killers — allocations\, branches\, cache misses\, and synchronization primitives — that don't show up in code review but do show up in production. \n \n
CATEGORIES:GENERAL
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:063731370df25dcf657a12a12905541b
URL:http://cppcon2026.sched.com/event/063731370df25dcf657a12a12905541b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T150000Z
DTEND:20260917T153000Z
SUMMARY:Tying up Loose Threads: Making Your Project No-GIL Ready
DESCRIPTION:Python's Global Interpreter Lock\, which determines which single thread can execute native Python code and call C API functions\, simplifies writing multithreaded code. By default\, the most popular C++ bindings to this API\, pybind11 and Cython\, implicitly enables the GIL by default. However\, sticking with this execution model leaves out extra performance afforded by modern multicore CPUs with hyperthreading\, as automatic locking and unlocking of the GIL does not scale well with thread counts\, especially in performance-sensitive workloads. \n \n The newfangled free-threaded interpreter promises salvation when running either pure Python code or with compiled extensions. General multithreading rules apply (prefer thread-local variables\, using locks to prevent simultaneous access of shared data)\, but when dealing with projects containing compiled extensions that directly or indirectly interface with Python's C API\, more porting rules also apply. \n \n Key porting tips\, including projects using the Limited API\, include: port native code away from C API functions that avoid borrowed references because they aren't thread-safe\; modify unit tests to catch concurrency bugs arising from assuming the presence of the GIL\; and extend CI coverage of Python interpreters both for testing and to build free-threaded compatible wheels. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:b73694b0fea338e0d125fcbcc5eff3e5
URL:http://cppcon2026.sched.com/event/b73694b0fea338e0d125fcbcc5eff3e5
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T153500Z
DTEND:20260917T160500Z
SUMMARY:[[musttail]]-ling Our Way to a Faster Python Interpreter and New JIT Compiler
DESCRIPTION:In CPython 3.14\, we introduced an alternative interpreter implementation. This implementation used [[musttail]] \, an experimental C/C++ feature that tells the compiler to enforce tail calls. Against the previous interpreter using computed gotos/switch-case\, the new interpreter style shows 2%--15% performance improvement (i.e. geometric mean running time)\, and is more resilient against certain types of compiler bugs. This feature is already supported by Clang\, GCC\, and MSVC\, and is also the center of a draft proposal targeting C++29. In this talk\, I’ll cover the story of getting this feature into the Python interpreter\, our collaboration with compiler developers\, and the potential wider impact on the C++ community. I’ll also cover interesting use cases of this feature other than for writing interpreters\, such as for automatically generating a simple Just in Time (JIT) compiler. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:7fc6667c0e32af2d2e7db433168c8e8b
URL:http://cppcon2026.sched.com/event/7fc6667c0e32af2d2e7db433168c8e8b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T163000Z
DTEND:20260917T180000Z
SUMMARY:The Address is Not The Place: Object Residency in C++26
DESCRIPTION:Random Access Memory is what you buy when you don’t know what your program will do next.\n&nbsp\;Until recently\, alternative tiers of memory with vastly different latency characteristics were largely speculative. Then DRAM got expensive. CXL memory pools\, far memory\, even high bandwidth flash moved from blips to serious contenders. C++ has grown its vocabulary for ownership (smart pointers) and lifetimes (RAII)\; but intelligent memory tiering\, specifically object residency\, is a word we don’t natively have.\n&nbsp\;Attempts have been made to solve this issue at an OS-level (Meta’s TPP)\, or even a compiler/runtime level (OBASE) but they approach the problem transparently by design. And thus…blind by design. You can improve tiered object locality with clever placement within pages\, but all these methods are structurally incapable of predicting intent. What if the power was in the developer’s hands?\n&nbsp\;With reflection (P2996) and annotations (P3394)\, C++26 finally lets us extend the vocabulary ourselves. Game developers have deeply understood smart data grouping for decades\, but much of the work is locked behind game engines\; not suitable for general application development. [[likely]] and [[unlikely]] hint hot and cold paths\, but the future of high-performance development hints at general purpose object residency to tier-aware allocators.\n&nbsp\;This talk introduces an open-source C++26 residency library\, demonstrating capabilities against current\, and even (simulated) future hardware. The pieces are in place for C++ to create durable abstractions for object residency\; with the flexibility to accommodate memory tiers that have not been invented yet!\n
CATEGORIES:PLENARY
LOCATION:Colorado A\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:60f994d52740340b1a8d62ca347ce6ca
URL:http://cppcon2026.sched.com/event/60f994d52740340b1a8d62ca347ce6ca
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T200000Z
DTEND:20260917T210000Z
SUMMARY:Back to Basics: Containers 1/2
DESCRIPTION:How to Choose and Use the Right Container in Modern C++: Part 1\, Classic Containers \n \n Choosing the right container and using it correctly can have a profound impact on the performance of a program\, but doing so is harder than you might think. In Part 1 we will survey the containers and adaptors in the C++17 Standard Library\, and discuss how to choose the best tool for the job and extract the best performance from it. We will consider the abstractions they model and the practical limitations they impose\, and find that choosing between them requires an understanding not only of the speed and size tradeoffs of each container\, but also of the difference between algorithmic complexity and actual behavior. And we will flag aspects of the standard containers that\, without this understanding\, can lead you to the wrong choice. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:2b8aedefe525f812229cd3c875166381
URL:http://cppcon2026.sched.com/event/2b8aedefe525f812229cd3c875166381
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T200000Z
DTEND:20260917T210000Z
SUMMARY:Generating Reliable Reference Documentation for Modern C++ Using the Clang AST
DESCRIPTION:Teams writing modern C++ libraries with concepts\, niebloids\, deduction guides\, and SFINAE-driven overload sets either accept wrong reference documentation or maintain a Doxygen + XSLT + Sphinx pipeline of workarounds. A different approach is to read C++ from the Clang/LLVM AST\, separate corpus extraction from output templates\, and recognize common idioms as first-class. This allows the source to stay clean from workarounds. \n \n Doxygen-based pipelines all share these failures on modern C++. Constraint\, noexcept\, and explicit specifier expressions get truncated or dropped. Niebloids and function objects show as wrappers\, not callables. Overloads distinguished by SFINAE or concepts scatter across the output\, and CRTP base classes render with the wrong members. All of this disappears when the tool reads the compiler's AST and is able to instantiate specializations. \n \n The talk then covers the architecture of MrDocs\, an open-source documentation generator built on Clang/LLVM. Corpus extraction handles the redeclaration\, template instantiation\, and overload resolution problems that break naive AST traversal. Idiom recognition treats modern patterns as first-class metadata: niebloids\, overload sets\, concept constraints\, requires-clauses preserved verbatim\, function-object auto-detection\, SFINAE overload sets\, and deduction guides. It also captures the specifiers: explicit\, noexcept\, consteval\, storage class\, defaulted and deleted functions\, and attributes. The templating layer gives full control over the output (HTML\, AsciiDoc\, Markdown\, XML\, or custom formats) without forking the tool. \n \n The session is heavy on code from real C++ template libraries\, with examples drawn from fmt\, nlohmann/json\, mp-units\, and several Boost and Beman libraries. By the end\, you will know why partial AST tools break on modern C++\, what an alternative architecture looks like\, and which idioms it has to recognize. \n \n
CATEGORIES:GENERAL
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:29a79b4d46d65ff89c359380d3773c6d
URL:http://cppcon2026.sched.com/event/29a79b4d46d65ff89c359380d3773c6d
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T200000Z
DTEND:20260917T210000Z
SUMMARY:Type Punning: the joke is on you\, pun intended. Fixing UB of reinterpret_cast!
DESCRIPTION:Many codebases contain several spots of type punning\, and unfortunately a whole lot of those are incorrect and undefined behavior. While many current versions of compilers seem to do the correct thing\, they might no longer do that tomorrow. Safety considerations wants to reduce/eliminate UB. \n \n It might be worthwhile to inspect your reinterpret_cast constructs\, most probably they are wrong. In this talk we will inspect what is wrong about those\, we will learn about alignment\, strict aliasing\, object lifetime. 3 areas which might flag a red card on our type punning constructions. \n \n Luckily the language evolved and gave us more tools to do it correctly\, things like memcpy\, memmove\, bit cast\, start lifetime_as\, launder. It does however remain a dark corner and a dangerous territory to wander in. Because let's face it\, zero copy is something we love in C++\, and those bytes that came from the network\, really are an array of integers\, array of coordinates\, ... Compiler\, trust me\, I know what I am doing. Am I? \n \n
CATEGORIES:GENERAL
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:6763fbbd76156ff96d0ba8b88ccba136
URL:http://cppcon2026.sched.com/event/6763fbbd76156ff96d0ba8b88ccba136
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T200000Z
DTEND:20260917T210000Z
SUMMARY:What Is Your Algorithmic Core?
DESCRIPTION:Production C++ code often hides small but deeply complex algorithms inside layers of engineering: APIs\, lifetimes\, error handling\, integration\, logging\, and glue code. We test classes and systems\, but rarely the algorithm itself in isolation. \n \n Off-by-one errors and broken or missing invariants can survive extensive pre-production testing. Line coverage does not imply branch coverage. Branch coverage does not imply coverage of algorithmic corner cases. Testing through a wide public API often obscures the mathematical structure of the problem\, making subtle bugs difficult to discover through multiple layers of abstraction. \n \n This talk explores how to extract an "algorithmic core" from a larger component. Its correctness is fundamentally mathematical and largely language-agnostic rather than C++-specific. \n \n Using examples such as substring matching\, topological sorting variations\, and lazy evaluation on trees\, we will examine how problem corner cases differ from implementation corner cases\, and how easily some of them are skipped. \n \n We will discuss: \n \n Recognizing when an algorithm is entangled with boilerplate Extracting core logic without introducing accidental complexity What it takes to test algorithmic code in isolation Raising the level of abstraction to make reasoning easier without merely relocating complexity Using LLMs to assist in exploring and validating implementations Gradual rollout and comparison of competing implementations
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:3dc1e54e39197a1a24953deedaea494b
URL:http://cppcon2026.sched.com/event/3dc1e54e39197a1a24953deedaea494b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T200000Z
DTEND:20260917T210000Z
SUMMARY:When Zero-Cost Abstractions Aren’t Zero-Cost
DESCRIPTION:Zero-cost abstractions are a foundational idea in C++\, promising expressive\, high-level code without sacrificing performance. However\, developers often encounter unexpected costs when using modern abstractions in practice\, even when the code appears idiomatic and well-designed. \n \n This talk explores the assumptions behind zero-cost abstractions and examines what happens when those assumptions no longer hold. Through concrete examples drawn from modern C++ — including ranges and views\, type erasure\, allocators\, and other common abstractions — we will examine how factors such as optimizer visibility\, inlining boundaries\, allocation behavior\, and runtime flexibility influence performance. \n \n This talk treats abstraction as a powerful engineering tool\, examining the limits of its zero-cost guarantees in real-world systems. We will look at how seemingly small design choices can introduce hidden costs\, why those costs are often difficult to spot through inspection alone\, and how to recover performance without abandoning good design or readability. \n \n Attendees will leave with a clearer understanding of when abstractions are truly zero-cost\, how to recognize situations where they are not\, and how to make informed tradeoffs between expressiveness\, flexibility\, and performance in modern C++. \n \n
CATEGORIES:GENERAL
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:e9722867ea23895ce08f8873ed62ee9c
URL:http://cppcon2026.sched.com/event/e9722867ea23895ce08f8873ed62ee9c
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T200000Z
DTEND:20260917T210000Z
SUMMARY:Generating Language Bindings using C++ Reflection
DESCRIPTION:Language bindings for C++ can be valuable tools for developers who wish to make C++ libraries available for use in other programming languages\, like Python. There are many reasons developers may wish to do this\, including testing\, prototyping\, or performance. \n \n One of the issues often faced when writing bindings for C++ is the need to write excessive amounts of boilerplate code to bridge the gap between the C++ types and interfaces and their equivalents in other languages. \n \n Building on previous presentations\, this talk will not just explore how you can use Reflection in C++26 to generate the necessary binding code\, but also how you can integrate this into a CMake-based build system to enable the automatic generation of bindings for existing classes or libraries with minimal additions. We will present real-world examples\, primarily using Python\, to show how language bindings can be automatically generated\, but we also show how this can be extended to other languages. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:a7819ff7960d841960f429187aee96ff
URL:http://cppcon2026.sched.com/event/a7819ff7960d841960f429187aee96ff
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T211500Z
DTEND:20260917T221500Z
SUMMARY:Back to Basics: Containers 2/2
DESCRIPTION:How to Choose and Use the Right Container in Modern C++: Part 2\, New and Future Containers \n \n Choosing the right container and using it correctly can have a profound impact on the performance of a program\, but doing so is harder than you might think. In Part 2 we will survey the new containers and adaptors introduced to the Standard Library in C++23/26\, and discuss how to choose the best tool for the job and extract the best performance from it. We will consider the abstractions they model and the practical limitations they impose\, and find that choosing between them requires an understanding not only of the speed and size tradeoffs of each container\, but also of the difference between algorithmic complexity and actual behavior. And we will examine a proposal for a future container that diverges from the historical STL design principles and ask: what makes for a good container design? \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:f92db0a98d32953328177295dbcdc153
URL:http://cppcon2026.sched.com/event/f92db0a98d32953328177295dbcdc153
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T211500Z
DTEND:20260917T221500Z
SUMMARY:Coroutines for Dummies
DESCRIPTION:C++20 coroutines are a game-changer for writing asynchronous code and generators\, but they come with a steep learning curve. This talk is designed to simplify the concept and make coroutines more approachable. \n \n We’ll focus on co_await — how it works\, what it does under the hood\, and why it's useful. If you’ve been curious about coroutines but found the resources confusing\, this talk is for you. \n \n
CATEGORIES:GENERAL
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:6da2e815aa350ac0236b321f2d5d9bfe
URL:http://cppcon2026.sched.com/event/6da2e815aa350ac0236b321f2d5d9bfe
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T211500Z
DTEND:20260917T221500Z
SUMMARY:Leveraging LLM to Generate Unittests for Notifiers in Taskflow
DESCRIPTION:Notifiers are a critical synchronization primitive in task-parallel programming systems such as Intel TBB and Taskflow\, responsible for efficiently sleeping and waking worker threads as tasks become unavailable and available over and over again\, directly impacting scheduler throughput and latency. Correctness here is non-negotiable: a single missed wakeup can significantly hamper the performance of an entire program. Yet writing strong unit tests for notifiers is notoriously difficult\, because the bugs they target\, lost wakeups\, spurious wakes\, race conditions\, are timing-dependent\, non-deterministic\, and often only surface under specific thread interleavings that are hard to force reliably. \n \n The problem is compounded in practice. Notifier implementations evolve constantly: small algorithmic tweaks\, memory ordering changes\, and refactors across systems demand a fresh round of carefully constructed tests. This is tedious\, expertise-heavy work that takes a lot of time and engineering effort. In this talk\, we explore using Large Language Models (LLMs) to automate the generation of the unit tests for notifiers. Specifically\, we will demonstrate how LLM-generated tests\, guided by proper prompts can systematically stress the two-phase wait protocol across Notifiers in Taskflow. We will show this in a widely used Notifier implemented in Taskflow. We are able to find an undiscovered bug that has been existing in the project. \n \n
CATEGORIES:GENERAL
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:e9d7a049aa00313458bb1f1e7b0f25f3
URL:http://cppcon2026.sched.com/event/e9d7a049aa00313458bb1f1e7b0f25f3
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T211500Z
DTEND:20260917T221500Z
SUMMARY:The Biggest Misconception of Computer Science
DESCRIPTION:From our very first algorithms class\, we are taught a simple rule: a better Big-O complexity means a faster algorithm. We spend years mastering asymptotic analysis\, memorizing complexity tables\, and losing sleep over worst-case scenarios. Big-O becomes a mental shortcut for “good” and “bad” code. \n \n But the real world doesn’t run on whiteboards. \n \n Modern performance is shaped far more by hardware realities than by asymptotic notation alone. CPUs have deep cache hierarchies\, wide vector units\, speculative execution\, and memory systems that punish the “theoretically optimal” solution. GPUs thrive on massive parallelism where simple linear work can outperform asymptotically superior algorithms. Even on regular CPUs\, cache-friendly linear scans often beat clever sub-linear approaches that fight memory latency. \n \n In this talk\, we will challenge the traditional Big-O mindset. We’ll look at classic algorithms through a modern lens and explore how hardware-aware designs cache-efficient layouts\, SIMD/AVX vectorization\, and parallel execution models can outperform algorithms with “worse” theoretical complexity. You’ll see why a higher Big-O algorithm can be faster\, more scalable\, and more predictable in practice. \n \n The goal is not to dismiss Big-O\, but to put it back in its proper place: as a tool\, not a truth. By the end of this talk\, you’ll think differently about performance and start writing code that works with the hardware\, not against it. \n \n
CATEGORIES:GENERAL
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:230cef9aaf66b111add54bd0b42bdf16
URL:http://cppcon2026.sched.com/event/230cef9aaf66b111add54bd0b42bdf16
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T211500Z
DTEND:20260917T221500Z
SUMMARY:The C++ safety issues your tools can't see
DESCRIPTION:Much of the public criticism of C++ safety comes from vulnerabilities rooted in C patterns: raw pointer arithmetic\, unchecked buffer indices\, manual memory management. Modern C++ offers real answers to those problems through RAII\, smart pointers\, containers\, and type-safe abstractions. But C++ also has its own distinct safety issues that have nothing to do with its heritage. Temporary lifetime rules that silently create dangling references. Iterator invalidation semantics that differ across containers in ways even experienced developers get wrong. Smart pointer ownership pitfalls that RAII cannot prevent. Coroutine frames that outlive their captured locals. Implicit conversions that turn a safe string into a dangling view between one line and the next. These are purely C++ problems. They compile cleanly\, look correct in code review\, and ship to production. \n \n A survey of public CVE reports and security-fix commits across prominent open-source C++ projects shows the same patterns recurring again and again. This talk walks through those patterns\, in code that looks correct in review\, compiles cleanly\, and then breaks at runtime. The session is aimed at intermediate-to-experienced C++ developers who already know modern C++ but want a working catalog of the subtle patterns that ship past typical code review. \n \n Recognizing these patterns has long been the domain of library authors and security researchers. This talk distills a catalog from real-world fixes for everyone else: not a prescriptive standard like the Core Guidelines\, but a pattern-recognition toolkit any C++ developer can apply in their next code review. The session also makes the case for expanding the community-level safety conversation to give these C++-unique patterns the same attention as the C-heritage debates. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:d94251d4f8740df57d95e75a9f27f3a4
URL:http://cppcon2026.sched.com/event/d94251d4f8740df57d95e75a9f27f3a4
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T211500Z
DTEND:20260917T221500Z
SUMMARY:Modernizing Legacy Codebases without Stopping the World
DESCRIPTION:Every mature codebase carries history and technical debt. The challenge is modernizing without stopping the world or introducing big re-write failure risks. \n \n In this talk\, we’ll explore how to modernize legacy C++ codebases incrementally using a mix of deterministic code transformations and AI-assisted refactoring . \n \n After delving into some of the common problems with legacy modernization\, we'll start tackling the simple "boring" stuff that deliver huge leverage of changes via clang tooling . These represent repeatable\, deterministic reviewable upgrades that can be automated and applied at scale. \n \n Then we can look at more difficult transformations that can be AI assisted with more aggressive transformations including API improvements and how to prevent it going off the rails. This will be backed by Compiler diagnostics\, static analysis and testing to keep changes maintainable and correct . \n \n The goal is not to replace engineering judgment\, but to accelerate it: turning modernization into a continuous\, low-risk workflow instead of a disruptive project. \n \n Attendees will leave with a repeatable playbook for modernizing legacy codebases incrementally\, safely\, and at scale—using the right tool for each class of change \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:4fdcfea746bb491f389257d0ab83f017
URL:http://cppcon2026.sched.com/event/4fdcfea746bb491f389257d0ab83f017
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T224500Z
DTEND:20260917T234500Z
SUMMARY:Back to Basics: Computer Systems
DESCRIPTION:Every software engineer needs to understand the fundamentals of how your computer works. My mantra for teaching computer systems is 'no more magic'\, and in this talk I'll do my best to dispel what feels like 'magic' in our hardware in a single hour. In this talk\, we will investigate '3' pictures of the 'the compilation process'\, 'program stack'\, and a 'cpu' to understand how these components work together to ultimately compile and execute code. An emphasis during this talk will focus on the 'CPU' and the hardware components (e.g. registers\, cache memory\, main memory\, page table) interact with the operating system to efficiently execute a program. Hardware will be presented side-by-side with code so we can understand what happens in the hardware as software executes. Attendees will leave this talk with a better mental model of how their hardware works\, and the implications their software design choices have on performance. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:55439ce65fa46592630fb6c05acaf3af
URL:http://cppcon2026.sched.com/event/55439ce65fa46592630fb6c05acaf3af
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T224500Z
DTEND:20260917T234500Z
SUMMARY:A Duck Does More Than Quack: Synthesizing VTables with C++26 Reflection
DESCRIPTION:Non-intrusive runtime dispatch in C++ has never had a clean answer. Virtual functions couple your interface tightly to its implementation\, type erasure libraries tend to rely on macros or templating magic\, and manual vtables are boilerplate-heavy and easy to get wrong. C++26 reflection changes that: you can now tell the compiler to synthesize a vtable for you at compile time from a simple interface declaration\, with zero overhead compared to hand-written virtual dispatch. The duck library is built on exactly that idea. This talk explains how duck works through the story of how it came to exist. A required data structures college course stuck firmly in C++11 sparked the speaker's curiosity in modern C++\, leading him to view conference talks and proposals on C++26 reflection. Experimentation with Compiler Explorer turned into the discovery that reflection can be used to generate vtables\, simulate overload sets\, reduce dispatch overhead\, and more. Viewers will be introduced to C++26 reflection's core operations and code generation mechanisms\, grounded entirely in real use cases from duck's implementation. We'll look at how existing approaches struggle with generality\, and the central technique that lets duck overcome this: using define_aggregate both to synthesize a vtable struct from a reflected interface and to simulate member function call syntax directly on a duck. A blog post about the project led to an invitation to CppCon and an introduction to the authors of P4148 (protocol)\, an upcoming proposal aiming to get a library feature similar to duck into the C++29 standard. We'll close with a preview of P4148\, as well as a look at how more powerful generative programming like token injection (P3294) can improve the implementation of duck and fundamentally shape the future of metaprogramming in C++. \n \n
CATEGORIES:GENERAL
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:1586a49d4cb7de6dbd70762bb6dfdc22
URL:http://cppcon2026.sched.com/event/1586a49d4cb7de6dbd70762bb6dfdc22
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T224500Z
DTEND:20260917T231500Z
SUMMARY:Getting More Out of AI in C++: Custom Hooks\, Skills\, and MCP servers
DESCRIPTION:AI coding agents are transforming how we write C++ code and come with a growing extensibility stack. Between hooks\, skills\, and MCP servers it's not obvious when to reach for which in your day to day workflow. This talk demonstrates the differences through demos in a real C++ codebase. We'll build a hook that runs the project's linter and lets the agent fix any issues it finds\, create a skill to flag C++ performance pitfalls\, and use an MCP server to verify portability across compilers\, with each technique solving a problem the others can't. Along the way\, you'll see how these mechanisms compose into a single workflow. Whether you're just getting started with AI tooling or already using it daily\, you'll leave knowing exactly which tool to reach for and how to get the most out of your AI coding agent for C++ development. \n \n
CATEGORIES:GENERAL
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:70ad0992237a8286133f561844c2ea82
URL:http://cppcon2026.sched.com/event/70ad0992237a8286133f561844c2ea82
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T224500Z
DTEND:20260917T234500Z
SUMMARY:Prioritizing Pretty-printers
DESCRIPTION: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. \n \n 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. \n \n 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! \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:b4bf7f061264636f6598ea1f4d6e9337
URL:http://cppcon2026.sched.com/event/b4bf7f061264636f6598ea1f4d6e9337
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T224500Z
DTEND:20260917T234500Z
SUMMARY:Queue Discipline: A Deep Dive into Lock-Free SPSC\, MPSC\, SPMC\, and MPMC Queues in Modern C++
DESCRIPTION: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. \n \n
CATEGORIES:SOFTWARE DESIGN
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:a291571d6dee30df815b6436e0116900
URL:http://cppcon2026.sched.com/event/a291571d6dee30df815b6436e0116900
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T224500Z
DTEND:20260917T231500Z
SUMMARY:Extending Google Test for Statistical Benchmarking\, CUDA Profiling\, and CI Performance Regression
DESCRIPTION:Benchmarks shouldn't live in a different world from tests. Most C++ projects already use Google Test\, but the moment performance enters the picture\, developers reach for separate tools\, separate workflows\, and ad-hoc timing loops that don't survive contact with CI. This talk argues for a different default: treat performance measurements as first-class tests. They are written in the same harness\, run in the same suite\, and fail the same builds. \n \n Using a real C++23 framework built on top of Google Test\, the session shows what that looks like in practice. Semantic macros distinguish throughput\, latency\, and contention tests\; built-in statistical analysis tracks medians\, percentiles\, and coefficient of variation. Adaptive thresholds scale with payload size\, so tiny operations and multi-megabyte workloads aren't held to the same stability expectations. \n \n Once benchmarking lives inside the test framework\, the rest of the performance toolchain follows. Five CPU profiler backends drop in behind a single --profile flag: perf\, gperftools\, bpftrace\, RAPL\, and callgrind. Attaching a memory profile to a test prints bandwidth\, efficiency\, and a CPU-bound or memory-bound classification with no extra code. The same harness extends to CUDA through a fluent kernel builder that captures launch configuration\, achieved occupancy\, transfer overhead\, multi-GPU scaling efficiency\, and thermal throttling. Nsight Compute drops in through the same --profile flag. \n \n The payoff is CI integration that's nearly automatic. A companion CLI tool compares baseline and candidate runs\, applies statistical thresholds\, posts markdown reports on pull requests\, and fails the build on regressions. The result is a single workflow for performance verification that scales from a developer's laptop to a CI runner to a Jetson on a workbench\, across hardware ranging from x86 to ARM to RISC-V. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:b5829e7355e8880c18fe7326f07f8df5
URL:http://cppcon2026.sched.com/event/b5829e7355e8880c18fe7326f07f8df5
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T232000Z
DTEND:20260917T235000Z
SUMMARY:API Design is Language Design: Lessons from Go's net/http library for C++
DESCRIPTION:Years ago while working on a service that would be deployed in Kubernetes\, we decided to use the simplest possible TCP based healthcheck. Not because TCP was the right choice\, but because implementing a simple HTTP endpoint was more code than it was worth. For our Go services the equivalent HTTP endpoint was only a couple of lines. In fact\, we eventually ended up replacing our TCP endpoint with a small Go wrapper around our C++ service. \n \n The Go standard library has done a great job at designing a very ergonomic HTTP library. C++ now has all the right building blocks to express the same design concepts: coroutines\, concepts\, std::expected\, std::jthread. The question is\, do these patterns transfer from Go to C++? How do we evaluate the effectiveness of the resulting design? \n \n In this talk I will present a small HTTP library inspired by Go's net/http\, built with the tools available in C++23. To evaluate the resulting design I will draw on ideas from Felienne Hermans' The Programmer's Brain and the principle\, from Structure and Interpretation of Computer Programs\, that API design is language design. \n \n Along the way we'll see which patterns transfer cleanly\, which need translation\, and why telling the difference is a skill worth developing even if you only work with C++. \n \n
CATEGORIES:GENERAL
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:98f8c6bdc5667df3834ca586d0725c5b
URL:http://cppcon2026.sched.com/event/98f8c6bdc5667df3834ca586d0725c5b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260917T232000Z
DTEND:20260917T235000Z
SUMMARY:Who Is #include-ing You? Measuring the Impact of C++ Libraries
DESCRIPTION:C++ library maintainers are often in the dark as to everyone who actually depends on their code. Without that knowledge\, deprecation decisions are guesses\, the downstream impact of any API change is hard to predict\, and the case for funding or continued investment is difficult to make rigorously. This talk demonstrates how mapping your downstream ecosystem changes the way you maintain and evolve a library\, using dependent-audit\, an open-source tool that discovers real-world dependents by searching public source code for #include directives and CMake integration files\, and cross-referencing published academic citations. We'll show concrete examples of what this data reveals: where your true API surface lies\, which users are candidates for upstream contribution\, and how to make the case for your project's real-world significance. Attendees will leave with a lens for library stewardship built on data and ecosystem analysis \n \n
CATEGORIES:GENERAL
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:202bc85478237389823859cff76e5938
URL:http://cppcon2026.sched.com/event/202bc85478237389823859cff76e5938
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T003000Z
DTEND:20260918T023000Z
SUMMARY:Meet the Presenters Banquet (Susquehanna)
DESCRIPTION:The Meet the Presenters Banquet is presented in partnership with Susquehanna and is open to all attendees. Ticket required. Invitation is included with "Regular" and "Full" conference registration and is also available as a separate\, stand-alone registration.\n\n This is your opportunity to meet and discuss with the presenters (main program\, poster\, instructors) in a relaxed\, informal environment.
CATEGORIES:SOCIAL
LOCATION:Colorado C/D\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:86ee6f8ac36ac9089af10b95a20b9e60
URL:http://cppcon2026.sched.com/event/86ee6f8ac36ac9089af10b95a20b9e60
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T023000Z
DTEND:20260918T040000Z
SUMMARY:Lightning Talks
DESCRIPTION: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. \n\n Submit your talk here
CATEGORIES:OPEN CONTENT
LOCATION:Colorado B\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:f5ccdfd927d35935ec845786ff11c175
URL:http://cppcon2026.sched.com/event/f5ccdfd927d35935ec845786ff11c175
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T150000Z
DTEND:20260918T160000Z
SUMMARY:Back to Basics: std::unordered_map
DESCRIPTION:In modern C++\, std::unordered_map is the de facto #2 container. Its dominance signifies a fundamental shift in application design: the performance-critical need for O(1) average-case key-value lookups. \n \n Join as we move beyond "just use a hash map" and explore the critical\, real-world implications of this choice. We'll start by benchmarking the classic std::map (red-black tree) against std::unordered_map (hash table) to understand exactly what you gain-and what you might lose. \n \n However this power comes with risks. An average-case O(1) can quickly degrade to a catastrophic O(n) without warning. We will profile and dissect the actual costs of using a hash map: \n \n The Hash: What makes a good hash function? We'll go beyond std::hash and see how to write effective\, fast hashers. The Collision: How do different collision-handling strategies impact performance and memory? The Re-hash: What is "load factor\," and when does the hidden cost of a full table re-hash destroy your performance gains? We'll conclude with a practical decision-making framework for when to choose std::unordered_map \, when to fall back on the ordered std::map \, and how std::string -the container we often forget is a container-fits into this modern landscape. \n \n You will leave this session knowing precisely which data structure to deploy for maximum performance. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:cddf487a8a82fe36b6d66b7e2f37927f
URL:http://cppcon2026.sched.com/event/cddf487a8a82fe36b6d66b7e2f37927f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T150000Z
DTEND:20260918T160000Z
SUMMARY:The Next 20 Weeks of Systems Engineering
DESCRIPTION:For a long time\, programming was constrained by our ability to produce code. That constraint is eroding rapidly. AI systems can now generate substantial amounts of code with little effort\, while inspection\, validation\, and integration remain difficult. \n \n This transition alters the economics of software engineering. Code is becoming easier to generate than to reason about\, and sound judgment grows scarcer relative to specialized intelligence. The emphasis shifts from authoring programs to understanding systems: their structure\, invariants\, interactions\, and long-term evolution. \n \n The talk examines this transition through the lenses of history\, language design\, and recent developments in AI and metaprogramming. It argues that the central challenges ahead concern not code generation\, but the management of complexity at scale. \n \n Topics include: - historical parallels and failed predictions in computing - AI-assisted software development - language design and metaprogramming - C++ reflection and compile-time programming - abstraction as context compression - complexity management in large systems \n \n AI will undoubtedly transform how we build software. As before\, the decisive factor will be our capacity to adapt. \n \n
CATEGORIES:BUSINESS & CAREER
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:def6f7b222a03f54a2b5dd64cbaca747
URL:http://cppcon2026.sched.com/event/def6f7b222a03f54a2b5dd64cbaca747
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T150000Z
DTEND:20260918T160000Z
SUMMARY:“If You Can’t Measure It\, You Can’t Improve It”: From Profiling to Automatic Benchmarking
DESCRIPTION:Modern hardware is increasingly complex and difficult to reason about\; effective C++ performance work therefore demands a disciplined loop - profile\, benchmark\, analyze. Yet profiling alone is tricky\, doesn’t answer “what if” questions\, and manual benchmarking is dominated by hidden biases. \n \n This talk presents a novel automatic benchmarking approach that focuses on eliminating measurement biases. We combine symbolic execution of identified hot regions with microarchitectural state randomization to systematically explore latency and throughput behavior under diverse - cache\, branch\, data layout - conditions. The technique is integrated with Linux perf\, so the entire process - region isolation\, state variation\, measurement\, analysis - is fully automatic. \n \n The talk first grounds attendees in profiling with hardware performance counters\, Top‑down Microarchitecture Analysis (TMA)\, and processor tracing. We then demonstrate how to automatically stress specific microarchitectural features to produce statistically reliable\, "bias‑free" benchmarks. Finally\, we close the loop with machine‑code analysis\, showing how the measured numbers connect directly to instruction‑level behavior and ultimately to C++ code. \n \n Attendees will leave with a concrete framework they can apply immediately to better understand and improve C++ performance. \n \n
CATEGORIES:GENERAL
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:8b7c2f0b4b76af418029874f8e576c57
URL:http://cppcon2026.sched.com/event/8b7c2f0b4b76af418029874f8e576c57
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T150000Z
DTEND:20260918T160000Z
SUMMARY:CMake: Making Hard Things Easy
DESCRIPTION:Modern C++ development involves much more than compiling source files. Cross-platform builds\, dependency management\, C++ modules\, package metadata\, SBOM generation\, CI infrastructure\, and distributed builds have all increased the complexity of software engineering over the last two decades. \n \n CMake has evolved alongside those challenges. \n \n This talk explores how modern CMake helps make difficult software-engineering problems more manageable through targets\, dependency modeling\, metadata generation\, debugging tools\, and scalable build orchestration. \n \n We will examine how CMake supports C++20 modules\, including dynamic dependency scanning\, build graph updates\, and import std. \n \n We will also look at CPS and SBOM generation together: CPS provides machine-readable package metadata\, while SBOM support helps CMake expose software supply-chain information from the dependency graph. \n \n Next\, we will discuss debugging CMake itself using the CMake debugger protocol\, and debugging builds using the CMake Instrumentation API to understand where time is spent during configuration and build execution. \n \n Finally\, we will examine distributed execution and build acceleration\, exploring options available to CMake users in both open-source and commercial environments. \n \n Along the way\, we will discuss the real-world challenges\, trade-offs\, and lessons learned from evolving a long-lived build system to meet the demands of modern C++ development. \n \n This is not your mother’s CMake. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:fb3494fe48fad4084d2c32e5f3f3af77
URL:http://cppcon2026.sched.com/event/fb3494fe48fad4084d2c32e5f3f3af77
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T150000Z
DTEND:20260918T160000Z
SUMMARY:Safety in Numbers
DESCRIPTION:The C++ standard is moving more and more in the direction of safety. In the process\, the committee is providing us with tools to help make our own code safer. \n \n Many of these tools are specifically around numerics and none of them are enabled by default! To make matters worse\, most C++ programmers don't even know these library features exist! Even if they did know\, they wouldn't use them\, because they are far too wordy. \n \n We're going to do a survey of the relatively recently added new numeric safety related language features and see how they might come together in a real-ish project. \n \n
CATEGORIES:SCIENTIFIC COMPUTING
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:3182eb3646855bdf889ec0289b1f72be
URL:http://cppcon2026.sched.com/event/3182eb3646855bdf889ec0289b1f72be
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T150000Z
DTEND:20260918T160000Z
SUMMARY:Code Like a Library Author: How to Write Better C++ Application Code
DESCRIPTION:To write the best C++ application code\, you must think like a library author. This talk reframes application development as a form of library design\, where every component is a potential asset for future maintenance and extension. \n \n We'll survey the C++ language features that empower library authors to create powerful\, flexible\, and safe abstractions. From there\, we'll distill the 'library author mindset.’ You will leave with concrete principles and techniques to make your application code more modular\, maintainable\, composable\, reusable\, testable\, and ultimately\, more valuable. \n \n
CATEGORIES:SOFTWARE DESIGN
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:5b785a9f2b0090ef43cb42a682896444
URL:http://cppcon2026.sched.com/event/5b785a9f2b0090ef43cb42a682896444
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T163000Z
DTEND:20260918T173000Z
SUMMARY:Memory Safety on a Microcontroller: What Embedded C++ Teams Can Actually Do Today
DESCRIPTION:The White House says stop using C++. CISA wants a memory safety roadmap. The internet says rewrite everything in Rust. Meanwhile\, embedded teams are shipping firmware on Cortex-M microcontrollers with limited flash\, no MMU\, no virtual memory\, and a codebase that cannot be rewritten overnight. So what do you actually do? \n \n This talk is a practical\, tool-by-tool walkthrough of every memory safety technique available to embedded C++ developers right now — and what is coming in C++26. It starts with what you can turn on today without changing a single line of code: compiler warnings that most projects still ignore\, AddressSanitizer and UndefinedBehaviorSanitizer running on host-compiled firmware\, and stack protection options that cost single-digit bytes of overhead. It then moves to code-level improvements that modern C++ makes possible: replacing raw pointer arithmetic with std::span\, using std::expected instead of error codes that nobody checks\, applying constexpr to move validation to compile time\, and adopting strongly typed wrappers to eliminate unit-of-measure bugs. Finally\, it covers what C++26 brings to the table — hardened standard library containers with bounds checking at 0.3% overhead\, safety profiles for type and bounds and lifetime checking\, contracts for defensive preconditions\, and the elimination of uninitialized-variable undefined behavior — and evaluates which of these features are realistic for embedded targets today. \n \n Every technique is evaluated on three axes: how much code do you have to change\, what does it cost in code size and runtime on a real microcontroller\, and what class of bugs does it actually prevent. Attendees will leave with a prioritized adoption checklist they can bring back to their team on Monday. \n \n
CATEGORIES:EMBEDDED
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:a8e6416fe28cfc765f389fddb0a294c8
URL:http://cppcon2026.sched.com/event/a8e6416fe28cfc765f389fddb0a294c8
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T163000Z
DTEND:20260918T173000Z
SUMMARY:What can C++26 reflection do for you?: A practical experiment in using reflection with an emphasis on binary protocol support
DESCRIPTION:How far can C++26 reflection take us? What are some techniques\, gotchas\, limitations and workarounds? How would reflection help write code that interacts with bespoke binary data formats? Come along as we explore a practical example together. \n \n This talk will review advice gleaned from applying C++26 reflection to binary (structs on a wire) protocol handling. This type of protocol exists all around the world from financial market data formats to custom hardware interaction. Is the proposed reflection support enough to take a protocol definition written in the native terms of C++ and create flexible components to interact with that protocol? \n \n
CATEGORIES:GENERAL
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:a36b90408b047277c4dd659e44e589d6
URL:http://cppcon2026.sched.com/event/a36b90408b047277c4dd659e44e589d6
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T163000Z
DTEND:20260918T173000Z
SUMMARY:Senders\, Receivers\, and Robots: Structured Concurrency for Autonomous Navigation
DESCRIPTION:To navigate safely\, a robot must simultaneously ingest high-frequency sensor data\, compute complex spatial algorithms\, and publish control commands. Historically\, frameworks like ROS 2 have handled this via asynchronous callbacks. However\, as autonomous stacks scale\, relying heavily on unstructured callbacks can obscure control flow\, making state synchronization difficult and robust task cancellation notoriously complex. \n \n This talk explores how to transform unstructured\, callback-based architectures in a robotics navigation stack into declarative pipelines using structured concurrency (specifically\, C++ Senders and Receivers via stdexec). Attendees will dive into two real-world architectural examples: a collision monitor and a waypoint follower\, showcasing readable logic pipelines\, thread-hopping between an event loop and a static thread pool\, and clean task cancellation. \n \n
CATEGORIES:ROBOTICS & AI
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:5cc1c37d75481c37391feaa184ec54c1
URL:http://cppcon2026.sched.com/event/5cc1c37d75481c37391feaa184ec54c1
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T163000Z
DTEND:20260918T173000Z
SUMMARY:IEEE 754 Decimals for C++: The Boost.Decimal Library
DESCRIPTION:Why does 0.1 + 0.2 not equal 0.3? Because binary floating-point cannot exactly represent most decimal fractions\, the value 0.1 simply does not exist in IEEE 754 binary. For applications where rounding errors are unacceptable\, finance\, billing\, regulatory reporting\, scientific data interchange\, this is a structural problem\, not a precision setting that can be tuned away. IEEE 754-2008 introduced a decimal floating-point alternative that stores the significand in base 10\, and ISO/IEC TR 24733 sketched a C++ binding for it. Compiler support\, however\, has remained uneven across vendors and architectures. \n \n Boost.Decimal is a header-only\, dependency-free\, C++14 implementation of IEEE 754-2008 and TR 24733 decimal floating-point. It provides three IEEE-conformant types\, decimal32 t\, decimal64 t\, and decimal128 t\, and three companion decimal fast* t types that trade strict bit-layout conformance for speed where you don't need on-the-wire interoperability. All six types behave like built-in floating-point: they're constexpr-friendly throughout\, support mixed arithmetic and promotion\, and ship with their own implementations of \, \, \, \, \, hashing\, \, and Boost.Math integration. The library is tested natively on x86 64\, ARM64\, and s390x\, and under emulation on PPC64LE and ARM Cortex-M. \n \n This talk is the introduction to decimal floating-point that most C++ programmers never got. We'll cover what decimal floating-point actually is at the bit level (BID vs. DPD encodings\, the cohort concept that has no analogue in binary)\, why the standard library's defaults are what they are (e.g. Rounding)\, and how Boost.Decimal's API maps onto familiar and patterns. We'll work through worked examples\, parsing a price feed\, computing financial summary statistics through Boost.Math\, round-tripping values through while preserving cohort information\, and walk through the library's deliberate deviations from both IEEE 754 and the C++ standard\, including why floating-point exception flags were sacrificed to keep constexpr and how from_chars was extended to distinguish overflow from underflow as well as preserve cohorts. We'll close with reviews of the benchmarks versus binary floating point\, as well as other existing libraries. \n \n By the end\, attendees will know when reaching for decimal is the right call\, which of the six types fits their workload\, and what trade-offs the library made on their behalf. \n \n
CATEGORIES:SCIENTIFIC COMPUTING
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:b186ee7aa5687836f769f6a787a14835
URL:http://cppcon2026.sched.com/event/b186ee7aa5687836f769f6a787a14835
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T163000Z
DTEND:20260918T173000Z
SUMMARY:Incremental Modernization: Refactoring Legacy OOP Application Code using Type Erasure and Functional C++
DESCRIPTION:As legacy C++ codebases evolve to meet new requirements\, fix architectural issues\, and address performance bottlenecks\, refactoring becomes inevitable — but full rewrites are risky\, costly\, and rarely practical. This talk explores how modern C++ features — especially functional programming techniques and type erasure — can be used to refactor and extend legacy systems. We will present a concrete\, low-risk\, and measurable four-step technical framework for incremental modernization\, by leveraging pure functions\, discriminated union types\, and type-erased callables to achieve safer\, more flexible code with compile-time guarantees\, even in traditionally object-oriented codebases. \n \n The core of the talk will walk through the entire process on a concrete code example\, illustrating (1) how to isolate existing logic\, (2) define safer data models using immutable types\, (3) deploy type erasure to create a robust\, non-disruptive adapter boundary between old and new code\, and (4) measurably execute the migration with safe testing practices. We will also share lessons learned from real-world experience and conclude by showing how these foundational patterns can be extended into future-thinking designs\, leveraging examples with accepted C++26 features. Every step is grounded in real production constraints and trade-offs\, and the techniques transfer directly to any domain where full rewrites are not an option. Attendees will walk away equipped with practical strategies to incrementally refactor your legacy systems without sacrificing stability or velocity. \n \n
CATEGORIES:SOFTWARE DESIGN
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:88eabd805594fd263d239e2a12811523
URL:http://cppcon2026.sched.com/event/88eabd805594fd263d239e2a12811523
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T163000Z
DTEND:20260918T173000Z
SUMMARY:Works on My Machine\, Works in CI: Treating Your Build Toolchain as a Dependency
DESCRIPTION:Modern C++ development has embraced package managers like Conan and vcpkg for dependency management\, gaining reproducibility and productivity. However\, a significant weak point remains: the build toolchain. Unlike standard dependencies\, the disparate set of tools comprising the compiler\, linker\, standard libraries\, and OS-specific headers often remains outside this managed ecosystem. This gap leads to frequent complications\, where misaligned versions between local environments and CI cause build errors and subtle ABI incompatibilities. \n \n The operational cost of maintaining these toolchains is high. Updating a compiler version often necessitates the creation and deployment of new VM images or manual infrastructure updates\, a process that can be even more complex if specialized environments like CUDA are involved. These hurdles directly impact engineering productivity and organizational alignment. Docker is a popular solution to isolate toolchains\, but it does not support all the mainstream platforms. \n \n This talk proposes a shift in perspective: treating the build toolchain as just another dependency. We will explore how leveraging toolchain isolation allows developers to express specific toolchain versions within their project manifests—using cross-platform tools like Conan and vcpkg to ensure strict repeatability across local developer environments and CI machines.By automating the fetching and configuration of the entire compiler suite\, teams can ensure perfect alignment across all environments\, simplify the upgrade path\, and ultimately boost engineering velocity. \n \n
CATEGORIES:TOOLING & ECOSYSTEM
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:b23fac39d130d5a884fdb1b06df70905
URL:http://cppcon2026.sched.com/event/b23fac39d130d5a884fdb1b06df70905
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T193000Z
DTEND:20260918T203000Z
SUMMARY:Back to Basics: Text Formatting
DESCRIPTION:Most C++ programmers are familiar with the traditional C++ facilities for text processing found in the iostream and string libraries. However\, std::format (C++20) and std::print (C++23) provide new text formatting tools that are unfamiliar to many C++ programmers. While these new facilities can be very helpful\, they can also produce some very intimidating error messages when misused. Moreover\, the process for writing your own user-defined types that you can format with std::format and std::print is not very straightforward. \n \n This session starts with an overview of the traditional C and C++ text processing libraries. It then shows how std::format and std::print neatly combine benefits from both the C and C++ libraries to create a safer\, more convenient interface. After that\, this session explains the steps you must take to write user-defined types that work cleanly with std::format and std::print. You’ll leave this session with a clearer understanding of the benefits of using these new text formatting facilities and how to integrate them into your existing code base. \n \n
CATEGORIES:BACK TO BASICS
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:0e7e81235f79616bf1506cdc9dd45c15
URL:http://cppcon2026.sched.com/event/0e7e81235f79616bf1506cdc9dd45c15
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T193000Z
DTEND:20260918T203000Z
SUMMARY:Code You Didn't Write: Understanding Large and Unfamiliar Codebases
DESCRIPTION:First day on a new project. You set up your workstation and then download a repository of over 1\,000\,000 lines of code. Even more intimidating\, the code has been around for 20 years. Parts are in legacy C++\, parts use the latest C++26 features\, and increasingly\, AI coding assistants are weaving new code through all of it\, meaning some parts of the codebase may have never been fully understood by a developer. You feel overwhelmed. Don't Panic! In this talk\, we share techniques and tools that real engineers use to find their bearings in code they didn't write\, from the humble grep through debuggers and profilers to time-travel debugging and AI-assisted exploration. The audience will leave this talk with a mix of simple and advanced tricks for navigating large and complicated codebases. \n \n
CATEGORIES:BUSINESS & CAREER
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:6c5671e9d22164981b2f34db696260b5
URL:http://cppcon2026.sched.com/event/6c5671e9d22164981b2f34db696260b5
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T193000Z
DTEND:20260918T203000Z
SUMMARY:Escaping the AST: A Data-Oriented\, Lock-Free Parallel Compiler Architecture
DESCRIPTION: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? \n \n 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). \n \n By stepping away from traditional recursive tree-walking and object-oriented compiler design\, attendees will learn how to implement high-throughput parallel pipelines. \n \n 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. \n \n
CATEGORIES:EMBEDDED
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:2009fddbfe1d197f75d9652dec3ea1ca
URL:http://cppcon2026.sched.com/event/2009fddbfe1d197f75d9652dec3ea1ca
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T193000Z
DTEND:20260918T203000Z
SUMMARY:The Real Story of C++26: Beyond the Headline Features
DESCRIPTION:C++26 is often defined by its headline features — reflection\, contracts\, and senders/receivers. But those don’t tell the whole story. \n \n In this talk\, we’ll look beyond the headlines to explore the changes that more accurately reflect where C++ is heading. While less visible\, these features address long-standing pain points\, improve consistency\, and quietly reshape everyday programming in C++. \n \n We'll examine the continued expansion of constexpr\, including the ability to throw exceptions at compile time\, and what it means for the boundary between compile-time and runtime. We'll also discuss the evolving model of erroneous behavior and indeterminate values\, making it more explicit what constitutes incorrect code — and how implementations can reason about it. \n \n Safety is also becoming a stronger focus in the standard library. With the introduction of library hardening\, C++26 takes steps toward making incorrect usage easier to detect and harder to ignore\, without sacrificing performance. \n \n Along the way\, we'll look at improvements to function wrappers with std::function_ref and std::copyable_function \, enhancements to structured bindings\, and the growing capabilities of std::format . We'll also cover pack indexing and its impact on template expressiveness\, as well as the ongoing expansion of the freestanding library. \n \n Rather than focusing on individual features in isolation\, this talk connects them into a broader narrative: the real direction of C++26 — toward greater clarity\, expressiveness\, and safety in everyday code. \n \n
CATEGORIES:GENERAL
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:8d236fd97e9cb5204edfa4e0d052e6d7
URL:http://cppcon2026.sched.com/event/8d236fd97e9cb5204edfa4e0d052e6d7
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T193000Z
DTEND:20260918T203000Z
SUMMARY:When Air Gaps Learn: AI\, Data\, and the New C++ Attack Surface
DESCRIPTION:Air-gapped systems used to be protected by what they could not reach. That assumption breaks when telemetry\, sensor data\, and diagnostic output leave the system and AI model-influenced behavior comes back in\, even without a network connection. \n \n This talk examines the C++ engineering decisions that determine whether that data exchange is safe or silently dangerous. The problems are C++-specific and subtle: struct layout and padding that corrupt data silently across serialization boundaries\; undefined behavior in type-punned casts that passes tests but breaks under a different compiler or optimization level\; ownership and lifetime assumptions that hold inside the system but become dangling references once data crosses a trust boundary\; allocator and exception constraints in no-exception embedded environments that make standard validation patterns unavailable. \n \n We will look at how C++ systems in industrial\, embedded\, and safety-critical environments can export logs\, telemetry\, and traces into AI pipelines without creating feedback loops that affect production behavior in unverified ways. The engineering controls are concrete: typed serialization boundaries that make layout assumptions explicit\, schema validation that survives ABI differences between host and edge\, provenance tracking built into ownership types\, deterministic guardrails around probabilistic inference outputs\, and fail-safe fallbacks that don't rely on the model being correct. \n \n Attendees will leave with a design approach for integrating AI-adjacent workflows into high-integrity C++ systems. One that treats the data boundary as a first-class security surface\, not an afterthought. \n \n
CATEGORIES:ROBOTICS & AI
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:d394c960ce0cfed3ec6d603d8b180c27
URL:http://cppcon2026.sched.com/event/d394c960ce0cfed3ec6d603d8b180c27
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T193000Z
DTEND:20260918T203000Z
SUMMARY:Implementing Async RAII
DESCRIPTION:C++ lifetime management is fundamentally built around synchronous scope exit. Constructors establish invariants\, destructors release resources\, and RAII permits ownership and cleanup to compose naturally with ordinary control flow. Asynchronous systems disrupt this model. Destruction may itself require asynchronous work\, and “just launch another task in the destructor” quickly turns deterministic lifetime management into unstructured background activity. \n \n This talk explores the implementation of async lifetime management in std::execution\, based on the enter/exit scope sender framework proposed in P3955. Rather than treating async construction and destruction as special cases\, the model reframes them as composable asynchronous protocols built around explicit async scope entry and exit operations. The talk follows the process of turning these ideas into working code\, beginning from the low-level enter/exit sender abstractions and progressively assembling higher-level lifetime facilities on top. Along the way\, the implementation uncovers an important self-similarity in the problem domain: Higher-level async lifetime facilities can themselves be expressed in terms of the same lower-level async lifetime primitives. \n \n The implementation discussion focuses on the machinery required to make these guarantees real: Coordinating async teardown within structured concurrency\, managing partially-entered scopes\, and preserving deterministic cleanup semantics even when destruction itself becomes asynchronous. The resulting design serves both as a practical exploration of async lifetime management and as a case study in how implementing an abstraction can reveal deeper structural properties hiding inside the model itself. \n \n
CATEGORIES:SCIENTIFIC COMPUTING
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:06126704a779bdcdf71ff56fc646511b
URL:http://cppcon2026.sched.com/event/06126704a779bdcdf71ff56fc646511b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T204500Z
DTEND:20260918T214500Z
SUMMARY:Ensuring Code Quality in the Age of AI : More Code\, Less Engineering!
DESCRIPTION:Was generating lines of code / upping the commit count the major impediment to delivering stable production ready software? \n \n AI-assisted development has lowered the barrier to churn out code\, helped engineers move faster in unfamiliar codebases\, and made legacy systems easier to approach. however increased code output does not automatically mean better delivery of more reliable code. \n \n In this talk\, we will look at some of the emerging problems that are now becoming evident with AI ***amplifying existing weaknesses** such as code duplication\, larger pull requests and the temptation to accept plausible generated changes without sufficient scrutiny . AI does not remove the need for engineering judgment. It removes the friction that used to slow down code creation \n \n We will explore practical lines of defense to effectively reinforce long-term codebase health including stronger pull request descriptions\, shared reviewer responsibility\, review checklists\, and metrics \n \n The goal is not to reject AI. The goal is to ensure that AI improves engineering delivery rather than accelerating technical debt. \n \n
CATEGORIES:BUSINESS & CAREER
LOCATION:_6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:1372acd187021b0a0f7353d4c22ba982
URL:http://cppcon2026.sched.com/event/1372acd187021b0a0f7353d4c22ba982
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T204500Z
DTEND:20260918T214500Z
SUMMARY:Escaping 1996: Meta-Modern C++ Techniques for Embedded Systems
DESCRIPTION:The software in most embedded projects written in 2026 looks like the software in embedded projects written in 1996. This isn't because 1996 was the peak of innovation and quality but rather has more to do with biases and FUD. Unfortunately\, much of the world suffers from these choices: users\, developers\, managers\, and shareholders. \n \n There are better ways to write firmware for embedded systems\; proven techniques and implementation strategies that I will describe in this talk. We will explore techniques based on abstraction and composition that maximize understanding while reducing the codegen footprint. We will apply these strategies at all levels of the firmware stack: interrupts\, register manipulation\, peripheral communications\, and the application glue. \n \n Join me and leave with open-source libraries\, an open-source starter project\, and techniques that you can apply to your greenfield and existing projects. \n \n
CATEGORIES:EMBEDDED
LOCATION:_4\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:799b843930501048f1a90ac419478cb6
URL:http://cppcon2026.sched.com/event/799b843930501048f1a90ac419478cb6
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T204500Z
DTEND:20260918T214500Z
SUMMARY:Breaking the Speed Limit: Building a High-Throughput Hashing Engine With C++26
DESCRIPTION: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. \n \n 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. \n \n 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. \n \n
CATEGORIES:GENERAL
LOCATION:_5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:a13091452453654ead004b171ea1dfc0
URL:http://cppcon2026.sched.com/event/a13091452453654ead004b171ea1dfc0
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T204500Z
DTEND:20260918T214500Z
SUMMARY:C++ in an AI World
DESCRIPTION:Last year\, the title of this talk would have been "AI in a C++ World." That it isn't anymore tells you most of what changed. \n \n A year ago\, AI was the visitor we were evaluating. Now\, it is the room we work inside\, and the question for C++ programmers is no longer whether to take the technology seriously but how to keep doing serious work in its presence. \n \n Another year of using these tools in earnest on production C++ has clarified what works\, and given me an actual workflow to point at instead of a set of slogans. \n \n I'm a professional C++ developer\, and yet I haven't written a line of code since last November. Not because I've not written any code\, but because AI has written every line. \n \n It is not a theoretical presentation\, but a working practitioner's report. I'll walk you through the development workflow I now use for serious C++ development. \n \n Along the way I'll cover what C++ developers actually need to know about how LLMs work\, what the agentic loop is\, and how to get production-quality C++ out of these systems. The tone is practical\, but opinionated\, though those opinions are based on personal experience. \n \n If you are not yet using AI as another independent member of your development team\, or if you think I'm completely off my rocker\, then this talk is definitely for you. \n \n
CATEGORIES:GENERAL
LOCATION:_2\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:b2bb193ee2b2435c5d31869a88461926
URL:http://cppcon2026.sched.com/event/b2bb193ee2b2435c5d31869a88461926
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T204500Z
DTEND:20260918T214500Z
SUMMARY:What 25 Days of Optimisations Taught Me About Compilers
DESCRIPTION:In December I posted a short video every day about a different compiler optimisation. Some were obvious. Some surprised me. A handful caught me out completely\, and some even were compiler bugs! \n \n This talk distils the most interesting into one talk. It isn't a clip show: the order matters\, the gaps matter\, and together they tell a story about where modern optimisers are scarily good\, where they're stubbornly bad\, and where that gap has moved in the last few years. With outtakes about what didn't make the cut and what I got wrong on camera. \n \n
CATEGORIES:GENERAL
LOCATION:_1\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:653ffeb98c266f7b167ea4f1025ef2b0
URL:http://cppcon2026.sched.com/event/653ffeb98c266f7b167ea4f1025ef2b0
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T204500Z
DTEND:20260918T214500Z
SUMMARY:Concurrency for Modern CPUs - Lock-Free or Lock-based?
DESCRIPTION:For decades\, lock-free programming has been the go-to optimization for the most contended parts of concurrent programs. The reasoning was simple: locks are slow under contention\, so eliminate the locks. This made sense on the hardware of the time\, and I should know—I've given several talks explaining how and why to do it. The hardware has changed. Modern CPUs are highly optimized for the operations that make locks fast: cache-line transfers\, memory ordering\, and speculative execution through lock acquisitions. To set the stage\, we will briefly establish why\, under high contention\, a well-written lock consistently outperforms lock-free atomics and CAS loops. (As an aside\, I'll hand you a concrete recipe for a spinlock that actually holds up under extreme contention—and show why systematic backoff\, by batching cache-line ownership\, is what protects the shared interconnect.) But the core of this talk addresses a completely flipped reality: at low contention\, lock-free code decisively outperforms spinlocks\, for the most surprising reason. Conventional wisdom assumes an uncontended spinlock is practically free. Using raw hardware performance counters\, we will see why it isn't: the implicit synchronization a spinlock imposes—even with no contention at all—is deeply unfavorable to modern out-of-order pipelines\, while a single lock-free XADD or CAS\, an indivisible read-modify-write\, is not. The path everyone assumes is free turns out to be the quietly expensive one. Putting these two facts together—locks winning high contention via cache-line batching\, atomics winning low contention by staying out of the pipeline's way—points to a concrete design. I will present a highly optimized MPMC (multi-producer\, multi-consumer) queue built on a dual-domain structure that deliberately segregates the contended path from the uncontended one\, letting each run on the mechanism the hardware actually favors. We will then walk extensive benchmarks across modern silicon—Intel\, ARM server (Graviton/Grace)\, and Apple (M3)—showing this queue is the fastest\, often by wide margins\, across most operating regimes. We will also see why the tradeoffs play out so differently per chip\, in ways that aren't obvious from the spec sheet\, and why "ARM vs x86" is the wrong axis entirely—what matters is the chip's target market\, not its instruction set. Finally\, no benchmark is complete without honest caveats. I will detail the specific corners where this design can still be beaten\, the hidden system costs you pay elsewhere to buy this throughput\, and why systems that strictly require progress guarantees—deadlock avoidance\, priority inversion\, safe execution in a signal handler—mean traditional lock-free programming is not dead. It has simply relocated. If you've ever reached for a complex lock-free algorithm to speed up a highly contended hot path—or wondered what your CPU is actually doing during a mutex unlock—this talk will change your mind about where lock-free programming truly belongs. \n \n
CATEGORIES:SCIENTIFIC COMPUTING
LOCATION:_3\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:d5262700e6e39dcd684393eaf304603f
URL:http://cppcon2026.sched.com/event/d5262700e6e39dcd684393eaf304603f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260918T221500Z
DTEND:20260919T000000Z
SUMMARY:C++: Growing in a world of efficiency\, safety\, and AI
DESCRIPTION:C++ is adding major expressive power (e.g.\, reflection) and addressing weaknesses (e.g.\, memory safety hardening) at exactly the moment when chip supply and power budgets are raising the value of what people came to C++ for in the first place: control over memory layout (space) and deterministic performance (time). This talk is about that convergence\, in two parts.\nFirst\, we cover the latest developments in ISO C++ itself\, where the committee completed technical work on C++26 in March 2026\, and then in June voted the first additions into the working draft for C++29:\nKey C++26 language improvements like reflection and the initial round of memory safety hardening\, and standard library performance enhancers like std::simd and std::execution.A new Annex in the C++29 working draft cataloging every case of core language undefined behavior\, the first step toward addressing it systematically rather than one paper at a time.Draft “profiles” for stronger portable memory safety guarantees\, now being prototyped and targeted at C++29.Second\, we consider how quickly both hardware and software are moving in the industry around us. This year\, capital is pouring into silicon and power at a jaw-dropping rate\, and agentic systems are arriving with new capabilities and new failure modes. We’ll see how both affect C++ programming in the trenches:\nWhy performance efficiency has been enduringly important\, from the 1940s through to today and with no end in sight.How current industry data (SlashData\, IDC) documents sustained growth in demand for professional programmers\, especially who know languages that can operate under real space and time constraints.What AI does and doesn’t change about any of it: a pragmatic view both of where AI has shown real benefit in our programming world\, and of what it’s not good at (yet\, or ever).Throughout\, we might hear a little grumbling from the speaker about how he has always written his own talk titles and abstracts and prose using em-dashes\, but now can’t use em-dashes anymore because of\, well\, you know.\n\n
CATEGORIES:PLENARY
LOCATION:Colorado A\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:2c8ca8db44586b1f093a4e24dccdec0f
URL:http://cppcon2026.sched.com/event/2c8ca8db44586b1f093a4e24dccdec0f
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260919T150000Z
DTEND:20260919T231500Z
SUMMARY:AI++ 201: Building High Quality C++ Infrastructure with AI
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nIn a previous conference talk\, I demonstrated building a complete OPRA feed handler without writing a single line of code by hand. Over the two days of this workshop\, you’re going to do something even more difficult. \n \n We’re building a matching engine. Not a toy\, one that conforms to IEX specifications\, with the kind of IPC infrastructure you’d actually deploy: lock-free queues\, seqlock arrays\, a sequencer pattern. The works. And you won’t write a single line of code yourself. \n \n Every line comes from Claude Code. You prompt\, you guide\, you review\, you course-correct\, but your fingers don’t type C++. By the end\, you’ll have a working matching engine and a visceral understanding of what AI can and can’t do with a serious C++ project. \n \n We will first cover the foundations: how agentic loops work (condensed review)\, and why C++ is uniquely challenging for AI assistants. Compilation latency breaks the fast-iteration feedback loop. Header/source splits multiply context requirements. Templates generate error novels. The agent can write code that compiles but has undefined behavior. We’ll develop strategies for each problem\, then begin building. \n \n We will build the necessary pieces: lock-free queues\, seqlock arrays\, order books\, matching logic\, end-to-end integration. Everyone codes with their own Claude instance. Results will diverge\, but that’s also a great opportunity for learning. \n \n You don’t need previous experience with trading infrastructure. \n We are choosing this project\, because it is not a toy example\, yet modern AI techniques are fully capable of building a functioning system that is at least on par with something that a team of junior engineers could build. \n \n The goal is to learn how to use the AI tools\, not write production-grade trading software. \n \n By spending two days in an intense lab setting\, attendees gain hands-on experience building real C++ software systems using generative artificial intelligence.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Red Rock 5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:5a1b2da159d9b3c2ab25ff23ee72af78
URL:http://cppcon2026.sched.com/event/5a1b2da159d9b3c2ab25ff23ee72af78
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260919T150000Z
DTEND:20260919T231500Z
SUMMARY:Function and Class Design with C++2x
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nC++20 to C++26 brings a massive number of new language and library features – which can feel overwhelming to developers coming from older standards. This tutorial focuses on introducing those tools and how to use them in construction of functions and classes — which are the foundation of C++ programs. The tutorial is based\, first and foremost\, on the presenters experience building production large non-stop distributed systems with C++2x and also his work on C++ libraries\, including work on the C++ standard library. \n \n Participants will leave with a base knowledge of applying C++2x features to their designs and projects. In particular\, concepts\, reflection\, contracts\, modules\, ranges and range algorithms\, aggregate types\, advanced error handling\, and other features.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Red Rock 6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:56dbc3e7d57e3cc2de1d9e32f708e782
URL:http://cppcon2026.sched.com/event/56dbc3e7d57e3cc2de1d9e32f708e782
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260919T150000Z
DTEND:20260919T231500Z
SUMMARY:High-performance Concurrency in C++
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nThis course is designed to empower participants with the knowledge and skills required to unlock the full potential of high-performance concurrency in C++. By delving into fundamental principles and advanced techniques\, attendees will gain a profound understanding of how to design\, implement\, and optimize concurrent programs effectively. \n \n The class begins by addressing the essentials of performance and guiding participants on how to evaluate and measure the efficiency of concurrent programs. Emphasis is placed on the significance of performance measurement\, providing insights into practical methodologies for assessing program efficiency. The exploration of threads and memory management goes beyond the basics\, offering a nuanced understanding of threads in C++\, multi-threaded memory access\, and the critical aspects of avoiding data races. \n \n Participants will learn effective strategies for synchronizing memory accesses and gain insights into memory models\, equipping them to navigate complex memory-related challenges in concurrent programming. The attendees will learn the tools offered by the C++ language\, including C++20 and coroutines. We will learn about thread schedulers\, thread pools\, and pipelines\, as well as thread-safe data structures. This class equips participants with a comprehensive skill set to harness the full potential of C++ for high-performance concurrency\, covering everything from fundamental principles to advanced tools and techniques. \n \n Unlock the power of high-performance concurrency in C++ with this comprehensive\, hands-on two-day course. Designed for developers looking to push their C++ applications to the next level\, this class covers everything from fundamental principles to the latest\, production-ready concurrency tools in C++20 and C++23cutting-edge concurrency tools introduced in C++20\, with a strong focus on practical implementation and real-world challenges. \n \n We begin by addressing the core question of performance: What makes a concurrent program efficient\, and how can we measure it? Participants will explore key performance metrics and learn profiling and benchmarking techniques to ensure their code runs optimally in multi-threaded environments. \n \n The class delves into the complexities of multi-threaded programming in modern C++\, offering a deep dive into thread management\, memory synchronization\, and avoiding data races. Attendees will learn how to navigate C++’s memory model and apply best practices for thread-safe programming\, ensuring robustness and correctness even in highly concurrent systems. \n \n We will explore practical solutions for real-world concurrency problems using modern C++ features\, including thread pools\, pipelines\, and coroutines\, and dive into thread-safe data structures and lock-free algorithms. Through hands-on exercises\, participants will build and optimize scalable systems that can handle high workloads efficiently. \n \n By the end of this course\, attendees will walk away with a comprehensive toolkit to write high-performance\, concurrent C++ applications that are both fast and safe. Whether you’re building server-side systems\, real-time applications\, or tackling parallel processing challenges\, this class will give you the skills to harness modern C++ concurrency like a pro.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Red Rock 7\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:653ca26327ff6d5438e018a6e209a557
URL:http://cppcon2026.sched.com/event/653ca26327ff6d5438e018a6e209a557
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260920T150000Z
DTEND:20260920T231500Z
SUMMARY:AI++ 201: Building High Quality C++ Infrastructure with AI
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nIn a previous conference talk\, I demonstrated building a complete OPRA feed handler without writing a single line of code by hand. Over the two days of this workshop\, you’re going to do something even more difficult. \n \n We’re building a matching engine. Not a toy\, one that conforms to IEX specifications\, with the kind of IPC infrastructure you’d actually deploy: lock-free queues\, seqlock arrays\, a sequencer pattern. The works. And you won’t write a single line of code yourself. \n \n Every line comes from Claude Code. You prompt\, you guide\, you review\, you course-correct\, but your fingers don’t type C++. By the end\, you’ll have a working matching engine and a visceral understanding of what AI can and can’t do with a serious C++ project. \n \n We will first cover the foundations: how agentic loops work (condensed review)\, and why C++ is uniquely challenging for AI assistants. Compilation latency breaks the fast-iteration feedback loop. Header/source splits multiply context requirements. Templates generate error novels. The agent can write code that compiles but has undefined behavior. We’ll develop strategies for each problem\, then begin building. \n \n We will build the necessary pieces: lock-free queues\, seqlock arrays\, order books\, matching logic\, end-to-end integration. Everyone codes with their own Claude instance. Results will diverge\, but that’s also a great opportunity for learning. \n \n You don’t need previous experience with trading infrastructure. \n We are choosing this project\, because it is not a toy example\, yet modern AI techniques are fully capable of building a functioning system that is at least on par with something that a team of junior engineers could build. \n \n The goal is to learn how to use the AI tools\, not write production-grade trading software. \n \n By spending two days in an intense lab setting\, attendees gain hands-on experience building real C++ software systems using generative artificial intelligence.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Red Rock 5\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:04d31c7088a00aaabe0634a837b688af
URL:http://cppcon2026.sched.com/event/04d31c7088a00aaabe0634a837b688af
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260920T150000Z
DTEND:20260920T231500Z
SUMMARY:Function and Class Design with C++2x
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nC++20 to C++26 brings a massive number of new language and library features – which can feel overwhelming to developers coming from older standards. This tutorial focuses on introducing those tools and how to use them in construction of functions and classes — which are the foundation of C++ programs. The tutorial is based\, first and foremost\, on the presenters experience building production large non-stop distributed systems with C++2x and also his work on C++ libraries\, including work on the C++ standard library. \n \n Participants will leave with a base knowledge of applying C++2x features to their designs and projects. In particular\, concepts\, reflection\, contracts\, modules\, ranges and range algorithms\, aggregate types\, advanced error handling\, and other features.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Red Rock 6\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:d383c079411d649cdae932328f9312dc
URL:http://cppcon2026.sched.com/event/d383c079411d649cdae932328f9312dc
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260920T150000Z
DTEND:20260920T231500Z
SUMMARY:High-performance Concurrency in C++
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nThis course is designed to empower participants with the knowledge and skills required to unlock the full potential of high-performance concurrency in C++. By delving into fundamental principles and advanced techniques\, attendees will gain a profound understanding of how to design\, implement\, and optimize concurrent programs effectively. \n \n The class begins by addressing the essentials of performance and guiding participants on how to evaluate and measure the efficiency of concurrent programs. Emphasis is placed on the significance of performance measurement\, providing insights into practical methodologies for assessing program efficiency. The exploration of threads and memory management goes beyond the basics\, offering a nuanced understanding of threads in C++\, multi-threaded memory access\, and the critical aspects of avoiding data races. \n \n Participants will learn effective strategies for synchronizing memory accesses and gain insights into memory models\, equipping them to navigate complex memory-related challenges in concurrent programming. The attendees will learn the tools offered by the C++ language\, including C++20 and coroutines. We will learn about thread schedulers\, thread pools\, and pipelines\, as well as thread-safe data structures. This class equips participants with a comprehensive skill set to harness the full potential of C++ for high-performance concurrency\, covering everything from fundamental principles to advanced tools and techniques. \n \n Unlock the power of high-performance concurrency in C++ with this comprehensive\, hands-on two-day course. Designed for developers looking to push their C++ applications to the next level\, this class covers everything from fundamental principles to the latest\, production-ready concurrency tools in C++20 and C++23cutting-edge concurrency tools introduced in C++20\, with a strong focus on practical implementation and real-world challenges. \n \n We begin by addressing the core question of performance: What makes a concurrent program efficient\, and how can we measure it? Participants will explore key performance metrics and learn profiling and benchmarking techniques to ensure their code runs optimally in multi-threaded environments. \n \n The class delves into the complexities of multi-threaded programming in modern C++\, offering a deep dive into thread management\, memory synchronization\, and avoiding data races. Attendees will learn how to navigate C++’s memory model and apply best practices for thread-safe programming\, ensuring robustness and correctness even in highly concurrent systems. \n \n We will explore practical solutions for real-world concurrency problems using modern C++ features\, including thread pools\, pipelines\, and coroutines\, and dive into thread-safe data structures and lock-free algorithms. Through hands-on exercises\, participants will build and optimize scalable systems that can handle high workloads efficiently. \n \n By the end of this course\, attendees will walk away with a comprehensive toolkit to write high-performance\, concurrent C++ applications that are both fast and safe. Whether you’re building server-side systems\, real-time applications\, or tackling parallel processing challenges\, this class will give you the skills to harness modern C++ concurrency like a pro.
CATEGORIES:EDUCATION AND COACHING
LOCATION:Red Rock 7\, 6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:9c16d3ba89bfe3101628579c1c245c9b
URL:http://cppcon2026.sched.com/event/9c16d3ba89bfe3101628579c1c245c9b
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260921T150000Z
DTEND:20260921T210000Z
SUMMARY:C++ Fundamentals You Wish You Had Known Earlier
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nC++ is a complex programming language. When used correctly\, it delivers the best possible performance. Unfortunately\, it is often misused\, which causes many problems.However\, it turns out that consciously using selected language features can make it relatively easy to produce high-quality software that delivers excellent runtime performance and is error-proof. This coding style is called Modern C++.The material of this workshop is the first chapter of the trainer’s most successful and popular training called “Advanced Modern C++”. During the class\, we will go through all the key features of the C++ language\, discuss potential issues and pitfalls\, and provide guidelines on how to use them correctly. This training discusses various topics ranging from identifiers that do not result in undefined behavior through vital language features like name lookup\, overload resolution\, one definition rule\, and move semantics up to the design recommendations like Rule of Zero. Among others\, we will see how we can provide a custom dynamic allocation strategy for our programs and how we should design and implement customization points for our engine.If you are wondering if you should attend this class\, maybe&nbsp\;this short quiz&nbsp\;will help you decide:. Those and many other questions will be addressed during the training.What You Will Learn?Emphasis on understanding the philosophy and mechanisms of C++ programming language and learning how to reuse this knowledge in one’s own code.Particular focus on the usage of C++ templates in practical tasks.Development of error-unfriendly code.Selection of useful patterns and techniques that prove in a demanding production code.Workshop Structure40% lecture30% discussion20%hands-on coding10% knowledge quizEnvironmentA laptop with a web browser and access to the InternetAll hands-on exercises will be implemented using&nbsp\;Compiler Explorer\n
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:b56dcb91fedb5131dd6019403bfff2e4
URL:http://cppcon2026.sched.com/event/b56dcb91fedb5131dd6019403bfff2e4
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260921T150000Z
DTEND:20260921T210000Z
SUMMARY:C++23 in Practice: A Complete Introduction
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nC++23 is now fully available by major C++ compilers so that more and more projects and companies are using it. Therefore\, it is time to look at the contents of C++23 (new features and significant extensions in both the language and the standard library).\nThis three-days training introduces and discusses all major language and library features of C++23. The goal is to be ready to use them in practice and benefit from their purpose and design in your day-to-day work.\nMany features extend C++20 features and make them (more) usable in practice. For example\, std::generator is the first interface class to deal easily with coroutines\, so that C++23 introdcues a new paradigm to implement generators and state machines. For these topics\, the basics of C++20 will be part of this training.\nAs usual for his trainings and books\, Nicolai Josuttis will focus on both the design and the practical usability of the new features. Attendees will understand why we have them and how to use them right. As a long-term active member of the C++ Standard Commitee and well-known educator\, the quality of this training will give you the best revenue for understanding\, use\, and avoiding the traps of C++23.
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:b1463b6aebecd2f86172d11b7f0905fa
URL:http://cppcon2026.sched.com/event/b1463b6aebecd2f86172d11b7f0905fa
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260922T150000Z
DTEND:20260922T210000Z
SUMMARY:C++ Fundamentals You Wish You Had Known Earlier
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nC++ is a complex programming language. When used correctly\, it delivers the best possible performance. Unfortunately\, it is often misused\, which causes many problems.However\, it turns out that consciously using selected language features can make it relatively easy to produce high-quality software that delivers excellent runtime performance and is error-proof. This coding style is called Modern C++.The material of this workshop is the first chapter of the trainer’s most successful and popular training called “Advanced Modern C++”. During the class\, we will go through all the key features of the C++ language\, discuss potential issues and pitfalls\, and provide guidelines on how to use them correctly. This training discusses various topics ranging from identifiers that do not result in undefined behavior through vital language features like name lookup\, overload resolution\, one definition rule\, and move semantics up to the design recommendations like Rule of Zero. Among others\, we will see how we can provide a custom dynamic allocation strategy for our programs and how we should design and implement customization points for our engine.If you are wondering if you should attend this class\, maybe&nbsp\;this short quiz&nbsp\;will help you decide:. Those and many other questions will be addressed during the training.What You Will Learn?Emphasis on understanding the philosophy and mechanisms of C++ programming language and learning how to reuse this knowledge in one’s own code.Particular focus on the usage of C++ templates in practical tasks.Development of error-unfriendly code.Selection of useful patterns and techniques that prove in a demanding production code.Workshop Structure40% lecture30% discussion20%hands-on coding10% knowledge quizEnvironmentA laptop with a web browser and access to the InternetAll hands-on exercises will be implemented using&nbsp\;Compiler Explorer\n
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:5a50b6f117fc14512a330b3c750e0172
URL:http://cppcon2026.sched.com/event/5a50b6f117fc14512a330b3c750e0172
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260922T150000Z
DTEND:20260922T210000Z
SUMMARY:C++23 in Practice: A Complete Introduction
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nC++23 is now fully available by major C++ compilers so that more and more projects and companies are using it. Therefore\, it is time to look at the contents of C++23 (new features and significant extensions in both the language and the standard library).\nThis three-days training introduces and discusses all major language and library features of C++23. The goal is to be ready to use them in practice and benefit from their purpose and design in your day-to-day work.\nMany features extend C++20 features and make them (more) usable in practice. For example\, std::generator is the first interface class to deal easily with coroutines\, so that C++23 introdcues a new paradigm to implement generators and state machines. For these topics\, the basics of C++20 will be part of this training.\nAs usual for his trainings and books\, Nicolai Josuttis will focus on both the design and the practical usability of the new features. Attendees will understand why we have them and how to use them right. As a long-term active member of the C++ Standard Commitee and well-known educator\, the quality of this training will give you the best revenue for understanding\, use\, and avoiding the traps of C++23.
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:a627143d5b66c75d4288a1871e69cadd
URL:http://cppcon2026.sched.com/event/a627143d5b66c75d4288a1871e69cadd
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260923T150000Z
DTEND:20260923T210000Z
SUMMARY:C++ Fundamentals You Wish You Had Known Earlier
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nC++ is a complex programming language. When used correctly\, it delivers the best possible performance. Unfortunately\, it is often misused\, which causes many problems.However\, it turns out that consciously using selected language features can make it relatively easy to produce high-quality software that delivers excellent runtime performance and is error-proof. This coding style is called Modern C++.The material of this workshop is the first chapter of the trainer’s most successful and popular training called “Advanced Modern C++”. During the class\, we will go through all the key features of the C++ language\, discuss potential issues and pitfalls\, and provide guidelines on how to use them correctly. This training discusses various topics ranging from identifiers that do not result in undefined behavior through vital language features like name lookup\, overload resolution\, one definition rule\, and move semantics up to the design recommendations like Rule of Zero. Among others\, we will see how we can provide a custom dynamic allocation strategy for our programs and how we should design and implement customization points for our engine.If you are wondering if you should attend this class\, maybe&nbsp\;this short quiz&nbsp\;will help you decide:. Those and many other questions will be addressed during the training.What You Will Learn?Emphasis on understanding the philosophy and mechanisms of C++ programming language and learning how to reuse this knowledge in one’s own code.Particular focus on the usage of C++ templates in practical tasks.Development of error-unfriendly code.Selection of useful patterns and techniques that prove in a demanding production code.Workshop Structure40% lecture30% discussion20%hands-on coding10% knowledge quizEnvironmentA laptop with a web browser and access to the InternetAll hands-on exercises will be implemented using&nbsp\;Compiler Explorer\n
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:4aee4eed789ed22c4a6c9194ea24b115
URL:http://cppcon2026.sched.com/event/4aee4eed789ed22c4a6c9194ea24b115
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260923T150000Z
DTEND:20260923T210000Z
SUMMARY:C++23 in Practice: A Complete Introduction
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nC++23 is now fully available by major C++ compilers so that more and more projects and companies are using it. Therefore\, it is time to look at the contents of C++23 (new features and significant extensions in both the language and the standard library).\nThis three-days training introduces and discusses all major language and library features of C++23. The goal is to be ready to use them in practice and benefit from their purpose and design in your day-to-day work.\nMany features extend C++20 features and make them (more) usable in practice. For example\, std::generator is the first interface class to deal easily with coroutines\, so that C++23 introdcues a new paradigm to implement generators and state machines. For these topics\, the basics of C++20 will be part of this training.\nAs usual for his trainings and books\, Nicolai Josuttis will focus on both the design and the practical usability of the new features. Attendees will understand why we have them and how to use them right. As a long-term active member of the C++ Standard Commitee and well-known educator\, the quality of this training will give you the best revenue for understanding\, use\, and avoiding the traps of C++23.
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:6178141d785d9f0d3387bb30a97f18b4
URL:http://cppcon2026.sched.com/event/6178141d785d9f0d3387bb30a97f18b4
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260926T150000Z
DTEND:20260926T230000Z
SUMMARY:Using C++ for Low-Latency Systems
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nThis course will focus on techniques programmers can use to get better\, more predictable or more stable performance from systems with low-latency constraints. It is subdivided in sections that cover subsets of the subject matter\; each section discusses C++ features that help achieving the section’s objectives\, with emphasis on contemporary (C++20 and C++23) features wherever that makes sense.\nThis training emphasizes portable C++ code. We might on occasion examine platform-specific aspects of programming\, but the intent is that participants will be able to use the ideas and techniques covered in this class regardless of their chosen platform.\n\n\n
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:caf7ddd2c77a959c5540225bbba10d75
URL:http://cppcon2026.sched.com/event/caf7ddd2c77a959c5540225bbba10d75
END:VEVENT
BEGIN:VEVENT
DTSTAMP:20260828T230432Z
DTSTART:20260927T150000Z
DTEND:20260927T230000Z
SUMMARY:Using C++ for Low-Latency Systems
DESCRIPTION:** Separate registration is required for CppCon Academy Classes. **\n\nClass Page\n\nThis course will focus on techniques programmers can use to get better\, more predictable or more stable performance from systems with low-latency constraints. It is subdivided in sections that cover subsets of the subject matter\; each section discusses C++ features that help achieving the section’s objectives\, with emphasis on contemporary (C++20 and C++23) features wherever that makes sense.\nThis training emphasizes portable C++ code. We might on occasion examine platform-specific aspects of programming\, but the intent is that participants will be able to use the ideas and techniques covered in this class regardless of their chosen platform.\n\n\n
CATEGORIES:EDUCATION AND COACHING
LOCATION:6700 North Gaylord Rockies Boulevard\, Aurora\, CO 80019\, USA
SEQUENCE:0
UID:bcd4030ab323342d175533233653b602
URL:http://cppcon2026.sched.com/event/bcd4030ab323342d175533233653b602
END:VEVENT
END:VCALENDAR