Experimental C++ Features

The C++ standards committee publishes experimental C++ language and library extensions for future standardization.

Note: until 2012, these publications used the TR (technical report) format. Since 2012 ISO procedure changed to use the TS (technical specification) format.

A proposal to add linear algebra support to the C++ standard library - P1385R7 (2022-10-15)
Evolving a Standard C++ Linear Algebra Library from the BLAS - P1674R2 (2022-05-15)
Presentation of P1385R7 to LEWG at Issaquah 2023 - P2802R0 (2023-02-09)
Fix C++26 by optimizing linalg::conjugated for non-complex value types - P3050R2 (2024-08-13)
Fix C++26 by making the symmetric and Hermitian rank-k and rank-2k updates consistent with the BLAS - P3371R2 (2024-10-14)

<linalg>

std::execution

Forwarded to LWG, wording in progress.

✔Merged into C++26. Proposal: P2300R10 (2024-06-28).

More proposals:

System execution context - P2079R5 (2024-10-16)
Sender-Receiver Interface for Networking - P2762R2 (2023-10-12)
Member customization points for Senders and Receivers - P2855R1 (2024-02-22)
An Event Model for C++ Executors - P2882R0 (2023-05-11)
Sender Algorithm Customization - P2999R3 (2023-12-13)
std::execution introduction - P3090R0 (2024-02-14)
A plan for std::execution for C++26 - P3109R0 (2024-02-12)
Improving diagnostics for Sender expressions - P3164R0 (2024-03-01)
Reconsidering the std::execution::on algorithm - P3175R3 (2024-06-25)
finally, write_env, and unstoppable Sender Adaptors - P3284R1 (2024-07-16)
Fixing Lazy Sender Algorithm Customization - P3303R1 (2024-06-25)
A Utility for Creating Execution Environments - P3325R3 (2024-07-23)
When Do You Know connect Doesn't Throw? - P3388R0 (2024-09-10)
std::execution wording fixes - P3396R0 (2024-09-16)
Enabling more efficient stop-token based cancellation of senders - P3409R0 (2024-10-16)
system_scheduler on Win32, Darwin and Linux - P3456R0 (2024-10-15)
Summarizing std::execution::bulk() issues - P3481R0 (2024-10-16)

Execution, <execution>

std::inplace_vector

✔Merged into C++26. Proposal: P0843R14 (2024-06-26).

More proposals:
`inplace_vector` - P0843(R7) LEWG presentation - P2925R0 (2023-06-16) A direction for Vector - P3147R1 (2024-03-18) An allocator-aware std::inplace_vector - P3160R2 (2024-10-15)

<inplace_vector>

Pattern Matching

Early development. Draft P1371R3 (2020-09-15).

More proposals:

Pattern Matching using is and as - P2392R3 (2024-10-16)
Pattern Matching: match expression - P2688R3 (2024-10-16)
switch for Pattern Matching - P2940R0 (2022-04-18)
Identifiers for Pattern Matching - P2941R0 (2022-02-24)
A Postcondition is a Pattern Match - P3210R2 (2024-09-10)
A unified syntax for Pattern Matching and Contracts when introducing a new name - P3249R0 (2024-05-22)
A simpler notation for PM - P3332R0 (2024-06-18)
Slides for P2688R2 - Pattern Matching: match Expression - P3476R0 (2024-10-16)

Reflection

The main document (ISO/IEC TS 23619:2021) is described in Reflection TS above.

More proposals:

Scalable Reflection in C++ - P1240R2 (2022-01-14)
Expansion statements - P1306R3 (2024-10-14)
Reflection on attributes - P1887R1 (2020-01-13)
Metaprogramming - P2237R0 (2020-10-15)
Python Bindings with Value-Based Reflection - P2911R1 (2023-10-13)
Reflection for C++26 - P2996R7 (2024-10-13)
Using Reflection to Replace a Metalanguage for Generating JS Bindings - P3010R0 (2023-10-13)
ABI comparison with reflection - P3095R0 (2024-02-15)
Function Parameter Reflection in Reflection for C++26 - P3096R3 (2024-09-15)
Generative Extensions for Reflection - P3157R1 (2024-05-22)
Syntax for Reflection - P3381R0 (2024-09-17)
Attributes reflection - P3385R1 (2024-10-15)
Annotations for Reflection - P3394R0 (2024-10-14)
Reflection Syntax Options Summary - P3419R0 (2024-10-11)
Reflection of Templates - P3420R0 (2024-10-16)
Reflection header should minimize standard library dependencies - P3429R0 (2024-10-16)
Reflection and meta-programming - P3435R0 (2024-10-14)
Proposed default principles: Reflect C++, Generate C++ - P3437R0 (2024-10-16)
Reflection on SG21 2024 Process - P3443R0 (2024-10-14)
A Suggestion for Reflection Access Control - P3451R0 (2024-10-15)

Reflection

std::simd

The main document (TS ISO/IEC 19570:2018) is described in "C++ Extensions for Parallelism V2" above.

