In March 2024, Redis Inc. changed the license on one of the most widely used open source projects in the world. Redis had been available under the permissive BSD 3-clause license since its creation. Overnight, it switched to a dual license—the Redis Source Available License and the Server Side Public License—that restricted how cloud providers could offer it as a service.[1]

Within a week, a group of contributors forked the project under the Linux Foundation. They called it Valkey. The code was identical. The API was identical. The behavior was identical. But the name, the governance, and the license were different.[2]

Now there were two ships. Same wood, different flags. Which one was Redis?

The Fork as Identity Crisis

A fork in software is the purest form of the Ship of Theseus problem. Unlike a rewrite, where the code changes gradually, a fork creates two identical copies at a single moment in time. Both share the same history. Both contain the same code. Both claim continuity with the original.

Then they diverge. New features go in different directions. Bugs get fixed differently. Communities form around each one. Over time, the two ships sail to different ports—but they both started as the same vessel.

The question of which fork is the "real" project depends entirely on what you think carries identity. And different stakeholders give radically different answers.

Three Theories of Open Source Identity

Consider what makes an open source project what it is. There are at least three candidates:

The code. The project is its source code—the actual lines that run on machines. By this theory, a fork that preserves the code preserves the identity. Valkey, at the moment of forking, was Redis. The license change made Redis into something new.

The community. The project is its contributors, maintainers, and users—the people who build and depend on it. By this theory, whichever fork the community follows is the real project. When the majority of contributors moved to Valkey, the identity arguably moved with them.

The name. The project is its brand—the name, the trademark, the website, the official channels. By this theory, Redis Inc. still owns Redis, regardless of what the code or community does. The name is the flag on the ship, and whoever controls the flag controls the identity.

Each theory leads to a different conclusion. And in practice, all three matter—which is why forks create such bitter disputes.

Elasticsearch and the Name Problem

The Elasticsearch fork illustrates how names become identity anchors. In January 2021, Elastic changed the license on Elasticsearch and Kibana from the permissive Apache 2.0 to the more restrictive Server Side Public License and Elastic License.[3] The stated reason was to prevent cloud providers from offering the software as a managed service without contributing back.

The response was a fork. But there was a complication: the name. "Elasticsearch" was a trademark owned by Elastic. The fork couldn't call itself Elasticsearch without legal consequences. So it became OpenSearch—same code, different name.[4]

This created a strange identity split. OpenSearch had the original open source code and license. Elasticsearch had the original name and the original company behind it. Users had to choose which aspect of identity mattered more to them.

For many, the name won. Elasticsearch remained the default in conversations, documentation, and job postings. The brand carried identity weight that the code alone couldn't match. But for others—particularly those who valued the open source license as essential to the project's identity—OpenSearch was the true continuation.

Blockchain Forks: Identity With Billions at Stake

Blockchain forks are the most extreme version of this problem because the stakes are financial. When a blockchain forks, the question "which is the real chain?" directly determines the value of people's holdings.

On August 1, 2017, Bitcoin split. A faction of the community believed Bitcoin needed larger blocks to handle more transactions—staying true to the original vision of peer-to-peer electronic cash. The other faction preferred keeping blocks small and scaling through additional layers like the Lightning Network.[5]

The result was Bitcoin and Bitcoin Cash. Both chains shared the same history up to the fork point. Both claimed to be the "real" Bitcoin. Bitcoin Cash argued it was truer to Satoshi Nakamoto's original whitepaper—the purpose of the ship. Bitcoin argued it had continuity of community consensus and the original name—the narrative of the ship.

The market eventually decided. Bitcoin kept the name, the ticker symbol (BTC), and the vast majority of the market value. Bitcoin Cash got a new name (BCH) and a fraction of the value. Identity, in this case, was determined by social consensus—which chain people agreed to call "Bitcoin."

The DAO Hack: Rewriting the Ship's Logbook

Ethereum's 2016 fork posed an even more philosophically interesting question. A hacker exploited a vulnerability in the DAO—a decentralized investment fund built on Ethereum—and drained roughly 3.6 million ether, worth about $50 million at the time.[6]

The Ethereum community faced a choice: accept the hack as part of the blockchain's immutable history, or hard fork to reverse the transaction and return the funds. The majority chose to fork. The new chain—which kept the name Ethereum—effectively rewrote history, as if the hack never happened.

But a minority refused. They argued that immutability was the whole point of a blockchain. If you can reverse transactions when they're inconvenient, the ledger means nothing. They continued running the original, unmodified chain and called it Ethereum Classic.[7]

