Home »

CppCon 2025 Beyond Sequential Consistency: Unlocking Hidden Performance Gains -- Christopher Fretz

By Blog Staff | May 5, 2026 02:27 PM | Tags: None

sequential-fretz.pngRegistration 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!

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.

C++26: A User-Friendly assert() macro -- Sandor Dargo

By Blog Staff | May 4, 2026 03:30 PM | Tags: None

SANDOR_DARGO_ROUND.JPGC++26 is bringing some long-overdue changes to assert(). But why are those changes needed? And when do we actually use assert, anyway?

At its core, assert() exists to validate runtime conditions. If the given expression evaluates to false, the program aborts. I’m almost certain you’ve used it before — at work, in personal projects, or at the very least in examples and code snippets.

So what’s the problem?

C++26: A User-Friendly assert() macro

by Sandor Dargo

From the article:

assert() is a macro — and a slightly sneaky one at that. Its name is written in lowercase, so it doesn’t follow the usual SCREAMING_SNAKE_CASE convention we associate with macros. There’s a good chance you’ve been using it for years without ever thinking about its macro nature.

Macros, of course, aren’t particularly popular among modern C++ developers. But the issue here isn’t the usual - but valid - “macros are evil” argument. The real problem is more specific:

The preprocessor only understands parentheses for grouping. It does not understand other C++ syntax such as template angle brackets or brace-initialization.

As a result, several otherwise perfectly valid-looking assertions fail to compile:

// https://godbolt.org/z/9sqM7PvWh
using Int = int;
int x = 1, y = 2;

assert(std::is_same<int, Int>::value);
assert([x, y]() { return x < y; }() == 1);
assert(std::vector<int>{1, 2, 3}.size() == 3);
 

 

Results summary: 2026 Annual C++ Developer Survey "Lite"

By Blog Staff | May 4, 2026 02:03 PM | Tags: None

Thank you to everyone who reponded to our 2026 annual global C++ developer survey. As promised, here is a summary of the results, including one-page summaries of your answers to the free-form questions:

CppDevSurvey-2026-summary.pdf

A 145-page version of this report that also includes all individual write-in responses has now been forwarded to the C++ standards committee and C++ product vendors, to help inform C++ evolution and tooling.

Your feedback is valuable, and appreciated.

GCC 16.1 released: C++26 reflection / contracts / safety hardening, C++20 by default, and more!

By Blog Staff | Apr 30, 2026 03:35 PM | Tags: None

GCC 16.1 has been released! Lots of good C++26 material including reflection and contracts.

GCC 16 Release Series: Changes, New Features, and Fixes

From the announcement:

  • C++20 by default: [...] N.B. C++20 modules support is still experimental and must be enabled by -fmodules.
  • Improved experimental C++20 modules support:
    • New command line option --compile-std-module that conveniently builds the <bits/stdc++.h> header unit and the std and std.compat modules before compiling any source files explicitly specified on the command line.
    • Whenever the <bits/stdc++.h> header unit has been built, GCC now transparently translates an #include of any importable standard library header into an import of <bits/stdc++.h>.
    • Many reported bugs have been fixed, thanks to Nathaniel Shead.
    • [...]

Runtime Library (libstdc++)

  • [...]
  • Improved experimental support for [...]
    • std::mdspan, thanks to Luc Grosheintz.
    • [...]
    • std::simd.
    • std::inplace_vector.
    • [...]

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

By Marc Gregoire | Apr 29, 2026 06:39 AM | Tags: c++26 becppsymposium2026 becpp

BeCPP Symposium 2026 (organized by BeCPP): Now on YouTube!

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.

 

Glaze 7.2 - C++26 Reflection | YAML, CBOR, MessagePack, TOML and more

By Blog Staff | Apr 28, 2026 03:24 PM | Tags: None

Glaze is a high-performance C++23 serialization library with compile-time reflection. It has grown to support many more formats and features, and in v7.2.0 C++26 Reflection support has been merged!

Glaze 7.2 - C++26 Reflection | YAML, CBOR, MessagePack, TOML and more

From the article:

Glaze now supports C++26 reflection with experimental GCC and Clang compilers. GCC 16 will soon be released with this support. When enabled, Glaze replaces the traditional __PRETTY_FUNCTION__ parsing and structured binding tricks with proper compile-time reflection primitives (std::meta).

The API doesn't change at all. You just get much more powerful automatic reflection that still works with Glaze overrides! Glaze was designed with automatic reflection in mind and still lets you customize reflection metadata using glz::meta on top of what std::meta provides via defaults.

CppCon 2025 The Wonderful World of Designing a USB Stack Using Modern C++ -- Madeline Schneider

By Blog Staff | Apr 27, 2026 02:24 PM | Tags: None

usbstack-schneider.pngRegistration 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!

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.

BeCPP Symposium 2026 - Herb Sutter - C++ Growing in a world of competition, safety, and AI

By Marc Gregoire | Apr 26, 2026 06:17 AM | Tags: c++26 becppsymposium2026 becpp

BeCPP Symposium 2026 (organized by BeCPP): Now on YouTube!

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

 

CppCon 2025 Can Standard C++ Replace CUDA for GPU Acceleration? -- Elmar Westphal

By Blog Staff | Apr 23, 2026 02:22 PM | Tags: None

cuda-westphal.pngRegistration 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!

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.