Why I often don’t use OSI Approved Open-Source Licenses

Why do (or will) you often see a custom license in my projects? Does my custom license mean that you are more restricted in using my projects or snippets from it? Well that totally depends on what your goal with the project is.

The main problem with true open-source (in my opinion)

In my opinion one of the most simple (and simplified for this article!) examples is that you could basically do the following to a FREE Linux distro:
1. Download it to your PC
2. Remove all original branding (logo’s, naming, etc).
3. Rebrand and rename it to your like
4. Sell the EXACT same software you’ve downloaded for €100,- a pop.

Yeah it’s a bit more nuanced, but that is technically possible. And that goes for many many many many, and did I mention?: MANY open-source projects which are released under GPL, MIT etc licenses. Those developers often release their project under such a license hoping it will serve and help as many people as possible. But the main problem (again in my opinion!) is that this also means that a major software company could take a project you have been working on for years by yourself, published for free for others to enjoy and they start selling it with massive profits leaving you (the developer empty handed) even if they didn’t change a single byte of your code.

Funny nuance to that ‘reselling a distro’ part though is that if you would buy it, it still is (should be!) GPL licensed, and thus you can LEGALLY redistribute it after you paid €100 for it🤷🏽‍♀️😂. And you should also be given access to the source in such a case btw.

This is (again: in my opinion) not only a problem for the developer(s), but also for the end-user, who could have been using your program/work for free instead of having to pay “100 bucks a year” for it to a corporate entity which didn’t contribute much (if any) to that project/product.

And yes, the purists could now argue: “Well it’s your own dumb fault if you keep paying 100 bucks a year, because the license it still GPL, so if you know where to find it, you can just work around that.“

Yeah sure! That’s what I’ll tell grandma or the father-in-law: “Ahh, just download/fork the source, change those lines and re-compile it👍🏽“🤦🏽‍♀️

NOTE: I’m NOT against open-source being used commercially entirely, but I will get back to that a little bit further 😉

No (Ethical) Limitations

For some, even ethical considerations might be a limiting factor in being able (or allowed to) use an OSI approved open-source license (like GPL for example). Why so? Well in general approved “OSI open source” does not allow allow you to for example limit your work to not be used in or for:

• In weapons, warfare, or military systems.
• Nuclear reactors, uranium enrichment, or nuclear arms
• Lethal autonomous systems or drones
• Mass surveillance or spying
• Surgery robots, pacemakers, or life-support systems
• Aviation or aerospace control systems
• Betting, casinos, or gambling platforms
• (children’s) personal data collection systems
• AI systems or training of AI systems
• (Re)selling the work(s) for commercial use/exploitation
• Software or systems designed to intentionally defraud, scam, or otherwise exploit users financially or otherwise

This can be a problem for many who have certain ethical standpoints in regards to how their work can or can’t be used. Just to be clear: I’m not stating that I personally agree with or disagree with these standpoints! I’m pointing out one of the limitations in the OSI open-source model if you would like to restrict use of your projects for these purposes for example.

The biggest problem for me (commercial exploitation)

For me the biggest issue is that you (when using “OSI approved open-source”) are not able to for example say:
“You can do everything with you want with my code including: inspecting it, learning from it, using snippets, make your own alternative version from it, redistribute it etc. But you are not allowed to turn this into a commercial project and thus effectively exploiting the end user. I designed this project to be free (as in free-of-charge) and accessible to anyone and everyone to learn from and enjoy.“

This sounds like a “nice thing to state” for the end-users of your project, but this is a limitation in the license and thus means that it is not OSI Approved open-source🤷🏽‍♀️.

And this is where my personal view on open-source and the OSI approved open-source definition collide. Once you allow another entity to ‘runoff’ with your work which you intentionally created ‘open’ for others to enjoy for free, learn from etc to rebrand it (sometimes even without rebranding/renaming) and then ‘exploit’ the end-user with your work by asking money or even monthly subscriptions for it? Then it loses all my interest to even “label” (license) my work as GPL, MIT etc for most of my projects.

