C++20 Is Nearly Done — What Developers Get This Summer

C++ doesn’t get a new standard every year, so when one lands it tends to be a big deal. C++20 is on track for finalization this summer, and from what’s been published in the working papers, it’s shaping up to be one of the more consequential revisions the language has seen in a while — arguably the biggest jump since C++11 introduced things like lambdas and move semantics.

Four features are getting most of the attention.

Concepts let you put readable constraints on templates instead of leaning on cryptic SFINAE tricks or wall-of-text error messages. If you’ve ever tried to debug a template instantiation failure in C++17 and stared at a screen of nested type errors, you’ll understand why this matters. Concepts should make generic code both easier to write and dramatically easier to read when something goes wrong.

Modules are the one I think will have the longest tail of impact. C++ has been leaning on the header/textual-include model since the 1980s, and it shows — compile times balloon as codebases grow, partly because the same headers get re-parsed over and over across translation units. Modules are meant to replace that with a proper compiled-interface model. The catch is that build tooling, package managers, and IDEs all need to catch up, so I’d expect the practical benefits to show up gradually rather than overnight this summer.

Coroutines bring native support for suspend/resume style code — useful for async I/O, generators, and lazy sequences without hand-rolling state machines or reaching for callback soup. It’s a lower-level primitive than what you get in languages with coroutines baked in from day one, but library authors should be able to build nicer abstractions on top of it.

The spaceship operator (<=>) is the small-but-satisfying one. Instead of writing out ==, !=, <, <=, >, and >= by hand for every comparable type, you define <=> once and the compiler generates the rest. It’s the kind of quality-of-life change that doesn’t make headlines but saves real boilerplate in day-to-day code.

Worth noting: “nearly done” doesn’t mean “usable everywhere tomorrow.” Standard finalization and compiler support are two different clocks. Expect GCC, Clang, and MSVC to roll out partial support unevenly over the following months, with modules likely being the slowest to mature given how much tooling has to change underneath it. If you’re on a team that cares about portability, I’d hold off putting modules into production code until at least one major compiler has solid, well-tested support — probably not this year.

It’s also a decent moment to note that C++ isn’t the only language mid-overhaul right now. Scala 3.0 has been in the works for a while too, though it’s moving on a slower timeline and isn’t expected until later this year at the earliest. Different ecosystems, similar impulse: clean up long-standing rough edges without breaking the world.

For working developers, my advice is the usual one for any new standard: read up on concepts and the spaceship operator now since they’re the easiest wins, and keep an eye on modules as a multi-year transition rather than a switch you flip in September.