Implement the C++ Standard Library: Design, Optimisations, Testing while Implementing Libc++

by Hui Xie

Summary of the talk:

This presentation covers various practical examples in the designs, optimisations and testing in libc++, a standard library implementation.

In space optimisation section, it presents various examples of using compact type, reusing tail padding bytes, reusing unused bits in existing bytes, in various standard types: std::stop_token , std::expected , std::optional , std::variant , std::ranges library and std::move_only_function .

In time optimisations section, it presents examples of how we optimise std::atomic＜T＞::wait 's waiting strategy, how we optimised algorithms for segmented iterators, and also how we keep in mind optimisations by leaving the door open for future optimisations. At the same time, compilation time is also important so it also contains examples how unnecessary template instantiations can be avoided.

Finally, this talk covers the unit tests of libc++, including the high test coverage of standard spec, the technique we share tests between runtime and constexpr, negative testing and so on.

Keith Stockdale - The journey to "/W4 /WX": How hard could it be?

Abstract:

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. 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.

About the Speaker:

Keith is a Northern Irish senior software engineer who has been working on the Engine and Rendering teams at Rare Ltd for the last 9 years. He primarily works on Engine and Rendering level systems involving General Purpose GPU systems such as GPU particle systems. Keith is enthusiastic about promoting writing good quality code, whether it is running on the CPU on the GPU.

Chris Croft-White - Agentic Time-Travel Debugging

Abstract:

Time-travel debugging is a powerful technique to dive deep into the execution of your applications, providing visibility simply not available any other way and enabling rapid diagnosis of issues as well as understanding of unfamiliar code bases. With the AI revolution going on today, hallucinations are a major concern and limiting factor for adoption. Combining these two technologies enables us to give the AI Agent all the information it could possibly want about what happened in your application. This enables it to both investigate when something goes wrong to develop a hypothesis, but also a way to validate that hypothesis, and iterate on it as needed until the AI Agent is able to verifiably explain what happened and why.

About the Speaker:

Chris Croft-White is a Staff Solutions Architect at Undo, where he works at the intersection of debugging technology and developer productivity. With a career spanning field applications engineering, security, and technical pre-sales, he brings a practitioner's perspective to the challenge of helping engineering teams ship reliable software faster. Chris is currently focused on the emerging field of agentic debugging, exploring how AI can move beyond code generation to become a genuine partner in root cause analysis and defect resolution. He writes and speaks on practical approaches to integrating AI into real-world debugging workflows, cutting through the hype to find what actually works.

Lazy and Fast: Ranges Meet Parallelism in C++

by Daniel Anderson

Summary of the talk:

Recent advances in the C++ standard have introduced powerful features like ranges and parallel algorithms—both aimed at writing faster, cleaner, and more expressive code. Ranges offer lazy, on-demand computation that improves I/O efficiency and composability. Parallel algorithms, on the other hand, harness multitasking to speed up compute-heavy workloads.

At first glance, these two features seem like a perfect match: lazy evaluation to minimize I/O overhead, and parallelism to maximize throughput. However, in practice, they don’t play well together. Many range operations—especially those over non-random-access sources—are inherently sequential due to their lazy pull-based, one-element-at-a-time nature.

In this talk, we’ll explore a modern library technique that unlocks the synergy between lazy ranges and parallelism. You’ll see how to build lazy, composable range pipelines that are parallel-friendly—capable of efficiently expressing operations like filter, scan, and flatten without sacrificing performance or elegance. We’ll walk through real-world examples where these techniques deliver strong parallel speedups with minimal programming overhead.

Whether you’re a library designer, performance enthusiast, or just curious about making your range-based code scale, this talk will equip you with practical tools to bridge the gap between composability and parallelism in modern C++.

How to Tame Packs, std::tuple, and the Wily std::integer_sequence

by Andrei Alexandrescu

Summary of the talk:

Template parameter packs and std::tuple unlock powerful metaprogramming capabilities in C++, but they also introduce a parallel sublanguage—one with unfamiliar rules, verbose idioms, and surprising limitations. Packs were originally designed for perfect forwarding, not compile-time iteration, which makes even simple tasks like filtering or transformation awkward. std::integer_sequence helps, but mostly by shifting the burden rather than removing it.