It’s NOT about the fact they earn all the dough and I don’t (well partially😂, but then I should have just charged for my project/project, period). For me it’s about the fact that the entire intention of the project can be yeeted out of the door with just a single click on a button labeled “Fork”.

Do note though, that this ‘initial intention of the project yeeted out the door’ if a feature of the OSI licensing (NOT a flaw! it’s a choice you make when using that type of licensing!). And that is actually what makes it ‘true open source/freedom software in the OSI definition’.

Sure you do have copyleft when using GPL, which for example requires them to use the same license format, but that license format doesn’t say (or can say) anything about keeping the same intention, target audience and/or restricting commercial exploitation of the (intended) end-users.

The second biggest problem for me (and my projects)

One sentence: Endless forking and cluttering.
What I mean with this? Simple if I make a small (and simple) project, util, program etc, and publish it and it then gets endlessly forked, redistributed with tons of small changes etc, then it will/can eventually end up with over 100+ (slightly) different versions (forks) which all use the same name.

This can and will make it extremely unclear to regular users which version they need, which one was the original and which one does actually what they expect it to do.

This is just an undeniable fact which does happen with for example GPL licensing (and yes! I myself am also guilty of this when I use certain parts of GPL projects in my projects and need to assure that I have permanent access to that code).

If my project is however “stupidly simple” to make your complete own version of instead of (endlessly) forking mine, then it is in my opinion just contributing to the ‘version cluttering mess’ when you do so. I’m however yet again not allowed to restrict this kind of behavior when it comes to using true open-source licenses (even if it is intended to actually project the open-source space from cluttering).

And that again is in my personal opinion a serious problem when I would be using a license as such.

And I AM aware that you can’t disable forking on websites like GitHub, which is exactly why I for example host such projects (of which I think forking would either cause cluttering or should not be forked) on my own website.

The Linux kernel – A good (positive) example of paid vs free GPL licensing

A very good (and positive!) representation of the GPL license (currently GPLv2 if I’m correct) is the Linux Kernel. This is a ‘product’ which is being used in 100% free projects (here meaning not as in freedom but as in you don’t have to pay for them), and on paid products. You can for example download almost any Linux distribution for free and use it for anything you like.

You can however also rebrand (almost) any Linux distro, add some packages of your own for a specific purpose and start providing it with a subscription with additional services, hosted on a server or for business use for example.

That, that is the perfect use case (and intended use case) of those OSI approved open-source licenses.

Nothing wrong with it, and those projects are also made with that intent, and you still have the choice to download (or even build) your own Linux distro without paying a single penny.

And like that, there are many projects which do exactly that, are designed with that exact purpose, and that perfectly fine. I totally appreciate those projects, use those projects and love contributing to them where I can.

And I DO also release projects under GPL like licenses, just not all my projects, and that’s perfectly fine. If you want to set custom rules/limitations on your work? Then you have all right to do so, after all: It’s your work. If someone doesn’t like your license or the fact that you do allow everything GPL would allow but your custom license doesn’t allow “rebranding and/or commercial exploitation”? FINE, It’s not like you’re holding a gun to their head forcing them to use it right😉? Then they could do two things in my opinion: A: Move on and look for an alternative, or B: Write their own version from scratch.

And I’m not going to dance around it: I have also chosen to reject using a certain library, piece of code etc because for my project the licensing of that ‘piece’ was too restricting for my goal. Perfectly fine, then I respect the authors decision to use that licensing type, but will search for an alternative for my project or write my own. Like I said: perfectly fine, but don’t start nagging to the developer that you don’t like the license he/she put on the works just because you can’t “exploit it” the way you like to 😉.

So are my license formats that restrictive?

No, not at all, most (not all) of my project licenses do for example allow:
– Learning from the code
– Using snippets of the code (with or without attribution)
– Using entire modules
– Using (parts of it) it in commercial projects (to a degree)

I will for example often also allow things like:
– Commercial use when it’s bundled in a larger project
– Commercial use in/for your business
– Making your own alternative version of it (with attribution and keeping copyright)

And more of the alike.

Things I do often limit, restrict or disallow for example?
– Selling the project as a stand-alone product/service
– Turning a free project into something users suddenly have to pay for (either onetime or subscription)
– Rebranded re-releases without any significant changes and/or improvements

