› P0260R20 C++ Concurrent Queues D. Vollmann , L. Crowl , C. Mysen , G. Nishanov
Abstract
Queues provide a mechanism for communicating data between components of a system.
› P0870R8 A proposal for a type trait to detect narrowing conversions G. D'Angelo
› P1040R11 std::embed and #depend J. Meneide
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
› P2721R1 Deprecating function in C++29 M. Hava
Abstract
**Poll:** Forward “P2721R0: Deprecating function” to LWG for C++26 (to be confirmed by an electronic poll).
› P2728R14 Unicode in the Library, Part 1: UTF Transcoding E. Nolan
› P2906R2 Structured bindings for std::extents B. Gruber , Y. Wang , M. Hoemmen
Abstract
[[P0009R18]](https://wg21.link/p0009r18) proposed `std::mdspan`, which was approved for C++23. It comes with the utility class template `std::extents` to describe the integral extents of a multidimensional index space. Practically, `std::extents` models an array of integrals, where some of the values can be specified at compile-time. However, `std::extents` behaves very little like an array. A not
› P2964R5 Allowing user-defined types in std::simd D. Towner , R. Arutyunyan
Abstract
The C++ standard library includes data-parallel types in the `<simd>` header, currently restricting element types to a closed list of *built-in vectorizable* types: arithmetic types and `std::complex` specializations. This paper proposes a minimal change to the specification in which this list is extended. Firstly, `std::byte` is added to the closed list as a standard library type with fixed seman
› P3045R9 Quantities and units library M. Pusz , D. Berner , J. Peña , C. Hogg , N. Holthaus , R. Michaels , V. Reverdy
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 [[
› P3099R3 Contracts for C++: User-defined diagnostic messages T. Doumler , P. Bindels , J. Berne
Abstract
* Updated Section 2.6 “Constant evaluation”; specified behaviour for unevaluated contexts, discarded contexts, SFINAE, and trial evaluation
› P3100R7 A framework for systematically addressing undefined behaviour in the C++ Standard T. Doumler , J. Berne
Abstract
In this paper, we enumerate all cases of core language undefined behaviour explicitly specified in the C++ Standard, group them into ten categories, and classify them along a number of relevant criteria.
› 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
› P3155R1 noexcept policy for SD-9 (The Lakos Rule) T. Doumler , J. Lakos
› 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
› P3290R6 Integrating Existing Assertions With Contracts J. Berne , T. Doumler , J. Lakos
Abstract
* Presenting feedback from SG22 on the `assert` macro choices, including new subsections on implementation-defined integration and throwing violation handlers
› P3385R8 Attributes reflection A. Cassagnes
Abstract
Attributes are used to a great extent, and there is new attributes being added to the language somewhat regularly. As reflection makes its way into our standard, we are missing a way for generic code to look into the attributes appertaining to an entity. That is what this proposal aims to tackle by introducing the building blocks.
› 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.
› P3771R1 constexpr mutex, locks, and condition variable H. Dusíková
Abstract
It's really hard to conditionally avoid non-`constexpr` types in a code which is supposed to be `constexpr` compatible. This paper fixes it by making these types (and algorithms) `constexpr` compatible. There is no semantical change for updated types and algorithms.
› 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
› 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.
› P3832R3 Timed lock algorithms for multiple lockables T. Lyngmo
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.
› P3833R3 std::unique_multilock T. Lyngmo
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
› P3850R1 A proposed plan for extending Contracts in C++29 T. Doumler , J. Berne
Abstract
At the March 2026 WG21 meeting in Croydon, the ISO C++ committee completed the C++26 Standard, including the addition of *contract* assertions. This milestone is the result of a sustained effort by the authors of [[P2900R14](https://wg21.link/p2900r14)] and the WG21 subgroups responsible for evaluating the proposal: SG21, EWG, and CWG. This success was made possible in part by the existence of a c
› 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.
› P3935R2 Rebasing <cmath> on C23 J. Schultke
Abstract
[[P3348R4]](https://wg21%2elink/p3348r4) rebased the C++26 standard on C23; it previously referred to C17. However, this process was deliberately left incomplete: some of the new C23 `<math.h>` features are only used by decimal floating-point types, or they require core language changes, etc.
› P3969R2 Fixing std::bit_cast of types with padding bits J. Schultke
Abstract
> The following use of `std::bit_cast` has undefined behavior at compile time: > > ```cpp > constexpr auto x = std::bit_cast<__int128>(0.0L); // GCC accepts (x = 0), Clang rejects > ``` > > That is because an 80-bit x87 `long double` has 6 bytes of padding, and it is undefined behavior to map those padding bits onto non-padding bits in the destination type via `std::bit_cast`. [[bit.cast]](https:/
› P4030R1 Endian Views E. Nolan
Abstract
The main reason for adding these views is to assist users of the UTF transcoding range adaptors (see [[P2728R11]](https://wg21.link/p2728r11)). 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 encodi
› P4157R1 LEWG Slides for P3666R4 J. Schultke
Abstract
C23 now has `_BitInt` type for N-bit integers (WG14 N2763, N2775):
› P4188R1 Extensible Math Functions for C++ S. Gros-Lemesre
› P4217R1 when_all() is just just() R. Leahy
Abstract
The standard currently specifies, by fiat, that `std::execution::when_all()` is ill-formed (§33.9.12.12 [exec.when.all]):
› P4220R1 Design goals for zstring_view A. Krzemieński
Abstract
During the 2025 Sofia meeting, LEWG declared consensus to spend more time on `zstring_view` ([[P3655R4]](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2026/p3655r4.html)). This paper follows the direction. We want to make sure that the design goals for `zstring_view` are clearly understood before any decisions whether to even have it, or in what form, are made.
› P4221R3 Atomic Compare M. Michael , P. McKenney , M. Wong
Abstract
This paper proposes adding a `compare_load` member function to `std::atomic<T>` and `std::atomic_ref<T>`, alongside corresponding free functions. This function performs an atomic comparison of the atomic object's value with an expected value, following the same value representation comparison semantics as `compare_exchange_strong`. It updates the expected argument on failure, operating entirely as
› P4226R0 2026-05 Library Evolution Poll Outcomes I. Levi , F. Fracassi , A. Weis , C. Jabot
Abstract
In 2026-05, the C++ Library Evolution group conducted an electronic poll [[P4225R0]](https://wg21.link/P4225R0). This paper provides the results of this poll and summarizes the responses.
› P4243R0 `zip()` Should Be Ill-formed H. Xie , T. Melen
Abstract
This paper proposes a fix that makes the `views::zip()` ill-formed instead of the current `views::empty<tuple<>>`.
› P4254R0 Throwing Violation Handlers Are Post Hoc Library Design R. Leahy
Abstract
The Lakos Rule [1] has long been treated as a trump card in LEWG: A proposal contains a function with a precondition which is declared `noexcept`, someone in the room invokes “the Lakos Rule,” and the function must presumptively be redesigned to remove the `noexcept`. This has impeded the adoption of `noexcept` in the library, and has led to arguably-ridiculous consequences (e.g. `std::vector::ope
› P4257R0 Marking wide contract non-throwing functions noexcept is not controversial N. Liber
Abstract
For C++11, LWG (there was no LEWG) was being very arbitrary about which non-throwing functions to mark `noexcept`.
› P4259R0 The name of the floor division function should probably have floor in it B. Revzin
Abstract
In 1962, Kenneth Iverson introduced the names “floor” and “ceiling”, and the syntax `⌊x⌋` and `⌈x⌉`, for operations that return the greatest integer less than or equal to `x` and the smallest integer greater than or equal to `x`, respectively. Since then, these names have become broadly used in math and programming.
› P4261R0 Presentation for P4189 get()ing the pointer from optional N. Liber
› P4265R0 Presentation for P3655 in Brno P. Bindels
› P4266R0 Presentation for P3655 in Croydon P. Bindels
› P4269R0 when_all Oughtn't Hallucinate set_stopped R. Leahy
Abstract
When `std::execution::when_all` is provided with multiple senders it becomes possible that:
› P4276R0 A Policy for Scalar Overloads in std::simd D. Towner
Abstract
`std::simd` includes scalar overloads for a few operations where variants of a function or operator accept a scalar where a `simd::vec` value would otherwise be expected. Recent papers continue this theme, with better shifts [P3793R1] and funnel shifts [P4010R0] adding scalar-operand variants. This has inadvertently created an expectation that every new operation should provide scalar overloads to
› P4279R0 No Endian Views J. Schultke
Abstract
The design direction of [[P4030R1]](https://isocpp%2eorg/files/papers/P4030R1%2ehtml) Endian Views should not be pursued.
› P4282R0 Away From co_yield For std::execution::task R. Leahy
Abstract
The coroutine promise protocol shipped in C++20 not only banned `return_void` and `return_value` on the same promise type, but did so in an unusually restrictive manner [1]. Notably the aforementioned manner barred implementing the aforementioned mutual exclusion via mutually exclusive constraints.
› P4288R0 Stop the Decay R. Leahy
Abstract
`std::execution` can be thought of as the realization of the asynchronous analogue of a synchronous function [1][2]. The sender is the function itself (with all arguments selected and applied), the receiver is the channel by which the function communicates with its caller (in the synchronous realm by returning or throwing), and the operation state is the “stack” (i.e. a collection of variables wit
› 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.
› P4293R0 std::execution::decay_copy R. Leahy
Abstract
* Allows for asynchronous operations which advertise ref-qualified completions, and
› 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.
› P4295R0 Single Ends for C++ Concurrent Queues D. Vollmann
Abstract
[P0260](https://wg21.link/P0260) proposes concurent queue concepts as communication mechanism for concurrent systems. This communication is typically uni-directional, i.e. a specifc part of a system is either a producer and therefore only needs the pushing interface, or it is a consumer and only needs access to the pop interface.
› P4305R0 Design problems with P2964R5 (User-defined element types in std::simd) J. Schultke
Abstract
This paper discusses some design problems in [[P2964R5]](https://isocpp%2eorg/files/papers/P2964R5%2ehtml).
› P4309R0 Constructing owning node-handles without containers M. Hava
Abstract
Whilst the existing `node-handle` API works fairly well, there is one annoyance we’ve encountered multiple times: being unable to directly create an owning `node-handle` without constructing a container. Creating a container just to emplace one element that is immediately extracted, after which the container is destroyed is silly … yet is necessary with the current API, if a separation from the ta
› P4311R0 Getting a const element type version of an mdspan accessor, and of an mdspan too M. Hoemmen , R. Parolin
Abstract
Given an accessor `a` of type `A`, a “const element type version of `a`” (if it exists) is an accessor `b` of a possibly different type `B`, where
› P4313R0 Bitmask operations for enums I. Guterman , A. Williams
Abstract
As a developer coming from languages other than C++, I grew accustomed to using enums to represent flags. However, such behavior is noticeably absent from the C++ language.
› P4320R0 std::execution::sequence R. Leahy
Abstract
`sequence` adapts any number of input senders into a sender which completes when all input senders have completed, with each input sender’s asynchronous operation being started only after the completion of the preceding input sender’s asynchronous operation.