Existing library utilities offer some relief, but often feel inconsistent and difficult to compose. This talk explores why working with packs and tuples feels harder than it should, and demonstrates a small set of clean, reusable abstractions that make these tasks simpler, safer, and more expressive. Attendees will leave with practical tools—(and, with luck, a renewed hope) that structured metaprogramming in C++ doesn't have to be so hard.

Cache-Friendly C++

by Jonathan Müller

Summary of the talk:

When you need a container, pick std::vector＜T＞ by default. This is because std::vector＜T＞ is cache-friendly.

What does that mean, though?

This talk will answer that from the ground-up. We will cover the need for CPU caches and their consequences, how the CPU tricks to make them as seamless as possible, and when and why those tricks sometimes fail. This means that you need to be careful when structuring your program to avoid slowdowns. We will thus explore cache-friendly data structures, data-oriented design, and how to avoid common pitfalls.

C++ Performance Tips: Cutting Down on Unnecessary Objects

by Prithvi Okade & Kathleen Baker

Summary of the talk:

In C++, unnecessary temporary object creation can lead to costly runtime operations, increased code execution, and higher memory usage. Luckily this can be improved! This talk investigates common scenarios that result in the creation of temporary objects and how to detect these scenarios, demonstrated through code examples. We will then explore strategies to reduce the creation of such objects with techniques like explicitly moving objects, passing objects by reference, leveraging lightweight classes like std::string_view and std::span , using functions like reserve and emplace , and more. Join us to learn how to optimize your code’s performance and adopt better practices.

Zero-Overhead Abstractions: Building Vector Math Libraries with Concepts and Customization Points

by Greg von Winckel

Summary of the talk:

This talk demonstrates how C++20's Concepts and Customization Point Objects (CPOs) provide a flexible, opt-in approach to vector algorithms—a compelling alternative to inheritance-based interfaces. Starting with foundational concepts and CPOs, we'll design mathematical abstractions that enable precise compile-time requirements with helpful diagnostics and clear error messages.

Through a practical vector framework implementation, we'll explore patterns essential for high-performance scientific computing applications, including interpolation and iterative methods for linear and nonlinear systems. Attendees will learn how CPOs with intelligent fallbacks parallel the familiar base-class/override structure of OOP, providing similar code reuse and customization opportunities without inheritance entanglements, while enabling seamless interoperability between diverse container types in the spirit of the STL.

As a C++ developer and architect at Sandia National Laboratories for the past decade, I've witnessed the burden of OOP overuse: complicated class hierarchies, parallelism compatibility issues, and testing challenges. The Real Vector Framework I've developed demonstrates how static polymorphism and free functions provide cleaner, more flexible alternatives to inheritance—bringing modern C++ practices to scientific computing while preserving the performance critical to our applications.

Last week, the film's world premiere event in New York was followed by a live panel discussion with Matt Godbolt (moderator), Bjarne Stroustrup, Gabriel Dos Reis, Nina Ranns, Eric Lubin, and Herb Sutter. That panel was recorded and will be also released in the next few days on the CppCon YouTube channel.

Best Practices for AI Tool Use in C++

by Jason Turner

Summary of the talk:

AI (LLMs) are becoming prolific in C++ tooling. Virtually everything has an AI bot built in or available to it. Common wisdom says that these tools simply regurgitate what they find on the internet. As we all know, the internet is full of terrible examples of outdated memory leaks, undefined behavior, and worse!

How do we effectively and safely use these tools while ensuring good code quality?!

Back to Basics: Master C++ Friendship

by Mateusz Pusz

Summary of the talk:

C++ offers a rich set of access specifiers to control the visibility of class members. However, the friend keyword introduces a unique and often misunderstood concept. This talk explores the nuances of friendship, examining its role in code design, testing, and compilation performance optimization.

We'll delve into the intricacies of friendship, exploring its benefits and potential pitfalls. We'll examine how to leverage friendship effectively, discuss best practices, and uncover hidden gems and common misconceptions. We will see how friendship affects name lookup and compile-time error messages. We will discuss best practices for using it effectively and learn how to avoid or resolve compilation problems that may occur when C++ templates are involved.

By the end of this session, you'll have a solid grasp of friendship and be able to use it to write more elegant, efficient, and maintainable C++ code.

Could C++ Developers Handle an ABI Break Today?

by Luis Caro Campos

Summary of the talk:

