I have used and or made open source software for most of my life. In recent years, some questions have popped up that I have some concerns about. You may have read a previous rant of mine on that topic.
Free and Open Source Software is exactly that: Free and open. It is a gift from one or more developers to society at large under some or no conditions. You don't need me for the history lesson of how the GPL came about or why the OSI was founded or even the lengthy debate on what is "Open Source" vs "Source Available". But I think a reminder that open source is a gift is sometimes warranted. Both for those who take up that offered gift and those who want to make it.
Nobody is entitled to a gift. I think that is something everyone understands. But that also includes those who gave it away. Taking back something is generally considered rude.
I want to make it very clear that I would not include future work into that. If you give me a game for free and sell me the sequel, that is perfectly reasonable. If you make version 1.0 of your app open source and decide that you don't want to give away the work for 1.1 away for free, that is also fine on the ethics of gift giving.
Where this gets tricky is with promises you have made along the way. Some licenses come with certain expectations. The entire goal of the copyleft is to keep the software free forever. If you make me that promise with the initial gift, explicit or otherwise, and then take back that promise you are necessarily taking something back. See the previous logic. But I think you can understand why that might be considered a dick move and how that reflects badly on how trustworthy you are.
It is very much true that many free and open source projects are not, in the traditional sense, financially sustainable. I can't put 40 hours of work in every week without ruining my health from effectively working two jobs (one paid, one not) or getting destitute and ruining my health that way.
Some projects have found ways to lessen that problem. Organization is one of them. If you have a project that demands 40 hours of work in weekly maintenance, but you have 5 maintainers and 5 other contributors, then suddenly any individual workload can be as little as 4 hours a week. Sharing time can be a viable solution.
Another solution is of course to set up a charitable organization and pay for some core staff. That works well for the Linux Foundation, the Apache Foundation, the Free Software Foundation, the KDE e.V., the GNOME foundation, the Eclipse Foundation, Codeberg e.V., the python softawre foundation... you get the idea. It is of course not viable to every project. And I imagine approaching one of these organisations for funding can be intimidating or even undesirable. At the same time, we also have seen them become proactive when a FOSS project is under threat. The Linux Foundation forked Redis; the OpenBSD Foundation decided to fork OpenSSL when that whole snafu happened; when facebook dropped jest the OpenJS Foundation adopted the project.
We also see this in corporate open source sometimes. If some company is unhappy with how an open source project is maintained or has misaligned goals for said project they can't and don't want to enforce upon the upstream, they just fork it. This has happened with libjpeg-turbo (Mozilla, Google), KHTML (Apple), OpenSSL (Google), OpenSSL (Akamai & Microsoft), Elasticsearch (Amazaon) and probably has happened internally in a bunch places that I have not heard about. Maintaining your own fork does not automatically mean you have to (or even should) make that public, after all.
But even before forks, many a company just pays employees to patch open source software. The most extreme case is the linux kernel, which has such a long list of companies paying their employees to work on it that I'd be here all day. But this also happens with a bunch of random libraries you never heard of. I had a guy submit PRs on a really obscure library I wrote because he found some bugs while putting it in a commercial piece of software.
Similarly, there are people in the free software foundation who have an interest in making sure that the tools they rely on are stable. If the maintainer of Bash were to decide that gardening is a more productive use of his time, you just know that there'd be a new maintainer found within the day. Because there are millions of developers who need bash to work and their bugs fixed. And the same goes for many other FOSS organizations and their respective ecosystems.
The point of all of the above is not to say that individual projects do not struggle. They absolutely do and that is definetely a problem. I just want to offer two additional perspectives on that matter: Money is not the only solution and that support might already be there and waiting to happen. If you are one of the people who struggle with the work you have to put into your tool, application or library then you might just have a pool of support you could draw from right now without realizing and without having to ask for money if that is not something you feel comfortable with.
Oh and also, I have to put this somewhere: Just because a project is maintained by one guy doesn't mean it is a general failure of society at large or the benefactors of that software. Some people just don't want to deal with external submissions or additional maintainers. And we should respect their decision. And if we don't like it, well, we fork it.
Sometimes the solution to the sustainability question is to change license. Go from AGPLv3 to SSPL. Or from MIT to dualicensed AGPL/commercial. That can be a workable approach, but it has some potential downsides that can go overlooked.
First, you have to be clear about your own motivations to do this. A commonly communicated one is that there are large companies that use the project in their own software, make a bunch of money with that but never meaningfully contribute anything back. If Toyota is using your networking library to make billions with cars, you might have some temptation to sour their free use and instead make pay for a commercial license. A common strategy for that is to use a license with a copyleft that a company may not want to comply with. If toyota has to open source their entire entertainment system code to use that networking library, they will instead look for alternatives. If the alternative is that same library but for a thousand bucks a year, that is cheaper than anything else so they'll likely go for that.
But you have to be careful on how exactly you do this. Let's look at a very recent example: PdfSharp is a .NET library for creating PDFs. It used to be under the MIT License. Something basically everyone can use without any consideration for compliance or complications. With version 6.5 they changed the license to the AGPLv3, which has a pretty aggresive copyleft to it. If you run a web service publicly that creates a PDF using PDFSharp, you are now obligated to publish that entire web service under the AGPLv3. If your software already is AGPLv3, that is not an issue.
However, if you are a small open source project that uses the library, you now have a really big problem. Because the same copyleft demands are now placed on your project if you link against that DLL. You may not want to switch to the AGPLv3 because it hurts your own users or even yourself. Or in the worst case: You simply can not change the license at all. A lot of my own projects right now are GPLv2-only because I derived them from existing GPLv2-only projects. If I was a PFDSharp user, I can not legally upgrade to 6.5 because I'd be in violation of either the GPLv2 or the AGPLv3. I'd have to put time and effort into finding an alternative library and port all my code that uses it.
According to Nuget.org, there are 231 packages that depend on PDFSharp. Let's just assume that there are 200 FOSS projects that use the library. And let's ballpark it and say switching to another PDF generator is about 2 hours of work with coding and testing and review. That's 400 hours of work imposed on free and open source software projects just to have that one project take some crumbs out of the corporate pie.
Negative externalities like this are likely not going to be huge. Not unless you are curl or some other foundational piece of software infrastructure anyway. But if your goal is actually make FOSS development sustainable, you shouldn't just create work for the ecosystem without care. If your very public complaint is that profit driven actors take more for themselves than they give back: Don't be that guy.
Be careful with your licensing decisions, especially if you make up your own license. Make sure that you hurt the people you actually think deserve instead of ruining the weekend of some guy in Nebraska. Pick a model that works best for your comrades first and annoys the fat cats second so they give you money for the commercial license.
And, also, don't forget that people can still fork your stuff if do go down this dual license route. A lesson that Redis recently learned the hard way. And before that ElasticSearch. You might just end up achieving your goal in the opposite way you intended. As I said above:
support might already be there and waiting to happen.
If you are proactive in the wrong way, that support might not materialize in the way that benefits you anymore.
String.Epsilon
Creative Commons Attribution-ShareAlike 4.0 International