WG21 PAPERS

Mailings Beta

Volunteer-driven · Not affiliated with WG21 or ISO

Filter and export papers from the C++ Committee’s monthly mailings by time frame and audience using the options below, or refine your export further with the Select button. Links point directly to the official WG21 papers on open-std.org.

Submit Issue C++ Standards Committee Papers

	Paper	Title	Authors	Audience
	P0260R20	C++ Concurrent Queues	D. Vollmann, L. Crowl, C. Mysen, G. Nishanov	LEWG SG1
Mailing Date 2026-07 Post-Brno Author(s) Detlef Vollmann, Lawrence Crowl, Chris Mysen, Gor Nishanov Target Audience LEWG SG1 Tracking issue View on GitHub Abstract Queues provide a mechanism for communicating data between components of a system.
	P3771R1	constexpr mutex, locks, and condition variable	H. Dusíková	LEWG SG1
Mailing Date 2026-07 Post-Brno Author(s) Hana Dusíková Target Audience LEWG SG1 Tracking issue View on GitHub 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.
	P3832R3	Timed lock algorithms for multiple lockables	T. Lyngmo	LEWG SG1
Mailing Date 2026-07 Post-Brno Author(s) Ted Lyngmo Target Audience LEWG SG1 Revisions R2 R1 Tracking issue View on GitHub 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	LEWG SG1
Mailing Date 2026-07 Post-Brno Author(s) Ted Lyngmo Target Audience LEWG SG1 Revisions R2 R1 Tracking issue View on GitHub 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
	P4221R2	Atomic Compare	M. Michael, P. McKenney, M. Wong	SG1
Mailing Date 2026-07 Post-Brno Author(s) Maged Michael, Paul McKenney, Michael Wong Target Audience SG1 Revisions R3 R1 R0 Tracking issue View on GitHub 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
	P4269R0	when_all Oughtn't Hallucinate set_stopped	R. Leahy	LEWG SG1
Mailing Date 2026-07 Post-Brno Author(s) Robert Leahy Target Audience LEWG SG1 Tracking issue View on GitHub Abstract When `std::execution::when_all` is provided with multiple senders it becomes possible that:
	P4282R0	Away From co_yield For std::execution::task	R. Leahy	LEWG SG1
Mailing Date 2026-07 Post-Brno Author(s) Robert Leahy Target Audience LEWG SG1 Tracking issue View on GitHub 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	LEWG SG1
Mailing Date 2026-07 Post-Brno Author(s) Robert Leahy Target Audience LEWG SG1 Tracking issue View on GitHub 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
	P4293R0	std::execution::decay_copy	R. Leahy	LEWG SG1
Mailing Date 2026-07 Post-Brno Author(s) Robert Leahy Target Audience LEWG SG1 Tracking issue View on GitHub Abstract * Allows for asynchronous operations which advertise ref-qualified completions, and
	P4295R0	Single Ends for C++ Concurrent Queues	D. Vollmann	LEWG SG1
Mailing Date 2026-07 Post-Brno Author(s) Detlef Vollmann Target Audience LEWG SG1 Tracking issue View on GitHub 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.
	P4320R0	std::execution::sequence	R. Leahy	LEWG SG1
Mailing Date 2026-07 Post-Brno Author(s) Robert Leahy Target Audience LEWG SG1 Tracking issue View on GitHub 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.

Showing 11 of 11 papers · source: open-std.org

Mailings Beta

Sign in