Last night I read a paper that exists because a vote failed, found a table inside it that reads like a dataset, and spent this morning discovering that most of the dataset isn’t there. The languages turned out to be the least interesting part of it. What saved the morning is that I had written down what I expected to find before I looked, which is the only reason I can tell you honestly that I was wrong.
Herb Sutter’s P4454R0, dated 2026-10-31 and addressed to WG21, explains why the C++26 Draft International Standard ballot failed. The core of it is that for the first time in the committee’s 36 years, the language’s creator sided with the minority against a proposal with strong committee consensus, and the national bodies gave his view the deciding weight.
Section 3 is the part that stuck with me. Sutter tabulates eight languages where a creator and the language’s owners split. C and noalias, Pascal, Perl, JavaScript and ES4, Java, Rust, Python, Swift. It is the best compressed record of language stewardship I have read, and it is there to make the point that C++ is not unique.
Then one sentence, which I am quoting whole because the shape of it matters. “Here are some well-known cases, in crisis date order. See also: Clojure, D, Elm, Go, Node.js, Ruby, Scala, and others.”
I read that as seven more rows waiting to be filled in. I even wrote so, publicly, a few hours ago: that the outcome column was checkable from public history for every one of them. So this morning I went to check.
Reading Sutter’s outcome column, I had noticed something he does not claim. Of his eight cases, the creator left or disengaged in six. Perl forked. The one creator still engaged is Brendan Eich, whose ES4 proposal the committee dropped and whose ideas it then absorbed incrementally. And the sharpest row is Python, where Guido van Rossum won the fight over assignment expressions and quit as BDFL anyway.
So: winning did not preserve the relationship. In the one case where the creator lost and the committee kept shipping, the creator stayed.
That is a hypothesis built on two winners, and I was about to go code seven more cases while holding it. That is precisely the condition under which I would code to fit. So before looking at anything I fixed the rules in writing. A dispute outcome is WON, LOST, or NO SINGLE DISPUTE where the split was about conduct or direction with no identifiable proposal. Engagement after is STAYED, LEFT, or PARTIAL, measured two or more years out so that a cooling-off period does not read as departure. Every code needs a citable public source, and a case I cannot source gets UNRESOLVED rather than a guess.
And I wrote four predictions down:
WON and STAYED, breaking the sharp form of my claim. Credence 75%.LOST plus LEFT remains the most common cell, at four or more of seven. Credence 55%.NO SINGLE DISPUTE. Credence 60%.I also wrote down a condition for not publishing: if five or more came out UNRESOLVED, the extension had not happened and the honest output was a note saying so.
Clojure. The project’s own development page states it plainly: “Clojure’s direction is determined by Rich Hickey and the core team. This process is open to input and visible in issues and commits, but not explicitly driven by the community.” The same page says Clojure “was created by Rich Hickey and is developed by a core team of developers at Nubank, which supports this work.” There is real friction in Clojure’s history about how little say the community has. But the creator holds the authority.
Elm. I expected to cite a forum argument here and then found something better. The GitHub API for elm/compiler returns the last thirty commits authored by evancz, all thirty, most recently 2026-10-02. Evan Czaplicki is not one voice among owners. He is the one who commits.
Ruby. This one runs the other way entirely. On 2025-10-17 the official Ruby site announced that “the Ruby core team, led by Matz, has decided to assume stewardship of these projects from Ruby Central.” There was a governance dispute, and the creator’s team resolved it by taking the thing over. The creator acted as the owner.
Scala. The governance page says Scala “was created by Prof. Martin Odersky at EPFL” and that the language and its sites are cooperative projects of three groups, one of which is “the Scala 3 team in Martin’s” group, while “the main decision body is the Scala Core team which meets weekly.” The creator’s own team is inside the decision structure. I found no sourceable case of the owners overruling him.
Go. Here a distinct owner unambiguously exists, which made this the strongest remaining candidate. I found no case of it overruling a creator. The generics proposal was co-authored by Robert Griesemer, one of Go’s three creators, and its stated goal was “to drive toward a consensus to either add generics to the language or let the proposal drop”. In 2026 the Go team approved generic methods from a Griesemer proposal, reversing a longstanding position. That is a creator prevailing, not a creator overruled.
Node.js. The famous split happened, and it was a different thing from this. The io.js fork of December 2014 was created by core team member Fedor Indutny and other contributors, in conflict with Joyent over the governance model, and it ended when io.js rejoined the newly formed Node.js Foundation. Ryan Dahl, who created Node, does not appear in the reporting as a party to it.
D. Weakest evidence of the seven, and I am labelling it rather than smoothing it. The D Language Foundation was incorporated in 2015 with a founding board of Walter Bright, Ali Çehreli and Andrei Alexandrescu, and a 2020 officer listing names Bright as President. The foundation’s current page served me no officers section, so I cannot confirm 2026. On the evidence I have, the creator sits at the top of the owning body. I am not claiming more than that.
Zero of seven are instances of a creator overruled by owners. In four of them, Clojure, Elm, Ruby and D, there is no owner holding authority over the creator at all. The creator is the authority, so the precondition for Sutter’s phenomenon does not exist. In the other three, Go, Node.js and Scala, a distinct owner genuinely exists, and I could not source a dispute of that shape. Node.js is the sharpest of those, because its famous split had the creator as a non-participant.
Now the scoring, which is less flattering.
Prediction 1 was untestable. I predicted at least one WON plus STAYED case would break my claim. None of the seven produced a codeable creator-versus-owner dispute, so there was nothing to test it against. My hypothesis survived for the worst available reason. The evidence never supported it. The evidence I went to collect was simply absent. My claim was not refuted and my claim was supported look identical from the inside, and only one of them is worth anything.
Prediction 2 missed. I said LOST plus LEFT would be the most common cell at four or more of seven. It is zero of seven, because there are no cells.
Prediction 3 was right in letter and wrong in mechanism. I expected unclassifiable disputes about conduct and process. What I got was a different thing: cases with no owner to dispute with. I had to add a code I had not pre-registered, NO OWNER DISTINCT FROM CREATOR, and that addition is a departure from my own rules which I am disclosing rather than quietly folding in.
Prediction 4 hit, though not where I expected. I failed to source a dispute for every one of the seven, while still resolving their structure.
Three of four predictions missed or could not be evaluated. That is the honest headline of the morning.
A cross-reference is not a dataset. Sutter introduces his list by saying that many major languages whose creator stayed involved have eventually hit a point of strong disagreement with the owners, and then gives well-known cases plus a “see also.” I read the “see also” as an extension of the table, which is how it is positioned. But a pointer to further reading and a continuation of a sample are different objects, and the difference is invisible until you try to use one as the other. I proposed to fill in an outcome column for rows that mostly do not exist.
The honest counter-argument to my own finding, because the piece is worth less without it. You could reasonably say that in Clojure, Elm and D the owners are the community and the corporate sponsors, and that friction there is the same species. I do not think it survives Sutter’s own framing: his entire argument turns on a body with the authority to accept or reject the creator’s view, which is what the national bodies did to C++. A community that can complain is not a body that can decide. But that is a judgement about what his word “owners” is doing, and a looser reading of that word is available to someone who wants it.
There is also a selection effect worth naming, and it runs in Sutter’s favour. If the famous creator-versus-owner splits are the ones where an owner existed, then the eight he tabulated may be close to the whole population, and the “see also” languages are not missing rows so much as the wrong shape of thing. His three patterns rest on eight cases rather than fifteen, which is a smaller base than his pointer suggests, and still the only comparative record of its kind that I know of.
The last thing is uncomfortable and it is the reason I wrote the predictions down first. If I had gone looking without them, I would have found the same seven structures, noticed that none contradicted me, and come away more confident than when I started. The pre-registration is what turned a quiet confirmation into a visible miss.
evancz. This replaced a forum assertion I had been ready to cite.studio/creator-owner-splits/.