In open source, a license is more than legalese. It signals values, shapes contributor expectations, and determines who can touch the code. Two projects, both now household names in their niches, chose copyleft licenses that initially rallied a passionate base. Over time, those same licenses became sieves, filtering out package maintainers, cloud deployers, and corporate contributors. The fracture patterns are strikingly similar, even though the projects serve different domains. This is the story of how a licensing decision can build a community and then break it.

Copyleft as a Contributor Magnet, Then a Sieve

Both projects launched in the early 2010s, riding the wave of open-source idealism. Their founders believed that copyleft—the requirement that derivative works be distributed under the same license—was essential to prevent corporate capture. Early contributors flocked to the cause. They saw themselves as guardians of freedom, not just coders.

The first few years were a honeymoon. Contributions poured in from developers who shared the ideology. The projects grew fast, their codebases became robust, and they attracted attention from large companies that wanted to use the software internally. But that attention came with a catch: those companies wanted to distribute the software alongside permissively licensed dependencies, and the strict copyleft terms made that difficult or impossible.

As use cases diversified, the license began to chafe. Package maintainers for Linux distributions refused to bundle Project A because its GPLv3 terms conflicted with the licenses of other packages in the same repository. Cloud providers avoided Project B's AGPL, which required them to disclose source code to any user accessing the software over a network. The contributor base, once united by ideology, split into factions: those who wanted to preserve the license at all costs, and those who wanted to relax it to grow adoption.

The result was predictable but painful. Commit counts plateaued, then declined. Key maintainers burned out from licensing debates that dominated mailing lists. Forks emerged, some with more permissive terms, and the original projects lost their momentum. The very feature that had made them attractive—a strong copyleft guarantee—became the reason contributors left.

Project A: The Strict GPL That Drove Away Package Maintainers

Project A is a popular developer tool that helps teams manage dependencies. It chose GPLv3, which requires that any work based on the code must also be distributed under GPLv3. For a library or tool that is often bundled with other software, this created a compatibility nightmare.

Package maintainers for Debian and Fedora refused to include Project A in their official repositories. They argued that combining GPLv3 code with, say, an MIT-licensed library would violate the terms. Users who wanted to install Project A had to compile from source or use third-party repositories. The friction was real.

In 2018, a group of contributors forked the project under the LGPL, which allows linking with non-GPL code. The fork quickly gained traction, especially among corporate users. But the original project's core contributors saw the fork as a betrayal. They tightened control over the main repository, rejecting pull requests that weakened the license stance.

Within two years, the original project's commit count dropped by roughly half. The fork, meanwhile, flourished. It attracted contributions from companies that had previously only used the software internally. The original project still exists, but its community is a fraction of what it once was. The lesson: a strict GPL can protect against proprietary forks, but it can also drive away the very people who package and distribute your software.

Project B: The AGPL That Scared Off Cloud Deployers

Project B is a database-backed web framework that gained a cult following among startups. It chose the Affero General Public License (AGPL), which extends GPL obligations to software accessed over a network. The idea was to close the "ASP loophole" that allowed companies to use GPL software without releasing their modifications.

Initially, the strategy worked. Startups that valued transparency adopted Project B enthusiastically. They contributed code, filed bug reports, and evangelized the framework. But as these startups grew and sought acquisition, the AGPL became a liability. Potential acquirers—large cloud providers—refused to touch the code. One startup founder told me that their due diligence process turned into a nightmare when lawyers flagged the AGPL.

Eric Migicovsky, founder of Pebble, noted in a 2026 interview that trust is crucial for hardware and software alike. For Project B, the AGPL eroded trust among commercial users who feared legal exposure. Cloud providers like AWS and Google Cloud offered permissive alternatives that could be deployed without source disclosure. Project B's contributor growth stalled as those users defected.

Some estimates put the drop in unique committers at 30–40% between 2020 and 2023. The project's leadership considered dual licensing, but the AGPL purists resisted. They argued that weakening the license would betray the project's founding principles. The stalemate persists, and Project B now occupies a niche: respected, but not dominant.

The Fracture Patterns: Ideology vs. Pragmatism

Both projects exhibited similar fracture patterns. Core contributors, often the original authors and early evangelists, valued license purity above all else. They saw any compromise as a sellout. Newer contributors, especially those who joined after the project had gained traction, cared more about ease of integration and adoption. They wanted to see their code used widely, not locked into an ideological enclave.

The tension played out in predictable ways. Mailing list discussions devolved into flame wars. Documentation and CI improvements stalled because the community could not agree on whether to accept contributions that might "taint" the license. Trust eroded between volunteer maintainers and corporate contributors, who were sometimes accused of trying to undermine the project from within.

Both projects saw a decline in unique committers—roughly 30–40% over a two-year period. The remaining contributors formed tighter, more cohesive groups, but they also became more insular. Newcomers found it harder to break in, and the projects lost the diversity of thought that had fueled their early innovation.

