Research shelf / Software & languages / Future C++
Written Updated
The argument before the RFC: what a third systems language would need
Between C++ and Rust there is a recurring question: what would a third option look like that keeps C++ syntax but bakes in memory safety, data-race detection, green threads, algebraic data types and a package manager? This transcript works through it and is honest that its own opening argument partly undercuts its conclusion.
Theory or design only. No in-house measurement.
A long design conversation about a compiled language with C++ syntax and modern guarantees — which opens by arguing modern C++ already covers most of the wishlist, then works out what is left.
The discussion axes are the expected ones done properly: memory safety (borrow checking, bounds checking, lifetime annotations), concurrency (compile-time data-race detection, async/await, green threads, message passing, software transactional memory), metaprogramming (compile-time function evaluation, algebraic data types with pattern matching, traits and concepts), and tooling — the package manager, test runner, benchmark harness and documentation generator that C++ has chronically lacked.
The syntax position is "C++ look, C#-style ergonomics": property<> and event<>, async Task, extension methods, string interpolation, a simplified generic syntax, and Boost-as-core for the standard library with modules replacing headers.
The arc is the interesting part, and the folder flags it as a weakness. Phase one argues that modern C++ — concepts, ranges, coroutines, modules, std::expected, std::format — already closes most of the gap. Phase two asks what borrow checking and integrated tooling would still add. Phase three sketches "cleaned-up C++ plus cherry-picked C# ergonomics". The README notes that phases one and three do not fully reconcile.
Every number, and what stands behind it
A claim is only worth the evidence attached to it. Each row below carries its basis: measured on the author’s own hardware, derived from the construction, measured on synthetic data, projected from literature, or simply cited.
| Claim | Figure | Basis | Context |
|---|---|---|---|
| Transcript length | ~3,700+ lines | Derived | Single conversation log |
| Discussion axes | 6 | Derived | Safety, concurrency, metaprogramming, tooling, syntax, standard library |
| Arc phases | 3 | Derived | Modern C++ may suffice → the wishlist → cleaned-up C++ + C# ergonomics |
| Grammar | none | Derived | No formal syntax specification |
| Compiler | none | Derived | No implementation |
| Benchmarks | none | Derived | Nothing to measure |
| Self-identified inconsistency | phases 1 and 3 do not reconcile | Derived | Stated in the folder’s own caveats |
Measured — author-run experiment on the stated setup. Synthetic — measured, but on synthetic rather than real data. Derived — follows from the stated construction or proof. Projected — paper-stated projection, not an author-run benchmark. Cited — taken from external literature.
How it works
- Borrow checking and lifetimes. Rust-style compile-time memory safety, discussed as an addition to C++ syntax rather than a replacement for it.
- Green threads plus STM. Concurrency borrowed from Go, C# and Haskell/Clojure rather than from C++’s own threading model.
- ADTs and pattern matching. From ML, Swift and Rust — the metaprogramming gap the discussion keeps returning to.
- Integrated toolchain. Package manager, test runner, benchmarking and documentation as first-class, which is the one axis where the case is unambiguous.
What it does not do
Taken from the folder’s own README. Nothing here has been softened.
- Speculative. No grammar, no compiler, no benchmarks — the folder’s own caveat list.
- Free-form question-and-answer, not a normative specification.
- The early "modern C++ might already be enough" argument and the later expansive feature mashups are in tension, as the README acknowledges.
- Illustrative pseudo-syntax throughout; nothing that a parser could consume.
- No comparison against the languages already occupying this space (Rust, Zig, Carbon, Circle).
Free under AGPL-3.0+ for almost everyone
Personal use, charities, education and organisations under AUD 50,000 a year pay nothing. A tiered commercial licence covers everyone else.