The C++ Evolution Working Group recently reaffirmed its commitment to ABI stability, prioritizing link compatibility with C and older C++. The C++11 libstdc++ ABI updates introduced in gcc 5.1, although not strictly “breaking”, are still in the collective memory of C++ developers and this experience shows us how sensitive the ecosystem is to ABI updates.

This talk challenges the assumption that a future ABI break would be equally problematic, as the landscape has evolved significantly in the last decade.

On the one hand, the C++ standard has evolved in such a way that even if the standards committee and compiler vendors go through great lengths to avoid breaking the ABI of standard library implementations, library authors are not as cautious - so in practice, the ability to link objects built with different C++ standard levels does not hold true for a lot of cases.

On the other hand, tooling has evolved significantly in this time period. For example, both Conan and vcpkg are able to “tag” binaries on some arbitrary ABI version. We can see similar examples in other tools or ecosystems that need to work around ABI complexities.

This talk is not intended to argue about the merits or risks of future ABI changes - but to ask ourselves the question: are we overestimating the pain of a future ABI break?

How To Build Robust C++ Inter-Process Queues

by Jody Hagins

Summary of the talk:

This talk will offer design and implementation details of a queue intended to be used between multiple processes.

The C++ standard was written with a single-process worldview, mentioning processes only once—in a note stating that lock-free atomic operations work across process boundaries. This has led to widespread but incorrect advice about using std::atomic in shared memory. When moving queue implementations from threads to processes, seemingly rock-solid code can induce undefined behavior.

In addition, traditional queue interfaces are fundamentally insufficient for cross-process communication. A properly designed inter-process queue API must enforce role separation, ensuring that a process can only perform operations appropriate to its designated role. For example, a producer process should not be able to consume messages or manage the queue itself, and the API should prevent multiple processes from accidentally assuming the same role in a single-producer design.

By the end of this talk, you will understand the fundamental differences between thread process synchronization, how to design proper interfaces for interprocess queues that enforce correct usage across process boundaries, and practical techniques to ensure your cross-process code works reliably in production environments.

Oh yeah, and you will have a full implementation that you can use and improve upon.

The road to 'import boost': a library developer's journey into C++20 modules

Rubén Pérez Hidalgo

Watch now:

Concept-based Generic Programming

by Bjarne Stroustrup

Summary of the talk:

This talk presents programming techniques to illustrate the facilities and principles of C++ generic programming using concepts. Concepts are C++’s way to express constraints on generic code. As an initial example, it provides a simple type system that eliminate narrowing conversions and provides range checking.

Concepts are used throughout to provide user-defined extensions to the type system. The aim is to show their utility and the fundamental ideas behind them, rather than to provide a detailed or complete explanation of C++’s language support for generic programming or the extensive support provided by the standard library.

The final sections briefly present design rationales and origins for key parts of the concept design, including use patterns, the relationship to Object-Oriented Programming, value arguments, syntax, concept type-matching, and definition checking. They also mention static reflection, a C++26 improvements in the support of general programming.

Gabriel Dos Reis - Tightening the Screws with C++ Profiles

Abstract:

The C++ community has been challenged to provide practical solutions to the problem of memory safety prevalent in some software with large blast radius.  By "practical", I mean solutions that scale to billions of lines of existing running code that deliver value every single day.  The constraints we are dealt afford us neither the luxury of pausing the world for complete rewrite from scratch, nor only focusing on "future", yet to be written, code.  C++ profiles are a tooling-based evolutionary approach that meets those constraints.  They enable the C++ community to tackle similar problems in a single, extensible, and flexible framework.

About the Speaker:

Dr. Gabriel Dos Reis is an Architect for Visual Studio at Microsoft, working in the area of large scale software construction, tools, and technique.  His contributions to C++ include scalable generic programming, pioneering compile-time computation, language support for modularity, safety, and security.  He is interested in all aspects of software construction with bias towards computational logic, formal methods, and the fun of building useful tools.

The trailer premieres today at 19:00 UTC. Click Notify me on the YouTube Premiere page to get a reminder when it goes live.

The film will have its world premiere on May 28 at a special live event in New York City’s Financial District, followed by a panel discussion that will be recorded for later release. C++: The Documentary will be released worldwide on YouTube on June 4, with the panel recording following a few days later.

Crafting the Code You Don’t Write: Sculpting Software in an AI World

by Daisy Hollman

Summary of the talk:

It’s shockingly uncontroversial to say that the fields of developer experience and developer productivity have changed more in the past six months than in the 25 years before that.

