#news
86 posts tagged #news.
What C++23 and C++26 promise about a moved-from function wrapper
None of the standard function wrappers promises an empty source after a move: std::function, move_only_function and copyable_function all leave it valid but unspecified. libstdc++ 16.1 empties all three, libc++ trunk keeps a copy in std::function and does not ship the other two. A small wrapper that states its own move works on both.
Portable SIMD is in C++26, and you can try it now
C++26 adds <simd>, a portable vector type that compiles to SSE, AVX, or NEON without a single intrinsic. GCC 16.1 does not ship the standard header yet, but the experimental version it grew from works today, and the programming model is the same: declare a vector, use the arithmetic operators, let the library pick the width.
Read what the EU CRA reporting rules say, now that they apply
Reporting of actively exploited vulnerabilities and severe incidents under the EU Cyber Resilience Act has applied since 11 September 2026. This post quotes the 24 hour, 72 hour and final report deadlines from Article 14, says what the text says about open-source software stewards, and reads the Declaration of Conformity that Qt ships with commercial Qt 6.12 LTS. It is not legal advice.
Two dates for the pre-Búzios mailing, Búzios 16 November, and GCC 17 stage 3 the same day
The Búzios agenda lists the pre-Búzios mailing on 19 October and the WG21 home page says 23 October. The meeting opens on 16 November, and GCC 17 stops accepting new features on that same Monday. Read from the primary pages on 6 and 10 October.
Hand a task to another thread without leaving a copy behind
Two ways to stop a std::function from leaving a copy behind when it crosses to another thread: empty the source with an exchange, or box the task in a shared_ptr at the entry point. In a demo on libc++, the plain by-value chain destroys the task on the sending thread and both fixes destroy it on the worker.
simdjson 5.0 reads a struct from JSON keys in any order
simdjson 5.0.0 (28 Sep 2026) lists static reflection as an officially supported feature. A struct with a string, an int, a bool, a nested struct and a vector read from JSON with shuffled keys on GCC 16.2 and simdjson 5.0.2, and an integer of exactly 2^64 is now a big integer. The 1.8x speedup in the release notes covers parsing escaped Unicode.
libstdc++ on GCC trunk rejects a pair that binds a temporary
On GCC trunk, building a std::pair or std::tuple whose reference member binds to a temporary is an error from C++11 to C++26. GCC 16.2 rejects it only from C++20 on. The same weeks brought a libstdc++ fix for CVE-2026-102010, now on the GCC 14, 15 and 16 branches, and a std::bitset fix that is on trunk only. Compiler Explorer runs show 16.2 and trunk side by side.
C++26 removes the initializer_list constructor of std::span
With the initializer_list constructor that C++26 had added, std::span<const bool> s{ptr, n} builds a two-element span of bools, and GCC 15 compiles it with a warning. P4144R1 removes the constructor, the 2026-03 LWG motion put that into the C++ working draft, and libstdc++ 16 and libc++ 23 no longer have it. Compiler Explorer runs show each library side by side.
C++26 lets you throw and catch at compile time
Until now a throw inside a constant expression was an immediate compile error, which forced constexpr code to report failure some other way. C++26 allows exceptions during constant evaluation: a throw that gets caught in the same evaluation is fine, and only an uncaught one fails the build. GCC 16.1 runs it today.
GCC trunk accepts a coroutine promise with return_value and return_void
GCC 16.2 rejects a coroutine promise type that declares both return_value and return_void. GCC trunk accepted it from 3 October 2026, implementing P3950R1 as a defect report, and now reports __cpp_impl_coroutine as 202606L. The same program on Compiler Explorer shows both results.
std::optional can finally hold a reference
std::optional<T&> was ill-formed for fourteen years, so everyone used a raw pointer and wrote a comment explaining that null means absent. C++26 makes it legal: rebinding assignment, no allocation, and a value type you can return. It compiles and runs on GCC 16.1 today, though libstdc++ has not yet set the feature-test macro.
std::function_ref borrows a callable instead of owning it
C++26 adds std::function_ref, the non-owning counterpart to std::function. It is the right parameter type for a callback you will invoke but not store: it copies nothing, allocates nothing, and binds equally to a capturing lambda or a plain function. It is to std::function what string_view is to string.
A moved-from std::function can still hold the callable
The standard leaves a moved-from std::function valid but unspecified. libc++ keeps a copy of a small callable in the source, libstdc++ empties it. A Qt HarmonyOS bug filed on 2026-10-12 shows the cost: a task queued to another thread was destroyed on the thread that sent it.
You cannot move out of a priority_queue without a const_cast
priority_queue::top() returns a const reference, so a move-only element cannot be taken out of the queue at all: the copy constructor is selected and the code does not compile. The accepted workaround is a const_cast immediately followed by pop(), which is safe for one specific reason worth understanding before you write it.
Three September 2026 WG21 papers return to the C++26 contracts dispute
The September 2026 WG21 mailing carries P4238R1, P4272R0 and P4381R0, three papers about the C++26 contracts feature and how it was reviewed. This post says who wrote each, when, and what it asks. Corrected on 10 October 2026: the ISO ballot closes around 23 October, not 27 September.
EDG's C++ front end is open source, and Compiler Explorer builds it with reflection
The EDG C++ front end went open source on 30 September under the Apache 2.0 licence with LLVM exceptions, with the C++ Alliance as fiscal sponsor. Compiler Explorer added EDG 7.0 and trunk builds with P2996 reflection switched on the same day. One struct-walking snippet gives the same output on EDG, GCC 16.2 and clang-p2996 apart from one type spelling, and EDG rejects template for.
views::concat iterates several containers as one range
C++26 adds std::views::concat, a view that presents several ranges as a single sequence without copying any of them. The containers can be different types holding the same elements, the result composes with every other adaptor, and GCC 16.1 ships it today.
The hardened standard library turns an out-of-bounds read into a stop
GCC checks an out-of-bounds vector::operator[] at -O0 and stops checking at -O2, so the build you debug is guarded and the build you ship is not. One macro carries the check into the optimised build: -D_GLIBCXX_ASSERTIONS for libstdc++, _LIBCPP_HARDENING_MODE for libc++, _MSVC_STL_HARDENING for the MSVC STL. Google has reported this class of hardening cut its production segfault rate by about a third.
Four range views headed for the standard library
The 2026-07 mailing adds a concentrated wave of range adaptors: views::unique for adjacent duplicates, views::take_last and views::drop_last for tail slicing, and views::cycle for endless repetition. None ship yet, so the demo is what you write today to get the same results, which is exactly the boilerplate each proposal collapses into one named view.
std::array became compile-time in pieces, and the algorithms went last
std::array's own members have been constexpr since C++17, but sorting one at compile time only became possible in C++20, when the algorithms caught up. That two-standard gap is why older lookup-table code hand-rolls its sorting. Here is a table built, squared and sorted entirely during compilation.
Humble Bundle sells 21 Packt C++ ebooks for €16.35 until 12 October
Humble Bundle's C++ Programming Masterclass sells 21 Packt ebooks, DRM-free in PDF and EPUB. The floor is €4.53 for three books, €13.62 unlocks seven, and €16.35 unlocks all 21. Part of each purchase goes to The Global FoodBanking Network. It ends on 12 October at 18:00 UTC. The strongest titles are by Fedor Pikus, Marius Bancila, and Patrice Roy with Michael Wong; most target C++20 or C++23, one is about C and one about Rust.
When two enumerators share a value, the value carries both names
With red = 1 and green = 1, a reflection-based enum_to_string(green) returns "red", because once the value is in a variable nothing distinguishes the two. C++26 reflection can list every name for a value, reject duplicates at compile time with std::meta::exception, prefer a canonical spelling through an annotation, and keep the exact name when you reflect the enumerator itself. The names come back as string_views over static storage, so none of this allocates.
228 of 2,613 tracked C++ projects now ship a module
The arewemodulesyet tracker lists 228 projects with a C++20 module, up from 62 in November 2025. That is 8.7% of the 2,613 it follows, and a tick means a module exists, not that it is on: two of three well-known entries keep it behind a build option that defaults to off. A single-file import std; builds on Compiler Explorer only with GCC 16 and one extra flag.
Four CppCon 2026 keynotes are already free to watch
CppCon 2026 closed on Friday and four keynotes are already on YouTube as unlisted prerelease links, including the first panel keynote the conference has run. The rest of the programme sits in paid Early Video Access for at least 30 days before the free drip to YouTube begins, one Main Program talk per business day.
Boost and Abseil start deleting their C++14 shims
Two release notes nine days apart point the same way. Boost 1.92 tells Heap and Lockfree users that C++14 support ends here, and Abseil's August LTS deprecates absl::void_t in favour of the standard one. Both are removing code that only ever existed because C++17 was not yet safe to assume.
C++29 mode is open, and the compilers already disagree
LLVM 23.1 shipped with -std=c++2d, a mode for the standard after C++26, and GCC trunk has one too. Both report __cplusplus as 202700. They do not agree about C++26 itself: GCC says 202603, which is the ratified value, and clang still says 202400.
Meeting C++ 2026 lands in Berlin with a units-library keynote
Meeting C++ 2026 runs 26 to 28 November in Berlin, hybrid as always. Two keynotes are announced so far: Mateusz Pusz, author of the mp-units library now on its way into the standard, and Kate Gregory. For anyone following the quantities-and-units work, the library's author opening the main European C++ conference is worth a note in the calendar.
LLVM 23.1 shipped, and one of its changes is silent
Clang 23.1 landed on 25 August with partial expansion statements, modules dependency discovery, and a batch of core-issue fixes. It also elides more dead stores than 22 did, which is the one change that alters behaviour without saying anything at build time.
A C++26 structured binding that GCC and Clang disagree about
C++26 lets a structured binding declaration be the condition of an if. GCC 16.1 and Clang 22.1 both implement it and both agree on ordinary structs. Put a tuple-protocol type in the condition and evaluate it at compile time, and GCC rejects the program while Clang accepts it. The reproducer is twenty lines and needs no library.
The August 2026 C++ mailing, and the fight over contracts
Forty-eight papers, and a dozen of them are the same argument. Bjarne Stroustrup and four co-authors want the C++26 contracts design replaced before the final ballot, the P2900 authors have answered, and the committee already voted once against removal. Plus profiles, a reflection paper from Barry Revzin, and the usual crop of ranges additions.
Clang's lifetimebound warns about a copy, and that is the problem
The lifetimebound attribute lets -Wdangling see through a function call, which is how clang catches a string_view into a temporary. It has no conditional form, so a function that returns a copy on some instantiations and a reference on others has to pick between missing real dangles and warning about correct code. A proposal on the LLVM forum wants to close that gap.
C++26 contracts, and the const rule the compiler makes you learn
Contracts are one of the four headline C++26 features and they run on GCC 16.1 today. Two things surprise people on first contact: a by-value parameter named in a postcondition must be const, and what a violation actually does is a compiler flag rather than a property of your code.
GCC 16.2 is out, LLVM 23.1 is nearly there, MSVC is still finishing C++23
GCC 16.2 shipped on 7 August with more than a hundred regression fixes and no new features. LLVM 23.1 reached its third release candidate on 12 August and has not shipped. MSVC has no C++26 date. If you want to write C++26 today, the practical answer remains GCC, and this is where each toolchain actually stands.
std::constant_wrapper carries a compile-time value as an argument
A template parameter is a compile-time value you cannot pass as an argument. A function argument is a runtime value you cannot use as a template parameter. C++26's std::constant_wrapper is an empty object that carries a compile-time value, so it crosses that line: arithmetic on it stays constant, and the result still works as an array extent. GCC 16.1 ships it.
Carbon is still pre-0.1, with 1.0 somewhere after 2028
Carbon gets discussed as though it were an option you could evaluate. It is not one yet: the project has not reached 0.1, its own roadmap puts that at late 2026 at the earliest and 1.0 sometime after 2028, and it says so plainly. Reading the roadmap is a better use of ten minutes than another Carbon-versus-Rust argument.
Pattern matching did not make C++26
Enough people assumed pattern matching shipped in C++26 that it is worth stating plainly: it did not. P2688 missed the feature freeze and is now aimed at C++29, no shipping compiler implements it, and until then std::visit with an overload set remains the idiom. Here is what the proposal would actually give you.
{fmt} can do the whole format at compile time
FMT_COMPILE parses the format string during compilation and emits straight-line formatting code, so a format call can be a constant expression with no parsing at runtime. The 12.2 release adds a type-safe C API, a proper C++20 module target, and turns the full Dragonbox cache on by default for faster float formatting.
CppCon 2026 is onsite only, and Stroustrup opens it
CppCon runs 12 to 18 September in Aurora, Colorado, and this year there is no online track. Sessions are recorded and posted to YouTube afterwards, but nothing is streamed live, so remote attendance is not an option. Bjarne Stroustrup gives the Monday opening keynote.
Converting between std::function and copyable_function nests them
std::function and std::copyable_function are both type-erased callable wrappers and neither recognises the other. Converting between them does not unwrap and rewrap the lambda inside; it wraps the whole previous wrapper. Round-trip in a loop and every call walks a chain of indirections. In this run, 200 round trips made the same calls several hundred times slower.
std::indirect makes PImpl copyable without writing a copy constructor
PImpl with unique_ptr costs you the special members: hand-written copy operations, a destructor defined where Impl is complete, and const that stops at the pointer. C++26's std::indirect is an indirect value instead of an owning pointer, so it copies deeply and propagates const, and all five special members can be defaulted. GCC 16.1 ships it.
Two compilers, one float-to-int cast, two different wrong answers
Converting a float to an int is undefined behavior when the value does not fit, and for NaN. Nothing warns by default, and GCC and Clang produce different results for the same cast. Worse, GCC deliberately leaves the check out of -fsanitize=undefined, so you have to name float-cast-overflow to catch it.
Chrome fixed 1,072 security bugs in two releases and 97% of its code is span-clean
Chrome 149 and 150 fixed more security bugs than the previous 23 milestones combined, and 97% of first-party Chrome code now compiles cleanly under strict unsafe-buffer warnings. The strategy is worth reading closely: harden C++ aggressively, migrate selectively, and admit openly that runtime mitigations are approaching diminishing returns.
GCC will decline AI-generated contributions above the legal threshold
The GCC Steering Committee has adopted a policy declining any legally significant contribution that includes or is derived from LLM-generated content. Test cases are an explicit exception, small contributions are allowed if clearly marked, and using a model to find bugs or review patches stays permitted. Commits that had AI help need an Assisted-by tag, and only humans may submit or sign off.
std::mdspan views one flat buffer as a matrix
std::mdspan is C++23's non-owning multidimensional view. It separates storage (a flat buffer you already have) from shape (extents) from indexing (a layout), so one std::vector becomes a 3x4 matrix with real m[r, c] indexing and no copy. GCC 16.1 ships it, and Mark Hoemmen's C++Now 2026 keynote is on where it and standard parallelism go next.
std::inplace_vector is a vector that never touches the heap
C++26 adds std::inplace_vector<T, N>, a sequence container with a fixed compile-time capacity whose storage lives inside the object. It gives you a vector's dynamic size and push_back with zero heap allocation, which is exactly what embedded, real-time, and hot-path code has been hand-rolling for decades. GCC 16.1 ships it now.
A new proposal deletes your enum bitmask boilerplate
Every C++ codebase that uses a scoped enum as a flag set writes the same eight operator overloads by hand, just to get |, &, and ~ back. P4313 in the 2026-07 mailing proposes an opt-in attribute, enum class [[std::bitmask_type]], that generates all of it and keeps each bitmask a distinct type. Here is the boilerplate it removes, running today.
Google Benchmark runs live on Compiler Explorer
You do not need a local build to run a real microbenchmark. Add the benchmark library on Compiler Explorer, turn on execution, and Google Benchmark prints its timing table in the output pane. The demo is also the first lesson every microbenchmark teaches: without benchmark::DoNotOptimize the compiler deletes the loop you are trying to measure and reports a time near zero.
The sanitizers run live on Compiler Explorer
AddressSanitizer, UndefinedBehaviorSanitizer, and ThreadSanitizer all run in Compiler Explorer's execution pane. Add one -fsanitize flag, turn on execution, and the runtime report prints in the browser: the faulting line, the allocation site, the shadow-byte map, both racing stacks. There is no cheaper way to show a colleague exactly why a bug is a bug.
std::flat_map is just two vectors
C++23's std::flat_map is an adaptor over a sorted vector of keys and a parallel vector of values. That buys cache-friendly lookups and near-zero memory overhead, and costs O(n) insertion and aggressive iterator invalidation. It replaces std::map, not std::unordered_map, and knowing which vector trick it is tells you exactly when to reach for it.
The syscall behind C++ asymmetric fences
Asymmetric fences let you pay for a memory barrier only on the rare path. The common path gets a free compiler barrier; the uncommon path calls Linux membarrier(), which forces every other thread to run a full fence for you. Ryan Chung Yi Sheng's deep-dive follows the idea from the C++ standard down to the kernel, and finds a possible crack in the wording along the way.
Less standard library, faster program
Jussi Pakkanen (creator of Meson) rewrote a subset of the C++ standard library from scratch, dropping ISO conformance to chase compile speed. Converting his real CapyPDF library to it cut compile time ~80% and binary size ~75%, and made the program ~25% faster, with no runtime penalty for the faster build.
One word, final, turns a virtual call into two instructions
A C++ Weekly episode reminded everyone of a free win: marking a class final lets the compiler devirtualize. We took the canonical example to GCC 16.1 at -O2 and read the actual assembly. Without final, GCC hedges with a runtime vtable check; with final, the whole call folds to mov eax, 42; ret. The asm is the proof.
Three small C++26 string fixes you will use every day
C++26 quietly closes three long-standing paper cuts in the string library: you can finally write string + string_view, build a stringstream straight from a string_view, and construct a bitset from a view without a temporary. None of them are flashy, all of them remove a copy or a conversion you have been writing for years. Verified on GCC 16.1 and clang-p2996.
How the C++ community is actually using AI in 2026
The question in the C++ world has shifted from whether to use LLMs to how to use them well. A roundup of where that conversation is right now: Jason Turner's three-part C++ Weekly arc on getting useful code out of AI, CppCast on teaching C++ in the LLM era, and Herb Sutter asking the uncomfortable question about agents doing harm.
CppCon 2026 puts three language designers on one stage
CppCon 2026 (Sep 12-18, Aurora CO) will host the conference's first-ever keynote panel: Bjarne Stroustrup (C++), Guido van Rossum (Python), and Mads Torgersen (C#) on one stage. Three creators of three of the most-used languages alive, comparing notes on where their languages are headed.
C++26 makes an uninitialized read a defined bug
Reading an uninitialized variable has been undefined behavior in C++ since the beginning, and compilers optimize on that assumption. C++26 (P2795) reclassifies it as erroneous behavior: still a bug the compiler diagnoses, but with a defined value and no licence for the optimizer to delete surrounding code. A poisoned-stack demo shows the same source printing garbage under C++23 and a defined 0 under C++26.
Why you can't std::format a smart pointer (and how to anyway)
A recent r/cpp question: std::cout << a unique_ptr works, but std::println("{}", that_unique_ptr) is ill-formed. There is no std::formatter for smart pointers. Is that an oversight? No -- it is a deliberate, sustained decision. Here is the why, and three ways to format a smart pointer today, all verified on Compiler Explorer.
Embed a file at compile time: #embed in C++26
Baking a file into a binary has meant a build step forever: xxd -i, a generated header, a CMake custom command that drifts. C++26 adopts C23's #embed, so a file becomes a literal the compiler reads at translation time. No codegen, no glue. Here it is running on Compiler Explorer.
Gor Nishanov (1971-2026), who gave C++ its coroutines
Gor Nishanov, the architect of C++20 coroutines, has died at 54. From the 2014 resumable-functions papers to shipping implementations in MSVC and Clang, he spent the better part of a decade turning co_await into a standard language feature. Herb Sutter remembered him as intelligent and witty, but above all kind.
Structured concurrency: what std::future never had
A std::future is a dead end: you launch it, you get() it once, and composing two of them means manual threads and locks. C++26 senders compose. when_all runs work concurrently and joins it into one result, with no mutex and no leaked threads. Here is the pattern, running on Compiler Explorer.
Hello, sender: your first std::execution pipeline
C++26 shipped three big things: reflection, contracts, and std::execution. The first two get the headlines on this blog. std::execution (P2300) is the new standard model for asynchronous and parallel work, and it is the one most codebases will reach for first. Here is the smallest pipeline that does real work, running today on Compiler Explorer.
Define your own function colors: compile-time caller checks with C++26 reflection
C++ already enforces function colors -- consteval, CUDA's __device__, Clang's [[clang::nonblocking]] -- but every one of them needed a compiler change. C++26's std::meta::current_function() (P3795R1) lets a callee reflect on its caller at compile time, so you can paint your own colors as a 20-line library: audio-thread safety, capability tokens, or architectural layers that refuse to compile when called from the wrong place. Here is the pattern, three professional uses, and exactly where it breaks.
Reflection + annotations for hashing: opt out of fields, not whole structs
Krystian Piekos's May 29 post on infotraining.pl shows the cleanest demo so far of P3394 annotations combined with P2996 reflection: opt structs into hashing with [[=hashable]], and opt individual fields out with [[=skipped_for_hash]]. The Hashable concept and the calculate_hash walker fit in 40 lines. No macros.
std::rotate: how libstdc++ and libc++ actually differ
Raymond Chen's June 2026 series on The Old New Thing exposed a surprising fact: libstdc++ and libc++ implement std::rotate with completely different algorithms. libstdc++ swaps left-to-right and ends at n-1 swaps with good locality. libc++ decomposes the rotation into gcd(a, n) cycles and hits ~n/2 swaps but with poor locality. Which is faster depends entirely on your input shape.
Profiles take shape, and the contract C++26 left behind comes back
The other half of the Brno safety story: a profiles framework with real syntax (attributes, not pragmas) plus two concrete profiles from Stroustrup, and P3097 bringing virtual-function contracts back after they were cut from the C++26 MVP. All target C++29.
Five small C++29 papers from Brno you will actually use
Underneath the safety headlines, WG21 Brno cleared a stack of small papers that working programmers will feel every day: designated-initializers that reach through a base class, a map .get() that does not insert, defaultable postfix operators, constexpr pointer tagging (which quietly leans on reflection), and mandatory intptr_t. All target C++29.
C++ is writing down all of its undefined behavior
The structural move at WG21 Brno was not a feature -- it was a catalogue. P3596 adds two annexes that enumerate every case of undefined behavior and every ill-formed-no-diagnostic-required corner in the standard, and P3100 turns that list into a case-by-case program to close each one for C++29. There are exactly 80 core-language UB cases, and 70% of them are memory-safety bugs.
WG21 Brno: with C++26 done, the committee turns to undefined behavior
The WG21 Brno meeting (June 8-13, 2026) was the first since C++26 was finalized, and per Herb Sutter's trip report the theme is unmistakable: catalogue and eliminate undefined behavior, push memory-safety profiles toward C++29, and finish the pieces the C++26 MVP deferred. Reflection, the headline of C++26, was not on the marquee -- and that is exactly what shipping looks like.
CUDA 13.3: tile programming in C++ without the boilerplate
NVIDIA CUDA 13.3 (May 26) adds C++ tile programming: declarative tile abstractions replace manual shared memory, synchronization, and indexing. CompileIQ autotuning uses evolutionary algorithms to tune tile sizes and memory layout per kernel (up to 15% speedup on GEMM/attention). Works on Hopper and all other supported architectures.
Could C++ handle an ABI break? The 2026 case
Two pieces dropped in the same week: Luis Caro Campos' CppCon 2025 talk arguing package managers make ABI breaks manageable, and an HFT University article claiming a 58x P99 latency gap between Rust's and C++'s stdlib. The ABI debate is back. Here is what both sides are saying, and what C++26 shipped despite the constraint.
The fastest JVM is the C++26 compiler
Koen Samyn's BeCPP talk used std::meta::substitute to transform Java bytecode into executable C++ at compile time. The compiler constant-folds the entire program. The loop doesn't run faster. It doesn't exist. This is reflection used not for serialization or enum-to-string, but as a compile-time metaprogramming substrate for building language interpreters.
C++ modules in 2026: import std works, import boost is coming, your IDE still can't
import std compiles on GCC 16.1, Clang 18+, and MSVC. Boost has a per-library module prototype showing 45% build-time reductions. But CMake support is still experimental, clangd needs a full rebuild on module changes, IntelliSense has been 'experimental' for seven years, and almost no libraries ship module definitions. For reflection users: PCH is faster than modules on GCC 16.1 today.
C++: The Documentary is now on YouTube
CultRepo's 'C++: The Documentary' had its world premiere on May 28 in New York and is now available worldwide on YouTube. The film traces C++ from Bell Labs in 1979 through the language's role in modern infrastructure. Sponsored by Hudson River Trading.
simdjson meets reflection: sb << my_struct at 6.8 GB/s
simdjson now ships a C++26 reflection backend: define SIMDJSON_STATIC_REFLECTION, and sb << my_struct serializes any aggregate at SIMD speed. The CITM Catalog benchmark hits 6.8 GB/s. Combined with P3394 annotations for rename/skip, this is the production JSON path the reflection series has been building toward.
The hidden cost of <meta> -- and the three-line fix
Vittorio Romeo measured what C++26 reflection actually costs: the <meta> header adds ~181ms per TU on GCC 16.1, but the reflection algorithm itself is ~0.07ms per enumerator. The header is 2500x more expensive than the logic. A three-line CMake PCH stanza cuts the header cost by 2.3x. Modules, surprisingly, make it worse.
The May 2026 WG21 mailing in five papers (pre-Brno, 116 total)
WG21 dropped the pre-Brno mailing in early May -- 116 papers, the largest pre-meeting mailing since the C++20 design crunch. Five papers are doing the heavy lifting for C++29's safety story (the headline axis named in P5000R1 'Direction for ISO C++29'), plus the coroutines-for-I/O work that finally got first LEWG review on the schedule. This is the table of contents for what wro.cpp will be tracking through to Brno (8-13 June).
C++ Safety State of the Union: May 2026
C++ in May 2026 has four conversations running at once: regulators (CISA, EU CRA) demanding memory-safety roadmaps; the committee fighting over how to respond (Hagenberg vote 19 profiles / 9 Safe C++ / 11 both); what actually shipped in C++26 (P2900 contracts, P3471 hardened stdlib, P2996 reflection); and what the industry actually deployed (Chrome MiraclePtr -57% UAF, Google's 0.3% perf-cost data, Apple libc++ safe-buffers). They don't talk to each other in public. This essay wires them. Pre-Brno (8-13 June) reading.
Revzin at C++Now: 'Reflection Is Only Half the Story' -- what generation looks like next
Barry Revzin's C++Now 2026 keynote (Mon 4 May, Aspen) landed the line the C++ reflection community has been circling for two years: C++26 reflection lets you OBSERVE -- the next question is what it looks like to GENERATE. The 90-minute talk is a tour of source-code-generation design space (macros, templates, Rust proc-macros, Swift macros, D mixins) and reads as the natural sequel to wro.cpp's whole 'Where this is heading' triptych framing.
What reinterpret_cast doesn't do: Fertig on std::start_lifetime_as and the C++23 escape hatch
Andreas Fertig's 2026-05-18 post (re-shared on isocpp.org) makes a pointed case: reinterpret_cast and std::start_lifetime_as look interchangeable -- but only if you don't read the abstract-machine fine print. reinterpret_cast is a POINTER operation; std::start_lifetime_as is an OBJECT-LIFETIME operation. The 5-line difference between UB-then-it-works-on-my-compiler and defined-behavior.
Sutter's BeCPP keynote: C++ added more developers in 4 years than any other language
Herb Sutter's keynote at the BeCPP Symposium 2026 (March 30, Howest, Belgium) opened with a SlashData chart almost nobody outside the room has seen yet: C++ developer population grew 72% from Q1 2022 to Q1 2025 -- from 9.5M to 16.3M. That is the biggest absolute net gain of any general-purpose language over the period. Rust grew faster in percentage (137%) but on a smaller base (5.1M total). Here is the chart, the numbers behind it, and the thesis Sutter built on top -- plus an honest read on what 'fastest growing' means when JavaScript is still bigger than the second + third place combined.
The five most useful things C++26 reflection unlocks (in effort order)
C++26 reflection looks like it requires a PhD in template metaprogramming. It does not. Five concrete projects you can build with it, ranked from five minutes to weeks. Use this as a triage when picking your first reflection-powered project.
Is std::vector consteval or constexpr? A reader's question, answered
A colleague asked: 'Is std::vector consteval and not constexpr?' Short answer: no, but the intuition is right. Long answer: the constexpr/consteval/constinit trio, the transient-allocation rule, and why std::define_static_array exists.
Reflection in the wild: April 2026 in five links
Five things happened to C++26 reflection in April 2026: GCC 16.1, Glaze v7.2, a Revzin write-up, a Lemire/Thiesen JSON talk, and one honest list of what is still not shipping.
Glaze v7.2 vs your hand-rolled JSON: a 30-line benchmark
Glaze v7.2 ships a P2996 backend that retires __PRETTY_FUNCTION__, lifts the 128-member cap, and serializes private members. Here is when you still write your own thirty lines -- and when one call wins.
GCC 16.1 ships C++26 reflection -- your 30-line hands-on
GCC 16.1 dropped on 30 April 2026 with -freflection. C++26 was finalized at Croydon five weeks earlier. Here is a 25-line program you can compile and run today on your laptop.
C++26 is done -- five weeks since Croydon, here's what shipped
Five weeks ago WG21 voted C++26 to publication in Croydon. The dust has settled enough to take stock of what landed, what compiles today, and what it means for the wro.cpp reflection series.