If i however allow redistribution or not heavily depends on the project, the intentions of the project and most importantly HOW it is redistributed. A clear distinction when I have a ‘limited redistribution clause’ is when I for example would not allow it to redistribute the program on it’s own as a ‘standalone redistribution’ but that I would allow redistribution when it’s included in a bundle.

An example of this could for example be that I have made a special “launcher menu” for retro consoles, and that you ARE allowed to include it in your custom Retro OS Distribution (even if that’s a commercially sold one), but that I would not allow it if you start offering that same program on your website either as free download or paid download.

But what did you meant with ‘to a degree’ about commercial use?
Good question, and that is one which is often clearly stated as for example “standalone redistribution or commercial use not allowed” and for example “Standalone redistribution not allowed (either commercial or non-commercial), commercial bundled use allowed if this project is < 5% of the commercial product and functional part of it (no selling of software packs/collections)“. The ‘commercial part’ is indeed ‘a bit longer’ but it’s just to ensure that abuse of the line “bundled commercial use allowed” is minimized. If you for example build Arcade cabinets and have driver I developed for one of the controllers? Perfectly fine! Install it, bundle it and sell it WITH your Arcade cabinet😊👍🏽! Just don’t start selling the driver itself or a bundle of drivers like for example: “Arcade Cabinet Drivers Bundle, now just for $49.99!“.

WHY do I (sometimes) limit such ‘standalone redistribution’?
Very simple, that yet again comes down to ‘clutter prevention’. I would instead of you redistributing the ‘standalone package’, request you to just link to the original download page. This does not only ensure that end-users always have access to the latest version, it also ensures that I can actually see that those projects are ‘alive and well’ and do still deserve attention in regards to development for example.

And personally? I don’t think that this is unreasonable at all to be honest😊, but again: If you don’t like that type of license restriction? Just don’t use it😉😂

But, euhm… don’t you need a lawyer to setup big confusing licenses to be valid?!

DISCLAIMER: I’m NOT a lawyer, I DO write my own licenses, but for factual legal advice you should always consult a lawyer. This is just my point of view, and most of it is valid (and verified), it should not be considered as your legal advice in any way!

No! not at all actually😂! A lot of people (especially beginning developers) think this but this is not true at all. Obviously if you want to (or need to) cover all kinds of legal aspects for your projects then it is highly recommended to actually consult a lawyer specialized in this. But it would basically already legally be sufficient if you would put a license file with (or popup in) your program containing:

Copyright © 2026 John Doe
You can use this project for anything you like except for the following:
- educational institutions may not redistribute or use this software without written permission
- Uses in or for ANY type of military use (defense or offense)

And with the following limitation(a):
You are not allowed to redistribute this software, when you do need to 'share' the software you should refer to the original release page instead.

That alone is already 100% legally valid, and would technically make it illegal for campuses to use your software (just to name an example).
[Do note that enforcement is a whole different story though! which isn’t only problematic with custom licenses though!]

I do however have to state that in licensing terms it is very important to be as specific as possible about what is and isn’t allowed! If you declare something too broadly or vaguely, then such lines can (will be!) invalidated in court if it would come to that.

An absurd but clear example of being too broad in your limitations:
– Commercial use of this software in office spaces larger than 50 employees is not allowed

Sounds reasonable and simple right? You just excluded billion dollar companies from profiting from your free tool right? NOPE! it’s not because if for example an ‘North-pole division of Microsoft®‘ with only 20 employees would use the software with massive profits? You would legally not have a single leg to stand on. Because you said “office spaces”, and technically that 20 employee office is still a single workspace with just 20 employees. It also does not specify if its for the entire company, per building/location, per floor or per division. And thus too broad. Keep this in mind when you do setup your own licenses 😉.

It is however in my opinion also (highly) recommended to also include the following section in your license to make it clear you accept no liability from the use of your project:

THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE 
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Do I think you HAVE to use OSI Approved Licenses to be Open-source?

