› N5037 March 2026 admin telecon G. Davidson
Intent
Informational
Abstract
| Replaces: | | | 5035 | | --- | --- | --- | --- | | Date: | | | 2026-03-03 | | Reply to: | | | Guy Davidson (standard.guy@hatcat.com) |
› N5038 WG21 2026-03 Croydon Admin telecon minutes B. Ganetsky
Intent
Informational
Abstract
There will be about 6 meeting rooms in Croydon, 4 of which will be occupied all week long by the usual suspects. There is a “meeting rooms” wiki page. An email has been sent to ask that every subgroup chair requests meeting room space and time there. So far only 4 study groups have requested space and time. The rooms will be distributed based on those who registered. Anyone who is late will not ha
› N5040 WG21 2026-03 Croydon Hybrid Meeting Minutes B. Ganetsky
Intent
Informational
Abstract
Nina Ranns presents. Every participant is responsible for understanding and abiding by the following documents. It is assumed that every participant has read them before attending this meeting.
› N5043 Admin telecon 2026-05 G. Davidson
› P1000R8 Proposed C++ IS schedule G. Davidson
Intent
Proposal
Disposition Date
2026-03Adopted
› P1040R9 std::embed and #depend J. Meneide
Intent
Proposal
Abstract
> I’m very keen on std::embed. I’ve been hand-embedding data in executables for NEARLY FORTY YEARS now. — Guy "Hatcat" Davidson, June 15, 2018
› P1130R2 Module Resource Requirement Propagation J. Meneide
Intent
Proposal
Abstract
The only way to declare a dependency in C++ currently is to use a `#include` statement. With Modules coming to C++, dependency information was greatly enhanced by preambles and globule module fragments which allow for both the compiler and build system to understand physical and semantic layout of code. However, there is still a problem area that C++ has not addressed that people in the brave new
› P2034R6 Partially Mutable Lambda Captures R. McDougall , L. Garg
Intent
Proposal
Abstract
Type erased callables like `std::move_only_function` are the backbone of most asynchronous systems. Users of such systems close their operations in lambdas and place them in a concurrent queue to be processed elsewhere. Performance is often key in such systems, and such operations may want its own local reusable scratch memory. Or perhaps an accumulator for hysteresis over multiple calls.
› P2583R3 Info: Symmetric Transfer and Sender Composition M. Gill , V. Falco
Intent
Informational
Abstract
C++20 provides symmetric transfer ([P0913R1](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0913r1.html)[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`
› P2929R3 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
› P2956R2 Add saturating library support to std::simd D. Towner , R. Arutyunyan
Intent
Proposal
Abstract
The Working Draft of C++26 includes data parallel types. It mostly provides operators which work on or with `std::simd` types, but it also includes overloads of useful functions from other parts of C++ (e.g., sin, cos, abs). In [P0543R3] a proposal was made to provide saturating operation support for some basic arithmetic operations and casts. In particular, `saturating_add`, `saturating_sub`, `sa
› P2964R3 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`
› P3052R2 view_interface::at() H. Kang
Intent
Proposal
Abstract
This paper provides the `at()` method to `ranges::view_interface` to provide a safe access method for the view class. Revision history R2 Rename the feature-test macro based on LEWG feedback. R1 Added wording for freestanding. R0 Initial revision. Discussion Currently, the committee adopted [P2821](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2821r4.html) in C++26, which adds a missin
› P3059R2 Making user-defined constructors of view iterators/sentinels private H. Kang
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
The exposure of user-defined constructors for iterators/sentinels in `<ranges>` currently does not follow consistent rules, which is reflected in the fact that some of them are public and some are private. This paper disables their visibility to comply with best practices.
› P3154R2 Deprecating signed character types in iostreams E. Kosunen
› P3161R5 Unified integer overflow arithmetic T. Freire
Intent
Proposal
Abstract
Addition and uniformization of integer arithmetic functions with overflow behavior
› P3242R2 Copy and fill for mdspan N. Morales , C. Trott , M. Hoemmen , D. Lebrun-Grandie
Intent
Proposal
Abstract
C++23 introduced `mdspan` ([[P0009R18]](https://wg21.link/p0009r18)), a non-owning multidimensional array abstraction that has a customizable layout. Layout customization was originally motivated in [[P0009R18]](https://wg21.link/p0009r18) with considerations for interoperability and performance, particularly on different architectures. Moreover, [[P2630R4]](https://wg21.link/p2630r4) introduced `
› P3373R4 Of Operation States and Their Lifetimes R. Leahy
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
In broad terms a regular (i.e. synchronous) function call has access to two forms of storage throughout its lifetime (note that the “lifetime” of a regular function call is the time between the call thereto and the return therefrom):
› P3384R1 __COUNTER__ J. Rifkin
Intent
Proposal
Abstract
The `__COUNTER__` predefined macro is a common language extension for C and C++ which expands to an integer literal that starts at `0` and increments by `1` every time it is expanded in a translation unit. This is useful for generating unique identifiers, generating unique indices, and other preprocessor metaprogramming uses.
› P3427R3 Hazard Pointer Synchronous Reclamation M. Michael , M. Wong , P. McKenney , M. Wever
Intent
Proposal
Abstract
This paper proposes extending the working draft (N5008) C++26 hazard pointer interface to support synchronous reclamation. The R1 revision of this paper was reviewed by SG1 in Wroclaw 2024 and forwarded to LEWG with feedback "The word 'asynchronous' doesn't belong in the name of the free function". This revision, P3427R2, revises R1 by following SG1 feedback.
› P3440R3 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:
› P3450R1 Extending is_within_lifetime B. Revzin
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
In [[P2641R4]](https://wg21.link/p2641r4), I proposed adding the metafunction
› P3596R1 Undefined Behavior and IFNDR Annexes J. Berne , T. Doumler , J. Maurer , S. Yaghmour
› P3598R0 CWG3158 - `const`-ification of Splice Expressions J. Berne
Intent
Proposal
Disposition Date
2026-03Adopted
› P3605R1 isqrt: A function to calculate integer square root of the nonnegative integer N. Sakharin
Intent
Proposal
Abstract
This paper proposes to add an `isqrt` function (template) to calculate the integer square root of a nonnegative integer. Mathematically defined as:
› P3625R1 either neither M. Hava
› P3647R1 Slides for P3642R4 - Carry-less product: std::clmul J. Schultke
Intent
Proposal
Abstract
**Intuition**: "carry-less" means we use XOR instead of plus.
› P3655R4 cstring_view P. Bindels , H. Dusikova , J. Rifkin , M. Foco , A. Shevlyakov
Intent
Proposal
Abstract
We propose a standard string view type that guarantees null-termination.
› P3692R4 How to Avoid OOTA Without Really Trying P. McKenney , A. Stern , M. Wong , M. Michael , G. Brito
Intent
Proposal
Abstract
* P3692R4 updates the C++ working draft to N5032 and applies feedback from CWG. It also adds a citation to the NVIDIA PTX prohibition against OOTA.
› P3725R3 Filter View Extensions for Safer Use, Rev 3 N. Josuttis
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
Using filter views is both risky and non-intuitive. Let us look at some typical use cases.
› P3726R2 Adjustments to Union Lifetime Rules B. Revzin , T. Kamiński
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
[[P3074R7] (trivial `union`s (was `std::uninitialized<T>`))](https://wg21.link/p3074r7) was adopted in Hagenberg. One of the goals of that paper was to make an example like this work:
› P3732R2 Numeric Range Algorithms R. Arutyunyan , M. Hoemmen , A. Kukanov , B. Lelbach , A. Majumder
Intent
Proposal
Abstract
We propose `ranges` algorithm overloads (both parallel and non-parallel) for the `<numeric>` header.
› P3769R1 Clarification of placement new deallocation L. Vasama
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
[P3492R2] was forwarded to CWG in Hagenberg. In addition to its main language additions, it provided a drive-by fix for the poorly specified selection of deallocation functions in placement new expressions. The wording changes were split into this paper to make it easier to review the changes happening concurrently in this area:
› P3786R2 Tuple protocol for fixed-size spans M. Hava
› P3787R2 Adjoints to "Enabling list-initialization for algorithms": uninitialized_fill G. D'Angelo , R. Arutyunyan
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
In the Tokyo 2024 meeting [P2248R8] (Enabling list-initialization for algorithms) was adopted.
› P3795R2 Miscellaneous Reflection Cleanup B. Revzin
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
At the Sofia meeting, [[P2996R13] (Reflection for C++26)](https://wg21.link/p2996r13), [[P3394R4] (Annotations for Reflection)](https://wg21.link/p3394r4), [[P3293R3] (Splicing a base class subobject)](https://wg21.link/p3293r3), [[P3491R3] (`define_static_{string,object,array}`)](https://wg21.link/p349143), [[P3096R12] (Function Parameter Reflection in Reflection for C++26)](https://wg21.link/p30
› P3804R2 Iterating on parallel_scheduler L. Teodorescu , R. Arutyunyan
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
`parallel_scheduler` [[P2079R10](https://wg21.link/p2079r10)] was a long time in the making and was it adopted in Sofia 2025; still more design concerns were raised after that. This paper proposes to iterate on some of these aspects, aiming to achieve the best possible outcome from `parallel_scheduler`.
› P3826R5 Fix Sender Algorithm Customization E. Niebler
Intent
Proposal
Disposition Date
2026-03Adopted
› P3828R1 Rename the to_input view to as_input N. Josuttis
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
Nicolai Josuttis: P3828R1: Rename the to_input view to as_input
› P3832R1 Timed lock algorithms for multiple lockables T. Lyngmo
Intent
Proposal
Abstract
C++11 introduced `std::lock` and `std::try_lock` (and C++17 introduced `std::scoped_lock`) to simplify deadlock-free acquisition of multiple lockables. These algorithms support *BasicLockable* and *Lockable* objects, but there is currently no facility for timed acquisition of multiple *TimedLockable* objects.
› P3833R2 std::unique_multilock T. Lyngmo
Intent
Proposal
Abstract
This paper proposes `std::multi_lock`, a RAII class template that combines the functionality of `std::unique_lock` and `std::scoped_lock`. Unlike `std::scoped_lock`, which provides only basic RAII semantics, `std::multi_lock` offers the full flexibility of `std::unique_lock` (deferred locking, try-lock operations, timed locking, and ownership transfer) while supporting multiple mutexes simultaneou
› P3839R0 Slides from the Evening Session on P3045 (Quantities and Units Library) M. Pusz
› P3842R2 A conservative fix for constexpr uncaught_exceptions() and current_exception() V. Voutilainen
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
The papers [P3818](https://open-std.org/JTC1/SC22/WG21/docs/papers/2025/p3818r1.html) and [P3820](https://open-std.org/JTC1/SC22/WG21/docs/papers/2025/p3820r1.html) explain the background of the problem we have making uncaught_exceptions() and current_exception(). In short, having those function constexpr is a breaking change in some cases.
› P3846R1 C++26 Contracts, reasserted T. Doumler , J. Berne
Intent
Proposal
Abstract
[P3835R0], [US 25-052], [FI-071], and [RO 2-056] characterise P2900 as being ‘not safe’ and diminishing the overall ‘safety’ of C++. A central concern is that P2900 provides no method to guarantee *in* *code* that a particular assertion, or all assertions in a given ‘component of a program’, will always be checked. In addition, [RO 2-056] suggests that being able to alter the evaluation semantics
› P3856R8 New reflection metafunction - is_structural_type (US NB comment 49) J. Dave , A. Meredith
Intent
Proposal
Disposition Date
2026-03Adopted
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
› P3865R3 Class template argument deduction (CTAD) for type template template parameters C. Meerwald
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
[CWG 3003](https://cplusplus.github.io/CWG/issues/3003.html) "Naming a deducible template for class template argument deduction" has been raised to clarify that with the current core language wording, class template argument deduction does not work for type template template parameters.
› P3895R1 Slides for P3724R3 - Integer division J. Schultke
Intent
Proposal
Abstract
- C++ supports integer division with rounding towards zero - many other rounding modes are useful:
› P3899R2 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.
› P3924R1 Fix inappropriate font choices for "declaration" J. Schultke
Intent
Proposal
Disposition Date
2026-03Adopted
› P3927R2 task_scheduler Support for Parallel Bulk Execution E. Niebler
Intent
Proposal
Disposition Date
2026-03Adopted
› P3941R4 Scheduler Affinity D. Kühl
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
There are a few NB comments raised about the way `affine_on` works:
› P3948R1 constant_wrapper is the only tool needed for passing constant expressions M. Kretz
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
```cpp "int std:: __polyfunc :: _Base_invoker <false , int >:: _S_call_storage < …" jmp [QWORD PTR [rdi]] "int std:: __polyfunc :: _Base_invoker <false , int >:: _S_call_storage < …" mov eax , 2 ret ```
› P3951R1 String Interpolation Objects B. Revzin
Intent
Proposal
Abstract
The `std::format` approach to formatting offers many significant benefits over the prior `<iostream>`s approach that need not be revisited here. However, `<iostream>` does still have one significant advantage: ordering. It is easy to see at a glance with a long `std::cout` statement which pieces are to be formatted in which order. With `std::format`, as the amount of replacement fields increases,
› P3953R3 Rename std::runtime_format V. Zverovich
Intent
Proposal
Disposition Date
2026-03Adopted
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
› P3961R1 Less double indirection in function_ref (RU-220) Z. Yuan
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
RU-220 calls for allowing skipping indirections when constructing `function_ref` to improve codegen. The proposed change in LWG 4264<sup>[1]</sup> is not strictly an optimization because certain behaviors with and without the change are visible, therefore, need to be made unspecified. This paper (P3961) suggests that, in addition to the change, a subset of the "optimized" cases should be mandated.
› P3978R3 constant_wrapper should unwrap on call and subscript M. Kretz
Intent
Proposal
Disposition Date
2026-03Adopted
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::`
› P3980R1 Task's Allocator Use D. Kühl
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
There are a few NB comments about `task`’s use of allocators:
› P3981R2 Better return types in std::inplace_vector and std::exception_ptr_cast B. Revzin , J. Wakely , T. Kamiński
Intent
Proposal
Disposition Date
2026-03Adopted
› P3982R2 Split strided_slice into extent_slice and range_slice for C++26 T. Kamiński , M. Hoemmen
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
**Addresses [PL007: Define the extent member of the `strided_slice`](https://github.com/cplusplus/nbballot/issues/816)**
› P3983R1 simd object representation D. Towner , R. Arutyunyan
Intent
Proposal
Abstract
The Working Draft makes `simd` types *trivially copyable types*, which allows `std::bit_cast` operations. However, the object representation is unspecified, making the results implementation-defined.
› P3986R1 A Wording Strategy for Inlinable Receivers R. Leahy
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
When a sender and receiver are connected the result is an operation state. That operation state, once started, is the locus of an asynchronous operation which, upon completion, must notify its consumer of said completion (§33.3 [exec.async.ops]). The way this notification is accomplished is by sending a completion signal to the receiver provided when connecting the sender and receiver.
› P4003R2 Ask: A Minimal Coroutine Execution Model V. Falco , M. Gill , S. Gerbino
Intent
Proposal
Abstract
This paper asks the committee to advance the *IoAwaitable* protocol as a standard coroutine execution model.
› P4004R1 Reconsider CWG 1395 "Partial ordering of variadic templates reconsidered" C. Meerwald
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
```cpp template<typename ... T> char *f(T &...); // #1 template<typename T> int *f(T &&); // #2 int i; auto *p = f(i); ```
› P4007R2 Info: Open Issues in `std::execution::task` V. Falco , M. Gill
Intent
Informational
Abstract
`std::execution::task` ([P3552R3](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3552r3.html)[1]) had open issues identified by national ballot comments, LWG issues, and published papers. Croydon resolved several. This paper classifies each issue by whether it can be resolved after C++26 ships or whether shipping forecloses the fix, and notes which classified issues were addressed at Cr
› P4010R1 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.
› P4012R1 value-preserving consteval broadcast to simd::vec M. Kretz
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
1. Novel (no other type in the standard library does this2).
› P4014R1 Info: The Sender Sub-Language For Beginners V. Falco , M. Gill
Intent
Informational
Abstract
Every sender algorithm in C++26 - all thirty - explained, demonstrated, and mapped to its plain-C++ equivalent.
› P4019R1 constant_assert J. Persson
› P4021R2 compile_assert - an assert that evaluates at compile time J. Grant
Intent
Proposal
Abstract
`compile_assert()` provides a way to specify constraint predicates that are validated at compile time and reported to the user via a diagnostic. This proposal specifies the syntax but not the method used to determine a constraint failure.
› P4025R1 The SG19 Priority List for C++29/32 M. Wong , P. Ratzloff
Intent
Proposal
Abstract
Here is the standard WG21 Revision History section formatted for your SG19 direction paper. You can place this near the top of the document, typically right after the title and author block.
› P4028R0 2026-02 Library Evolution Poll Outcomes I. Levi , F. Fracassi , A. Weis , C. Jabot
Intent
Proposal
Abstract
In 2026-02, the C++ Library Evolution group conducted a series of electronic decision polls [[P4027R0]](https://wg21.link/P4027R0). This paper provides the results of those polls and summarizes the results.
› P4029R1 The SG14 Priority List for C++29/32 M. Wong , SG14
Intent
Proposal
Abstract
In low-latency finance, different threads (e.g., market data ingestion vs. order execution) must communicate without OS-level locks or blocking.
› P4031R1 Rename system_context_replaceability namespace R. Arutyunyan
Intent
Proposal
Abstract
This paper proposes to rename `system_context_replaceability` namespace.
› P4032R1 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.
› P4033R0 Synthesizing enum at compile time with define_enum A. Cassagnes
Intent
Proposal
Abstract
The generative capability of reflection as they were introduced in C++26 are limited to `define_aggregate`, with no quick paths to more powerful facilities (See [p3294r2] for example). We can already leverage `define_aggregate` to impressive effects (See a JSON parser [here](https://brevzin.github.io/c++/2025/06/26/json-reflection/)), here we introduce another basic and lightweight building block:
› P4035R0 Info: The Need for Escape Hatches V. Falco
Intent
Informational
Abstract
C++ should make the safe thing easy, and the unsafe thing possible.
› P4037R1 Supporting signed char and unsigned char in random number generation J. Schultke
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
Support for `unsigned char` and `signed char` in distributions would be useful. The ability to generate random bytes or octets is extremely valuable for [fuzz testing](https://en.wikipedia.org/wiki/Fuzzing). For example, when testing an implementation of an [LZ77 or LZ78](https://en.wikipedia.org/wiki/LZ77_and_LZ78) compression algorithm, a user would typically
› P4038R0 Slides for P3969R0 - Fixing std::bit_cast of types with padding bits J. Schultke
› P4040R0 Case ranges J. Schultke
Intent
Proposal
Abstract
The benefit of the range syntax is obvious: when there are several contiguous cases, it is much more concise than listing each case individually.
› P4042R0 Fix LWG4543: incorrect cast between simd::vec and simd::mask [...] M. Kretz
Intent
Proposal
Abstract
| Document Number: | P4042R0 | | --- | --- | | Date: | 2026-03-18 | | Reply-to: | Matthias Kretz <m.kretz@gsi.de> | | Audience: | LWG | | Target: | C++26 |
› P4043R0 Are C++ Contracts Ready to Ship in C++26? D. Neațu
Intent
Proposal
Abstract
The C++ Contracts facility introduced by P2900 represents a major addition to the C++ language, intended to support specification of program correctness through preconditions, postconditions, and assertions.
› P4044R0 Just `pre!`. Mandatory precondition for contracts. L. Teodorescu
Intent
Proposal
Abstract
C++26 contracts support a wide range of uses, but they currently cannot reliably enforce *UB-safety*. Because preconditions may be evaluated with *ignore* semantics, a library that relies on contract preconditions to prevent undefined behavior cannot guarantee that those checks will execute.
› P4049R0 Relaxing and extending std::copy G. D'Angelo
Intent
Proposal
Abstract
In this table we’re summarizing the status quo and the changes brought by the options and extensions illustrated above. The table refers to `std::copy`, but similar changes are expected for the other algorithms of the family.
› P4052R0 Renaming saturation arithmetic functions J. Schultke , C. Jabot
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
Saturation arithmetic functions should be renamed. This paper resolves NB comment [[FR-026-265]](https://github%2ecom/cplusplus/nbballot/issues/840).
› P4088R0 Info: What C++20 Coroutines Already Buy The Standard V. Falco
Intent
Informational
Abstract
C++ already got an asynchronous model: regular C++20 coroutines.
› P4089R0 Info: On the Diversity of Coroutine Task Types V. Falco
Intent
Informational
Abstract
The Environment parameter in `std::execution::task` makes cross-library coroutine interoperability structurally impossible without knowing every query by name.
› P4090R0 Info: Sender I/O: A Constructed Comparison V. Falco
Intent
Informational
Abstract
The sender composition algebra does not apply to compound I/O results without losing data, and the construction that preserves all data produces code identical to the coroutine version.
› P4091R0 Info: Error Models of Regular C++ and the Sender Sub-Language V. Falco
Intent
Informational
Abstract
Both coroutines and senders destroy compound data at an abstraction floor - the difference is that the sender floor sits below the composition algebra, and the coroutine floor is opt-in.
› P4092R0 Info: Consuming Senders from Coroutine-Native Code V. Falco , S. Gerbino
Intent
Informational
Abstract
A single class template bridges sender-based code into coroutine-native I/O with inline operation state, correct stop propagation, and automatic dispatch-back.
› P4093R0 Info: Producing Senders from Coroutine-Native Code V. Falco , S. Gerbino
Intent
Informational
Abstract
Coroutine-native awaitables can be wrapped as senders, but compound I/O results must be reduced to an error code before crossing the bridge.
› P4094R0 Info: The Unification of Executors and P0443 V. Falco
Intent
Informational
Abstract
The unification of three working executor models had unanticipated downstream consequences.
› P4095R0 Info: The Basis Operation and P1525 V. Falco
Intent
Informational
Abstract
Of the four deficiencies that [P1525R0](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1525r0.pdf)[1] identified in `execute(F&&)`, three do not arise under the original framing of the callable as a continuation, and the fourth addresses a different question.
› P4096R0 Info: Coroutine Executors and P2464R0 V. Falco
Intent
Informational
Abstract
The committee set aside the Networking TS in 2021. The process had no mechanism to verify that the analysis examined every applicable framing, and no mechanism to revisit the outcome against evidence.
› P4097R0 Info: The Networking Claim and P2453R0 V. Falco
Intent
Informational
Abstract
The committee expressed consensus that sender/receiver is a good basis for networking. The published evidence behind that word is documented here.
› P4098R0 Info: Async Claims and Evidence V. Falco
Intent
Informational
Abstract
Published claims about executors, networking, and unification shaped a decade of committee decisions. The published evidence behind those claims is documented here.
› P4099R0 Info: The Twenty-One Year Networking Arc V. Falco
Intent
Informational
Abstract
Four decisions, each locally reasonable, each under-evidenced, produced a decade without networking in the C++ standard.
› P4100R0 Info: Coroutine-Native I/O for C++29 (The Network Endeavor) V. Falco , S. Gerbino , M. Vandeberg , M. Gill , M. Nejati
Intent
Informational
Abstract
C++ coroutines have five language mechanisms that combine into the ideal substrate for coroutine-native I/O.
› P4101R0 Consteval-only Values for C++26 B. Revzin , P. Dimov , D. Vandevoorde , D. Katz
Intent
Proposal
Abstract
The Reflection design from [[P2996R13]](https://wg21.link/p2996r13) was based on a model of having consteval-only types to prevent reflections from leaking to runtime. But we’ve run into issues and limitations with that approach, so we propose that, for C++26, we change instead to a consteval-only value model. This solves the same problems, but has additional benefits.
› P4102R0 Container insertion and erasure should be allowed to relocate G. D'Angelo
Intent
Proposal
Abstract
The sequence containers `vector`, `inplace_vector` and `deque` store their elements in contiguous storage (or, in the case of `deque`, in blocks of contiguous storage). When an element is erased from the middle of such a container, the elements after the erased position must be shifted to fill the gap. Similarly, when an element is inserted in the middle, the existing elements must be shifted to m
› P4125R0 Info: Coroutine-Native I/O at a Derivatives Exchange M. Gill
Intent
Informational
Abstract
A derivatives exchange is porting from Asio callbacks to coroutine-native I/O. Early results: it works.
› P4126R0 Info: A Universal Continuation Model V. Falco , K. Morgenstern
Intent
Informational
Abstract
Senders pay a frame allocation to enter the awaitable protocol. They do not have to.
› P4135R0 Consteval-only Types W. Childers
Intent
Proposal
Abstract
If we take a step back and talk about types, a fundamental tenet is that types have invariants. These invariants are ultimately what drive many of the semantics of a C++ program. C++ would not be where it is today without RAII and RAII could not exist without a notion of invariants.
› P4136R1 #line is not in line with existing practices C. Jabot
Intent
Proposal
Abstract
line-directive: # line pp-tokens new-line The string-literal of a #line directive, if present, shall be a character string literal. The line number of the current source line is the line number of the current physical source line, i.e., it is one greater than the number of new-line characters read or introduced in translation phase 1[lex.phases] while processing the source file to the current prep
› P4137R0 Info: Profile Analysis and Verification Evidence (PAVE) V. Falco
Intent
Informational
Abstract
The paper offers a way to measure what the type-safety profile actually covers.
› P4138R2 CWG3103 “Corresponding members and by-value object parameters” V. Serebrennikov
Intent
Proposal
Abstract
While looking at [CWG3103](https://cplusplus.github.io/CWG/issues/3103.html), I got interested how we arrived at status quo, specifically how [[basic.scope.scope]/3.1](https://wg21.link/basic.scope.scope#3.1) came to be, and this is what I found. One of the conclusions I arrived at is that it doesn’t make much sense to overload member functions with explicit object parameter of non-reference type
› P4139R1 Better better lookups N. Myers , P. Halpern
Intent
Proposal
Abstract
``` Document #: P4139R1 Date: 2026-03-23 Project: ISO SC22/WG21 Programming Language C++ Title: Better better lookup Reply-to: ncm@cantrip.org Authors: Nathan Myers, Pablo Halpern Target: C++29 Audience: LEWG ```
› P4140R0 Proposed resolution for US70-126: allow incomplete types in type_order G. Ažman
Intent
Proposal
Disposition Date
2026-03Adopted
› P4142R0 Consteval Only Types Slides W. Childers
› P4143R0 Constant evaluation when? S. Herring
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
This paper partially addresses US 33 (065) by clarifying what evaluations of a (putative) constant expression take place. It does not proceed further as would be necessary to support visible side effects during translation (*e.g.*, output as in [P2758](https://www.open-std.org/JTC1/SC22/WG21/docs/papers/2025/p2758r5.html)) because those do not exist in C++26.
› P4144R1 Remove span's initializer_list constructor for C++26 M. Hoemmen , T. Kamiński , T. Song , J. Wakely
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
This paper expresses [LWG4520](https://cplusplus.github.io/LWG/issue4520) and proposes fixing it by reverting adoption of [P2447R6](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2447r6.html).
› P4145R0 C++ Standard Library Ready Issues to be moved in Croydon, Mar. 2026 J. Wakely
Intent
Proposal
Disposition Date
2026-03Adopted
› P4146R0 C++ Standard Library Immediate Issues to be moved in Croydon, Mar. 2026 J. Wakely
Intent
Proposal
Disposition Date
2026-03Adopted
› P4148R0 protocol: Structural Subtyping for C++ J. Coe , H. Dusikova , A. Peacock , P. Craig , N. Banglawala
Intent
Proposal
Abstract
We propose `protocol<T,` `A>` and `protocol_view<T>`, standard library vocabulary types for structural subtyping in C++. Interfaces are specified as plain structs; any type whose member functions satisfy the interface is accepted without requiring explicit inheritance.
› P4149R1 Define "immediate context" A. Krzemieński , B. Bi
Intent
Proposal
Disposition Date
2026-03Adopted
› P4150R0 Multidimensional Index-based For Each N. Morales , M. Hoemmen , B. Lelbach , D. Lebrun-Grandie
Intent
Proposal
Abstract
| **Before** | **After** | | --- | --- | | `std::ranges::for_each( std::execution::par_unseq, std::views::cartesian_product( std::views::indices(A.extent(0)), std::views::indices(A.extent(1))), [=] (auto idx) { auto [i, j] = idx; B[j, i] = A[i, j]; });` | `std::for_each_index( std::execution::par_unseq, A.mapping(), [=] (auto i, auto j) { B[j, i] = A[i, j]; });` |
› P4151R1 Rename affine_on R. Leahy
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
When `std::execution::affine_on` was added [1] it was a binary-invocable object accepting two parameters, respectively:
› P4154R0 Renaming various execution things T. Song , R. Arutyunyan , A. O’Dwyer
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
This paper provides replacement wording for the following papers:
› P4155R0 Responding to type erasure requirements for trivial relocation O. Hunt
Intent
Proposal
Abstract
P3937 presents a discussion of the type erasure requirements for any future trivial relocation feature in C++. This paper is a very short response to that paper addressing various issue in the presented requirements, and erroneous technical arguments.
› P4156R0 Rename meta::has_ellipsis_parameter to meta::is_vararg_function V. Voutilainen
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
This paper proposes wording to resolve the NB comment [FR-017-155](https://github.com/cplusplus/nbballot/issues/734).
› P4157R0 LEWG Slides for P3666R3 J. Schultke
Intent
Proposal
Abstract
C23 now has `_BitInt` type for N-bit integers (WG14 N2763, N2775):
› P4158R0 Subsetting and restricting C++ for memory safety O. Hunt
› P4159R0 Make sender_to and receiver_of exposition-only T. Song
Intent
Proposal
Disposition Date
2026-03Adopted
Abstract
In response to LEWG direction on [LWG4361], this paper provides wording to make the `receiver_of` and `sender_to` concepts exposition-only for C++26.
› P4160R0 Core Language Working Group "ready" Issues for the March, 2026 meeting J. Maurer
Intent
Proposal
Disposition Date
2026-03Adopted
› P4161R0 std::fewer J. Snyder , J. Coe , N. Banglawala
› P4168R0 Fix defects in floating-point std::from_chars (LWG3081, LWG3082, LWG3456) J. Schultke
Intent
Proposal
Abstract
This paper supersedes [[P2827R1]](https://wg21%2elink/p2827r1) and fixes [[LWG3081]](https://wg21%2elink/LWG3081), [[LWG3082]](https://wg21%2elink/LWG3082), and [[LWG3456]](https://wg21%2elink/LWG3456). It is intended as a defect report for C++17. The handling of floating-point overflow and underflow in `std::from_chars` is inconsistent; the implementations diverge from each other, and every imple
› P4172R0 Info: IoAwaitable for Coroutine-Native Byte-Oriented I/O V. Falco , S. Gerbino
Intent
Informational
Abstract
This paper documents the design rationale for the *IoAwaitable* protocol.
› P4173R0 A range facility for mdspan H. Kang
Intent
Proposal
Abstract
Standard `mdspan` accessors, such as `default_accessor`, are specialized for use with raw pointers. While `mdspan`'s design allows for custom accessors, providing a standardized iterator-based accessor simplifies integration with ranges such as views and containers.
› P4174R0 Named, composable type sets for concept constraints E. Spiridon
Intent
Proposal
Abstract
This paper explores the possibility of adding a library addition to <type_traits> to assist the programmer when writing concept constraints. Concept constraints can be written by using the std::is_same_v tool, however the compile time logic is hard to understand, and at times, are error-prone at scale. An issue that modern concept constraints have is that, despite how simple it is once you impleme
› P4175R0 Lift some arbitrary CTAD restrictions M. Izvekov
Intent
Proposal
Abstract
This paper proposes to relax some Class Template Argument deduction (CTAD) restrictions which were originally put in place for no well motivated reason other than simplicity and being conservative.
› P4176R0 Grammar non-terminals for postfix-expressions V. Serebrennikov
Intent
Proposal
Abstract
7.6.1 [[expr.post]](https://wg21.link/expr.post) lists all the grammar at the top, while the rest of the subclause resorts to either quoting the grammar or describing it with words. This paper aims to improve the situation, introducing new nonterminals and putting their definitions in the respective subclauses.
› P4179R0 view_interface::[c]rbegin() H. Kang
Intent
Proposal
Abstract
This paper provides `rbegin()`/`rend()`/`crbegin()`/`crend()` methods to `ranges::view_interface`, making its interface more symmetric with the existing `cbegin()`/`cend()` members and enhancing convenience for views. Revision history R0 Initial revision. Discussion In C++23, `view_interface` added `cbegin()`/`cend()` members to improve const-correctness and interface consistency. However, it stil
› P4182R0 Info: A Citable Inventory of Platforms, Operating Systems, and Compiler Toolchains M. Gill
Intent
Informational
Abstract
Every mailing repeats the same deployment background. This paper puts one citeable inventory in the record.
› P4186R0 A Plan For Profiles P. Bindels
Intent
Proposal
Abstract
This paper proposes a tentative plan for making progress on safety and profiles in C++. If adopted, this plan could allow SG23, EWG, and CWG to finalise the design and wording for profiles in time for inclusion of this feature in C++29.
› P4188R0 Extensible Math Functions for C++ S. Gros-Lemesre
› P4190R0 Restore span's initializer_list constructor for C++29 M. Hoemmen , H. Dusíková , R. Parolin
Intent
Proposal
Abstract
[P4144R1](https://isocpp.org/files/papers/P4144R1.html) reverted [P2447R6](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2447r6.html) by removing `span`’s `initializer_list` constructor. We propose to add it back in C++29, but with constraints this time, in order to avoid the unfortunate conversions that led to its removal.
› P4191R0 is_nothrow_connectable_in R. Leahy
Intent
Proposal
Abstract
Under the original design of `std::execution` [1] one could check whether or not `std::execution::connect` threw an exception via:
› P4192R0 Better specification of alignment V. Serebrennikov
Intent
Proposal
Abstract
There are multiple open Core issues against 6.8.3 [[basic.align]](https://wg21.link/basic.align) ([1211](https://cplusplus.github.io/CWG/issues/1211.html), [2840](https://cplusplus.github.io/CWG/issues/2840.html)) and 9.13.2 [[dcl.align]](https://wg21.link/dcl.align) ([1617](https://cplusplus.github.io/CWG/issues/1617.html), [2223](https://cplusplus.github.io/CWG/issues/2223.html), [3024](https://
› P4197R0 Design questions for trivial relocation in C++29 G. D'Angelo
Intent
Proposal
Abstract
Trivial relocation has been a long-standing goal for C++. Multiple proposals have been put forward over the years, most notably [P1144R12] and [P2786R13], each with a different design and different tradeoffs. In the C++26 cycle, [P2786R13] was adopted in Hagenberg, but was ultimately removed from the C++26 Working Draft in Kona due to a number of unresolved design concerns.