More proposals:

Expected Feedback from SIMD in Parallelism TS2 - P1915R0 (2019-10-07)
std::simd - Merge data-parallel types from the Parallelism TS 2 - P1928R12 (2024-10-11)
Intel's response to std::simd - P2638R0 (2022-09-22)
Proposal to support interleaved complex values in std::simd - P2663R5 (2023-12-08)
Proposal to extend std::simd with permutation API - P2664R8 (2024-10-15)
std::simd Intro slides - P2803R0 (2023-02-09)
Issaquah Slides for Intel response to std::simd - P2807R0 (2023-02-10)
Proposal to extend std::simd with more constructors and accessors - P2876R1 (2024-05-22)
Algorithm-like vs std::simd based RNG API - P2880R0 (2023-05-18)
std::simd types should be regular - P2892R0 (2023-05-19)
std::simd types should be regular - P2892R0 LEWG presentation - P2926R0 (2023-06-19)
simd_invoke - P2929R0 (2023-07-19)
std::simd overloads for <bit> - P2933R2 (2024-10-16)
Add saturating library support to std::simd - P2956R0 (2023-08-01)
Allowing user-defined types in std::simd - P2964R1 (2024-05-22)
Interface Directions for std::simd - P3024R0 (2023-11-30)
Provide predefined std::simd permute generator functions for common operations - P3067R0 (2024-05-22)
Replace std::simd operator[] with getter and setter functions - or not - P3275R0 (2024-05-22)
Exploration of namespaces for std::simd - P3287R1 (2024-10-15)
Range constructors for std::simd - P3299R2 (2024-10-16)
Add an iota object for std::simd (and more) - P3319R1 (2024-06-28)
std::simd issues: explicit, unsequenced, identity-element position, and members of disabled simd - P3430R0 (2024-10-15)
Add n_elements named constructor to std::simd - P3440R0 (2024-10-15)
Rename simd_split to simd_chunk - P3441R0 (2024-10-15)
Add utilities for easier type-bit casting in std::simd - P3445R0 (2024-10-16)
std::simd is a range - P3480R0 (2024-10-16)

Data parallel types

Contracts

Early development. Proposal P2659R2 (2022-11-30). Draft P2660R0 (2022-10-14).

More proposals:

A Proposal to Publish a Technical Specification for Contracts - P2659R2 (2022-12-05)
Miscellaneous amendments to the Contracts TS - P2661R0 (2022-10-15)
Contracts for C++: Prioritizing Safety - P2680R1 (2022-12-15)
A proposed plan for contracts in C++ - P2695R1 (2023-02-09)
Proposal of Condition-centric Contracts Syntax - P2737R0 (2022-12-30)
Contracts for C++: Prioritizing Safety - Presentation slides - P2743R0 (2022-12-13)
Evaluation of Checked Contracts - P2751R1 (2023-02-14)
A Bold Plan for a Complete Contracts Facility - P2755R1 (2024-04-11)
The idea behind the contracts MVP - P2817R0 (2023-03-05)
Proposal of Contracts Supporting Const-On-Definition Style - P2829R0 (2023-04-13)
Contract violation handling semantics for the contracts MVP - P2852R0 (2023-04-24)
The Lakos Rule: Narrow Contracts and noexcept Are Inherently Incompatible - P2861R0 (2023-05-19)
Requirements for a Contracts syntax - P2885R3 (2023-10-05)
Contracts on lambdas - P2890R2 (2023-12-13)
Constant evaluation of Contracts - P2894R2 (2024-01-11)
Outstanding design questions for the Contracts MVP - P2896R0 (2023-08-22)
Contracts for C++ - P2900R10 (2024-10-13)
A Principled Approach to Open Design Questions for Contracts - P2932R3 (2024-01-16)
An Attribute-Like Syntax for Contracts - P2935R4 (2023-11-05)
Contracts must avoid disclosing sensitive information - P2947R0 (2023-07-20)
Slides for P2861R0: Narrow Contracts and noexcept are Inherently Incompatible - P2949R0 (2023-07-14)
Contracts and virtual functions for the Contracts MVP - P2954R0 (2023-08-03)
Contracts and coroutines - P2957R2 (2024-10-14)
A natural syntax for Contracts - P2961R2 (2023-11-08)
An Overview of Syntax Choices for Contracts - P3028R0 (2023-11-05)
Protection against modifications in contracts - P3071R1 (2023-12-17)
Remove evaluation_undefined_behavior and will_continue from the Contracts MVP - P3073R0 (2024-01-27)
Should ignore and observe exist for constant evaluation of contracts? - P3079R0 (2024-01-11)
Contracts for C++: Support for virtual functions - P3097R0 (2024-04-15)
Contracts for C++: Postcondition captures - P3098R0 (2024-10-14)
Undefined and erroneous behavior are contract violations - P3100R1 (2024-10-16)
Tokyo Technical Fixes to Contracts - P3119R1 (2024-05-09)
Contracts on virtual functions for the Contracts MVP - P3165R0 (2024-02-27)
Inherited contracts - P3169R0 (2024-04-14)
Contract testing support - P3183R1 (2024-05-22)
Slides for LEWG presentation of P2900R6: Contracts for C++ - P3189R0 (2024-03-19)
Slides for LEWG presentation of P2900R7: Contracts for C++ - P3190R0 (2024-03-20)
A response to the Tokyo EWG polls on the Contracts MVP (P2900R6) - P3197R0 (2024-04-12)
A takeaway from the Tokyo LEWG meeting on Contracts MVP - P3198R0 (2024-03-29)
The contract of sort() - P3212R0 (2024-07-03)
Contracts for C++: Naming the Louis semantic - P3226R0 (2024-04-12)
Contracts for C++: Fixing the contract violation handling API - P3227R0 (2024-10-16)
Contracts for C++: Revisiting contract check elision and duplication - P3228R1 (2024-05-21)
An alternate proposal for naming contract semantics - P3238R0 (2024-05-06)
A unified syntax for Pattern Matching and Contracts when introducing a new name - P3249R0 (2024-05-22)
C++ contracts with regards to function pointers - P3250R0 (2024-05-07)
C++ contracts and coroutines - P3251R0 (2024-05-07)
Make the predicate of contract_assert more regular - P3257R0 (2024-04-26)
Ship Contracts in a TS - P3265R3 (2024-05-28)
Approaches to C++ Contracts - P3267R1 (2024-05-22)
C++ Contracts Constification Challenges Concerning Current Code - P3268R0 (2024-05-07)
Do Not Ship Contracts as a TS - P3269R0 (2024-05-21)
Repetition, Elision, and Constification w.r.t. contract_assert - P3270R0 (2024-05-22)
Function Usage Types (Contracts for Function Pointers) - P3271R1 (2024-10-15)
P2900 Is Superior to a Contracts TS - P3276R0 (2024-05-18)
Contracts: Protecting The Protector - P3285R0 (2024-05-15)
Integrating Existing Assertions With Contracts - P3290R2 (2024-09-06)
C++26 Needs Contract Checking - P3297R1 (2024-06-21)
An opt-in approach for integration of traditional assert facilities in C++ contracts - P3311R0 (2024-05-22)
Compile time resolved contracts - P3317R0 (2024-05-22)
Contracts Interaction With Tooling - P3321R0 (2024-07-12)
Contract assertions on function pointers - P3327R0 (2024-10-16)
Observable Checkpoints During Contract Evaluation - P3328R0 (2024-06-14)
Usage Experience for Contracts with BDE - P3336R0 (2024-06-23)
Contracts - What are we doing here (EWG Presentation) - P3343R0 (2024-06-25)
Virtual Functions on Contracts (EWG - Presentation for P3097) - P3344R0 (2024-06-28)
Class invariants and contract checking philosophy - P3361R1 (2024-07-23)
Static analysis and “safety” of Contracts, P2900 vs P2680/P3285 - P3362R0 (2024-08-13)
Contract assertions versus static analysis and “safety” - P3376R0 (2024-10-14)
Static Analysis of Contracts with P2900 - P3386R0 (2024-10-15)
Contract assertions on coroutines - P3387R0 (2024-10-09)
Improving the handling of exceptions thrown from contract predicates - P3417R0 (2024-10-16)
Contracts Implementors Report - P3460R0 (2024-10-16)
Standard library hardening - P3471R0 (2024-10-16)
Constification should not be part of the MVP (Minimal Viable Product) - P3478R0 (2024-10-16)

2D Graphics Early development. Draft P0267R10 (2019-10-07).

Graph Library

Early development.

More proposals:
Graph Library: Overview - P3126R2 (2024-08-05) Graph Library: Algorithms - P3128R2 (2024-09-12) Graph Library: Graph Container Interface - P3130R2 (2024-08-05) Graph Library: Graph Containers - P3131R2 (2024-08-05)

External links

1.	PL22.16/WG21 document list - All C++ committee documents (TS/proposals) for 2016-2024.
2.	JTC1/SC22/WG21 Proposals (mailing) for 2024.

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Technical Specification
Filesystem library (filesystem TS)
Library fundamentals (library fundamentals TS)
Library fundamentals 2 (library fundamentals TS v2)
Library fundamentals 3 (library fundamentals TS v3)
Extensions for parallelism (parallelism TS)
Extensions for parallelism 2 (parallelism TS v2)
Extensions for concurrency (concurrency TS)
Extensions for concurrency 2 (concurrency TS v2)
Concepts (concepts TS)
Ranges (ranges TS)
Reflection (reflection TS)
Mathematical special functions (special functions TR)
Experimental Non-TS
Pattern Matching
Linear Algebra
std::execution
Contracts
2D Graphics

cppreference.com

Namespaces

Variants

Views

Actions

Experimental C++ Features

Contents

TR/TS specifications

Non-TS proposals

See also

External links

Navigation

Toolbox