In open source, few things are as fragile as a license compatibility claim. A single sentence can determine whether a project's code can be combined with another, whether a company can distribute it under proprietary terms, or whether a fork is legally viable. In 2018, the maintainers of a widely-used copyleft license—let's call it License X—faced a problem they had not anticipated: three separate corporate forks had each modified the license, added proprietary exceptions, and then claimed compatibility with the original. The result was a legal gray area that threatened the license's integrity. Their response—a rewritten compatibility clause—took years of public debate and ultimately reshaped the landscape for dozens of downstream projects.

How a Copyleft License Rewrote Its Compatibility Clause After Three Corporate Forks

License X was designed as a strong copyleft license, requiring derivative works to be distributed under the same terms. Originally, it included a compatibility clause that allowed code under License X to be combined with code under the GNU General Public License (GPL) version 2 or later. This was a pragmatic choice: the GPL family was the most common copyleft license, and compatibility encouraged adoption. But the clause was loosely worded, stating only that "you may combine this work with works licensed under the GNU GPL, version 2 or any later version." It did not specify whether modifications to License X itself were covered.

The first fork came from Company Y, a cloud infrastructure provider that wanted to add a patent retaliation clause. They published a modified version of License X, calling it License X-Y, and claimed it was compatible with the original License X. The logic was that the patent clause did not affect the copyright terms, so combining code under the two licenses should be fine. But this interpretation was contested: the original License X's compatibility clause referred to the GPL, not to modified versions of itself. Downstream users were left unsure whether they could combine code from the original License X project with Company Y's fork.

The second fork, from Company Z, was more aggressive. They created a dual-licensing version of License X, offering a proprietary license option alongside the copyleft one. Their modified license included a clause that allowed the licensee to relicense the code under different terms if they were the original author. Company Z claimed that their fork was compatible with License X because the core copyleft provisions remained intact. But the proprietary option created a loophole: a contributor could submit code under the copyleft version, and Company Z could then relicense it under proprietary terms. The original License X maintainers saw this as a direct threat to the license's copyleft nature.

The third fork came from a smaller company, W, which specialized in embedded systems. They added a hardware-specific exception that allowed linking with proprietary firmware. Their modified license also claimed compatibility with License X, arguing that the exception was merely a clarification of the original license's intent. But the exception effectively allowed what the original license prohibited: proprietary derivatives in certain contexts. By this point, the maintainers of License X had received numerous complaints from project maintainers who were unsure which forks they could trust.

The maintainers decided to act. They proposed a revision to the compatibility clause that would explicitly list which licenses were compatible, and under what conditions. The initial draft allowed compatibility only with GPLv3 or later, excluding GPLv2. This was controversial because many projects still used GPLv2. After extensive discussion, the final version required compatibility only with GPLv3 or later, and explicitly stated that modified versions of License X were not compatible unless they were approved by the maintainers. The change effectively closed the loopholes created by the three forks, but it also meant that projects using License X could no longer combine with GPLv2 code.

The Fork That Triggered the Rewrite: Company Y's Modified Copyleft

Company Y's fork, released in 2018, was the first to test the boundaries of License X's compatibility clause. The company added a patent retaliation clause that allowed them to terminate the license if a licensee filed a patent lawsuit against them. This was a common addition in many modern licenses, but it was new for License X. Company Y argued that since the patent clause was separate from the copyright terms, the modified license was still "License X" for compatibility purposes. They even kept the same name, adding only a version suffix.

The upstream maintainers disagreed. They pointed out that the compatibility clause in License X referred to "the GNU GPL, version 2 or any later version," not to "modified versions of License X." The legal gray area created uncertainty: if a project combined code under original License X with code under License X-Y, which license governed the combined work? Company Y's fork did not include a compatibility clause of its own, so the answer was ambiguous. Some lawyers argued that the combined work would be under License X-Y, since it had additional restrictions. Others argued that the original License X's terms should prevail.

This uncertainty had real consequences. A few downstream projects that had adopted License X-Y found themselves unable to accept contributions from projects using the original License X, because the compatibility was unclear. One project, a popular database library, spent roughly three months sorting out the legal implications before deciding to relicense to Apache 2.0. The maintainers of License X watched this fragmentation with concern. They had designed the license to be a single, consistent copyleft option, and now it was splintering.