As part of the Claude Code team at Anthropic, I’ve had the privilege of witnessing the evolution of agentic coding from proof-of-concept experiments to nearly autonomous software engineers in just six months. In this keynote, I’ll share some of my experiences and learnings from that journey, talk about how LLMs work more generally, attempt some live demonstrations of the latest functionality, explore the future of agentic programming, and tie all of this back to what it means for your workflow as a software engineer.

When I agreed to give this talk earlier this year, there was some portion of the narrative that involved “why you should be using agents to accelerate your development process.” Since then, the world of software engineering has evolved such that the interesting question is no longer “why” but “how.” Like sculptors facing the invention of power tools, or painters around the invention of photography, we now live in a world where vast quantities of rough-draft code can be generated with a very low barrier to entry. How does the role of a software engineer evolve when AI can autonomously implement features from requirements? How do we build safety features into the power tools we’re chiseling away at our codebases with? What aspects of software craftsmanship become more important, not less, in an age of abundant code generation? And critically for the C++ community: how do we leverage these tools where correctness and performance are non-negotiable? The future isn’t about AI replacing programmers, but about a fundamental shift in how we think about software creation. And surprisingly, you might not miss the old way of doing things.

Reflection: C++’s Decade-Defining Rocket Engine

by Herb Sutter

Summary of the talk:

In June 2025, C++ crossed a Rubicon: it handed us the keys to its own machinery. For the first time, C++ can describe itself—and generate more. The first compile-time reflection features in draft C++26 mark the most transformative turning point in our language’s history by giving us the most powerful new engine for expressing efficient abstractions that C++ has ever had, and we’ll need the next decade to discover what this rocket can do.

This session is a high-velocity tour through what reflection enables today in C++26, and what it will enable next. We’ll start with live compiler demos (Godbolt, of course) to show how much the initial C++26 feature set can already do. Then we’ll jump a few years ahead, using Dan Katz’s Clang extensions and my own cppfront reflection implementation to preview future capabilities that could reshape not just C++, but the way we think about programming itself.

We’ll see how reflection can simplify C++’s future evolution by reducing the need for as many bespoke new language features, since many can now be expressed as reusable compile-time libraries—faster to design, easier to test, and portable from day one. We’ll even glimpse how it might solve a problem that has long eluded the entire software industry, in a way that benefits every language.

The point of this talk isn’t to immediately grok any given technique or example. The takeaway is bigger: to leave all of us dizzy from the sheer volume of different examples, asking again and again, “Wait, we can do that now?!”—to fire up our imaginations to discover and develop this enormous new frontier together, and chart the strange new worlds C++ reflection has just opened for us to explore.

Reflection has arrived, more is coming, and the frontier is open. Let’s go.

Back to Basics: Move Semantics

by Ben Saks

Summary of the talk:

While many C++ programmers are familiar with the broad idea of move semantics, even experienced C++ programmers often struggle with the fine details. For example, many programmers are unclear on exactly when an object is considered implicitly movable and when std::move() is required to make the object movable. This is especially unfortunate because using std::move() when it's unnecessary sometimes degrades performance.

This session starts by explaining how move semantics can substantially improve performance for certain types. It then shows how to implement a type with move semantics, and explores some important design issues in creating these types. After that, it explains how types like std::vector＜T＞ can operate much more efficiently on objects of types that support move semantics.

You'll leave this session with a clearer understanding of:

• how to implement move-semantic types,
• how to take maximum advantage of move-semantic types, and
• how move semantics are related to other language features like return-value optimization.

JSON and C++26 compile-time reflection: a talk

by Daniel Lemire

Watch now:

Beyond Sequential Consistency: Unlocking Hidden Performance Gains

by Christopher Fretz

Summary of the talk:

In 2011, C++ introduced a formally defined memory model, providing a foundation for portable, multi-threaded code with well-defined correctness guarantees. This was a major milestone, enabling expressive threading primitives and safe concurrency patterns while allowing low-level optimizations for performance.

By default, C++ atomics enforce sequential consistency, which ensures intuitive, predictable behavior. However, these strong guarantees often exceed what’s necessary for correctness and come with a performance cost.

This talk delves into weaker memory orderings, particularly acquire/release and relaxed semantics, using a ring buffer as a practical example of how they can be used. We’ll also examine how the C++ memory model maps to real hardware, focusing on x86’s native guarantees, and comparing against less coherent platforms like ARM. We'll explore how strategic use of weaker synchronization can unlock significant performance gains without sacrificing correctness.

