TL;DR: The Fox Way

Here’s my standard decision tree for open-sourcing a new project:

Open-source license choice decision treestartWrite some softwareq_viralDoes your software use acomponent that forces youto use a specific license?start->q_viralq_respectIs your software basedon or made to extendsomeone else's project?q_gpl2Is their project (A)GPL?q_respect->q_gpl2Yesq_shitpostIs your software a shitpostorreallytiny?q_respect->q_shitpostNoq_viral->q_respectNoq_gpl1Is it (A)GPL?q_viral->q_gpl1YesremoveRemove thecomponentq_gpl1->removeYesreuse_licenseUse their licenseq_gpl1->reuse_licenseNoq_gpl2->q_shitpostYesq_gpl2->reuse_licenseNoq_smallIs it relatively small?q_shitpost->q_smallNoWTFPLWTFPLq_shitpost->WTFPLYesMPL 2.0MPL 2.0q_small->MPL 2.0NoMITMITq_small->MITYesremove->q_viral

I believe this to be a fundamentally good approach to open–source licensing that simultaneously serves to promote good software licenses (the MPL) without contributing to license proliferation, minimize the time spent debating license choices, and help in cleansing the open–source community from the scourge of the GPL.

The presence of the WTFPL here could be considered a violation of the “no license proliferation” principle; it is a relatively obscure license that hasn’t been tested in court and is not OSI-approved. However, I believe that when choosing a public–domain–equivalent license, the exact variant chosen is of much less importance than when deciding between more restrictive licenses; as a point in its favor, the WTFPL’s wording choice and explicitly stated goal as a truly free parody of the GPL serve to dispel any doubts about the WTFPL–user’s position on the GPL and other similarly malicious licenses.

Evaluating a License

In choosing to open–source software written by oneself, the objective is generally to enable the open–source community to use, learn from and expand upon it.

It may be surprising, but the goal is not always to provide the Four Essential Freedoms of Free Software (if you’ll excuse me unironically linking a GNU text); licenses like the JSON license, which forbids using the software for “Evil”, or the Anti–Capitalist Software License exist explicitly to accommodate those authors who wish to make the source code of their work available but stop short of making the software open-source.

Since I consider those “source-available” edge–cases to be effectively proprietary software with exemptions to copyright law granted for specific users and usecases, I am going to disregard them entirely, since this page is only concerned with open–source licensing.

The Four Essential Freedoms, paraphrased here, are:

  1. The freedom to use the program for any purpose.
  2. The freedom to study how the program works and modify it to fit one’s desires. (i.e. the freedom to modify it in any way.)
  3. The freedom to redistribute copies of the program.
  4. The freedom to distribute copies of one’s modified version of the program.

GPL: A License to Fail

You’ll notice that, depending on your definition of “freedom”, the GPL explicitly restricts anywhere between one and all four of those freedoms.

As much as “being free to create art, provided the message aligns with the ruling party’s propaganda” is not “freedom to create art”, “freedom to use the program, provided anything that interfaces with it also uses a mandated, restrictive license” is not “freedom to use the program for any purpose”.

The GPL is a terribly written, malicious, holier–than–thou license that actively curtails its users’ freedoms to a degree rarely seen elsewhere (with the exception of the, frankly, comical AGPL whose sole legitimate purpose seems to be discouraging anyone from using the AGPL–licensed software or being able to demand payment for using the software despite making the source available). For this reason, I believe it is in the open–source community’s best interest to not just avoid licensing one’s own software GPL, but actively reject GPL–licensed libraries and work to create freer alternatives.


Having said that, the GPL has a noble goal: to ensure that improvements and fixes made to free software can be upstreamed and incorporated into the original work. Its failure lies in that it enforces this goal by means of posing an active threat to unsuspecting developers’ freedom to choose how to distribute their work–if a developer isn’t vigilant enough when pulling in dependencies, they may accidentally end up tainting their codebase with GPL–licensed code.

If the software is of a size where it’s reasonable to expect it to receive nontrivial improvements and fixes, a copyleft license that doesn’t suffer from the flaws of the GPL is nevertheless desirable.

Choosing a license is a balancing act between its popularity—software under obscure licenses is challenging to use, since it may require sifting through pages of legalese first to find out how exactly it allows incorporating itself into a larger work—robustness (the safest licenses are those that have been tested in court and those that anticipate as many edge cases and details as possible), and finally alignment with the developers’ wishes for how their software should be used.

I believe the sweet spot, if looking for a copyleft license, to be the MPL. The MPL grants its users all the freedoms one would expect from an open–source license, but requires that any modifications made specifically to the MPL code be made available under the MPL.