The next major revision of the C++ standard, informally known as C++26, is already feature-complete and moving through the final stages of ISO approval. If C++20 was the big leap and C++23 the consolidation, C++26 is shaping up to be the version that gives the language introspection, a modern async model and a much richer standard library.
The current working draft is document N5014. After the June 2025 meeting in Sofia, the committee froze the feature set and sent the text to national bodies for comments. The plan is to finish resolving those comments after the November 2025 meeting in Kona and then send the draft to final approval around March 2026.
In practice: toolchains are already starting to experiment with many of these features, and C++26 will quickly become the reference for modern C++.
Reflection: C++ learns to look at itself
The headline feature is compile-time reflection. C++26 introduces a new operator ^^ to query information about program entities—types, functions, members—directly in code at compile time.
Instead of using external code generators or template metaprogramming tricks, developers will be able to:
- Iterate over the members of a struct or class
- Inspect attributes and annotations
- Generate code (for example, serializers, GUI bindings, RPC stubs) based on the structure of user types
This is all done in a standardised way, via a new header <meta>, rather than via vendor-specific extensions. Several experimental implementations already exist (forks of Clang, GCC and EDG) and can be tested in Compiler Explorer.
Committee members like Herb Sutter and Hana Dusíková have described the impact of reflection as “almost like a whole new language”, because it opens the door to patterns that previously required heavy template magic or external tools.
Contracts: design-by-contract returns
C++26 also brings back contracts, after the controversial attempt that was pulled out of C++20.
This time the feature is more focused and centred around:
- A new keyword
contract_assert - Special identifiers
preandpostthat mark preconditions and postconditions
The idea is to let developers write explicit conditions that must hold at function entry and exit, and have implementations choose whether to check them at runtime, use them for optimisation, or both.
The design is still debated even inside the committee, and some members have criticised aspects of the current approach, but a contracts facility will be part of C++26 in some form. It will live in a dedicated header <contracts>, tying together language and library support.
Making more things constexpr – including containers
C++26 continues the trend of expanding what can be done at compile time:
constexprcontainers and adaptors: standard containers (and related utilities) will increasingly be usable in constant expressions, not just in runtime code.constexprstructured bindings, references toconstexprvariables, placementnewand even casts fromvoid*are now allowed in constexpr contexts.- Exception throwing inside constant evaluation is also permitted, which makes error handling for compile-time computations more regular.
All of this pushes C++ further toward powerful compile-time programming, where more validation and computation happens before the binary even runs.
Language tweaks: from pack indexing to = delete("reason")
Beyond the flagship features, C++26 includes many smaller but important language changes:
- Pack indexing and the ability for structured bindings to introduce packs, which improves template metaprogramming and variadic code.
- Attributes and conditions for structured bindings, making them more flexible and better integrated with control flow.
- Placeholder variables without a name, useful when the value is irrelevant but the syntax requires a declaration.
- A new
#embeddirective (inherited from C23) for including binary resources directly into the program, plus__has_embedfor checking availability in the preprocessor. - Unevaluated strings, primarily to support reflection and tooling.
- The basic character set is extended to include **
@,$and`as guaranteed characters. - A new form
= delete("reason");lets developers attach an explanatory string when deleting a function, to produce clearer diagnostics. - The so-called “Oxford variadic comma”: the old syntax
(int...)for variadic parameters without a preceding comma is deprecated; the preferred form is(int, ...), which is compatible with C and clearer to read. - Some clean-up: deprecated array comparisons are removed, deleting a pointer to an incomplete type becomes ill-formed, and uninitialised reads are treated more strictly as erroneous behaviour.
Together, these changes refine the language surface and make diagnostics more helpful.
Library: from SIMD to linear algebra and hazard pointers
On the standard library side, C++26 is packed with new facilities, many of which target performance-critical and concurrent code:
<simd>: data-parallel operations for exploiting SIMD (single instruction, multiple data), making it easier to write vectorised code in a portable way.- Async sender/receiver model: a standardised abstraction for asynchronous execution and structured concurrency, inspired by libraries like Libunifex. This finally gives the standard library a coherent foundation for future async APIs.
- Parallel scheduler: a standard async execution context that guarantees forward progress, providing a more robust basis for parallel and asynchronous algorithms.
<hazard_pointer>and<rcu>: low-level primitives for safe memory reclamation in concurrent data structures (hazard pointers and Read-Copy-Update).<inplace_vector>: a resizable vector with fixed capacity that stores elements in-place, useful in performance-sensitive code where dynamic allocation must be controlled.<hive>: a data structure that can reuse memory from erased elements efficiently.
There are also many targeted additions:
std::copyable_function: a safer, more predictable callable wrapper thanstd::functionin some scenarios.std::is_within_lifetime: utility for checking whether a pointer points to an object that is still within its lifetime.std::submdspan: for slicing multi-dimensional spans.- Better interoperability between string/stream types and
std::string_view; formatting support forstd::filesystem::path. - A new view
std::views::concatand easy concatenation of strings and string views. <text_encoding>to access the IANA character set registry.std::ranges::generate_randomfor generating random ranges.<linalg>: a linear algebra interface loosely aligned with BLAS, giving C++ a standard foundation for vector and matrix operations.- More
constexprfor<cmath>and<complex>, hashing forstd::chronovalue types, and a “tuple protocol” forstd::complexso it behaves better with generic tuple-like code. - Support for the 2022 SI prefixes (
std::quecto,std::ronto,std::ronna,std::quetta) in ratio types. - Saturating arithmetic helpers like
std::add_satandstd::div_sat. - A
<debugging>header aimed at giving debuggers and developers better hooks into the running program. - Quality-of-life details such as printing blank lines with
std::println().
On top of that, the standard library becomes bounds-hardened in more places, tightening undefined behaviour around out-of-range operations.
What was left out
Not everything made the cut. One high-profile proposal, trivial relocatability, was removed from C++26 and deferred to a future standard because of implementation bugs and concerns. It introduced properties like trivially_relocatable_if_eligible and replaceable_if_eligible to allow more aggressive optimisations when moving objects in memory.
The message from the committee is clear: the feature is desired, but it has to be right, and implementable, before it becomes part of the language.
A step towards “introspective, async C++”
When C++26 is finally approved, likely in 2026, it will consolidate a decade-long trend:
- More power at compile time (reflection, constexpr containers, contracts, static assertions with custom messages)
- A real async and concurrency story built into the standard (sender/receiver, schedulers, SIMD, RCU, hazard pointers)
- Richer math, text and systems primitives that reduce the need for ad-hoc third-party utilities
For developers, it means C++ will be better equipped for modern workloads—high-performance services, numerical code, low-latency systems—while offering stronger tools for correctness and introspection.
And as with previous revisions, adoption will be gradual: many C++26 features are already appearing experimentally in compilers and libraries, letting teams start to experiment long before the ink on the final standard is dry.