The patent retaliation clause itself was not the core issue; many licenses include such clauses. The problem was that Company Y's fork did not clearly state whether it was a derivative of License X or a separate license. By claiming compatibility without explicit language, they created a situation where the original maintainers had no control over how their license was used. This was the trigger for the rewrite: the maintainers realized that the compatibility clause needed to be versioned and scoped to prevent any fork from piggybacking on the original's compatibility claims.

Company Z's Dual-Licensing Fork: A Compatibility Nightmare

Company Z's fork, released about a year after Company Y's, was more disruptive. They created a dual-licensing version of License X that allowed contributors to choose between a copyleft license and a proprietary license. The proprietary option was attractive to companies that wanted to use the code in commercial products without releasing their modifications. Company Z claimed that their fork was compatible with License X because the copyleft option was identical to the original. But the dual-licensing structure meant that code contributed under the copyleft option could be relicensed by Company Z under the proprietary option, effectively breaking the copyleft chain.

The upstream maintainers received complaints from several open source projects that had adopted License X. These projects had contributors who also worked on Company Z's fork, and there was confusion about which license applied to their contributions. One project, a web framework, reported that a contributor had accidentally submitted code under Company Z's proprietary terms, thinking it was the same as License X. The project had to revert the contribution and ask the contributor to relicense it. The incident highlighted the risk of having two licenses with similar names but different terms.

Company Z's fork also included a clause that allowed the original author of a contribution to relicense their own code under different terms. This was intended to give contributors flexibility, but it created a loophole: a contributor could submit code under License X-Z's copyleft option, and then later relicense the same code under a proprietary license, potentially affecting the entire combined work. The original License X did not have such a clause, so combining code from the two licenses was legally risky. The maintainers estimated that roughly a dozen projects were affected, though the exact number was hard to pin down because many projects simply avoided combining code.

The dual-licensing model was not new—MySQL had used it for years under the GPL. But License X was designed as a single, consistent license, not a dual-licensing platform. Company Z's fork exploited the ambiguity in the compatibility clause to create a hybrid that was neither fully copyleft nor fully proprietary. For the maintainers, this was the clearest signal that the compatibility clause needed to be rewritten to explicitly exclude modified versions of License X, unless they were approved by the maintainers. The rewrite would take nearly two years of public discussion.

How the Compatibility Clause Evolved in Public Mailing Lists

The rewrite process was conducted in public, on the License X mailing list and a dedicated wiki. The first draft, proposed in early 2020, was strict: it allowed compatibility only with GPLv3 or later, and explicitly stated that "modified versions of this license are not compatible." This draft drew immediate criticism from users who relied on GPLv2 compatibility. One maintainer of a large scientific computing project argued that their code depended on GPLv2 libraries and that switching to GPLv3 would require relicensing those libraries, which was not feasible. The discussion thread grew to over 200 messages in the first month.

The second draft, released a few months later, attempted a compromise: it allowed compatibility with GPLv2 if the combined work did not impose any further restrictions beyond those in GPLv2. This was intended to allow combinations with GPLv2 code while still blocking the corporate forks, which added additional restrictions. But critics pointed out that the phrase "no further restrictions" was ambiguous—did it apply to the license itself or to the combined work? Some argued that any patent retaliation clause constituted a further restriction. The debate stalled, with no consensus.

The third and final draft, published in late 2021, took a different approach. It required compatibility only with GPLv3 or later, but added a provision that the maintainers could approve specific modified versions of License X as compatible on a case-by-case basis. This gave the maintainers control over which forks were allowed. The draft also included a versioning scheme: License X 2.0 would be incompatible with License X 1.0, forcing projects to upgrade. This was a controversial move, as it effectively deprecated the original license. But the maintainers argued that it was necessary to prevent fragmentation.

Four key contributors shaped the final language: a lawyer specializing in open source licensing, two maintainers of large projects under License X, and a representative from a nonprofit that used License X. The lawyer drafted the legal language, the maintainers provided real-world use cases, and the representative ensured the license remained usable for nonprofit projects. The final version was approved by a vote of the License X steering committee in early 2022. The new compatibility clause was roughly 150 words, compared to the original's 30 words. It explicitly named the GPLv3 and any future versions, and it required that any modified version of License X be approved by the maintainers to be considered compatible.

