C++26 fails ISO ballot over Contracts (P2900): 13 for, 9 against, 12 abstain

The draft of the next C++ standard, C++26, has failed its final-stage ISO vote, and the cause is a single feature: Contracts, the language-level preconditions, postconditions and assertions specified in proposal P2900. It is the first time in C++ history that a Draft International Standard (DIS) ballot has been lost, according to committee member Andreas Fertig, and it leaves the language's 2026 release date, and the features waiting behind Contracts such as static reflection and std::execution, in doubt. The ISO working group WG21 meets in Búzios, Brazil, in the coming days to decide what to do.

Key points

• The C++26 DIS ballot closed on 22 October 2026 (Margo's account; Fertig dates it 23 October) with 13 votes in favour, 9 against and 12 abstentions, short of ISO's thresholds.
• National bodies' comments point to Contracts (P2900) as the reason; Bjarne Stroustrup and four co-authors called it an "existential threat to C++" in paper P4334R0 in August.
• ISO's options are a revised draft and a new vote, a return to the committee draft stage, publication as a Technical Specification, or cancelling the project; the project lapses if not approved by the end of 2027.
• WG21 meets in Búzios, Brazil, next week to recommend a path; the chair of ISO's SC22 subcommittee decides.
• This is a standardisation dispute, not a code release: we have seen no compiler vendor announce a change.

What happened

C++ standards pass through a series of ISO stages. The DIS ballot is the penultimate one: national standards bodies vote on the final technical text. It is normally a formality. This time it was not. According to The Register and to Thibault Ricord-Marchal, a software engineering consultant at the French firm Margo, the vote produced 13 in favour, 9 against and 12 abstentions. Margo says ISO requires two-thirds approval and no more than a quarter of votes against. By our own arithmetic, 13 + 9 + 12 is 34 ballots, so the 9 negative votes are about 26.5 percent: just over the line on their own.

The date is a small point on which sources differ. Margo says the vote closed on 22 October; Fertig, who sits on the committee and represents Germany's vote, writes that the result came in on 23 October after a twelve-week voting period. Fertig also notes that ISO rules make parts of such votes internal, so the breakdown by country is not public, and that his article is his personal view.

Fertig says that as far as he knows this is the first failed DIS ballot in the history of C++. Searching ISO's system, he found only one other DIS in the programming-language area that was not approved: ISO/IEC DIS 26926, the C++/CLI Language Specification, in August 2006. That project was halted.

The reason for the rejection, Fertig writes, is clear from the national bodies' comments: Contracts. A number of them believe the feature is not ready to ship.

Background

What Contracts are

Contracts let a programmer write down what a function expects and promises, directly in its declaration. Under P2900 there are three forms, as Margo describes them: pre for preconditions, post for postconditions, and contract_assert for an assertion inside a function body. Margo's example is int sqrt(int x) pre (x >= 0) post (r : r >= 0);.

Each contract can be ignored, observed (a violation is reported and execution continues) or enforced (the program terminates). That choice is made at compile time, typically with a compiler flag, not in the source. A global violation handler, which an application can replace, centralises how violations are reported. Supporters say this exposes the rules to callers and to analysis tools without reading a function's body, replaces comments that drift out of date, and gives the standard library a ready way to harden itself, for instance by adding a bounds check to std::vector::operator[].

A long road

The idea is not new. Margo dates a first proposal to 2004. A version of Contracts was adopted for C++20 and then pulled at the 2019 meeting in Cologne; Fertig says he was in the room both times. A study group then worked on the topic from about 2020 to 2024, before the Evolution Working Group took it up. The committee restarted with what Margo calls a "minimum viable product", adopted in February 2025 by 100 votes to 14. Fertig says WG21 voted on the C++26 draft that included Contracts in March 2026 with a large majority, "though not without dissenting votes".

How the dispute works

The objections

A minority in the committee never accepted the design, Margo says, centred on Stroustrup and the compiler teams of Microsoft and EDG, and several national bodies, including France's AFNOR, had asked for Contracts to be removed as early as 2025. The objections fall into three groups.

First, guarantees. Margo's reading is that nothing in C++26 lets code guarantee that a contract is checked: only compiler flags set the level, and the granularity is coarse, all contracts on or all off. It also describes a case where an inline function built with different settings in two libraries can lose its check at link time without anyone noticing. Proponents answer that assert already has the same problems, and that an unexecuted check is "no worse than no assertion at all". Labels (proposal P3400, planned for C++29) would let programmers choose a strategy per contract, but only for those who use them.

Second, maturity. Margo reports that Contracts are implemented in GCC and Clang, but real deployment experience is limited to contract_assert; preconditions and postconditions on declarations, the genuinely new part, have not been tried at scale. Margo adds that this is also true of static reflection and std::execution, which were adopted anyway.

Third, process. Opponents say the design advanced through polls without their objections being resolved. Margo notes that the former study-group chair John Spicer published a mea culpa for supporting a pace that sidelined objections from key members, including implementers from Microsoft and EDG. Proponents point out that every objection was debated over several meetings and that opposition, however persistent, is not a veto. Even Andrzej Krzemieński, a co-author of the proposal, admits his model "is not adopted by a significant part" of the committee, according to Margo.

Stroustrup's paper

The sharpest statement is P4334R0, "P2900 Contracts' fundamental flaws", dated 9 August 2026 and written by Stroustrup with J-Daniel Garcia, Vinnie Falco, John Spicer and Ville Voutilainen. It says the P2900 contracts "aim to change the nature of C++ and are an existential threat to C++, adding complexity and bloat", and puts the specification at about 56 pages in the draft standard for what it calls an incomplete version. The authors say they are not against Contracts as an idea, nor against the rest of C++26. They would welcome a simple design presented as a debug aid, and they point to a library-based alternative in draft D4324R0. They criticise a stream of follow-on patches (P3097, P3099, P3100 and others) for extending something they consider untried.

The numbers

The ballot itself is small: 34 ballots. The chart shows how they fell.

In favour13

Abstain12

Against9

C++26 DIS ballot result by national bodies (votes)

	votes
In favour	13
Abstain	12
Against	9

Source: The Register; Margo (Thibault Ricord-Marchal)

Margo adds an observation about what a re-vote would take. Even if all 12 abstaining countries voted yes, the 9 negative votes would still exceed 25 percent, so a re-run without changes would need not only the abstainers but at least four countries to switch sides.

What it means

For developers, the immediate effect is uncertainty about names and timing rather than about code. Features already in the C++26 draft, with static reflection and std::execution named by Margo as the most anticipated, cannot become part of an official standard until the dispute is settled. Fertig notes that the label "C++26" itself may change; The Register says the language could end up called "C++27" informally if it misses this year's ship date. Compilers have their own release schedules and we have not seen any vendor announcement about removing a feature.

For the library side, Margo says standard-library hardening can survive any outcome: its first version was specified without Contracts, and existing implementations are already decoupled. It cites Google's deployment, which it says caught over a thousand bugs for a 0.3 percent overhead.

For the committee, the question is trust. Fertig calls the result "a massive disaster" and argues that national bodies had traditionally voted no only on new information or process errors; he says a new paper with old arguments is not new information to him. Harry Bott, CEO of the C++ Alliance, told The Register by email that "the draft being sent back isn't a failure of the process", but the process working as intended. Margo frames it as a governance test: either external oversight works when a committee overrides serious opposition, or a minority holding leverage in national bodies can block a majority.

What we don't know yet

• Which path WG21 will recommend. Ricord-Marchal, quoted by The Register, lays out three: remove Contracts so the rest of C++26 can ship (messy, since library hardening work depends on them), move Contracts to a separate technical specification, or make a minor revision and vote again.
• Whether the national bodies that voted no would change their position without changes to Contracts. Fertig finds that hard to imagine.
• The country-by-country breakdown of the vote, which ISO rules keep internal.
• Whether C++26 keeps its name and a 2026 publication date.
• The exact date of the ballot's close (22 or 23 October in our sources) and of the Búzios meeting: Fertig names 16 November, The Register says next week.

What to watch next

• The Búzios meeting outcome and the written recommendation from WG21.
• The SC22 chair's decision among ISO's four paths.
• Whether Contracts is removed, split out or re-voted unchanged. Margo's most pragmatic scenario is dropping Contracts to ship reflection and std::execution, with a precedent in the 2008 removal of Concepts from C++0x, which returned, redesigned, in C++20.
• The deadline: Margo says the project is cancelled automatically if the standard is not approved by the end of 2027.
• Compiler vendors' statements about Contracts support in GCC and Clang releases.

For another language that is shipping on a steady cadence, see our Rust 1.100 coverage.

Sources

• The Register: C++26 stumbles at finish line over Contracts dispute
• Margo: ISO C++26 Standard, why the draft was rejected
• Andreas Fertig: C++26 DIS failed, how does C++ survive?
• P4334R0: P2900 Contracts' fundamental flaws (Stroustrup et al.)
• P2900R6: the Contracts proposal