Between 2018 and 2021, the open source world went through a rupture it is still digesting. A series of companies that had built successful infrastructure on open licenses, Redis, MongoDB, Elastic, Confluent, and others, changed their terms, one after another, to stop cloud providers from taking the code and selling it as a hosted service. The relicensing wave is the most important episode on the record after the original definitions, because it is the moment the industry admitted that the open shelf's terms had a hole.

The hole was called the cloud, and it had been there since the Affero clause first tried to patch it.

The trigger in the machine

The problem was structural. The GPL's copyleft triggers on distribution, and a cloud provider does not distribute. It runs the code on its own servers and sells access over a network, which meant it could take Redis or MongoDB, wrap it in a service, and sell it at scale without ever triggering the share-alike duty or paying the authors. The companies watched their own code become a competitor's product, and the existing licenses offered no lever to pull.

The asymmetry was the wound. The company that wrote the code paid for its maintenance, its documentation, its security patches, while the cloud provider paid for none of it and captured most of the revenue. Every license on the open shelf had been written for a world where the person who profited from the code also had to redistribute it.

The instruments they wrote

Each company answered differently. MongoDB wrote the Server Side Public License in 2018, a modified GPL that extended the copyleft trigger to offering the software as a service, so that anyone selling MongoDB-as-a-service had to release their entire service stack. Redis added a restricted module license. Elastic moved its code to a dual source-available and proprietary model. Confluent wrote a community license that forbade offering the software as a competing service. The instruments differed in clause, but they all reached for the same thing: a term that stopped the free ride.

The drafting was deliberately aggressive in places. The SSPL's service-source requirement was broad enough that complying would mean publishing an entire hosting operation, which is why it was effective and why it was never going to be approved.

The argument over the definition

The wave forced a definitional fight that the binder keeps on file. The Open Source Initiative declined to approve the SSPL, on the ground that it discriminated against a field of endeavor and was, in their reading, unenforceable as drafted. The companies argued back that the definition, written for a world of shipped software, no longer described where software was actually consumed. Both were right. The definition had not changed; the delivery model had.

What the commons lost and kept

The relicensings were honest in a way the earlier experiments had not been. The companies stopped calling the new licenses open source, accepted that the texts belonged on the source-available shelf, and took the community's criticism on the chin. The commons kept the old open versions, which were forked and maintained under the original terms, while the companies took the future closed. The result was a split shelf: a last truly open release, and a restricted line continuing above it.

The descendants of the wave

The wave's descendants are still filing into the record. HashiCorp adopted the Business Source License in 2023. The post-open and fair source discussions are its continuation. Even the collaborative source texts of 2003 read differently after the wave: the contribute-or-pay question Jahia asked had finally been answered, not by royalties, but by licenses that reserved the one use the cloud could monetize.

It also produced the forks. OpenSearch rose from the last open versions of Elasticsearch, Valkey from the last open Redis, and the commons kept the code the companies had left behind, which is the part of the story the relicensing announcements never led with.

The record's verdict

The wave also left the binder with a working distinction it uses everywhere: open source is a definition with a fence, source-available is a family with a shared instinct, and the difference between them is not the license text but which uses each one is willing to permit. The relicensings made that difference legible, which is why they are filed here rather than as failures.

Filed in the binder, the relicensing wave is the episode that proved the old categories were load-bearing. Open source had defined itself against proprietary software; the cloud produced a third thing, a service built on open code that owed nothing back. The licenses written to close that hole moved the boundary of the definition, and the argument over whether they went too far is the live question the binder keeps open.

The record keeps the wave because it is the moment the licensing argument stopped being about the text and started being about the infrastructure. The cloud did not change what the licenses said; it changed what they had to reach, and the texts written since are all answers to that shift.

What the text grants

Source-available texts that keep the code readable and usable while reserving the right to offer it as a competing service.

What a reader should check

Whether the license is open source under the definition or source-available with a reserved use, and which version of the code is which.

The limit of this reading

The wave is still settling; the licenses it produced are young, and the forks it spawned are still being maintained.