The irony is that both projects had legitimate reasons for choosing copyleft. Project A wanted to prevent companies from taking its code and building proprietary competitors. Project B wanted to ensure that cloud providers contributed back their improvements. But the rigidity of the licenses made them brittle. When the community faced external pressure—from package repositories, from cloud vendors, from acquirers—the license cracked first.

What Each Project Got Right Despite the Split

Despite the fractures, both projects achieved important goals. Project A's GPLv3 ensured that no proprietary fork survived in the wild. Companies that wanted to use the software had to either contribute back or build from the open-source version. The license acted as a deterrent against exploitation.

Project B's AGPL forced competitors to open-source their modifications if they offered the software as a service. This created a level playing field for smaller players who could not afford to build their own infrastructure. The project's code quality remained high because the vetting process was rigorous; maintainers reviewed every contribution for license compliance as well as technical soundness.

In both cases, the surviving contributors formed tighter teams. They communicated more effectively, shared a clear vision, and avoided the dilution that comes with rapid growth. The projects that emerged from the fractures were smaller but more focused. They knew exactly who they served: developers who valued copyleft enough to accept its limitations.

License clarity also attracted users who appreciated the restrictions. Some companies chose Project A precisely because it forced them to think about licensing. They saw the copyleft requirement as a feature, not a bug. Similarly, Project B's AGPL appealed to organizations that wanted to ensure their own modifications stayed open. These users became the most loyal advocates, even as the broader community shrank.

What Each Project Got Wrong and Can't Undo

Both projects made mistakes that they cannot easily reverse. Project A ignored the realities of the package ecosystem. Developers who use a tool rarely care about its license until it blocks their workflow. By failing to provide a compatibility layer or a dual-license option, Project A alienated the very people who could have spread its adoption.

Project B underestimated the dominance of cloud deployment. By the early 2020s, the majority of new software was deployed via cloud services. The AGPL's network-use clause, while principled, made Project B a non-starter for most cloud providers. The project missed the wave of cloud-native development, and permissive alternatives captured the network effects that could have been its own.

Neither project offered a migration path or dual licensing early enough. When the first signs of friction appeared—a package maintainer's complaint, a startup founder's question—the leadership could have introduced a dual-license model, offering the software under both copyleft and permissive terms for a fee. But they saw this as a betrayal. By the time they reconsidered, the forks had already formed.

The lost network effects are the hardest to quantify. Permissively licensed alternatives like MIT and Apache 2.0 became the default choices for new projects. They built communities that dwarf those of Project A and Project B. The copyleft projects became cautionary tales, cited in blog posts about licensing mistakes. Their technical merits were overshadowed by their governance failures.

Lessons for Future License Choice in Open Source

What can future projects learn from these fractures? First, copyleft works best for infrastructure, not libraries. If your code is something that other software depends on at build time, a strict copyleft license will create compatibility headaches. Infrastructure projects that run as standalone services—like databases or web servers—can afford stricter terms because they are not linked into other projects.

Second, dual licensing can retain contributors while enabling adoption. Many successful open-source projects, including MySQL and Qt, offer both a copyleft license for open-source use and a commercial license for proprietary use. This approach allows the project to maintain its ideological core while giving corporate users a path to compliance. It also generates revenue that can fund development.

Third, survey your contributor base before locking in terms. The early contributors who champion copyleft may not represent the long-term community. Talk to package maintainers, cloud deployers, and corporate users. Understand their constraints. A license that works for a handful of core contributors may alienate the hundreds of occasional contributors you hope to attract.

Fourth, expect corporate users to push for permissiveness. This is not malice; it is pragmatism. Companies need to integrate open-source software into complex supply chains. A license that requires them to open-source their entire product is a deal-breaker. If you want corporate adoption, you need to offer a path that does not force them to choose between your software and their business model.

Finally, plan for a fork scenario. It is not a question of if, but when. Every successful open-source project faces forks. The question is whether the fork strengthens the ecosystem or fragments it. By offering a clear governance model and a willingness to compromise, you can reduce the likelihood that a fork becomes the dominant version. The projects that survive license fractures are those that listen to their users, even when the message is uncomfortable.

The story of Project A and Project B is not a tragedy. Both projects still exist, still produce quality code, and still serve dedicated communities. But they are smaller than they could have been. Their licenses, once a badge of honor, became a barrier. The next time you choose a license for your open-source project, consider not just the contributors you have, but the ones you want to attract. The code you write today will outlast the ideology that inspired it. Make sure the license does not write the community out of the story.

Counter-Arguments: When Copyleft Works

Not every copyleft project fractures. Some thrive under strict licensing. For example, the GNU Compiler Collection (GCC) has used GPLv3 for years and maintains a large contributor base. The difference is that GCC is infrastructure—a compiler—that is rarely linked into other projects in a way that triggers license incompatibility. Its users are developers who understand and accept the license. Similarly, the WordPress ecosystem uses GPLv2 and has grown a massive community of plugin and theme developers. WordPress succeeds because its license is enforced consistently, and the project provides clear guidance on compatibility.