Lieven de Cock - Type Punning, the joke is on you, pun intended

Abstract:

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.
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.
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?

About the Speaker:

Lieven is a passionate software developer, architect, team lead, manager, coach, with 30 years of experience. He is passionate about C++, software craftsmanship, and clean code. His career started in the text-to-speech domain and then moved to video recognition technology for  traffic environments. During the last 15 years he is active in the satellite communication industry. Lieven also contributes to several open source projects and is the lead developer of the open source IDE Code::Blocks. He is also the lead coach of the Coderdojo division in Ghent, Belgium where he lives. A major focus is on sharing knowledge on C++, coaching people to grow in C++, and maintaining and raising the bar on quality.

The Wonderful World of Designing a USB Stack Using Modern C++

by Madeline Schneider

Summary of the talk:

Have you ever wondered how to design a library to abstract and manage complex communication protocols like USB? Have you ever wondered which parts of a protocol need to be hardware abstractions and which parts are hardware agnostic? Well you’re in luck, my mentor and I have designed a USB stack from the ground up in modern C++! We found that the public offerings did not meet our needs. Our requirements are:

• Resource efficient
• Portable
• Modular
• Convenient to use
• Distributable via single pre-built binary using conan
• Without allocations after initialization

In this talk you’ll learn the basics of how USB works at the lowest level from a software perspective. You’ll learn why malleability and freedom are so important for USB device development and how C++ makes such a library design easy to implement. Embark with me on a deep-dive into shaping a library where complexity runs wild. This talk will have lessons on library and API design in situations where the degrees of freedom are vast and all parts must magically fit together. By the end, you’ll carry away practical patterns for taming vast design spaces—skills that apply to any ambitious library, far beyond USB.

Herb Sutter - C++: Growing in a world of competition, safety, and AI

Abstract:

These are exciting times for C++. This talk will cover why to be excited about the new C++26 standard, which is expected to be technically finalized 48 hours before this talk. More broadly, it will cover why C++’s strong market growth — and the strong growth of human software development in general — are likely to continue for the foreseeable future in a world of explosively growing software demands for performance, security, and AI.

About the Speaker:

Herb is a technical fellow at Citadel Securities, designer of several Standard C++ features, chair emeritus of the ISO C++ committee, and chair of the Standard C++ Foundation. His current interest is simplifying C++.

Can Standard C++ Replace CUDA for GPU Acceleration?

by Elmar Westphal

Summary of the talk:

On top of the woes of multi-threaded programming itself, coding for GPUs used to be about dealing with kernels, separate memory domains, warps, blocks and other strange things. Later, life became easier and you could sprinkle in a bunch of pragmas, hoping that your favorite language extension would deal with all of this for you, and better memory model abstractions came up that were less painful to deal with. In recent years, new drivers (seemingly) levelled the boundaries between memory domains and new compilers allow us to deploy code to the GPU using standard C++ execution policies. The performance of the generated code is often similar to that of its CUDA-C++ counterpart. Of course there is no magic bullet to shoot at your (legacy) code and there are caveats, but come and see how using standard parallelism (also) for programming GPUs makes it a lot easier to write portable and more future-proof high-performance C++ code.

C++: Some Assembly Required

by Matt Godbolt

Summary of the talk:

Join Matt in exploring how the C++ ecosystem has evolved through the interplay of intentional design and emergent collaboration. Standards committees craft language features and compiler teams implement them, but something amazing happens in the spaces between: tools appear, communities form, and solutions emerge that nobody quite planned for. What started as individual developers solving their own problems has grown into an interconnected ecosystem that shapes how we all write C++.

From documentation to testing, from build systems to package managers, we'll examine how the C++ community has assembled itself around shared pain points and accidental standards. Using examples and perhaps too many rainforest metaphors, this talk celebrates not just the language we've built, but the organic ecosystem that's grown up around it. Come discover why C++'s greatest strength might be that it's always required some assembly.

How C++ Finally Beats Rust at JSON Serialization

by Daniel Lemire & Francisco Geiman Thiesen

Summary of the talk:

