: Standard C++

Home »

« Prev Next »

C++: The Documentary trailer

By Blog Staff | May 14, 2026 08:00 AM | Tags: None

Sponsored by HRT and produced by CultRepo, we're pleased to share the official trailer for C++: The Documentary.

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.

CppCon 2025 Crafting the Code You Don’t Write: Sculpting Software in an AI World -- Daisy Hollman

By Blog Staff | May 13, 2026 02:35 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!

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.

Evolving a Translation System with Reflection in C++

By Blog Staff | May 12, 2026 03:39 PM | Tags: None

A nice example of C++26 reflection moving from theory into something practical.

Evolving a Translation System with Reflection in C++

By GitHub user: friedkeenan

From the post:

Lately, I’ve been using C++26 reflection to create some crazy and cursed stuff. But even though I quite enjoy that work, it is as well quite far from the norm of what reflection is going to offer us in our everyday code.

Reflection is definitely not just that craziness, and so I want to present reflection in a more grounded environment, and in a way that will probably land as more typical usage as our codebases gradually come into contact with it.

So then, in this blogpost, I will be exploring a spectrum of options for how reflection can upgrade a translation system that I already use in one of my projects. We’ll look at where it’s at now without reflection, identify places in which reflection could plausibly help, and then explore a series of modifications we could make to soothe those problem points.

The purpose of looking at each of these options will not be to declare that one is clearly the best option or the one that makes the most sense, but rather to get a better feel for what could make sense to do, and whether some things are really worth the effort. We’re trying to gauge the benefits that reflection can bring to our code.

And who knows, even if one option is less appealing for this particular situation, maybe in a different situation it could be the perfect fit.

CppCon 2025 Reflection: C++’s Decade-Defining Rocket Engine -- Herb Sutter

By Blog Staff | May 11, 2026 02:32 PM | Tags: None

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.

CppCon 2025 Back to Basics: Move Semantics -- Ben Saks

By Blog Staff | May 7, 2026 02:30 PM | Tags: None

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.

The ACCU on Sea 2026 Schedule is Now Announced -- ACCU

By Phil Nash | May 7, 2026 11:39 AM | Tags: community

C++ on Sea and the ACCU Conference combine, this, year for one big festival of C++ by the sea!

The 2026 Schedule is Here!

by ACCU

From the article:

Four days, five tracks, and a lineup that spans the full breadth of what ACCU on Sea is about: deep C++ content, broader software craft, and the kind of talks that make you rethink something you thought you understood.

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

By Blog Staff | May 6, 2026 03:34 PM | Tags: None

The next C++ standard (C++26) is getting exciting new features. One of these features is compile-time reflection. It is ideally suited to serialize and deserialize data at high speed. To test it out, we extended our fast JSON library (simdjson) and we gave a talk at CppCon 2025. The video is out on YouTube.

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

by Daniel Lemire

Watch now:

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

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

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

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