No, absolutely not. I know there are purists out there who think (“claim”) the definition open-source to be exclusively compliant with OSI Approved Licenses, but I will be very clear and direct:
OSI != law 🤷🏽‍♀️. In my text book open-source or open when you publish your work and (all) its source code openly to see for others. You do know you don’t have to do that right? You do have the choice to just distribute binaries? You made the choice to be open and transparent with your project (which I absolutely condone and appreciate), but in my book that doesn’t have to mean you ‘just give away your project to any entity that walks by‘.

And YES! I do realize that GPL licenses aren’t “just walkaway” with it (as I just discussed😉), but if you do still want to publish your project, its source code, allow others to modify it etc but don’t want others to turn it into a commercial project based on your work? That again in my opinion doesn’t invalidate your project as open source in any way.

It DOES invalidate it as being OSI Approved open-source, but as long as you don’t claim your software is OSI Approved open-source, that’s all fine no problem.

And I also do know that there now will be purists which would counter argue my argument with my own argument about ‘fork cluttering’ with something like: “Yeah but now you are cluttering the open-source world with partially limited software while calling it open-source“.

Honestly? I. do. not. care. if you feel that way😉. They could argue you should call it ‘source-available’ instead! No, I don’t agree, because that sounds too vague to me to be honest. It makes it sound like you have to request it, apply for it etc.. With open source everyone instantly knows you can get all the source code for the project.

And no matter if it has certain limitations due to my custom license, you DO still have to check the specific license for even an OSI Approved open-source project. For example to see how you need to include the license, which type of license it is (GPL, GPLv2, MIT/BSD etc) and how to ensure you comply correctly with that open source license. So in my personal opinion? Nothing different than my custom open source licenses.

But won’t custom licenses ‘hurt my reach’?

Oh you mean if there are possibly less people using your software/code? Yeah sure! If you don’t use GPL, MIT, BSD etc but have a custom license then chances are (very likely) that people will pass on your project. And that is where you have to choose what you want:
– Control over your software/project and it’s (re)distribution
– or publish and it possibly heading off in a totally different direction than you intended

And that is also a bit why those OSI Approved Licenses exist: to prevent ‘control by one entity’ over software, which can be a good thing if you consider it preventing ‘abuse of power’, and a bad thing if you want to limit commercial use/reselling of your application.

The standalone projects or larger projects on/for my platform I do release with a custom license, I already know it will still reach the intended audience I target for, while limiting massive corporations from exploiting my work (negatively impacting my target audience of those projects).

Other projects where I actually DO want (or better put hope😂) others pick up on it, ‘run away with it’ or that they turn into massive community projects or even get included in a larger project like a Linux distro? Jup there I DO intentionally pick a GPL or MIT license for example (as you should).

So YES, a custom license can definitely ‘hurt’ the reach of your projects, but if it’s worth it all depends on your goal and target audience 😊

So am I against OSI Approved Licenses?

No, not at all. I also do use project, product etc with GPL, LGPL, MIT etc etc licenses, I also released projects or worked on projects with such licenses all perfectly fine. I also released some projects, code or snippets as public domain (no license at all, do whatever you want with it). But I do want to have a choice in choosing my license and setting certain rules for some of my projects while they are still open source (or source-available for the purists that can’t get past the ‘there is more than the OSI Standard’ 😉). But that being said, I don’t want (or accept) being dictated that such custom licensed projects should not be called open-source.

Final words

I hope this post/article was a bit informative on why I choose custom licenses for some of my projects while using OSI Approved open-source licenses for other projects. You don’t have to agree with “my definition” of (non OSI) open-source, that’s all fine, just move along to the next project then😉😊, I just wanted to give my view and reasoning behind my own projects.

Many of my projects are (by me) considered as ‘production ready projects’ (as in: I did NOT just made them as ‘programming example’), but I do often tend to extremely over-comment the source so that beginners can learn from them. And when releasing project I have worked on for a long time with lots of educational comments, lots of (single developer) work put into it, I DO want others to be able to inspect it, learn from it, use parts of it etc but don’t want (commercial entities) to just take it and rake in the bucks. That is basically put the very short summarized reasoning behind it 😊