› P0876R22 fiber_context - fibers without scheduler
Oliver Kowalke
O. Kowalke
,
Nat Goodspeed
N. Goodspeed
2026-02
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).
› P2583R0 Symmetric Transfer and Sender Composition
Mungo Gill
M. Gill
,
Vinnie Falco
V. Falco
2026-02
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
Eddie Nolan
E. Nolan
2026-02
› P2929R2 simd_invoke
Daniel Towner
D. Towner
,
Ruslan Arutyunyan
R. Arutyunyan
2026-02
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
› P2964R2 Allowing user-defined types in std::simd
Daniel Towner
D. Towner
,
Ruslan Arutyunyan
R. Arutyunyan
2026-02
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
Mateusz Pusz
M. Pusz
,
Dominik Berner
D. Berner
,
Johel Ernesto Guerrero Peña
J. Peña
,
Charles Hogg
C. Hogg
,
Nicolas Holthaus
N. Holthaus
,
Roth Michaels
R. Michaels
,
Vincent Reverdy
V. Reverdy
2026-02
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 [[
› P3385R7 Attributes reflection
Aurelien Cassagnes
A. Cassagnes
2026-02
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`
Hui Xie
H. Xie
,
S. Levent Yilmaz
S. Yilmaz
,
Louis Dionne
L. Dionne
,
Patrick Roberts
P. Roberts
2026-02
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
Daniel Towner
D. Towner
2026-02
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:
› P3642R4 Carry-less product: std::clmul
Jan Schultke
J. Schultke
2026-02
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
Jan Schultke
J. Schultke
2026-02
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
› P3724R3 Integer division
Jan Schultke
J. Schultke
2026-02
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!
Jan Schultke
J. Schultke
2026-02
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:
› P3856R5 New reflection metafunction - is_structural_type (US NB comment 49)
Jagrut Dave
J. Dave
,
Alisdair Meredith
A. Meredith
2026-02
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
› P3936R1 Safer atomic_ref::address (FR-030-310)
Corentin Jabot
C. Jabot
2026-02
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.
› P3941R2 Scheduler Affinity
Dietmar Kühl
D. Kühl
2026-02
Intent
Proposal
Abstract
There are a few NB comments raised about the way `affine_on` works:
› P3953R1 Rename std::runtime_format
Victor Zverovich
V. Zverovich
2026-02
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
› P3969R0 Fixing std::bit_cast of types with padding bits
Jan Schultke
J. Schultke
2026-02
Intent
Proposal
Abstract
The following use of `std::bit_cast` has undefined behavior at compile time:
› P3971R0 Generalised type rebinding for structures of uniform elements
Daniel Towner
D. Towner
2026-02
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
Daniel Towner
D. Towner
2026-02
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
› P3978R2 constant_wrapper should unwrap on call and subscript
Matthias Kretz
M. Kretz
2026-02
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
Dietmar Kühl
D. Kühl
2026-02
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
Barry Revzin
B. Revzin
,
Jonathan Wakely
J. Wakely
,
Tomasz Kamiński
T. Kamiński
2026-02
› P3982R0 Fix the meaning of strided_slice::extent for C++26
Tomasz Kamiński
T. Kamiński
,
Mark Hoemmen
M. Hoemmen
2026-02
Intent
Proposal
Abstract
**Addresses [PL007: Define the extent member of the `strided_slice`](https://github.com/cplusplus/nbballot/issues/816)**
› P3983R0 simd object representation
Daniel Towner
D. Towner
2026-02
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.
› P4003R0 Coroutines for I/O
Vinnie Falco
V. Falco
,
Mungo Gill
M. Gill
,
Steve Gerbino
S. Gerbino
2026-02
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
› P4006R0 Transparent Function Objects for Shift Operators
Daniel Towner
D. Towner
2026-02
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
Vinnie Falco
V. Falco
,
Mungo Gill
M. Gill
2026-02
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
› P4012R0 value-preserving consteval broadcast to simd::vec
Matthias Kretz
M. Kretz
2026-02
Intent
Proposal
Abstract
1. Novel (no other type in the standard library does this2).
› P4014R0 The Sender Sub-Language
Vinnie Falco
V. Falco
,
Mungo Gill
M. Gill
2026-02
Intent
Proposal
Abstract
C++26 introduces a rich sub-language for asynchronous programming through `std::execution` ([P2300R10](https://wg21.link/p2300r10))[1].
› P4022R0 Remove try_append_range from inplace_vector for now
Barry Revzin
B. Revzin
,
Jonathan Wakely
J. Wakely
,
Tomasz Kamiński
T. Kamiński
2026-02
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`:
› P4030R0 Endian Views
Eddie Nolan
E. Nolan
2026-02
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
Ruslan Arutyunyan
R. Arutyunyan
2026-02
Intent
Proposal
Abstract
This paper proposes to rename `system_context_replaceability` namespace.