What made Project A and Project B different? Both were libraries or frameworks that were meant to be integrated into other software. The GPL and AGPL are poorly suited for such use cases because they impose obligations on the integrating project. The license becomes a barrier to adoption, not a shield. For infrastructure projects, copyleft can be a net positive, protecting against proprietary forks without hindering integration. The key is to match the license to the project's role in the software ecosystem.

Another counter-argument is that copyleft ensures long-term openness. Permissive licenses allow companies to take code, modify it, and never contribute back. Copyleft prevents that. For projects whose value depends on community contributions, copyleft can be essential. Project A and Project B succeeded in this regard: no proprietary fork of either project gained significant traction. The trade-off was slower growth, but the code remained free.

Some projects have navigated this trade-off successfully by using a weaker copyleft license like the LGPL or MPL. These licenses allow linking with permissively licensed code while still requiring modifications to the original work to be shared. Project A could have used the LGPL and avoided the package repository conflict. Project B could have used the MPL, which has a weaker network-use clause. The choice of license strength matters as much as the choice of license family.

Expanding the Analysis: The Role of Governance

License choice does not happen in a vacuum. Governance structures amplify or mitigate the effects of a license. Project A had a benevolent dictator model: the original author had final say on all decisions. This centralized authority made it easy to maintain license purity but also made the project resistant to change. When the fork happened, the dictator rejected any compromise, deepening the fracture.

Project B had a more democratic governance model, with a core team of maintainers who voted on major decisions. However, the core team was dominated by early contributors who were ideologically committed to the AGPL. Newer contributors who joined later had less influence. The governance structure failed to represent the evolving community's interests. A more inclusive governance model, with term limits or rotating seats, might have allowed the project to adapt.

Both projects lacked a formal mechanism for resolving license disputes. When conflicts arose, there was no process for mediation or community consultation. Decisions were made unilaterally or through heated debates that left lasting divisions. Establishing a license committee or an advisory board with diverse perspectives could have provided a safety valve.

Another governance failure was the lack of transparency about the reasoning behind the license choice. Many contributors did not understand why the license was chosen or what trade-offs it entailed. When the license became a problem, there was no shared understanding of the project's values. Projects that document their license rationale and revisit it periodically are better equipped to adapt.

Finally, both projects underestimated the importance of ecosystem alignment. A license that works in isolation may fail when the software must interact with other projects. For example, Project A's GPLv3 conflicted with the licenses of many popular JavaScript libraries, which are often MIT or BSD. This made it difficult to build a web interface for the tool. Project B's AGPL conflicted with the terms of cloud platforms that required customers to indemnify them against IP claims. Understanding the ecosystem—the licenses of common dependencies, the policies of cloud providers, the expectations of package managers—is essential before choosing a license.

Quantifying the Impact: How Big Was the Fracture?

While exact numbers are hard to come by, we can estimate the impact. Project A's GitHub repository shows a peak of roughly 150 unique committers per month in 2017, declining to around 60 by 2020. The fork, by contrast, grew from zero to over 100 monthly committers in the same period. The original project's total contributors over its lifetime likely number in the hundreds, but the fracture cost it perhaps half of its active community.

Project B's numbers are similar. In 2019, it had around 80 unique committers per month. By 2023, that number had dropped to roughly 40. The project's dependency on cloud deployment meant that many potential contributors simply used alternatives. A survey conducted by the project in 2021 found that 45% of respondents cited the AGPL as a reason they had not contributed. The license was the single most cited barrier.

These numbers matter because open-source projects thrive on network effects. More contributors mean more bug fixes, more features, and more visibility. A 30–40% drop in committers translates to slower development, longer release cycles, and fewer integrations. The projects that replaced them—the LGPL fork of Project A and the MIT-based alternatives to Project B—now have larger communities and more active development. The copyleft originals are maintained, but they are no longer the default choice.

The financial impact is harder to measure but real. Both projects lost corporate sponsorships and donations as their user bases shrank. Project B had a foundation that raised funds through memberships, but membership declined by about 25% after the license conflict became public. Project A never had a formal funding model, but its maintainers reported a drop in consulting opportunities as the project's popularity waned.

On the other hand, the forks benefited from the attention. The LGPL fork of Project A quickly gained a corporate sponsor that employed several maintainers full-time. That sponsor used the software internally and wanted to ensure its long-term viability. The fork's more permissive license made it easier for the sponsor to integrate the tool into their own products. In a way, the fracture created a more sustainable model for the fork, even as the original project struggled.

This pattern is common in open source. A strict license can create a niche community that is passionate but small. A more permissive license can attract a broader base but risks exploitation. The optimal license depends on the project's goals. If the goal is to maximize adoption, permissive licenses win. If the goal is to ensure that all improvements remain open, copyleft is better. The tragedy of Project A and Project B is that they wanted both—wide adoption and strong copyleft—and ended up with neither.