Dawid Ciężarkiewicz aka `dpc`

I've been a FOSS enthusiast since around 1998 when I discovered Linux when I was about 13 years old. It was truly one of the definitive events in my life. There is something extraordinary and even spiritual in the idea of a global, voluntary, collaborative yet competitive network of people sharing their knowledge and work and building together something that can challenge even the largest commercial organizations.

However, it's clear that there's a huge problem with FOSS:

https://imgs.xkcd.com/comics/dependency.png

and the older I get, the more this practical reality bothers me.

While sharing work freely is noble and leads to great overall efficiencies, the pragmatic reality is that FOSS developers live in a material world, a market economy, and need to make money somehow. Many approaches to funding FOSS development have been tried, all of which with rather unsatisfying results.

Here is an idea that has been sitting in my mind for more than a year now, and I still think it might work. I finally decided to write it down, so people can tell me if it already has been tried or why is it bad. I almost never have any truly unique idea, so I bet someone will send me a link proving that I just suck at googling stuff. If you think it's good – feel free to give it a try. After all, ideas are cheap and execution is where the value is.

OK. So we're going to build on the idea of dual licensing. You know – licensing under both AGPL, which is rather unfriendly to commercial applications and another separate commercial license. In my opinion, it is a very promising funding model for many projects, with one problem: it does not scale. Having worked in commercial software shops, I think that it's not that companies are not willing to pay for software. They would love to pay. The problem is just that maintenance effort of obtaining, keeping track, renewing, etc. of commercial licenses for every little piece of software that modern software is being built from would be a nightmare. It is truly easier to rewrite parts of a small NPM library licensed under (A)GPL than try to buy a commercial license for it, etc. Only the largest, most integrated solutions like game engines (like Unity), or some graphic frameworks (like Qt) make it worth the effort.

So what could we do for smaller, more typical Open Source projects?

First, we will need to create a “FOSS Collective”. Most definitely it should be a Non-Profit or something similar. More on why later. A legal entity, business.

The job of a FOSS Collective is to relicense software in aggregate. Think “Netflix for dual-licensed Open Source”. If the idea works, there would eventually be more of them, but in practice not all that many, because it defeats the purpose. Think 5 major ones, and maybe some long tail of smaller niche ones). Just enough to have some healthy competition.

As an Open Source developer, you build a new cool library or a tool and license it under AGPL. This preserves all the Free Software freedoms for all the non-commercial users out there. You don't have to compromise on it. Debian and Brew can still ship them. Then you go to one or more FOSS Collectives and sign a licensing deal (if they find your project worthwhile). From now on the Collective can license it to commercial organizations that don't want to touch AGPL stuff, and pay you a cut!

From a perspective of a commercial organization like a corporation or a startup, things become much easier now. They can go to one or more collectives, sign one bigger license and get a license to use thousands of FOSS projects aggregated by a given collective (there could be tiers).

The details of contracts between FOSS developers and the Collectives, and between commercial users and the Collectives are left out to be determined by each collective. In this respect, the collective is very much like any other reselling business – negotiating deals, trying to attract both producers and consumers with favorable terms, a variety of products, and so on.

I imagine that FOSS projects (or rather their developers) would get paid depending on some combination of their importance, usage statistics, and possibly additional terms like support, some liability and security guarantees, etc. The commercial users would negotiate individual deals depending on their size and market etc.

Assuming the idea works, a new accessible Open Source funding method is now possible, and everyone benefit: smaller FOSS developers can focus on their work and secure (hopefully) decent income streams to support themselves, free from having to bother with marketing and handling licensing requests, invoicing, etc. while the commercial users can easily get commercial licenses for a large number of projects.

Why The Collectives should be Non-Profit organizations? There's a great danger that I must warn everyone at the very start. The Collectives are a middleman/platform between developers and users. That puts them in a position of great power. Middleman like this more often than not, ultimately turn evil and try to use their dominance over both sides to extract as much value as possible, leaving everyone else dry. Non-Profits are not a golden bullet, but having Collectives as Non-Profits is just another layer of protection, in case the market competition is not enough (which it probably is not).

All right, that's all the time I have right now. I can't even proof-read it right now, and just wanted to get it out there. Feel free to let me know why this idea is great/stupid.