C++26 Standard Faces Setback as 'Contracts' Feature is Disapproved

The C++26 standard has encountered a notable impasse following a failed pro forma vote that blocked the inclusion of 'Contracts.' This development was reportedly influenced by opposition from key figures in the standards process, including a paper that suggested the feature was not yet ready for release. The rejection of this proposal serves as a bellwether for the current state of the C++ language, where the ISO National Bodies (NBs) are increasingly cautious about introducing new features that might contribute to the language's perceived bloat or lack of clarity.

Technically, C++ Contracts are intended as structured runtime assertions designed to improve software reliability. They are distinct from C++20 Concepts, which are compile-time 'types of types' used to constrain template parameters. While both aim to improve code safety, Contracts operate at runtime to verify conditions that cannot be checked during compilation. However, some critics argue that the practical payoff for Contracts is minimal. They contend that for developers already writing high-reliability code, the feature largely overlaps with what can already be achieved using `constexpr` and C++20 Concepts, offering little new utility for those who already follow standard reliability idioms.

Beyond the specific mechanics of Contracts, the disapproval reflects a broader tension regarding the evolution of C++ itself. Some members of the community argue that the language is 'buckling' under the weight of new features and would be better served by refining existing issues, such as 'erroneous behavior' or the complexities of `std::filesystem`. There is a growing call to prioritize fundamental improvements—such as memory safety—over the addition of new features that may increase complexity without significantly simplifying the developer experience. This impasse underscores a significant challenge for the C++ standards committee: balancing the desire for modern reliability tools with the need to manage a language that has become increasingly complex over decades of development.