› P0260R20 C++ Concurrent Queues
Detlef Vollmann
D. Vollmann
,
Lawrence Crowl
L. Crowl
,
Chris Mysen
C. Mysen
,
Gor Nishanov
G. Nishanov
2026-07
Abstract
Queues provide a mechanism for communicating data between components of a system.
› P0870R8 A proposal for a type trait to detect narrowing conversions
Giuseppe D'Angelo
G. D'Angelo
2026-07
› P1040R11 std::embed and #depend
JeanHeyd Meneide
J. Meneide
2026-07
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
Michael Florian Hava
M. Hava
2026-07
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
Eddie Nolan
E. Nolan
2026-07
› P2906R2 Structured bindings for std::extents
Bernhard Manfred Gruber
B. Gruber
,
Yihan Wang
Y. Wang
,
Mark Hoemmen
M. Hoemmen
2026-07
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
Daniel Towner
D. Towner
,
Ruslan Arutyunyan
R. Arutyunyan
2026-07
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
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-07
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
Timur Doumler
T. Doumler
,
Peter Bindels
P. Bindels
,
Joshua Berne
J. Berne
2026-07
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
Timur Doumler
T. Doumler
,
Joshua Berne
J. Berne
2026-07
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
Hana Dusíková
H. Dusíková
2026-07
Disposition Date
2026-06Adopted
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)
Timur Doumler
T. Doumler
,
John Lakos
J. Lakos
2026-07
› P3211R2 views::flat_map
Hewill Kang
H. Kang
2026-07
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
Hewill Kang
H. Kang
2026-07
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
Hewill Kang
H. Kang
2026-07
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)
Hewill Kang
H. Kang
2026-07
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
Joshua Berne
J. Berne
,
Timur Doumler
T. Doumler
,
John Lakos
J. Lakos
2026-07
Abstract
* Presenting feedback from SG22 on the `assert` macro choices, including new subsections on implementation-defined integration and throwing violation handlers
› P3385R8 Attributes reflection
Aurelien Cassagnes
A. Cassagnes
2026-07
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
Jan Schultke
J. Schultke
2026-07
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
Peter Bindels
P. Bindels
,
Hana Dusikova
H. Dusikova
,
Jeremy Rifkin
J. Rifkin
,
Marco Foco
M. Foco
,
Alexey Shevlyakov
A. Shevlyakov
2026-07
Abstract
We propose a standard string view type that guarantees null-termination.
› P3669R4 Non-Blocking Support for `std::execution`
Detlef Vollmann
D. Vollmann
2026-07
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
Hana Dusíková
H. Dusíková
2026-07
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
Paul E. McKenney
P. McKenney
,
Maged Michael
M. Michael
,
Jens Maurer
J. Maurer
,
Peter Sewell
P. Sewell
,
Hans Boehm
H. Boehm
,
Hubert Tong
H. Tong
,
Niall Douglas
N. Douglas
,
Thomas Rodgers
T. Rodgers
,
Will Deacon
W. Deacon
,
Michael Wong
M. Wong
,
David Goldblatt
D. Goldblatt
,
Kostya Serebryany
K. Serebryany
,
Anthony Williams
A. Williams
,
Tom Scogland
T. Scogland
,
JF Bastien
J. Bastien
,
Daniel Krügler
D. Krügler
,
David Tenty
D. Tenty
2026-07
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
Hewill Kang
H. Kang
2026-07
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
Ted Lyngmo
T. Lyngmo
2026-07
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
Ted Lyngmo
T. Lyngmo
2026-07
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
Timur Doumler
T. Doumler
,
Joshua Berne
J. Berne
2026-07
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
Hewill Kang
H. Kang
2026-07
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
Jan Schultke
J. Schultke
2026-07
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
Jan Schultke
J. Schultke
2026-07
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
Eddie Nolan
E. Nolan
2026-07
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
Jan Schultke
J. Schultke
2026-07
Abstract
C23 now has `_BitInt` type for N-bit integers (WG14 N2763, N2775):
› P4188R1 Extensible Math Functions for C++
Stephane Gros-Lemesre
S. Gros-Lemesre
2026-07
› P4217R1 when_all() is just just()
Robert Leahy
R. Leahy
2026-07
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
Andrzej Krzemieński
A. Krzemieński
2026-07
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
Maged Michael
M. Michael
,
Paul McKenney
P. McKenney
,
Michael Wong
M. Wong
2026-07
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
Inbal Levi
I. Levi
,
Fabio Fracassi
F. Fracassi
,
Andreas Weis
A. Weis
,
Corentin Jabot
C. Jabot
2026-07
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
Hui Xie
H. Xie
,
Tristan Melen
T. Melen
2026-07
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
Robert Leahy
R. Leahy
2026-07
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
Nevin Liber
N. Liber
2026-07
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
Barry Revzin
B. Revzin
2026-07
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
Nevin Liber
N. Liber
2026-07
› P4265R0 Presentation for P3655 in Brno
Peter Bindels
P. Bindels
2026-07
› P4266R0 Presentation for P3655 in Croydon
Peter Bindels
P. Bindels
2026-07
› P4269R0 when_all Oughtn't Hallucinate set_stopped
Robert Leahy
R. Leahy
2026-07
Abstract
When `std::execution::when_all` is provided with multiple senders it becomes possible that:
› P4276R0 A Policy for Scalar Overloads in std::simd
Daniel Towner
D. Towner
2026-07
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
Jan Schultke
J. Schultke
2026-07
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
Robert Leahy
R. Leahy
2026-07
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
Robert Leahy
R. Leahy
2026-07
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
Hewill Kang
H. Kang
2026-07
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
Robert Leahy
R. Leahy
2026-07
Abstract
* Allows for asynchronous operations which advertise ref-qualified completions, and
› P4294R0 views::take_last and views::drop_last
Hewill Kang
H. Kang
2026-07
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
Detlef Vollmann
D. Vollmann
2026-07
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)
Jan Schultke
J. Schultke
2026-07
Abstract
This paper discusses some design problems in [[P2964R5]](https://isocpp%2eorg/files/papers/P2964R5%2ehtml).
› P4309R0 Constructing owning node-handles without containers
Michael Florian Hava
M. Hava
2026-07
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
Mark Hoemmen
M. Hoemmen
,
Rob Parolin
R. Parolin
2026-07
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
Iliya Guterman
I. Guterman
,
Anthony Williams
A. Williams
2026-07
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
Robert Leahy
R. Leahy
2026-07
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.
