: Standard C++

Home »

« Prev Next »

CppCon 2025 Why Every C++ Game Developer Should Learn SDL 3 Now -- Mike Shah

By Blog Staff | Apr 15, 2026 12:30 PM | Tags: None

Registration is now open for CppCon 2026! The conference starts on September 12 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2026!

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.

Announcement: cppreference.com update

By Herb Sutter | Apr 14, 2026 03:35 PM | Tags: None

cppreference.com is the premier public reference site for documenting and tracking the C++ language. It is run by Nate Kohl, with the help of many volunteer wiki editors. I want to thank Nate and all the volunteers for making it such an enduringly valuable resource.

Like all software, the site requires maintenance. It has been in read-only mode for some time while Nate has been leading the work to migrate it to MediaWiki. Because the Standard C++ Foundation's web wizard, James Riordon, recently migrated the ISO C++ committee wiki (now also maintained by the Foundation) to MediaWiki, I asked Nate whether the Foundation and James could help. Nate accepted our offer, and thanks to Nate and James's work, cppreference is now almost ready to return to normal read-write operation.

To help keep the site running smoothly going forward, the Foundation plans to continue providing hosting and administrative support for the site's infrastructure, including future MediaWiki and related updates. That should let Nate stay focused on leading the site's content and coordinating the volunteer editors who keep cppreference current.

We expect the refreshed site, including support for all languages, to return to read-write mode later this month. Fingers crossed. My thanks again to Nate, James, and everyone who has helped make cppreference the indispensable reference it is today, and to everyone for their patience while this necessary maintenance has been underway.

Cheers,

Herb

using std::cpp 2026: Cross-Platform C++ AI Development with Conan, CMake, and CUDA

By jdgarcia | Apr 14, 2026 01:58 PM | Tags: None

Cross-Platform C++ AI Development with Conan, CMake, and CUDA

by Luis Caro Campos

From the talk at using std::cpp 2026:

Every year, the ISO C++ survey delivers the same verdict: dependency management is the #1 pain point for developers. For AI and machine learning development, introducing CUDA into the mix can cause that "pain point" to become a bigger bottleneck when developers these days are demanding “one-line, cross-platform” solutions.

This talk demonstrates how to use Conan and CMake to model the CUDA compatibility matrix directly in your code, achieving an ideal pipeline that works both on development machines, and CI, regardless of your target platform: One source checkout. One command. Identical builds on every platform.

CppCon 2025 Implementing Your Own C++ Atomics -- Ben Saks

By Blog Staff | Apr 14, 2026 09:23 AM | Tags: None

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.

Power of C++26 Reflection: Strong (opaque) type definitions -- r/cpp

By Blog Staff | Apr 9, 2026 02:35 PM | Tags: None

Inspired by a similar previous thread showcasing cool uses for C++26 reflection.

Power of C++26 Reflection: Strong (opaque) type definitions

From the article:

With reflection, you can easily create "opaque" type definitions, i.e "strong types". It works by having an inner value stored, and wrapping over all public member functions.

Note: I am using queue_injection { ... } with the EDG experimental reflection, which afaik wasn't actually integrated into the C++26 standard, but without it you would simply need two build stages for codegen. This is also just a proof of concept, some features aren't fully developed (e.g aggregate initialization)
struct Item { /* ... */ }; // name, price as methods

struct FoodItem;
struct BookItem;
struct MovieItem;

consteval { 
    make_strong_typedef(^^FoodItem, ^^Item); 
    make_strong_typedef(^^BookItem, ^^Item); 
    make_strong_typedef(^^MovieItem, ^^Item); 
}

// Fully distinct types
void display(FoodItem &i) {
    std::cout << "Food: " << i.name() << ", " << i.price() << std::endl;
}
void display(BookItem &i) {
    std::cout << "Book: " << i.name() << ", " << i.price() << std::endl;
}

int main() {
    FoodItem fi("apple", 10); // works if Item constructor isn't marked explicit
    FoodItem fi_conversion(Item{"chocolate", 5}); // otherwise
    BookItem bi("the art of war", 20);
    MovieItem mi("interstellar", 25);

    display(fi);
    display(bi);
    // display(Item{"hello", 1}); // incorrect, missing display(Item&) function
    // display(mi); // incorrect, missing display(MovieItem&) function
}

CppCon 2025 Back to Basics: Custom Allocators Explained - From Basics to Advanced -- Kevin Carpenter

By Blog Staff | Apr 7, 2026 10:16 AM | Tags: None

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.

CppCon 2025 Cache Me Maybe: The Performance Secret Every C++ Developer Needs -- Michelle D'Souza

By Blog Staff | Apr 3, 2026 10:14 AM | Tags: None

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!

std::vector — Four Mechanisms Behind Every push_back() -- Gracjan Olbinski

By Gracjan Olbinski | Apr 2, 2026 04:47 PM | Tags: None

A walkthrough of four mechanisms working behind every push_back() call — exponential growth and amortized O(1), the growth factor's effect on memory reuse, cache performance from contiguity, and the silent noexcept trap in move semantics during reallocation.

std::vector — Four Mechanisms Behind Every push_back()

by Gracjan Olbinski

From the article:

"You call push_back() a thousand times. The vector reallocates about ten. Behind that simple interface, four mechanisms are working together — each one invisible during normal use, each one shaping your performance in ways that push_back() will never tell you about."

CppCon 25 Matrix Multiplication Deep Dive || Cache Blocking, SIMD & Parallelization -- Aliaksei Sala

By Blog Staff | Mar 31, 2026 10:10 AM | Tags: None

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.

The hidden compile-time cost of C++26 reflection -- Vittorio Romeo

By Vittorio Romeo | Mar 30, 2026 06:18 PM | Tags: None

How much does C++26 Reflection actually cost your build?

In this article, we'll perform some early compilation time benchmarks of one of the most awaited C++26 features.

The hidden compile-time cost of C++26 reflection

by Vittorio Romeo

From the article:

Fast compilation times are extremely valuable to keep iteration times low, productivity and motivation high, and to quickly see the impact of your changes.

I would love to see a world where C++26 reflection is as close as possible to a lightweight language feature [...]

So, I decided to take some early measurements.