JSON, or JavaScript Object Notation, has become a cornerstone for storing and exchanging data. Its appeal lies in its simplicity—human-readable text that elegantly captures structured data through attribute-value pairs and arrays: {"age": 5, "name": "Daniel", "toys": ["wooden dog", "little car"]}. JSON is intuitive yet powerful. But ingesting and producing JSON can turn into a performance choke point. In C++, it can be a tedious, error-prone task. Programmers wrestle with unexpected content, manually mapping data to and from native structures, all while striving for speed and safety.

With languages like Java, C#, Zig, Rust, or Python, JSON serialization and deserialization typically requires far less work. In particular, Rust's serde library blends convenience with high speed. We wish for a C++ library to automatically handle JSON production and consumption, seamlessly tied to native data structures. It is not merely to simplify life for developers; it is also about crafting code that is both fast and solid, generated at compile time by a battle-tested library.

Thankfully, C++ might soon be getting reflective metaprogramming (  PR2996  ). Leveraging the  experimental Bloomberg LLVM fork  with reflective metaprogramming, we have built a full-fledged implementation—complete with tests, benchmarks, and documentation. Our goal is to have production-ready code the moment mainstream compilers catch up. The results speak for themselves: we are parsing JSON directly into C++ structures at gigabytes per second, outpacing even mature heavyweights like Rust's serde. Better yet, the conversion between C++ data structures and JSON is fully automated, thanks to metaprogramming. It has the potential to be a leap forward for C++ in the data-driven age. Unfortunately, there are still problems and limitations: we present them and provide some solutions.

Why Every C++ Game Developer Should Learn SDL 3 Now

by Mike Shah

Summary of the talk:

The C++ programming language does not have a standard graphics library, However, there exists many popular graphics frameworks for cross-platform graphics. In this talk, I will provide an introduction to the Simple Directmedia Layer (SDL) library, which has at the start of 2025 released version 3. This library for several decades has been a standard in the games and graphics industry. Throughout this talk, I will show how to get started with the library, some more advanced examples (including compiling graphics applications to web), and then talk about what a standard graphics library could look like in C++, or if it is even necessary. I will also talk about the 3D GPU library in SDL3. Attendees will leave this talk ready to build multimedia / game applications and with an understanding on if SDL3 is the right tool for them.

Implementing Your Own C++ Atomics

by Ben Saks

Summary of the talk:

Atomic objects are extremely useful for concurrent programming. Unfortunately, some embedded toolchains like AVR-GCC omit portions of the C++ Standard Library, including headers like ＜atomic＞ .This makes it much harder to program concurrent software on these platforms, since many tutorials and open-source libraries assume Standard Library support. For example, these talks from past CppCons present lock-free data structures and algorithms that rely strongly on lock-free instantiations of std::atomic＜T＞:

Single Producer Single Consumer Lock-free FIFO From the Ground Up – Charles Frasch – CppCon 2023
Introduction to Wait-free Algorithms in C++ Programming – Daniel Anderson – CppCon 2024
User API & C++ Implementation of a Multi Producer, Multi Consumer, Lock Free, Atomic Queue – Erez Strauss – CppCon 2024

This session will show you how to implement your own atomic types in the absence of library support. These atomic types can greatly expand the number of tutorials and open-source libraries available for you to use. A clear understanding of how atomic types are implemented will also help you use objects of those types more effectively on platforms that do provide native support.

Back to Basics: Custom Allocators Explained - From Basics to Advanced

by Kevin Carpenter

Summary of the talk:

Effective memory management is crucial for building efficient and reliable C++ applications. Custom memory allocators provide a powerful tool for optimizing memory usage, reducing fragmentation, and improving performance. This talk will explore the intricacies of memory allocation in C++, from the basics of dynamic memory management to the implementation of custom allocators. Attendees will gain insights into the standard allocator model, techniques for designing custom allocators, and practical examples of their use in real-world applications.

Join us to unlock the full potential of memory management in your C++ projects.

Cache Me Maybe: The Performance Secret Every C++ Developer Needs

by Michelle D'Souza

Summary of the talk:

Calling all code detectives! Grab your trench coats and magnifying glasses ... it's time to crack the case of sluggish C++ performance. In this thrilling investigation, we'll uncover the hidden world of your computer's built-in cache and how to harness it to turbocharge your code.

We'll comb through the fundamentals of caches like seasoned sleuths, uncover clues on optimizing access patterns, and interrogate suspects like false sharing and cache unfriendly data structures. We will also examine benchmark evidence based on real-world production code, exposing how each technique delivers the goods.