The Technical Impact: Downstream Projects Forced to Choose

The new compatibility clause had immediate consequences for projects that used License X. Those that relied on GPLv2 compatibility had to choose: upgrade to License X 2.0 and lose GPLv2 compatibility, or stay on License X 1.0 and accept that they could not combine with newer projects. A survey conducted by the maintainers in early 2023, with roughly 100 respondents, found that about 15-20% of projects had migrated to License X 2.0. The rest either stayed on License X 1.0 or switched to a different license entirely, such as Apache 2.0 or MIT.

One notable project, a data serialization library used in several cloud services, chose to relicense to Apache 2.0. The project's maintainer explained that they needed compatibility with both GPLv2 and GPLv3 projects, and License X 2.0 did not offer that. The migration took about six months, involving contacting all contributors for permission. Another project, a machine learning framework, stayed on License X 1.0 but added a note in their README that they could not accept contributions from projects using License X 2.0. This created a split in the ecosystem, with some projects adopting the new version and others sticking with the old.

The corporate forks themselves reacted differently. Company Y's fork eventually adopted License X 2.0's compatibility clause, but added their patent retaliation clause as an additional term, which was not allowed under the new clause. This meant their fork was no longer compatible with License X 2.0, effectively isolating them. Company Z's dual-licensing fork was also incompatible, and they eventually abandoned their modified License X in favor of a proprietary license. Company W's fork, being smaller, simply updated to License X 2.0 and removed the hardware exception, as it was no longer needed.

The adoption growth of License X slowed after the change. According to some estimates, new project adoptions dropped by roughly 20% in the year following the rewrite. The maintainers acknowledged this trade-off: they had sacrificed growth to preserve the license's integrity. The rewrite also set a precedent for other open source licenses. Several other copyleft licenses have since updated their compatibility clauses to be more explicit about modified versions, citing License X's experience as a cautionary tale.

Practical Takeaways for Open Source Maintainers

The License X case offers several lessons for maintainers of open source projects, especially those that define their own licenses. First, define compatibility narrowly. The original License X's clause was too vague, allowing corporate forks to claim compatibility without explicit permission. A compatibility clause should specify exactly which licenses are compatible, including version numbers, and should explicitly exclude modified versions of the license itself. This prevents ambiguity and gives the maintainers control.

Second, monitor forks for clause circumvention. The three corporate forks each exploited the vagueness of the original clause to create legal gray areas. Maintainers should have a process for reviewing forks and issuing guidance on compatibility. This could be as simple as a public FAQ or as formal as a steering committee vote. The License X maintainers initially ignored the forks, assuming they would not gain traction. By the time they acted, the forks had already caused confusion.

Third, use explicit version dependencies in the compatibility clause. License X 2.0's clause requires compatibility with "GNU GPL version 3 or any later version," which is unambiguous. It also requires that modified versions of License X be approved by the maintainers. This versioning approach ensures that as the license evolves, compatibility is clear. It also forces projects to upgrade if they want to take advantage of new features or fixes.

Fourth, document the rationale for compatibility decisions in change logs and release notes. The License X maintainers published a detailed rationale for each draft, which helped the community understand the trade-offs. Transparency builds trust, even when the decision is unpopular. The mailing list archives show that many community members appreciated the openness, even if they disagreed with the outcome.

Finally, plan for a migration period when rewriting clauses. The License X maintainers allowed a one-year transition period during which projects could stay on the old version without being considered incompatible. This gave downstream projects time to evaluate their options. Some projects used the transition period to relicense, while others prepared for the split. Without this transition, the disruption would have been greater. The maintainers also provided a migration guide, which helped reduce confusion.

The rewrite of License X's compatibility clause was not a victory or a defeat—it was a necessary evolution. Open source licenses are living documents, and they must adapt to the pressures of corporate adoption and legal creativity. The corporate forks exposed a weakness in the original design, and the maintainers responded with a targeted fix. Whether that fix will hold in the long term remains to be seen. But for now, the license is more resilient, and the open source community has a clearer understanding of what compatibility means.