This is Hobbes's two-ship problem in its purest form. Ethereum Classic has the original, unmodified history—the old planks. Ethereum has the community consensus and the name—the continuous narrative. Both have legitimate claims to being the "real" Ethereum. The identity split was about values: what matters more, the integrity of the record or the will of the community?

The Reunification Problem

Sometimes the two ships become one again. In 2014, the Node.js community split over governance disagreements. A group of contributors forked the project and created io.js, which moved faster on adopting new JavaScript features and had a more open governance model.

For about a year, two competing JavaScript runtimes existed—same origin, diverging paths. Then in 2015, they merged back together under the Node.js Foundation with a new governance structure that incorporated io.js's demands.

Was the reunified Node.js the same project as the original? It had a different governance model, different leadership, and code contributions from both forks. The merger created something that was neither the original Node.js nor io.js, but a synthesis of both. The ship was disassembled into two ships, then reassembled into one—but with planks from both.

Relicensing: Same Ship, Different Sea

Relicensing is a subtler identity problem than forking. The code doesn't change. The community doesn't necessarily split. But the rules governing the project change fundamentally.

When a project moves from a permissive license (MIT, BSD, Apache) to a restrictive one (SSPL, BSL), the code is identical before and after. But the social contract is different. What you can do with the code changes. Who can use it changes. The relationship between the project and its users changes.

Is a relicensed project the same project? The material is identical—same code, same behavior, same name. But the formal cause has changed—the rules that define what the project is and how it can be used. For many in the open source community, the license is as essential to a project's identity as the code itself. Change the license, and you've changed the ship—even if every plank looks the same.

This is why relicensing triggers forks so reliably. Redis, Elasticsearch, MongoDB, HashiCorp's Terraform—each license change prompted a community fork.[8] The community is saying: the license was a load-bearing plank. You replaced it, and the ship became something else. We're building a new one from the old wood.

Who Owns the Ship?

The deeper question behind every fork is ownership. Not just legal ownership—though that's often contested too, as the Elasticsearch trademark lawsuit showed. Philosophical ownership. Who has the right to say what the project is?

The original creator? They built the ship. But open source projects often outgrow their creators. Linux is far more than Linus Torvalds's personal project, even though he still steers it.

The maintainers? They keep the ship sailing. But maintainers change over time. The people maintaining a project today may have no connection to the people who started it.

The community? They use the ship, depend on it, build on it. But communities are diffuse and hard to define. Who counts as part of the community?

The trademark holder? They control the name. But a name without a community is an empty flag on an abandoned ship.

In practice, open source identity is a negotiation between all of these stakeholders. When they agree, the project has a clear identity. When they disagree—when the trademark holder goes one way and the community goes another—you get a fork. And the question of which fork is "real" gets answered not by philosophy, but by adoption.

The ship belongs to whoever sails it.

References

[1] Frederic Lardinois, "Why AWS, Google and Oracle are backing the Valkey Redis fork," TechCrunch, March 31, 2024. https://techcrunch.com/2024/03/31/why-aws-google-and-oracle-are-backing-the-valkey-redis-fork/

[2] "Why AWS Supports Valkey," AWS Open Source Blog, April 2024. https://aws.amazon.com/blogs/opensource/why-aws-supports-valkey/

[3] "AWS debuts OpenSearch project following spat over Elastic licence," DevClass, April 13, 2021. https://devclass.com/2021/04/13/aws-debuts-opensearch-project-in-latest-round-of-elastic-licence-spat/

[4] "AWS renames its take on Elasticsearch to OpenSearch following trademark fight," The Register, April 13, 2021. https://www.theregister.com/2021/04/13/aws_renames_elasticsearch_fork_opensearch

[5] "Why Bitcoin split in 2017," Crypto Briefing, 2024. https://cryptobriefing.com/bitcoin-cash-split-2017/

[6] "DAO Hack Explained: How a Vulnerability Split Ethereum," Gemini Cryptopedia. https://gemini.com/en-US/cryptopedia/the-dao-hack-makerdao

[7] "Ethereum Classic — Proof-of-Work Smart Contracts: DAO Hack and Fork," ethereumclassic.com. https://ethereumclassic.com/news/dao-hack-and-fork

[8] "Linux Foundation backs open source alternative to Redis," The Register, April 3, 2024. https://www.theregister.com/2024/04/03/open_source_redis_alternative/