By the end of this mission, you'll be armed with a detective's toolkit of cache savvy strategies, ready to solve cross-platform performance mysteries and bring blazing fast code to justice. Cache you at this session, maybe!

Matrix Multiplication Deep Dive || Cache Blocking, SIMD & Parallelization

by Aliaksei Sala

Summary of the talk:

Matrix multiplication is a fundamental operation in scientific computing, game development, AI, and numerous high-performance applications. While its mathematical definition is simple, achieving optimal performance in C++ is far from trivial.

In this talk, we will explore different optimization techniques for matrix multiplication, from naive implementations to highly tuned versions leveraging modern hardware features. We will cover key performance-enhancing strategies such as loop unrolling, cache blocking, SIMD vectorization, parallelization using threads and more. Through benchmarking and profiling, we will measure the real impact of these optimizations.

By the end of this session, attendees will gain insights into two critical questions:

How hard is it to implement an optimized matrix multiplication in C++? How effective is C++ for achieving peak performance in this task?

This talk is suitable for developers interested in performance optimization, computational efficiency, and modern C++ techniques for numerical computing.

Practical Reflection With C++26

by Barry Revzin

Summary of the talk:

With the adoption of Reflection for C++26, the landscape of what is possible has shifted. This talk will focus on implementing Struct-of-Arrays for an arbitrary aggregate, but will also take some detours to cover some techniques that will prove useful for solving a wide range of problems.

A Brief History of Bjarne Stroustrup, the Creator of C++

by CultRepo

Watch now:

<iframe width="560" height="315" src="https://www.youtube.com/embed/uDtvEsv730Y?si=QD_WmemwpsAfNsVI" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

Threads vs Coroutines: Why C++ Has Two Concurrency Models

by Conor Spilsbury

Summary of the talk:

The C++11 standard introduced a powerful set of tools for concurrency such as threads, mutexes, condition variables, and futures. More recently, C++20 introduced another powerful but fundamentally different concurrency abstraction in the form of coroutines. But coroutines are not just an evolution or a replacement for threads. Instead, they each solve different problems in different ways. Choosing the right tool for the job requires understanding how each works under the hood and where they shine. This talk will help build that intuition by looking at how each interacts with the operating system and hardware which will help make better decisions when choosing which to use.

We'll explore how threads and synchronization primitives work at the operating-system and hardware level, from thread creation and scheduling to where context switching and synchronization introduce performance costs. We’ll then contrast this to the coroutine model introduced in C++20 which takes a fundamentally different approach by using a cooperative model based on the suspension and resumption of work.

Given this understanding, we’ll finish by applying this intuition to a set of real-world scenarios to identify whether threads or coroutines are a better fit for the problem at hand.

CppCon 2025 More Speed & Simplicity: Practical Data-Oriented Design in C++

by Vittorio Romeo

Summary of the talk:

Data-Oriented Design (DOD) presents a different way of thinking: prioritizing data layout not only unlocks significant performance gains via cache efficiency but can also lead to surprising simplicity in the code that actually processes the data.

This talk is a practical introduction for C++ developers familiar with OOP. Through a step-by-step refactoring of a conventional OOP design, we’ll both cover how data access patterns influence speed and how a data-first approach can clarify intent.

We’ll measure the performance impact with benchmarks and analyze how the refactored code, particularly the data processing loops, can become more direct and conceptually simpler.

Key techniques like Structure-of-Arrays (SoA) vs. Array-of-Structures (AoS) will be explained and benchmarked, considering their effects on both execution time and code clarity. We’ll pragmatically weigh the strengths (performance, simpler data logic) and weaknesses of DOD, highlighting how it can complement, not just replace, OOP.

We’ll also demonstrate that DOD doesn’t necessitate abandoning robust abstractions, showcasing C++ techniques for creating safe, expressive APIs that manage both complexity and performance.

Let’s learn how thinking “data-first” can make your C++ code faster and easier to reason about!

Range adaptors - 5 years after C++20

by Hannes Hauswedell

Watch now:

<iframe allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen="" frameborder="0" height="315" referrerpolicy="strict-origin-when-cross-origin" src="https://www.youtube-nocookie.com/embed/nficAvk5RA4?si=w86EVk7oX89uVcPg" title="YouTube video player" width="560"></iframe>

