› N5035 2026-03 WG21 admin telecon meeting (obsolete; replaced by N5037) G. Davidson
› N5036 ISO/IEC JTC1/SC22/WG21 White Paper, Extensions to C++ for Transactional Memory Version 2 M. Wong , SG5
Intent
White-Paper
Abstract
1 The following referenced document is indispensable for the application of this document. For dated references, only the edition cited applies. For undated references, the latest edition of the referenced document (including any amendments) applies.
› P0876R22 fiber_context - fibers without scheduler O. Kowalke , N. Goodspeed
Intent
Proposal
Abstract
This paper proposes a minimal API that enables stackful context switching **without** the need for a scheduler. The API is suitable to act as building-block for high-level constructs such as stackful coroutines as well as cooperative multitasking (aka user-land/green threads that incorporate a **scheduling** facility).
› P2000R5 Direction for ISO C++ M. Wong , J. Garland , P. McKenney , R. Orr , B. Stroustrup , D. Vandevoorde , M. Wong
Intent
Proposal
Abstract
This is intended as a document updated as times go by and new facts and opinions emerge. It tries to articulate our aims for C++.
› P2285R1 Are default function arguments in the immediate context? A. Krzemieński , T. Kamiński
Intent
Proposal
Abstract
The motivation for default function arguments is to enable two different function invocation forms while providing a single function declaration:
› P2583R0 Symmetric Transfer and Sender Composition M. Gill , V. Falco
Intent
Proposal
Abstract
C++20 provides symmetric transfer ([P0913R1](https://wg21.link/p0913r1)[1]) - a mechanism where `await_suspend` returns a `coroutine_handle<>` and the compiler resumes the designated coroutine as a tail call. Coroutine chains execute in constant stack space. `std::execution` ([P2300R10](https://wg21.link/p2300r10)[5]) composes asynchronous operations through sender algorithms. These algorithms cre
› P2728R11 Unicode in the Library, Part 1: UTF Transcoding E. Nolan
› P2929R2 simd_invoke D. Towner , R. Arutyunyan
Intent
Proposal
Abstract
ISO/IEC 19570:2018 introduced data-parallel types to the C++ Extensions for Parallelism TS [P1928R15]. That paper, and several ancillary papers, do an excellent job of setting out the main features of an extension to C++ which allows generic data parallel programming on arbitrary targets. However, it is inevitable that the programmer will want to make some use of target-specific intrinsics in orde
› P2953R4 Forbid defaulting operator=(X&&) && M. Taylor , A. O'Dwyer
Intent
Proposal
Abstract
Currently, [[dcl.fct.def.default]/2.5](https://eel.is/c++draft/dcl.fct.def.default#2.5) permits an explicitly defaulted special member function to differ from the implicit one by adding *ref-qualifiers*, but not *cv-qualifiers*.
› P2964R2 Allowing user-defined types in std::simd D. Towner , R. Arutyunyan
Intent
Proposal
Abstract
The C++ standard library includes data-parallel types in the `<simd>` header, currently restricting element types to a closed list: arithmetic types and `std::complex` specializations. This paper proposes a minimal change to the specification in which the closed list is replaced with trait-based constraints that handle all existing types while naturally extend support to enumerations, `std::byte`
› P3045R7 Quantities and units library M. Pusz , D. Berner , J. Peña , C. Hogg , N. Holthaus , R. Michaels , V. Reverdy
Intent
Proposal
Abstract
Several groups in the ISO C++ Committee reviewed the “P1935: A C++ Approach to Physical Units” [[P1935R2]](https://wg21.link/p1935r2) proposal in Belfast 2019 and Prague 2020. All those groups expressed interest in the potential standardization of such a library and encouraged further work. The authors also got valuable initial feedback that highly influenced the design of the V2 version of the [[
› P3181R1 Atomic stores and object lifetimes H. Boehm , D. Claussen , D. Goldblatt
Intent
Proposal
Abstract
The current object lifetime rules insist that the last update to an object happens-before destruction of the object. This is arguably too conservative in ways that the authors found surprising and undesirable. We propose to relax the rule in a way that better aligns it with programmer intuition.
› P3385R7 Attributes reflection A. Cassagnes
Intent
Proposal
Abstract
Attributes are used to a great extent, and there is new attributes being added to the language somewhat regularly.
› P3411R5 `any_view` H. Xie , S. Yilmaz , L. Dionne , P. Roberts
Intent
Proposal
Abstract
This paper proposes a new type-erased view: `std::ranges::any_view`. That type-erased view allows customizing the traversal category of the view, its value type and a few other properties. For example:
› P3440R2 Add n_elements named constructor to std::simd D. Towner
Intent
Proposal
Abstract
When iterating over large dynamic data sets using `std::simd` there will inevitably be situations where the very last block of data doesn’t fill the entire `std::simd` object. This remainder needs to be processed using a partially filled `std::simd` object. For example:
› P3596R0 Undefined Behavior and IFNDR Annexes J. Berne , T. Doumler , J. Maurer , S. Yaghmour
› P3642R4 Carry-less product: std::clmul J. Schultke
Intent
Proposal
Abstract
[Carry-less multiplication](https://en.wikipedia.org/wiki/Carry-less_product) is a simple numerical operation on unsigned integers. It can be a seen as a regular multiplication where `xor` is being used as a reduction instead of `+`.
› P3666R3 Bit-precise integers J. Schultke
Intent
Proposal
Abstract
In distant history, there have been various attempts at standardizing multi-precision integers in C++, such as [[N1692]](https://wg21%2elink/n1692) "A Proposal to add the Infinite Precision Integer to the C++ Standard Library", [[N1744]](https://wg21%2elink/n1744) "Big Integer Library Proposal for C++0x", and [[N4038]](https://wg21%2elink/n4038) "Proposal for Unbounded-Precision Integer Types", al
› P3688R6 ASCII character utilities J. Schultke , C. Jabot
Intent
Proposal
Abstract
Testing whether a character falls into a specific subset of ASCII characters or performing some simple transformations are common tasks in text processing. For example, applications may need to check if identifiers are comprised of alphanumeric ASCII characters or underscores; Unicode properties are not relevant to this task, and usually, neither are locales.
› P3724R3 Integer division J. Schultke
Intent
Proposal
Abstract
C++ currently only offers truncating integer division in the form of the `/` operator. However, other rounding modes have various use cases too, and implementing these as the user can be surprisingly hard, especially when integer overflow needs to be avoided, and negative inputs are accepted.
› P3737R3 std::array is a wrapper for an array! J. Schultke
Intent
Proposal
Abstract
The `std::array` class template has established itself as a de-facto replacement for "builtin arrays" or "C-style arrays" in many code bases. This also means that it is frequently taught to novice programmers, with an explanation along the lines of:
› P3816R2 Hashing meta::info M. Cummins , V. Yukhymenko
Intent
Proposal
Abstract
This paper proposes a new standard library template, `consteval_hash<T>`, with a single specialization for `meta::info`. The purpose of this facility is to provide a standard interface for compile-time hashing, thereby allowing unordered containers such as `unordered_map` and `unordered_set` to be used with `meta::info` keys, and potentially with other types in future.
› P3822R1 Conditional noexcept specifiers in compound requirements V. Luchkin , G. Ažman
Intent
Proposal
Abstract
This paper extends compound requirements to allow noexcept specifiers to be applied conditionally. The proposed syntax for this is `requires { { *expression* } noexcept(*constant-expression*) -> *return-type-constraint*; }`.
› P3844R4 Reword [simd.math] for consteval conversions M. Kretz
Intent
Proposal
Abstract
| Document Number: | P3844R4 | | --- | --- | | Date: | 2026-02-13 | | Reply-to: | Matthias Kretz <m.kretz@gsi.de> | | Audience: | LWG | | Target: | C++26 |
› P3856R5 New reflection metafunction - is_structural_type (US NB comment 49) J. Dave , A. Meredith
Intent
Proposal
Abstract
Several parts of the standard and library refer to structural types, including library mandates that types be structural, yet there is no way to query whether a type is structural. Library mandates clauses mean that library implementers must somehow have this functionality, but it is simply not exposed to users. We propose a new reflection metafunction - *is_structural_type(info)* as a solution, w
› P3864R1 Correctly rounded floating-point maths functions G. Davidson , J. Schultke
Intent
Proposal
Abstract
This paper proposes adding five overload sets to the standard library for addition, subtraction, multiplication, division, and square root calculation, correctly rounded as specified in ISO/IEC 60559:2020.
› P3874R1 Should C++ be a memory-safe language? J. Bauman , T. Doumler , N. Liber , R. McDougall , P. Halpern , J. Garland , J. Müller
Intent
Proposal
Abstract
In recent years there have been numerous recommendations from industry, academia and government to prefer “memory-safe languages”1. Rust is consistently described as a memory-safe language while C++ is not — despite the fact that both can exhibit undefined behavior violating many of the commonly understood memory safety guarantees such as protection against buffer overflows and dangling pointers.
› P3876R1 Extending <charconv> support to more character types J. Schultke , P. Bindels
Intent
Proposal
Abstract
Support for `char8_t` and other Unicode character types in `std::to_chars` and `std::from_chars` is clearly useful. File formats such as JSON require the use of Unicode character encodings, so an application that deals with JSON may want to use `char8_t` in its APIs and internally. However, when attempting to use `char8_t` for this purpose, one quickly runs into problems:
› P3899R1 Clarify the behavior of floating-point overflow J. Schultke , M. Kretz
Intent
Proposal
Abstract
The current specification of floating-point overflow is unclear. Floating-point overflow occurs when finite operands are used as operands, and the result cannot be represented as a finite value. For [[ISO/IEC 60559:2020]](https://www%2eiso%2eorg/standard/80985%2ehtml) floating-point numbers, this results in infinity.
› P3904R1 When paths go WTF: making formatting lossless V. Zverovich
Intent
Proposal
Abstract
[P2845], adopted in C++26, added formatting support for `std::filesystem::path`, addressing encoding issues and making formatting lossless except for one case, unpaired surrogates on Windows. This paper proposes addressing this case and making formatting 100% lossless by default via the WTF-8 encoding ([WTF-8]). This will improve consistency in path handling between Windows and POSIX platforms and
› P3932R0 Resolve LWG4470: Fix integer-from in [simd] M. Kretz
Intent
Proposal
Abstract
| Document Number: | P3932R0 | | --- | --- | | Date: | 2026-02-13 | | Reply-to: | Matthias Kretz <m.kretz@gsi.de> | | Audience: | LWG | | Target: | C++26 |
› P3936R1 Safer atomic_ref::address (FR-030-310) C. Jabot
Intent
Proposal
Abstract
`atomic_ref<T>::address` currently returns a `T*`. This function was added by [P2835R7](https://wg21.link/P2835R7) [1], which cover the use cases for this function. In short, we might want to know the address for hashing for contention-aware data structure, indexing an array atomically, etc.
› P3938R1 Values of floating-point types J. Schultke
Intent
Proposal
Abstract
The core language wording in the C++ standard does not specify what values a floating-point type may represent. There are a few questions that have no obvious answer:
› P3941R2 Scheduler Affinity D. Kühl
Intent
Proposal
Abstract
There are a few NB comments raised about the way `affine_on` works:
› P3953R1 Rename std::runtime_format V. Zverovich
Intent
Proposal
Abstract
[P2918] introduced `std::runtime_format` to allow opting out of compile-time format string checks in `std::format`. Subsequently, [P3391] made `std::format` usable in constant evaluation. As a result, `std::runtime_format` can now be evaluated at compile time, making its name misleading. This paper proposes renaming `std::runtime_format` to `std::dynamic_format` to better reflect its semantics and
› P3966R0 2026-01 Library Evolution Poll Outcomes I. Levi , F. Fracassi , A. Weis , C. Jabot
Intent
Proposal
Abstract
In 2026-01, the C++ Library Evolution group conducted a series of electronic decision polls [[P3965R0]](https://wg21.link/P3965r0). This paper provides the results of those polls and summarizes the results.
› P3969R0 Fixing std::bit_cast of types with padding bits J. Schultke
Intent
Proposal
Abstract
The following use of `std::bit_cast` has undefined behavior at compile time:
› P3970R0 Profiles and Safety: a call to action D. Vandevoorde , J. Garland , P. McKenney , R. Orr , B. Stroustrup , M. Wong
› P3971R0 Generalised type rebinding for structures of uniform elements D. Towner
Intent
Proposal
Abstract
Modern C++ provides powerful facilities for generic programming, but lacks a uniform way to change the element type of containers and container-like types. Consider a simple requirement: convert a container of `float` values to `double` for higher precision computation.
› P3973R0 bit_cast_as: Element type reinterpretation for std::simd D. Towner
Intent
Proposal
Abstract
SIMD programming frequently requires reinterpreting vector data at different element granularities—converting packed bytes to shorts, accessing the bit representation of floats, or regrouping data for different operations. While platform intrinsics have long supported this pattern naturally, with `std::simd` programmers must use `std::bit_cast` with fully-specified target types, manually computing
› P3977R0 A New Taxonomy for Contracts O. Rosten
Intent
Proposal
Abstract
Document: P3977R0 Date: January 22, 2026 Audience: WG21 Reply to: Oliver J. Rosten (oliver.rosten@gmail.com)
› P3978R2 constant_wrapper should unwrap on call and subscript M. Kretz
Intent
Proposal
Abstract
As discussed in [P3948R0], because of language inconsistencies, `std::constant_wrapper` is inconsistently not unwrapping for call and subscript operators whereas all other operators can be found via ADL and the conversion operator implemented in `constant_wrapper`. Looking at `std::`
› P3980R0 Task's Allocator Use D. Kühl
Intent
Proposal
Abstract
There are a few NB comments about `task`’s use of allocators:
› P3981R1 Better return types in std::inplace_vector and std::exception_ptr_cast B. Revzin , J. Wakely , T. Kamiński
› P3982R0 Fix the meaning of strided_slice::extent for C++26 T. Kamiński , M. Hoemmen
Intent
Proposal
Abstract
**Addresses [PL007: Define the extent member of the `strided_slice`](https://github.com/cplusplus/nbballot/issues/816)**
› P3983R0 simd object representation D. Towner
Intent
Proposal
Abstract
The Working Draft makes `simd` types `TriviallyCopyable`, which allows `std::bit_cast` operations. However, the object representation is unspecified, making the results implementation-defined.
› P3984R0 A type-safety profile B. Stroustrup
Intent
Proposal
Abstract
* C’s ability to access hardware and manipulate data without overhead. * Simula’s ability to organize programs and guarantee type safety.
› P3985R0 Concepts for std::simd D. Towner
Intent
Proposal
Abstract
The C++26 standard library includes `std::simd::basic_vec<T, Abi>` for data-parallel programming ([simd]). Yet it lacks public concepts for constraining SIMD types in templates, forcing verbose and repetitive constraints:
› P4003R0 Coroutines for I/O V. Falco , M. Gill , S. Gerbino
Intent
Proposal
Abstract
C++20 coroutines have five properties that, taken together, make them uniquely suited to asynchronous I/O: type erasure through `coroutine_handle<>` , customization through `promise_type` , stackless independently- resumable frames, symmetric transfer through `await_suspend` , and compiler-managed state that persists across suspension points. Each was designed for generality. Their conjunction yie
› P4004R0 Reconsider CWG 1395 "Partial ordering of variadic templates reconsidered" C. Meerwald
Intent
Proposal
Abstract
```cpp template<typename ... T> char *f(T &...); // #1 template<typename T> int *f(T &&); // #2 int i; auto *p = f(&i); ```
› P4005R0 A proposal for guaranteed-(quick-)enforced contracts V. Voutilainen
Intent
Proposal
Abstract
This paper proposes a particular form of guaranteed-enforced contracts.
› P4006R0 Transparent Function Objects for Shift Operators D. Towner
Intent
Proposal
Abstract
Since C++14, the standard library has provided transparent function objects (functors with `void` template specialization and `is_transparent` member type) for most C++ operators, introduced by [N3421]. However, the shift operators (`<<` and `>>`) were not included.
› P4007R0 Senders and Coroutines V. Falco , M. Gill
Intent
Proposal
Abstract
`std::execution` serves its domain well. Different asynchronous domains have different costs, and a single model cannot minimize all of them simultaneously. This paper identifies four structural gaps where the sender model meets coroutines: three at the boundary - error reporting, error returns, and frame allocator propagation - and one inside the composition mechanism - the symmetric transfer gap
› P4008R0 Clean Modular Mode: Legacy Opt-out for C++ Z. Lin
Intent
Proposal
Abstract
Keep full backward compatibility by default, but allow users to opt out of historical C-compatible baggage via modular exclusion—preserving all low-level system programming capabilities in a non-excludable core.
› P4009R0 A proposal for solving all of the contracts concerns V. Voutilainen
Intent
Proposal
Abstract
We have had a couple of attempts to resolve the Romanian NB comment about the lack of guaranteed-enforced contracts. We've also had some suggestions (e.g. in D3894R0) for a different design for Contracts, but there were some major concerns about it (reliance on lambdas for deferring evaluation for 'ignore', concerns about generic preambles/postambles).
› P4010R0 Add funnel shift operations to bit header D. Towner
Intent
Proposal
Abstract
This paper proposes adding funnel shift operations to the C++ standard library. Funnel shifts concatenate two integer values, shift the concatenated result, and extract bits. This is a fundamental primitive bit operation with widespread use across many domains including cryptography, hashing, compression, and pseudo-random number generation.
› P4011R0 Redefining narrow contract M. Kretz
Intent
Proposal
Abstract
| Document Number: | P4011R0 | | --- | --- | | Date: | 2026-02-12 | | Reply-to: | Matthias Kretz <m.kretz@gsi.de> | | Audience: | EWG |
› P4012R0 value-preserving consteval broadcast to simd::vec M. Kretz
Intent
Proposal
Abstract
1. Novel (no other type in the standard library does this2).
› P4014R0 The Sender Sub-Language V. Falco , M. Gill
Intent
Proposal
Abstract
C++26 introduces a rich sub-language for asynchronous programming through `std::execution` ([P2300R10](https://wg21.link/p2300r10))[1].
› P4015R0 Enforcing Contract Conditions with Statements L. Lippincott
Intent
Proposal
Abstract
C++26 contracts come with an enforcement mechanism that provides to certain parties (function authors, function callers, and individual compilers, but not entire implementations or program builders) only a nebulous threat of contract enforcement, rather than certainty. This nebulous behavior is not only by design, but is in fact essential to the design. The uncertainty surrounding enforcement make
› P4016R0 Canonical Parallel Reduction: A Fixed Expression Structure for Run-To-Run Consistency A. Drakeford
Intent
Proposal
Abstract
This paper proposes **semantics** only. It seeks LEWG validation of the fixed expression structure defined in §4 before committing to API design. This proposal introduces no *algebraic* requirements on `binary_op`
› P4019R0 constant_assert J. Persson
› P4020R0 Concerns about contract assertions A. Krzemieński
› P4021R0 compile_assert - an assert that evaluates at compile time J. Grant
Intent
Proposal
Abstract
```cpp main4.c:15:9: note: in expansion of macro ‘compile_assert’ 15 | compile_assert(i < buf_size, "check buf index within buffer bounds"); error ```
› P4022R0 Remove try_append_range from inplace_vector for now B. Revzin , J. Wakely , T. Kamiński
Intent
Proposal
Abstract
In [[P3981R0] (Better return types in `std::inplace_vector` and `std::exception_ptr_cast`)](https://wg21.link/p3980r0), one of the changes proposed in that paper was changing the return type of `try_append_range`:
› P4023R0 Strategic Direction for AI in C++: Governance, and Ecosystem M. Wong , J. Garland , P. McKenney , R. Orr , B. Stroustrup , D. Vandevoorde , M. Wong
Intent
Proposal
Abstract
**Purpose:** To update the C++ Directions Paper (P2000) with a unified strategy for AI, focusing on governance and ecosystem encouragement.
› P4024R0 Guidance on Building Consensus and Converging Proposals M. Wong , J. Garland , P. McKenney , R. Orr , B. Stroustrup , D. Vandevoorde , M. Wong
› P4025R0 The SG19 Priority List for C++29/32 M. Wong , P. Ratzloff
› P4026R0 Core Issue 3123 "Global lookup for begin and end for expansion statements" V. Serebrennikov
Intent
Proposal
Abstract
— an enumerating expansion statement if its *expansion-initializer* is of the form *expansion-init-list*;
› P4027R0 2026-02 Library Evolution Polls I. Levi , F. Fracassi , A. Weis , C. Jabot
Intent
Proposal
Abstract
This paper contains the decision polls that the C++ Library Evolution group will take in February 2026.
› P4029R0 The SG14 Priority List for C++29/32 M. Wong
› P4030R0 Endian Views E. Nolan
Intent
Proposal
Abstract
The main reason for adding these views is to assist users of the UTF transcoding range adaptors (see [[P2728R7]](https://wg21.link/p2728r7)). That paper introduces the adaptors `to_utf8`, `to_utf16`, and `to_utf32`, which take as input ranges of `char8_t`, `char16_t`, and `char32_t`. The input and output of these views use native endianness. But users often need to convert to and from UTF encoding
› P4031R0 Rename system_context_replaceability namespace R. Arutyunyan
Intent
Proposal
Abstract
This paper proposes to rename `system_context_replaceability` namespace.
› P4032R0 Strong ordering for meta::info L. Szolnoki
Intent
Proposal
Abstract
Being able to compare `meta::info` directly makes metaprogramming that needs to sort types, functions, etc... into some canonical order with standard algorithms more convenient.
› P5000R0 Direction for ISO C++29 D. Vandevoorde , J. Garland , P. McKenney , R. Orr , B. Stroustrup , M. Wong
Intent
Proposal
Abstract
Given the severe constraints on committee time and implementation resources for C++29, the DG strongly encourages adherence to the following procedural guidelines in addition to Section 5 Process of P2000 as guidance to the chairs and members:
