Experimental C++ Features

Curated hub for Technical Specifications and experimental C++ facilities: status, domain clusters, and migration paths toward standardized library areas.

The experimental C++ area collects facilities that appeared in Library Fundamentals TSes, Concurrency TSes, Filesystem TSes, Ranges TSes, Networking proposals, and other incubation tracks before or instead of standardization in the main C++ standard library.

Treat this hub as a status and migration map, not as a recommendation to start new code on experimental APIs by default. Many of these facilities later moved into standardized C++ areas such as filesystem, ranges, utility, thread support, and memory.

# Start Here

Library Fundamentals and vocabulary types

Use this route for facilities that incubated common modern library building blocks before their standardized forms stabilized.

optional · any · string_view · observer_ptr

Memory resource and ownership experiments

Polymorphic memory resources, pool resources, and ownership-adjacent helper types that informed later standardized memory facilities.

memory_resource · monotonic_buffer_resource · propagate_const · observer_ptr

Concurrency and futures experiments

Use this route for Concurrency TS features, continuation-style futures, barriers, latches, and atomic smart pointer experiments.

future · latch · barrier · atomic_shared_ptr

Filesystem and networking

Use this route for larger domain TSes that eventually fed standard filesystem and still-not-yet-mainline networking work.

Filesystem TS · standard filesystem · networking

Ranges and execution incubation

Historical TS surfaces that predate the standardized ranges model or execution-related standardization.

experimental ranges · standard ranges · execution · standard execution

Reflection and other incubators

Use this route for proposal-heavy or still-emerging tracks that are useful mainly for status awareness and historical context.

reflect · parallelism · source_location

# Status Map

Experimental area	What it contains	Typical migration target
Library Fundamentals	Vocabulary types, helpers, memory-resource work, observer/ownership utilities, and scope-guard style tools.	Utility, Memory, String
Concurrency TS	Continuation-friendly futures, latch/barrier family, and smart-pointer atomics that informed later standard APIs.	Thread support, Atomic operations
Filesystem TS	Pre-standard filesystem paths, directory traversal, file status, and related error types.	Filesystem
Ranges TS	Historical experimental ranges taxonomy that predates the standardized C++20 ranges model.	Ranges
Networking / reflection / other incubators	Proposal-driven areas that may still be experimental or evolve independently from the main standard library surface.	Track the experimental pages directly first; only jump to a standardized hub if one now exists.

# Domain Clusters

Cluster	Key pages	Use it for
Vocabulary and value wrappers	optional, any, basic_string_view, function	Historical TS forms of value wrappers and callable wrappers that later influenced standardized utility surfaces.
Memory resource ecosystem	memory_resource, monotonic_buffer_resource, polymorphic_allocator, synchronized_pool_resource, unsynchronized_pool_resource	Allocator and PMR-adjacent experiments that led toward modern resource-oriented memory management.
Ownership and scope helpers	observer_ptr, propagate_const, unique_resource, scope_exit, scope_fail, scope_success	Non-owning pointers, const-propagation wrappers, and RAII-style cleanup helpers.
Concurrency and continuations	concurrency, future, latch, barrier, flex_barrier, atomic_shared_ptr, atomic_weak_ptr	Synchronization, continuation-based async workflows, and experimental concurrent ownership primitives.
Filesystem, networking, and system-adjacent domains	fs, networking	Broader domain TSes that either standardized later or remain incubating separately.
Execution, ranges, and parallelism	execution, parallelism, ranges, ostream_joiner	Pre-standard models for algorithms, execution policy work, range composition, and related utilities.
Metaprogramming and reflection incubators	is_detected, not_fn, reflect, source_location	Detection idiom helpers, callable adapters, reflection work, and proposal-stage compile-time support.
Early numeric and algorithm extras	gcd, lcm, simd, special functions	Experimental numerics that later moved into or influenced standard numeric facilities.

# Migration Notes

If you find an experimental page for...	Check first whether you should now prefer...
`fs`, path, directory traversal, file status	standard filesystem
`optional`, `any`, `string_view`, `not_fn`, `source_location`	utility and related standardized library pages
`memory_resource`, PMR allocators and pool resources	memory and standardized PMR facilities
experimental ranges taxonomy	standard ranges
concurrency primitives such as latch/barrier	thread support and atomic operations
facilities with no obvious standardized counterpart yet	Stay in the experimental page and verify your toolchain/library support before adopting them.