Templates and metaprogramming considered as the big bad wolf of C++, and it’s time to stop being scared of this wolf, as it’s one of the most powerful creatures of C++.

Talk: Who’s Afraid of the Big Bad Template

by Coral Kashri

From the description:

In this talk I’ve demonstrated the power of this incredible creature, while I hope that this talk would be an easy enterence to this concept (pan intended), and to help you developing the anticipation to walk into the cave of metaprogramming.

The talk was give on Core C++ 2025.

Templates and metaprogramming considered as the big bad wolf of C++, and it’s time to stop being scared of this wolf, as it’s one of the most powerful creatures of C++.

Talk: Who’s Afraid of the Big Bad Template

by Coral Kashri

From the description:

In this talk I’ve demonstrated the power of this incredible creature, while I hope that this talk would be an easy enterence to this concept (pan intended), and to help you developing the anticipation to walk into the cave of metaprogramming.

The talk was give on Core C++ 2025.

A little Introduction to Control Flow Integrity - James McNellis - Keynote Meeting C++ 2025

by James McNellis

Watch the video:

Software and Safety - Anthony Williams - Keynote Meeting C++ 2025

by Anthony Williams

Watch now:

To lie, and hopefully - to lie usefully - Patrice Roy - Meeting C++ 2025

by Patrice Roy

The Code is Documentation Enough - Tina Ulbrich - Meeting C++ 2025

by Tina Ulbrich

Watch now:

Explore the Doom C Codebase in VS Code | Learn to Navigate Complex C and C++ Code on Linux

by Greg Law

From the description:

Using the classic Doom C program on Linux as our real-world example, we trace the exact moment a zombie is killed and backtrack through the codebase to understand how it happened [..] using Undo’s Time Travel Debugging technology.

C++ in Embedded Systems Interview with Author Amar Mahmutbegović

by Jens Weller

Watch the video

Lightning Talk: The UB Detector: constexpr

by Andreas Fertig

Summary of the talk:

A constexpr function evaluated at compile time is free of any undefined behaviour they say. Do you think that statement is true as well?

Modern C++ Error Handling

by Phil Nash

Summary of the talk:

We’ve had exceptions in C++ since before the first standard. C++17 introduced std::optional and C++23 std::expected (along with the so-called Monadic Operations for both types).

What should we use and when?

Meanwhile we still have older approaches, such as boolean or error code returns, as well as global or thread local error status or pointer or reference arguments.

Do these still have a place?

And where does assert fit in? And the (hopefully) upcoming contracts?

Perhaps more importantly, once we’ve examined all the trade-offs, can we defer any of those decisions to when we are best positioned to commit to them?

Erroneous conditions can have a big impact on your code’s safety and security, so error handling shouldn’t just be left to the “exercise left for the reader” in the books we used to read. Let’s get this all straight.

Lightning Talk: How Far Should You Indent Your Code? - The Number Of The Counting

by Dave Steffen

Summary of the talk:

Coding Standards have to say something about how we indent our code.  Is there a definitive answer?

Guide to Linear Algebra With the Eigen C++ Library

by Daniel Hanson

Summary of the talk:

Linear algebra is an essential part of scientific programming, particularly in domains such as quantitative finance, data science, physics, and medical research.  It is also relevant to imaging in game development.  As C++ did not have all the convenient built-in multidimensional array capabilities and supporting libraries that came with typical Fortran platforms, scientific programmers making the transition to C++ back in the late 1990’s and early 2000's often found themselves in an inconvenient situation with limited options.  These included building up this functionality mostly from scratch, wrestling with interfaces to numerical Fortran libraries such as BLAS and LAPACK, or somehow convincing management to invest in a third-party commercial C++ linear algebra library.

The situation has improved substantially over the years with the development of several well-regarded open-source linear algebra libraries for C++.  One in particular that has become popular, first released in 2006, is the Eigen library.  It has been adopted for use within both the TensorFlow machine learning library and the Stan Math Library, as well as at CERN, and it can also be found in the implementation of high-performance quantitative trading strategies in C++.

In this talk, we will examine the setup and basics of the Eigen library, followed by a discussion of some of its more advanced features, including applications of matrix decompositions frequently used in quantitative work, as well as its compatibility with STL algorithms.  It will conclude with an overview of how it can be used within the context of the C++26 BLAS interface proposal (P1673), via an interface with std::mdspan now available in C++23.