I checked the part that made me discard earlier versions of GPL. If I distribute work based on a GPL library that entire binary must also be GPL… which means if you give away a binary you must also give full source and a working build script.
For a statically linked language like Zig, where we have multiple threads on how to actually dynamically link because it’s not “the zig way”, introducing GPL means every project that produces a binary rather than a service you more or less needs to either work the system and somehow dynamically link it or release full source.
Since my goal is always to build (and sell) a binary, GPL means giving away trade secrets and hope nobody abuses them or trains their AI on them… (a rather naive hope these days where AI is obviously being trained on proprietary data)
Even if I dynamically link it, I still have to go through the hassle of making it clear how to obtain the library source, or even host it myself if I make any minor change that would not be merged back into the official repo. I’m not saying MIT is perfect, I would prefer a much stronger license a kin to what @mnemnion mentioned in another thread where you’re only free to use it if your company is less than 100 people.
I think the best solution would be a common established license that was essentially free for small companies but had a foundation that larger companies had to pay license to. This foundation could then pay it’s contributors, hire developers, pay hosting, donate to another OS project or charity if they felt like it. If anyone knows such a license please DM me.
That’s not necessarily true, you could augment the GPL with linking exception.
While I’m not aware of any such licenses, it’s worth noting that GPL allows you to add additional permissions, see its section 7, so you could easily make the GPL permissive for small companies. Alternatively, you could dual license it with a license preventing commercial usage, e.g., SUL-1.0 OR AGPL-3.0-only; Qt does something similar to that. Both options have the benefit of being compatible with GPL so it would still be considered free software/open source.
Note that it’s not an ideal solution, a downstream fork could remove additional permissions making it impossible to merge its improvements back into your project but that applies equally to any permissive license.
So at default it’s worse, but you can add a clause to solve this. I mean that’s sorta good news, but at the same time it’s the kind of thing that makes me run for the hills… now you’re saying that your entire program doesn’t have to be GPL, but only if the library contains a clause.. why not give that a name? GPLv3-FreeLinking so us common folks doesn’t get confused.
I’m not a lawyer, but that’s not what I read…I read you can apply additive permissions A-F, or further restrictions. That’s not what I was suggesting, finally it has a block that states: Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.
Which is too deep lawyer talk for me to dare assume either way, so final verdict I’m still out… even though GPLv3 might technically be able to serve my need, it’s still a template that I have to tweak, not a clear cut license that clearly signals my intent.
My understanding is that the linking exceptions are usually project specific since you may want to limit it to only certain interfaces/parts of program. There actually is one generalized one, it’s called LGPL 3.
It’s the other way around: the clauses A-F are the only restrictions you can add but you can add arbitrary additional permissions.
I do agree that it’s asking too much for an average person to write their own small business exception, dual licensing is probably more realistic.
Did anyone consider EUPL? A European license which can be used worldwide though.
It has similarities with LGPL I think, but permits static linking explicitly.
It comes with a list of compatible licenses, which could make it a bit more complicated to manage maybe, but it also makes it more permissive than GPL. Fills the gap between GPL and MIT maybe, the same as MPL tries to do.
If you publish without a license, nobody besides you is allowed to use it.
There are Public Domain like licenses out there if you want. You can also go and explicitly put it into the public domain, but depending on where you live this could require going to a notary, or it may not be possible at all (yes, in quite a few jurisdictions you can only put stuff into the public domain by dying and then waiting for a few decades; fun fact: copyright transfer also does not exist in all jurisdictions like for example in Germany).
But while we are at it from a philosophical pov: There are two main philosophies when it comes to copyright law: civil law and common law. The latter is mostly used by the UK, former British colonies, and a few more countries. The former by everyone else.
The main difference is who they focus on. Under common law the focus is on the thing which was created. Who is allowed to copy it etc. Under civil law the focus is on who created the thing. What their rights are etc. And these differences can show themselves quite unexpectedly, for example under civil law you don’t normally have a work for hire doctrine which meant that when software came around an exception for that was necessary since without one the copyright would have been with the employees.
Exactly. My ideal is abolishing copyright law, because it is completely bogus. It only creates an artificial monopoly for the copyright holders (usually distinct from the creator!) to do any meaningful, monetizable actions.
Read up on the last paragraph on why that’s only the case under certain legislations.
That would kill quite a few industries. A big chunk of the German solar industry died because other companies (mostly China and USA) ignored their intellectual property and were able to undercut them in price considerably (after all, they didn’t have to carry the development costs, which in manufacturing industries is often a very big chunk of the price, in some even the majority).
I think a lot of people don’t know about or forgot just how much the industry vehemently hated and tried to kill open source projects in the 80s, 90s, early 2000s, and that the GPL was one of the tactics produced as a defense.
A ton of people entered the field during 2012-20?? hyper-growth and tight labor market era when big tech had to pretend they love us, love open source, want to make the world better, etc, and I think that the renaissance in open, permissively licensed software was partially a result of that. We’re seeing a retrenchment in the behavior of the major corps so the dynamics of how free/open source software communities relate to the industry could change again (or not, who knows).
Do you know any good sources to read to learn more? I’m unfamiliar with that history, the closest thing I remember hearing about is embrace-extend-extinguish
You can read more about the FSF’s philosophy of free software at
I’ve not read this, but there’s a book called “Open Sources” (c. 1999) that is a collection of essays by big names in free software and open source software:
The problem with the GPL / FSF attitude I have is that they value the rights of the user way above the rights of the developer. Maybe not in theory, but in practice the FSF community sees the code of the developer as theirs. Also there is only one good way in their book, see how they advise users how to deal with EUPL:
Last, to operate its famous “relicensing” or “conversion”, the FSF provides the recipe of a real tinkering (what in French is called “Bidouillage”), encouraging followers to commit what could be a real copyright infringement:
To do this two-step relicensing, you need to first write a piece of code which you can license under the CeCILL v2, or find a suitable module already available that way, and add it to the program. Adding that code to the EUPL-covered program provides grounds to relicense it to the CeCILL v2. Then you need to write a piece of code which you can license under the GPLv3+, or find a suitable module already available that way, and add it to the program. Adding that code to the CeCILL-covered program provides grounds to relicense it to GPLv3+.
These vibes makes me consider EUPL above GPL, all though the latter is more simple to maintain probably as the advise of FSF towards EUPL shows. Imagine someone takes the advise of FSF and use your EUPL code in a way you don’t want. You don’t want to have to deal with these issues as a developer.
@flow , IANAL, but just a couple distinctions here:
I think the FSF has (or had (?)) a policy where, if you contribute code to an official FSF project, then you’re supposed to officially assign copyright of your code contributions to the FSF. The logic here being that if at some point in the future the FSF needed to defend the copyright (like in court), it could do so because it holds full copyright over the entire project.
Also, while it may be possible that there are some bad actors who might wish to surreptitiously commit some GPL’d code to a non-GPL’d project in an attempt to relicense the whole project GPL, I can’t imagine this being a common problem in practice (maybe I’m wrong here?). The project maintainer would simply refuse the PR. Or, if GPL’d code were accidentally added, they could revert the commit. Maybe I’m missing something here.
Lastly, I think that the GPL favors the rights of the original developer to keep their GPL’d program free/libre: if developer-2 comes along and augments the GPL’d code, and then distributes that augmented program, then developer-2 is bound by the GPL to release the augmented program under the GPL as well. The software stays free/libre, as the original developer wished.
A permissive license, OTOH (like the MIT license), favors the rights of future developers who would like to augment an MIT-licensed program and distribute the augmented program without sharing their changes.
The assumption here being that creators (writers, artists, programmers, etc.) of easily-copyable things have copyright over their creations. For example: developer-2 doesn’t have the right to build upon original-developer’s code, and then distribute this augmented software unless explicitly given the right to do so by the original copyright holder. Original-dev’s choice of license makes their wishes explicit.
Wow — I did not expect all that to sound so legal-ese-ey.
This reminds me of the reason why one of my former coworkers got banned from their mailing list in the early days of the FSF (he is close to retirement now): He wanted to contribute and then was asked to assign the Copyright. Since Copyright assignment doesn’t exist under German law, he pointed that out that he straight up can’t because of that.
That caused him to get banned from the mailing list and he never bothered to get unbanned but he has heard that they changed how to deal with this since that’s the case with many countries.
This is exactly why the Unlicense and ‘public domain’ dedications are awkward under German law. Since we can’t legally give up our copyright, those declarations have to be re-interpreted by courts as broad usage rights. Providing a standard license like MIT — or CC0, which has a specific ‘fallback’ license for countries like ours — skips that legal gray area entirely.
By making it MIT you ensure that you can also use it the next time you need it
None of these licenses prevent the creator and owner from relicensing it to themselves any time they want. Software can have more than one license, and you’re under no legal obligation to tell anyone your private business dealings. Contributors might revolt if they find out, but they can always fork. Such is the risk of working for someone else for free.
Certainly not saying it’s moral, but let’s be honest, we’re talking about contract law here.
The reason permissive licenses like the MIT are mentioned with regards to being able to “take [the project] with you” to future work environments is that once you have multiple contributors, relicensing can get hairy.
Let’s say your project uses a copyleft license. Your project has gotten several contributors, and now you want to use it at work.
If you want to relicense something in a way that grants permissions your previous license didn’t grant (such as statically linking without sharing the source code), then you will have to either get the permission of every contributor, or remove disagreeing / unreachable contributors’ code from the project prior to relicensing.
Edit:
This is because even if they don’t own/control the project as a whole, contributors still own the copyright to their contributions (and have licensed it under either the same or a compatible license to the project).
Part of the reason companies can relicense their stuff is that their employees sign contracts that state that things they make on company time belongs to the company (and not them individually). AFAIK no FOSS license has a term like that, and if it did, it probably wouldn’t be considered FOSS.
If you don’t accept contributions you’re in the clear - that’s the model I had in my head when I said it, but I didn’t think hard enough about it. I just was thinking “dual licenses exist”.
But contributors basically break your ability to “own” the code unless CAA or CLA. Which dissuades most contributors.
I am glad the system is a bit more robust than I gave it credit for. I have seen open source get ripped often enough that its starting to give me a little bit of distaste (as a person putting the license on it, not as a consumer or contributor) unless I’m willing to just public domain the stuff, cause I’m not involving lawyers. But it sounds like I’ve over corrected.
You actually can explicitly make assign yourself the sole copyright holder and set a term that all contributors assign their copyright claim to you. FSF in fact encourages that when using the GPL!
