React just left Meta. Here’s what that means for developers.
From Kubernetes to Node.js to Rust, history shows what happens when major open source projects leave their corporate parents, and what doesn’t change at all
If the intersection of open source, corporate strategy, and developer tools is your thing, subscribe. I go deep on this regularly.
On 24 February 2026, React got a new home. The React Foundation launched as a Linux Foundation project, with eight platinum members (Amazon, Callstack, Expo, Huawei, Meta, Microsoft, Software Mansion, and Vercel), a dedicated executive director in Seth Webster, and a five-year, $3 million-plus commitment from Meta.
Talk about grand.
Your npm install react still works. Your components still render. Your JSX still compiles.
So what, exactly, just happened?
To answer that, you need to look at the six or seven other major open source projects that went through this same transition. Some thrived. Some stumbled. And one became a cautionary tale that React’s founders would be wise to study closely.
What a foundation actually does
Strip away the press releases and the congratulatory tweets, and a foundation is a legal wrapper. Specifically, it’s typically a 501(c)(6) trade association under the Linux Foundation’s umbrella.
Think of it as a holding company for open source: it takes custody of trademarks, manages intellectual property, and provides the operational structure so that no single corporation owns the keys.
The important separation is between technical governance and business governance. A Technical Steering Committee (or equivalent) handles what goes into the code. A board of member organisations handles funding, strategy, and the business of keeping the lights on.
In theory, these two groups operate independently. In practice, how well that separation holds determines whether a foundation is real or just plain decorative.
Funding comes from tiered membership. Platinum seats at Linux Foundation projects reportedly run around $500,000 per year. With eight platinum members, plus events and training revenue, the React Foundation has a financial base that most open source projects would plain envy.
A foundation doesn’t change how React works. It changes who gets a say in where React goes.
Until recently, Meta held the trademarks, controlled the infrastructure, and employed nearly all of the core team. That’s fine when a company’s incentives align with the community’s. It becomes a problem the moment they diverge.
The best case: Kubernetes
If you want to see what a successful foundation transition looks like, look at Kubernetes.
Google built Kubernetes internally, open-sourced it in 2014, and donated it to the newly formed Cloud Native Computing Foundation in 2015. Before that transfer, Kubernetes had a problem that had nothing to do with the technology itself: it was a Google project. AWS wasn’t going to invest engineering resources into something a direct competitor controlled. Neither was Microsoft. Neither was anyone else who competed with Google Cloud.
The CNCF changed the calculation. Under neutral governance, competitors could collaborate without handing strategic advantage to Google. AWS built EKS. Microsoft built AKS. The contributor base grew from roughly a hundred engineers to thousands, spread across more than a hundred companies.
Neutrality opened the door to adoption that corporate ownership never could. That’s the single biggest lesson from Kubernetes.
The parallel to React is very hard to miss. Amazon already uses React extensively. So does Microsoft; Ruhiyyih Mahalati from Microsoft’s team noted that “React is a core part of our front-end architecture across Azure.” Both are now platinum members. But does foundation membership translate into deeper engineering contributions, or does it remain a logo on a webpage and a line item on a sponsorship budget?
Google’s experience suggests the former, but Kubernetes also had a specific forcing function: cloud vendors needed to build Kubernetes distributions to compete. React’s dynamics are different. Nobody needs to fork React to sell a cloud product. The incentives for deep contribution are, honestly, weaker.
The crisis resolution: Node.js
Kubernetes is the success story. Node.js is the cautionary tale that still had a happy ending.
By late 2014, the Node.js community had a governance problem. Joyent, the company that controlled Node.js, was moving slowly. The community wanted faster releases, more transparent decision-making, less corporate gatekeeping. When they didn’t get it, they did the one thing that keeps corporate open source sponsors up at night.
They forked.
The io.js project was a pointed message: we will route around you. It worked. The Node.js Foundation formed under the Linux Foundation in 2015, merging io.js back in under open governance. It later became the OpenJS Foundation in 2019, which now also hosts jQuery, webpack, and Electron.
Foundations can heal community fractures caused by corporate control. They’re credible neutral ground where competing interests get resolved without anyone reaching for the nuclear option.
React hasn’t had a governance crisis. Nobody forked React over frustration with Meta’s stewardship. This move is preventive, not reactive, which is arguably the smarter play. Better to build the bridge before you need it.
The cautionary tale: .NET
Not every foundation transition works.
Microsoft open-sourced .NET Core and established the .NET Foundation to govern it. On paper, it looked right: independent governance, community representation, transparent process.
In practice, Microsoft still drove virtually all technical direction. Board members resigned. Community members publicly criticised the foundation as governance theatre, a structure that provided the appearance of independence without the substance.
“Foundation in name only” showed up more than once.
A foundation is only as independent as the community makes it. The legal structure is necessary but not sufficient.
This is the scenario that should worry React’s community most. Meta still employs the majority of the core team. Seth Webster, the new executive director, came from Meta’s React team. The initial announcement emphasised that technical governance would be independent from the board. But independence is something you demonstrate over years, not something you declare in a blog post.
The .NET Foundation’s mistake was assuming good intentions would substitute for genuine structural independence. Meta and the React Foundation need to learn from that. Diversifying who employs core maintainers matters more than diversifying who sits on the board. (I’d argue it matters a lot more.)
The mixed result: Rust
Mozilla created Rust. When Mozilla laid off a large portion of its workforce in 2020, Rust’s future suddenly looked precarious. The Rust Foundation formed in 2021 with backing from AWS, Google, Huawei, Microsoft, and Mozilla, providing stable funding independent of any single company’s fortunes.
That part worked. Rust didn’t collapse when Mozilla stumbled.
But foundations create new problems even as they solve old ones. In 2023, the Rust Foundation proposed a trademark policy that the community received about as well as a mass email from HR titled “exciting changes to your benefits package.” Developers felt the policy was too restrictive, and the backlash was immediate and loud.
The Rust episode shows a tension every foundation faces. Trademarks need protecting (that’s partly what foundations are for). But developer communities have a visceral reaction to anything that feels like corporate overreach on tooling they consider theirs.
How will the React Foundation handle the React trademark? What can and can’t be called “React-compatible”? These questions will matter more than the membership roster.
Meta’s done this before
Meta has already run this exact playbook. (And honestly, it went fine.)
In 2019, Meta transferred GraphQL to the Linux Foundation, creating the GraphQL Foundation. GraphQL had grown well beyond Meta’s internal use, and the transfer to neutral governance was smooth. The specification evolved. New implementations appeared. No drama, no community revolt, no rubber-stamp criticisms.
React is following the same path at much larger scale. That matters because institutional knowledge compounds. The people involved in the GraphQL transfer understand the legal mechanics, the community dynamics, the governance pitfalls. Eli White from Meta framed it in corporate-speak, calling React’s growth “a testament to the power of open source collaboration,” but the substance behind the PR language is real: this team has done this before.
The GraphQL precedent doesn’t guarantee success, but it reduces the risk of unforced errors considerably.
What the sceptics are saying
Every foundation launch attracts the same objections. They deserve honest answers.
“Meta is offloading maintenance costs.”
Maybe. But the $3 million commitment over five years, plus continued employment of the core team, doesn’t look like a dump-and-run. Compare this to Facebook shutting down Parse in 2016 with twelve months’ notice and a “good luck” pat on the back. That was abandonment. This is something else.
“Bureaucracy will slow React down.”
This one’s legitimate. Foundations add process: board meetings, working groups, consensus-building. Kubernetes shows that a foundation can maintain velocity at scale. .NET shows it can become a bottleneck. The React Foundation’s success depends on keeping technical governance lean. If every RFC needs to go through committee, React will lose the speed that made it dominant.
“Meta still employs most of the core team.”
True, and this is the foundation paradox. You can transfer trademarks and infrastructure overnight. But what you can’t is transfer employment relationships and institutional knowledge overnight. The React Foundation will be genuinely independent only when multiple companies employ significant numbers of core contributors.
That took Kubernetes three to four years. React should plan for the same.
“What happens after the five-year commitment?”
The honest answer: nobody knows. Five years of guaranteed funding from Meta provides a runway, and five years sounds like a long time until you remember how fast this industry moves. Whether the foundation is self-sustaining by then depends on membership growth, the community’s willingness to contribute, and whether React remains dominant. That’s the bet.
What changes for you, the developer
If you build with React, here’s the practical timeline.
Today: Nothing changes. Same packages, same APIs, same MIT licence, same people making decisions. Your code doesn’t care about governance structures.
Next 6-12 months: Governance formalises. Repositories and infrastructure transfer to the foundation. You might notice new contribution guidelines or a different CLA (Contributor Licence Agreement). Day-to-day? Still no difference.
1-3 years: If it works, you’ll see a more diverse contributor base, ecosystem grants, community programmes, and potentially faster evolution of the framework. If it doesn’t work, you’ll see bureaucratic slowdowns and community frustration. Your code won’t notice either way, but the trajectory of the framework you depend on will be shaped by how this plays out.
3-5 years: This is where it actually counts. Is the React Foundation genuinely independent, with diverse funding and diverse maintainer employment? Or is it the .NET Foundation with better PR?
The single most important thing the React Foundation does is reduce bus factor. React’s survival is no longer coupled to Meta’s strategic priorities.
Open source projects die when their corporate parent loses interest. We’ve seen it. Facebook shut down Parse. Red Hat turned CentOS into CentOS Stream, breaking the implicit contract with its community. A foundation doesn’t make React immortal, but it makes a sudden rug-pull dramatically harder.
The bigger picture
React powers somewhere around 50 million websites. Millions of developers use it. Thirteen years old; ancient by JavaScript framework standards, middle-aged by infrastructure standards. It faces real competition from newer approaches, but it’s still the default for a plurality of web development teams.
Putting React into a foundation is an acknowledgement that the project has outgrown any single company’s stewardship. It joins a lineage: Linux, Python, Kubernetes, Node.js, Rust. Each matured through foundation governance. Each emerged stronger, though the growing pains varied.
Tom Occhino from Vercel captured the sentiment: “React transformed what’s possible on the web.” Fair enough. But transformation and sustainability are different things. The foundation is about the second one, and it’s the less glamorous job by far.
Nobody remembers the launch announcement. Launch announcements are easy. Press releases write themselves. What counts is years three, five, and ten, when the enthusiasm fades and the hard work of governance, funding diversification, and community stewardship has to happen without a spotlight.
The legal structure is the easy part. The community showing up is the hard part.
I write about the structural shifts behind the tools we build with; where open source, corporate strategy, and developer ecosystems collide. If that’s your thing, follow along. More coming.