› P0870R8 A proposal for a type trait to detect narrowing conversions G. D'Angelo
› P0876R24 fiber_context - fibers without scheduler O. Kowalke , N. Goodspeed
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).
› P2019R9 Thread attributes C. Jabot
Disposition Date
2026-06
Abstract
Most operating systems, including real-time operating systems for embedded platforms, provide a way to name threads.
› P2434R5 Nondeterministic pointer provenance S. Herring
Disposition Date
2026-06
Abstract
[P2318R1](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2318r1.pdf) describes a variety of plausible models of pointer provenance that differ principally in how they handle conversions between pointers and integers (including the integer values of the storage bytes for a pointer). (See its §A.4 for discussion of the variants in terms of examples.) It proposes the variant called PNVI-ae-
› P2956R3 Add saturating library support to std::simd D. Towner , R. Arutyunyan
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
› P3049R2 node-handles for lists M. Hava
Abstract
Node handles are an over-specified solution to the relatively simple problem of moving nodes between associative containers, which can be done with a more conservative interface similar to std::list::splice. There is a lack of consistency with std::list, where splicing and merging can be done but there is no node handle-based interface, yet lists are indeed node based, too. P00832 acknowledges the
› P3091R6 Better lookups for `map` , `unordered_map`, and `flat_map` P. Halpern
Disposition Date
2026-06
Abstract
The most convenient way to look up an element of a `map` -like container is to use the index operator, i.e., `theMap[key]` . This operator cannot be used, however, when 1) the container is `const` , 2) the mapped type is not default constructible, 3) the default-constructed value is inappropriate for the context, or 4) the container should not be modified. These limitations often force the user to
› P3104R6 Bit permutations J. Schultke
Disposition Date
2026-06
Abstract
The C++ bit manipulation library in `<bit>` is an invaluable abstraction from hardware operations. Functions like `countl_zero` help the programmer avoid use of intrinsic functions or inline assembly.
› P3125R6 constexpr pointer tagging H. Dusíková
Disposition Date
2026-06
Abstract
Pointer tagging is widely known and used technique ([Glasgow Haskell Compiler](https://takenobu-hs.github.io/downloads/haskell_ghc_illustrated.pdf), LLVM's `[PointerIntPair](https://github.com/llvm/llvm-project/blob/8e5aa538caccef167e8096b2173fdaf2be9cc129/llvm/include/llvm/ADT/PointerIntPair.h#L80)`, `[PointerUnion](https://github.com/llvm/llvm-project/blob/8e5aa538caccef167e8096b2173fdaf2be9cc12
› P3154R3 Deprecating signed character types in iostreams E. Kosunen
› P3211R2 views::flat_map H. Kang
Abstract
We propose `views::flat_map`, a range adaptor that applies a function returning a range for each element, then flattens the result. This pattern, commonly known as *flat mapping*, is widespread in functional programming and data processing. Providing it as a dedicated view improves readability and expressiveness, and also opens opportunities for optimization in lazy evaluation contexts.
› P3216R3 views::slice H. Kang
Abstract
This paper proposes the Tier 1 adaptor `views::slice` (as described in [P2760](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2760r1.html)) to enhance the C++29 ranges library. Notably, this is the first standard range adaptor that accepts two arguments — `start` and `end` — to specify the interval [`start`, `end`) for slicing a range.
› P3220R3 views::take_before H. Kang
Abstract
This paper proposes the Tier 1 adaptor in [P2760](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2760r1.html): `views::delimit`, which is renamed into `views::take_before` along with its corresponding view class to improve the C++29 ranges facilities.
› P3230R3 views::unchecked_(take|drop) H. Kang
Abstract
This paper proposes two Tier 1 adaptors in [P2760](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2760r1.html): `views::unchecked_drop` and `views::unchecked_take`, cousins of `drop` and `take`, to improve the C++26 ranges facilities, which were renamed to `views::unchecked_take` and `views::unchecked_drop` after Tokyo WG21, as "unchecked" better describes the utility's nature than "exa
› P3242R4 Copy and fill for mdspan N. Morales , C. Trott , M. Hoemmen , D. Lebrun-Grandie
Disposition Date
2026-06
Abstract
C++23 introduced `mdspan` ([P0009R18]), a non-owning multidimensional array abstraction that has a customizable layout. Layout customization was originally motivated in [P0009R18] with considerations for interoperability and performance, particularly on different architectures. Moreover, [P2630R4] introduced `submdspan`, a slicing function that can yield arbitrarily strided layouts. However, witho
› P3248R5 Require [u]intptr_t G. Gadeschi
Disposition Date
2026-06
Abstract
Proposals like [P2835](https://wg21.link/p2835) and [P3125](https://wg21.link/P3125) use `[u]intptr_t` as an integer type capable of holding a pointer value in their APIs<sup>[1]</sup>. However, `[u]intptr_t` being *optional* forces sub-optimal design choices such as making APIs optional or introducing workarounds.
› P3296R6 let_async_scope A. Williams
› P3319R6 Add an iota object for simd (and more) M. Kretz
Disposition Date
2026-06
Abstract
There is one important constant in SIMD programming: `0,` `1,` `2,` `3,` `...`. In the standard library we have an algorithm called `iota` that can initialize a range with such values. For `simd` we want to have simple to spell constants that scale with the SIMD width. This paper proposes a simple facility that can be generalized.
› P3367R5 constexpr coroutines H. Dusíková
Abstract
Currently C++'s [doesn't allow coroutines to be `constexpr`](https://eel.is/c++draft/dcl.constexpr#3.1). This limitation forces users to choose between having `constexpr` compatible library or (maybe) simpler coroutine interface. As a library author I do prefer `constexpr` but I do not want to make this decision.
› P3395R6 Fix encoding issues and add a formatter for std::error_code V. Zverovich
Disposition Date
2026-06
Abstract
This paper proposes making `std::error_code` formattable using the formatting facility introduced in C++20 (`std::format`) and fixes encoding issues in the underlying API ([LWG4156]).
› P3427R6 Hazard Pointer Synchronous Reclamation M. Michael , M. Wong , P. McKenney , M. Wever
Abstract
Hazard pointer interface from P2530R3 merged into the working draft (N5008):
› P3505R4 Fix the default floating-point representation in std::format V. Zverovich , J. Jeon
Disposition Date
2026-06
Abstract
When `std::format` was proposed for standardization, floating-point formatting was defined in terms of `std::to_chars` to simplify specification. While being a positive change overall, this introduced a small but undesirable change compared to the design and reference implementation in [FMT], resulting in surprising behavior to users, performance regression and an inconsistency with other mainstre
› P3642R6 Carry-less product: std::clmul J. Schultke
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 `+`.
› P3655R5 cstring_view P. Bindels , H. Dusikova , J. Rifkin , M. Foco , A. Shevlyakov
Abstract
We propose a standard string view type that guarantees null-termination.
› P3669R4 Non-Blocking Support for `std::execution` D. Vollmann
Abstract
Some execution environments want to make sure that specific operations are non-blocking. These can not signal an event using the facilities of `std::execution` as currently specified as it doesn’t provide operations that are guaranteed to be non-blocking.
› P3772R2 std::simd overloads for bit permutations J. Schultke
Disposition Date
2026-06
Abstract
[[P3104R4]](https://wg21%2elink/p3104r4) has been been design-approved by LEWG for C++29. During the discussion of the paper, it was *not* mentioned that [[P2933R4]](https://wg21%2elink/p2933r4) adds `std::simd` overloads for almost all functions in the `<bit>` header.
› P3785R1 Library Wording Changes for Defaulted Postfix Increment and Decrement Operators M. Taylor , A. (Waffl3x)
› P3790R2 Pointer lifetime-end zap proposed solutions: Bag-of-bits pointer class P. McKenney , M. Michael , J. Maurer , P. Sewell , H. Boehm , H. Tong , N. Douglas , T. Rodgers , W. Deacon , M. Wong , D. Goldblatt , K. Serebryany , A. Williams , T. Scogland , J. Bastien , D. Krügler , D. Tenty
Author(s)
Paul E. McKenney , Maged Michael , Jens Maurer , Peter Sewell , Hans Boehm , Hubert Tong , Niall Douglas , Thomas Rodgers , Will Deacon , Michael Wong , David Goldblatt , Kostya Serebryany , Anthony Williams , Tom Scogland , JF Bastien , Daniel Krügler , David Tenty
Abstract
The C++ standard currently specifies that all pointers to an object become invalid at the end of its lifetime [basic.life]. Although this permits additional diagnostics and optimizations which might be of some value, it is not consistent with long-standing usage, especially for a range of concurrent and sequential algorithms that rely on loads, stores, equality comparisons, and even dereferencing
› P3791R1 constexpr deterministic random H. Dusíková
Abstract
Algorithms `shuffle`, `sample` are useful even in compile time, same applies to random distribution types which are fully deterministic.
› P3793R2 Better shifting B. Bi , J. Schultke
Disposition Date
2026-06
Abstract
C++ has built-in shift operators, `<<` and `>>`, inherited from C with semantics essentially unchanged, including the following two inconvenient properties:
› P3806R1 views::cycle H. Kang
Abstract
This paper proposes adding `views::cycle`, a Tier 1 range adaptor as described in [P2760](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2760r1.html), to enhance the C++29 Ranges library by enabling infinite repetition of a range's elements.
› P3928R1 static_sized_range H. Kang
Abstract
This paper introduces `static_sized_range`, a refinement of `sized_range` for ranges whose sizes are known at compile time.
› P4188R1 Extensible Math Functions for C++ S. Gros-Lemesre
› P4291R0 views::unique H. Kang
Abstract
This paper proposes a range adaptor `views::unique` that filters out consecutive equivalent elements from a range, leaving only one element from each group of consecutive equivalent elements. This adaptor complements the existing `std::unique` algorithm by providing a composable, lazy, and allocation-free view for a common filtering operation.
› P4294R0 views::take_last and views::drop_last H. Kang
Abstract
This paper proposes two new range adaptors, `views::take_last` and `views::drop_last`, that respectively produce the last *N* elements of a range and all-but-the-last *N* elements of a range. They mirror the shape of the existing `views::take` / `views::drop` adaptors and fill an obvious gap in the standard range adaptor set.
