Nobody pays for FOSS, we can force them to | Hacker News Reader

Nobody pays for FOSS, we can force them to

seldo.com

196 pointsMuhammad523209 comments

If you want people to pay you for your software, stop writing it for free. Conversely, if you write it for free, don't expect people to pay you for it. Otherwise you are no better than someone at an intersection with a bottle of Windex and a squeegee who, unsolicited, cleans a windshield and then demands the driver to pay for it.

The original authors of Free Software and open source were career academics and others who were paid to do other things, or were sponsored by scientific and defense research grants. I don't know how anyone got the nutty idea that you could make money on FOSS itself. Practically every time someone has tried to make money on FOSS it has failed.

(Edit: this comment previously ended with "...from Netscape on down.")

In what world was Netscape a failure? Made some people an awful lot of money and then gave us Firefox... Pretty far from failure

Netscape basically died and was replaced by Firefox which doesn't/can't effectively charge users for the software so instead makes money by selling default search engine, etc.

Netscape existed as the internet was coming into existence. You used to have to buy a physical copy in the store to install it. People barely knew how to use their computers so the activation cost for bypassing their "pay wall" was high enough.

Netscape was included free with almost every ISP installation disk.

Netscape lost the ability to charge before it went open source. Among other things, Microsoft released internet explorer for free (part of embrace, extend, extinguish, afaik).

The open sourcing of Netscape 5.0 happened in early 1998, and AOL purchased Netscape later that year. Firebird/Firefox came a few years later.

> You used to have to buy a physical copy in the store to install it.

That is not true. They also made it available to download over the internet free of charge (and, as others said, they licensed it to ISPs to distribute to their customers). You were expected to buy a commercial license if you used it for business, though. Practically everyone had a copy of it in 1997 and used it as their primary browser, paid or not, until Microsoft shipped Internet Explorer.

First, a self-correction: Netscape did not produce open source products until it open-sourced Navigator 5.0 in 1998. Until then, Navigator was freeware: free to download and run, but not open source.[1] I shouldn't have mentioned them, but my point still stands.

Second, it depends on what you define as success and failure. Netscape made its pre-IPO shareholders money if they timed their stock sales right. But the stock didn't go up because the company was profitable. It went up along with every other dot-com stock until the 2000-2002 crash, based on hopes and dreams, not fundamentals. The company never turned anywhere near close to a profit.

To me, a successful company is one that makes a sustainable profit based on its business fundamentals, not one that makes its founders and early investors rich in an investment bubble.

[1] Correction: Netscape did charge for the browser if used in a commercial context, but few people actually paid up.

Netscape was actually selling a licence, which became free for endusers and eventually the entire browser was free, as the company concentrated on its Enterprise Server as a source of revenue. Netscape becoming freely available for endusers is pretty much what made the Web a mass phenomenon.

Most people only measure success as something like being a B or Trillion dollar company, and thats part of the reason in a different way why nobody pays for FOSS.

There's nothing stopping you from charging money for FOSS software. Sell the first one for as much as it cost to write it.

I assume you mean "sell it before you open source it."

If you found one willing buyer while it was still closed source, odds are there are others. Why deprive yourself of additional income? Open sourcing does happen from closed source, but usually that's long after the income stream has exhausted itself (see, e.g., https://github.com/microsoft/ms-dos).

Or before you make it. Lots of folks get paid to make open source- they are employees, contractors, and creators with patrons who pay them to create.

There's nothing stopping you, true. But I think you will find that nobody is going to buy software for whatever thousands of dollars it took you to make it. So the limitation in this case is a practical one, not a legal or moral one.

That suggests there's never been a viable market for commercial software at all, which is obviously wrong.

That's kind of black and white thinking though. No one is going to pay a million dollars for QuickBooks, but a lot of people paid several hundreds. Just because no one pays you to develop a new QuickBooks (at least pre LLM), doesn't mean there's not a market there.

Okay, then sell it until you make a million bucks then open source it.

Isn't that the whole point of crowdfunding platforms like kickstarter?

Developer presents the idea and how much it costs. If enough people pitch in, then the idea is funded, the developer gets the money as a lump sum and can turn the idea into reality.

Why did this model fail?

I can't possibly take this at face value since it's obvious that people (businesses) pay others many tens or hundreds of thousands and millions of dollars to build software for them. So, what do you really mean?

Honestly, there's a real elegance to this model.

I'd argue the best possible model for goods that have no marginal costs (aka IP) is the "pay me to create it" model.

As in, let a creator decide how much they value creating the work. Then pay them that to create it - then release it free for everyone.

---

No ridiculous societal restraints that cost time and money to enforce (poorly) as IP law. Compensation is happening. Creating is encouraged.

Practical constraints make it unlikely we'll get much closer to this than Kickstarter (and equivalents) but it's a very honest model, that works with intellectual property by default.

I think Kickstarter and similar are a great model for creating open source software. It's more problematic for maintaining it. It could work for some features and bugs, but it doesn't scale down super well (maybe have campaigns for a packet of related features and bugs?), and more importantly it isn't great to have security fixes dependent on a successful funding campaign.

Are you aware of what FOSS stands for?

You know that F stands for free as in freedom not beer?

Please go read about the origins of Free software; Richard Stallman is a good starting point. Or even read a FOSS licence and tell me where it says you can't sell it.

>Otherwise you are no better than someone at an intersection with a bottle of Windex and a squeegee who, unsolicited, cleans a windshield and then demands the driver to pay for it.

This seems like a pet-peeve that's slipped through, because

1) It's really not; the FOSS developers never forced anyone to use their software, even if they're asking for payment for a product that was originally "marketed" as "free",

and

2) With the damage to society done by the work of many of the people in the tech industry and "respectable" white collar work in general, they should hope to be as virtuous as the window washers. Service done, pay for service, they go away and don't bother you for a while? No subscription shenanigans? Don't have to give them my credit card number? No annoying marketing emails? Not intentionally designing their service to be addictive? Geez. Adobe, Google, Facebook, Amazon employees make them look like saints. People give themselves way too much of a pass just because they sit in an air-conditioned office all day.

I have found not all open source to be the same in the modern era. The FOSS of yesteryear has been replaced by a lot of projects aimed at enterprise where the FOSS offering is the "free demo." This may have been novel and clever of the original pioneers of the practice, but there's a lot of cargo culting going on.

The worst offenders release the source but with gotcha licensing, wait for the enterprise to use it, then detect their usage and go in demanding payment or be sued. This happened to my team enough times to be a pattern.

It isn't novel at all, it is going back to Shareware, demos and PD kind of software before GNU ideas took off.

One does wonder, if we'd gotten really used to the idea of paying for software, if advertising, and the resulting tracking that came from it, would have really taken off as much.

Not possible, under the current economic regime. People simply cannot pay for things anymore; the wage-to-productivity ratio has fallen so much that we can't afford the things that are being produced; they get rented to us instead.

People need more wallet-votes, relative to the total number of wallet-votes that are out there. That's the only way this changes.

The thing is; if your software wasn't offered for free, nobody would use it because someone else would offer their alternative for free.

Also, the most difficult problems which software solve are hidden problems. Sometimes critical, but hidden nonetheless. Nobody cares about system failure, at all, until it happens to them.

No matter how good your software is, you can't effectively market it as "reliable" because every single piece of software ever created in the world claims to be realiable even though almost none of them are! The label has lost all of its meaning and hence, cannot be communicated.

So this means that far worse competitors can gain adoption and take the entire market from you if there is any friction at all between the user and your product. Open source is an attempt to reduce friction as close as possible to 0.

Anyway this creates a hyper-competitive environment. If you don't have a voice in the economy, open source can seem like your only option to gain any adoption at all. It's a business model born out of desperation, not out of choice.

> if your software wasn't offered for free, nobody would use it because someone else would offer their alternative for free.

That suggests there's never been a viable market for commercial software at all, which is obviously wrong.

I disagree that a viable market exists. What set of arrangements exist there may be viable, for select few people, but it's not a market.

A market implies that people are allowed to compete on price. If a participant can only compete after receiving investment from certain VCs (and otherwise can't participate, at any price point), then it's not a market.

Also I'm not claiming anything about the past. I'm just saying today, there's no market.

> A market implies that people are allowed to compete on price.

That's a pretty narrow definition. Markets can also compete on features.

Well features hardly matters either in the tech market because the condition of having raised money from the right VCs, who act as gatekeepers for your sector, is still there.

The label has not lost its meaning. Everybody knows what it means and wants it, just almost everybody “selling it” is claiming it without regard for the truth of their claim for their own financial gain. In polite society that is called lying and fraud.

People accept a surprising amount of unreliability. For example, I've been using SharePoint to modify excel files at scale. We kept running into issues with cache that we would write to a file, the service would respond with success, but then when we read the file, it shows the old cached value, not the new one we just WROTE! And there was no reliable way to check when the newly written value had been completely flushed using that API.

Microsoft will call this 'optimized'. They'll say that caching is good; it's a feature, not a bug!

But really, it's unreliable! It's not doing the job it claims to do.

You entirely miss the point of open source.

Open source is not about your ability to charge for the software. It is about the ability of the users of your software to modify it.

"Open-source software has its roots in the culture of source code sharing that dates back to the origins of computing in the 1950s. The term was formalized in 1998 with the founding of the Open Source Initiative, succeeding the free software movement initiated in the 1980s, with the intention of overcoming the ambiguity of the word "free" — meaning both freedom and gratis — to better appeal to the business world."

https://en.wikipedia.org/wiki/Open_source

You seem to be caught up in the 'free' part of 'free software'. It does not mean 'gratis software'.

https://en.wikipedia.org/wiki/Free_software

I know what it means. The problem is that people are expecting to be paid after they've already released it to the public for free.

You can make it work. Odoo is making money selling services, and there are many businesses making money re-selling Odoo in one form or another: partially rebranding, SaaS, support...

A non negligible amount of FOSS follows a similar path: yes, they are OSS, but if you really need it, you'll be better served paying a fee to someone who knows how to make it work properly.

That's a different business model from trying to sell the software itself. Plenty of consultants make a living doing integration work. They don't claim to be in the business of selling FOSS software, though.

Another model is selling an enterprise-grade release that builds atop the FOSS version, but with closed-source features and support. This is the model that nginx (now F5) and haproxy use.

I think a small issue with foss and monetization is that you can accept money for said software hell even release it with expectations that you have to pay for it, but you can't insert a clause in the license that stipulates that the foss rights only applies to paying or paid customers.

Thus there is no legal protection you really got if you go foss as a developer when it comes to ensuring fair compensation.

There is plenty of legal protection: copyright law so far held up pretty well. With the AI laundromat in play it's a completely different story though.

I meant when it comes to ensuring you as a non paying user can circumvent said restriction as that restriction goes against foss license.

Is there any well known, successful FOSS that isn't also free as in gratis?

I understand the distinction but have literally never encountered it in practice.

Red Hat Enterprise Linux is almost that. Technically they can't lock it all down, but they play tricks so that's practically the case.

Companies pay for support, CentOS reason to be was people wanted Red-Hat work putting out a great distro, while not wanting to pay for it.

Also very few software can be sold only on having support, regular users don't care about support.

Open source was never about doing stuff for free - at least not originally.

It’s about the definition of ownership. What does it mean to own a program?

When you distribute the program, you must also distribute the code for it. That’s open source.

It's not about the definition of ownership, either. The author of FOSS software retains ownership, unless they explicitly convey it to someone else.

It's about how software is licensed--the terms and conditions under which someone can make a copy. That's why it's called the GNU Public License, or the MIT License, and why there's a LICENSE file.

The mere act of copying does not convey ownership, and never has.

I think the license was the best tool available for the ideology around ownership.

Yes and no. It isn't about ownership of the project as a whole, but it is about ownership of your copy of the software.

I'm an attorney who specialized in copyright law, and I don't even know what you're trying to say.

You are likely too much in it to see the other side.

Free software licensing is an attempt to make copyright irrelevant: it's basically a no-copyright world it aims for, but then structured into the copyright world of licensing to use and distribute. It is nothing but a workaround, and copyleft uses it to make the default an even stronger case for reuse (by including sources).

In no-copyright world, you get a copy of something and do with it as you please. No licenses, no permissions. People frequently consider this "ownership" akin to owning a physical item (you get a copy of a book, or a toaster, and you do not ask for a license to tear a page out or repaint the toaster).

> Free software licensing is an attempt to make copyright irrelevant

The creators of the GPL never said this. That's an interpretation that Richard Stallman would probably disagree with if you asked him.

> In no-copyright world, you get a copy of something and do with it as you please. No licenses, no permissions. People frequently consider this "ownership" akin to owning a physical item (you get a copy of a book, or a toaster, and you do not ask for a license to tear a page out or repaint the toaster).

I'm aware of all this. It's also irrelevant, because we live in a world with copyright, and despite the fever dreams of some, that's not changing any time soon.

Perhaps you should allow the person I was responding to answer for him/herself.

I apologize for intruding on your personal conversation on a public forum.

What the RMS's opinion on copyright in software was when he kicked off "free software" is pretty obvious from https://www.gnu.org/philosophy/why-free.en.html — you may certainly have a different interpretation of "you should be able to give a copy to your friend" than I do.

No, it isn't an attempt to make copyright irrelevant. Almost all OSS licenses impose some conditions - even if it is only attribution.

OSS licenses are fully part of the copyright system and could not exist without it. Maybe you are thinking of "public domain".

I am talking of how "copyleft" came to be. See the motivation at eg.

https://www.gnu.org/philosophy/why-free.en.html

It is interesting that a philosophy opposed to ownership and restriction of control has pretty much the most controlling terms of any OSS license - to the extent it is usually banned in any commercial software development.

I do understand the copy left rationale - to ensure the freedom to modify and for the community to benefit from those modifications, it is necessary to use the machinery of control!

Ok, but this kind of seems like semantic quibbling.

At least since I've been programming (early 2000s), open source has been almost entirely free as in beer. Whatever the origins of the movement, as it actually exists today and has for a long time, both definitions of free are integral parts of the concept. If anyone ever uses the term "open source" in the widely understood, colloquial sense, a dozen eager HN commenters always jump in to explain the exact bounds of the various terms in their own idiolect. I can occasionally enjoy a good debate about semantics, except on HN it's basically always orthogonal to whatever issue is actually being discussed. I've been reading on HN about how the term has been misappropriated for 10 years and I'm very ready to move on.

The parent's point is that if you are looking to make some money, putting a bunch of code on github with an open source license and helpful readme is extremely unlikely to move you towards that goal.

The unsolicited comparison doesn’t work when entire businesses will be defunct without it

There are two free software business models:

1. Choosing the most copyleft, most business hostile license imaginable (AGPLv3) and charging for permission to violate it.

2. Relying on crowd funded patronage via platforms like Patreon, GitHub Sponsors, Kickstarter.

AI's ability to rewrite entire codebases is quickly killing 1, and even the biggest projects which are most successful at 2 don't make enough to cover even a single full time developer's salary.

All of my new projects will be private by default from now on.

> AI's ability to rewrite entire codebases is quickly killing 1

People say things like this, but can you name an instance of this actually happening? What non-trivial existing free software has been displaced in popular use by a vibe-coded alternative?

Anthropic rewrote the MIT licensed Bun. The capability has clearly been demonstrated. As far as I'm concerned, the writing is on the wall.

And it's not just free software either. AI can quickly reverse engineer compiled software too. It's almost scary how it made short work of all the firmwares running on my laptop. Even the days of compiled proprietary software are numbered since AI can trivially make free software out of them.

We live in interesting times. The very act of publishing software at all is now questionable.

That is a first party mechanical rewrite from one language to another. And I'm sure a significant part of the motivation was as a publicity stunt to increase demand for Anthropic's products. If anthropic hadn't acquired bun and had instead "vibe coded" their own replacement, do you think that would have become more popular than bun?

Disassembling a binary to tell you what it does is neat, but it doesn't give you anything new against free software whose source code was public to begin with.

Whereas if you ask it to generate a new large complex piece of software, the amount of human labor required to guide it into producing something that isn't hot garbage and then continue to maintain it indefinitely generally compares unfavorably with the amount it costs to buy a support contract for the existing thing.

There is a pretty reliable way to do this. Which is to distribute the code under two licenses, where one of them is the AGPL and the other is a paid license.

AGPL allows you to satisfy the free software people (and the free-as-in-beer people) and correspondingly win market share and get code contributions etc., but it also scares a lot of large corporations (whether or not it should). And if their in-house bureaucrats won't let them license code under the AGPL but they still want to use it then it leaves them to pay you for the other license. Meanwhile the bureaucratic corporations are the ones with the resources to pay you anyway.

Accepting contributions when you do this is a bit weird. They need to sign away their rights to their code so you can sell it. This is why the “open-source” database companies (all of which dual-license) don’t accept contributions.

> They need to sign away their rights to their code so you can sell it.

They can't accept contributions under the AGPL, but what stops them from accepting contributions under e.g. the BSD license? Does the BSD code stop Apple from selling macOS?

BSD/MIT are functionally equivalent to “sign away your rights.”

There is a meaningful difference between allowing someone to use your code for whatever and assigning the rights to it so that you can no longer use it.

And requiring contributions under BSD/MIT doesn't seem to be a huge problem for the projects that actually use those licenses.

The bigger problem they have is that nobody uses e.g. FreeBSD because if they do anything interesting the code just ends up in Linux/macOS/Windows whereas the reverse doesn't happen.

Please don't believe that this strategy is "reliable" in any way to get paid, if you or your company need that money for survival. FOSS and especially (A)GPL is just about forcing the balance to put more power in end user's hands, nothing else. A Proprietary+AGPL license combo might get you some cash from business wanting to change the code, but it will still allow any Amazon out there to host your code for free as part of their service catalog, while you are left to go out of business.

> it will still allow any Amazon out there to host your code for free as part of their service catalog, while you are left to go out of business.

Most other licenses allow them to do that without even contributing back improvements, since they're running the software but not distributing it.

Moreover, what is your business supposed to be? When you're selling support contracts or getting paid to make specific improvements to the code, what difference does it even make that some customers are running the software on AWS rather than their own local hardware?

Nothing "unsolicited" is suggested in the article ...

It is not so black and white.

I am annoyed by people who do bait and switch, like „we are open and promise free forever” - just after they build community or they manage to get some VC to talk with suddenly they start charging for project taking in all work contributors also created with it.

On the other hand there is bunch of cool projects that started like that and even if they bait switched it is hard to be angry at them.

> Otherwise you are no better than someone at an intersection with a bottle of Windex and a squeegee who, unsolicited, cleans a windshield and then demands the driver to pay for it.

I am struggling to see how this analogy is relevant. It seems more like a knee jerk to the use of "force" in the headline. TFA seems to be talking about a potential way to _generate revenue_ through side channels that are deemed valuable by the users. This is clearly different from "demand the user to pay for it" as the analogy would imply.

Open source contributors don't come unsolicited to "clean the users' windshields". They just write stuff that they find useful and the inherent value of that work attracts other developers as much as users. And then the whole thing grows too large to maintain without serious money.

If the language were centered around donations (charitable gifts) instead of revenue and the implicit expectations that go with it, then I might take a different view.

> If you want people to pay you for your software, stop writing it for free. Conversely, if you write it for free, don't expect people to pay you for it. Otherwise you are no better than someone at an intersection with a bottle of Windex and a squeegee who, unsolicited, cleans a windshield and then demands the driver to pay for it.

There are two ways to think about this whole situation, two mindsets. One is "what is ok to do?", the other one is "given my goals, what actions will lead to the desired outcome". I don't know any good name for the first mindset, and the second one I would call a chess player mindset.

We should at least understand and aknowledge the difference between these two mindsets. Laurie Voss (the author of the post) uses this second way of thinking, you are using the first one, so it will be hard for both of you to come to any agreement.

I like to think of it as a sieve. The first, coarser filter is: "will this functionally work?" The second, finer filter is, "is this socially acceptable?"

A psychopath skips the second filter.

An interesting problem is which filter apply first. On one hand, you don't want to waste time discussing if it is socially acceptable (such discussions tend to be long and nonconclusive) for things which we are not sure if they would work. On the other hand, you don't want to waste time discussing if it would work if the solution is clearly wrong from ethical point of view.

I'm not sure it fits the free and/or libre software philosophy but I'm a big fan of releasing otherwise free and open source software as a paid version and with some exclusive QoL features in proprietary store fronts.

For example Krita. https://krita.org/en/download/ FOSS but you can buy it on Steam, Microsoft Store, Epic Store, and Apple Store. You get one exclusive feature, automatic updates (and more recently Steam Cloud sync support), and you also support the developers (on the other hand Valve, MS, Epic, and Apple also gets a cut too).

If you read for example the Steam reviews everyone points out that it's a free software but buying on Steam is also a good and very importantly straightforward way to support the devs + the platform itself has such a pull ("buying games you never play") that people buy it just for the case of having it in their library

https://store.steampowered.com/app/280680/Krita

Filebot used to be open source. I bought it on the AppStore, it was a way to support development and I figured it would give me easier updates that would just happen in the background.

When Apple moved to ARM, the App Store version lagged behind. An ARM version was available, but not in the App Store. I assume this is because that ARM version was a separate download instead of being a universal app, and the x86 app would run on everything (for now).

The app is no longer open source, and is paid. To get the ARM version (due to my stubbornness in not wanting to install Rosetta), I had to pay again just to get the app through a different means of distribution.

Too many run-ins with silly issues like this can really sour a person on the “free app in a paid store” model.

That can happen regardless of which storefront you use to buy a free app. It's more of a developer-specific nitpick than a chronic problem with FOSS and freeware.

If you're happy to sponsor the app's development, then owning the App Store version should make you feel proud. The developer is still able to make a living thanks to you, and they're offering extended support if you're unwilling to use a fork of the free version. A good example of this is Dwarf Fortress, which I have bought on Steam 3 times now so that I could gift it to two of my friends. God willing, nothing will prevent me from buying a 4th and 5th copy when Christmas rolls around.

Sounds like the problem is the app later became nonfree.

This kind of thing happens to apps regardless of whether they are closed source or FOSS.

If management of a closed source app in an app store changes in a way that you don't like, you have zero recourse.

If it happens to a FOSS app, then you could potentially use the source to install the app yourself or pay another supplier to do it for you.

Although given the reality of the low cost of mobile apps and small, niche user bases, your purchase probably amounts to something more like contributing to a tip jar anyway.

Not a very effective way to support the devs though: only about 60% of what you pay gets to the developers, because of Steam's cut and VAT.

Yet by the active unique user numbers they have estimated sold at least ~168k copies and maybe upwards ~500k https://steamdb.info/app/280680/charts/ And that's Steam alone. I'd be really curious compared to this how many people click on the Donate button on the Krita homepage.

That's a lot of purchases imo for a project like this. I'm kind of ambivalent about the store cuts but they give a huge enough exposure to any game or software.

UTM is another great example of this, which is basically a GUI for QEMU. They have a Mac App store $9.99 version and the free open source version:

https://github.com/utmapp/UTM

The free software philosophy aside, I feel like another problem is that once you start accepting payments then you start accepting various forms of responsibility/liability/accountability/etc. along with it. At a high enough price it'd become worth it, but that might not be anywhere near the price that your customers/users want to support you at.

Maybe but lots of $2 apps exist from random devs who don't take much responsibility.

Free open source -> compile it yourself

Affordable binaries and SASS are fine options that I’d like to see

Doesn't work, someone else would make them available for free.

Depends on the affordability and friction to pay, vs getting software from a random or unknown source vs a maker.

I understand it didn't work, but I think there is a way to get it to work (good enough).

Plenty of people pirate commercial software out of random sources, this isn't really an impediment.

I think I have donated more for Inkscape, Gimp, Firefox, and Libre Office than I ever spent on proprietary software. I also tend to buy paid versions of open-source apps in app stores, where available. It's great when a piece of open-source software has an easy donation link / button.

That said, I tend to trust all closed-source software significantly less, even if it's given away for free. Especially is it's given away for free.

Without knowing how much you've paid for proprietary software, that could be a lot, or a little. If you're coming from a position where there is alternative FOSS software available to use, that's your bubble/sphere of experience. In other realms, say software for doing aerospace CAD, there is no FOSS available because it's just such a niche piece of software.

I mostly speak about more mundane software than CAD. I would say that the total sums involved are in the $100-$200 range, accumulated from multiple $5-$10 donations and purchases. I buy really, really little proprietary software %)

I don't think this counts as an exclusive feature. But yes this pay for the binary model "libre non gratis" is a very good model.

> Now, finally, I have an idea. It's gonna take 5000 words to get there, though, so if you don't have that kind of time, skip to the part about registries.

This article is full of LLMisms, which is to be expected but maybe it wouldn't be 5000 words and wouldn't need this disclaimer if they wrote it themselves

The only llmism I sensed is the use of "load bearing". Im usually queasy after reading llm slop, and stop before the end. This didn't have that effect.

Maybe the llms are getting better, but either way, this article reads like a real hunan write the whole thing.

This article feels like it was written by a human who has just read to much llm writing

Humans don't write things like: "Now, the popular way to tell this story is "the system is breaking," and I don't think that's right, and the distinction matters."

This statement just makes me think of a line from The Diamond Age in which two kids in a post-nanotech future first see a scrap of hand-woven cloth and after thinking decide that it must have been made by nanomachines because no human could make something so regular.

It felt like unedited, unstyled Claude output. e.g. "No, and the difference is the important bit."

Before LLMs no load was ever borne

Stop whining about it, the constant whining is worse than the LLM prose

It's really not, actually. Often I read the comments before the article and getting a head's up that the article is slop is invaluable.

It's not only not 'worse than the LLM prose', it's a community service!

I don't know about you, but I personally really appreciate when people warn me in advance that something is going to be a waste of time.

"and I don't think that's right, and the distinction matters" Yeah right. lol

I for one always appreciate it. The comments help me judge whether I'm right or wrong in my own opinion.

While I’m usually one to also get annoyed at uncurated slop, this doesn’t strike me in any way as LLM text, and likely something the author meant in earnest. I reads lot of LLM text. What part about it appeared generated to you?

From my perspective the piece was well structured, paced and thought through (and yes, a bit long)

The whole paragraph titled "Isn't this just Tidelift again?" is exactly how Claude describes something it is excited about.

I’d recommend looking through the 20+ years of Laurie’s writing in the archives. The LLMs may very well be mimicking him. I wouldn’t put LLM assisted writing past him, but I feel like this is being judged on topical similarity, and is not the standard kind of egregious incoherent slop that has little substance or lacks coherence. See for example:

https://developer.nvidia.com/blog/introducing-cuda-rust-two-...

How is this a LLM output? A LLM can easily write out those 5000 words.

> Now, the popular way to tell this story is "the system is breaking," and I don't think that's right, and the distinction matters. The system isn't breaking. It's stable, at a level of human cost we've collectively decided to put up with.

Reads like an LLM to me. "Load bearing" also used a few paragraphs down.

(Speaking only for myself.)

Having open indices charge money is the “easy” part, relatively speaking. The author is correct that most companies will grumble a bit and then fork over the nominal amount of money needed to preserve their existing assumptions.

I think the rest of this don’t really work in practice though: it’s actually incredibly hard to distribute money to open source maintainers across hundreds of jurisdictions, and it’s not immediately obvious how a service like PyPI (which is barely funded to maintain and sustain itself) would shoulder such a burden without diverting a very large fraction of that money for things that would make people upset (read: lawyers and tax professionals).

(NPM would appear to be the exception to this since it has - at least on paper - the legal resources of Microsoft behind it. But I think it’s largely a quirk of history that the JavaScript packaging ecosystem ended up with a single corporate owner, and no ecosystem I’ve worked with seems eager to pursue a similar relationship.)

This is why I just advocate for UBI nowadays. It's impossible for certain people to get paid for work they do and value they create and the reasons are numerous and different for every single person.

A lot of it is because human attention has been fully centralized and monopolized. Regulations are the nail in the coffin.

This industry is cooked, to a crisp. Tech people who have been excluded from the tech markets should be paid some kind of compensation.

I think Alex Gaynor is essentially right here[1].

[1]: https://alexgaynor.net/2025/apr/08/putting-a-price-tag-on-op...

The first time I understood there is a systemic problem was years ago when I started attending investor events and was pitching my open source software to tech companies and investors and they were all asking me "But what are you selling?" and I kept telling them "I'm not selling anything, I'm just looking for adopters of my open source product." and I was shaking hands with every person in the room.

They couldn't understand. They must have thought I was crazy. But the thing is, I couldn't even sell it for free. Even though it was provably useful and many similar companies did use my product successfully, at scale. It really felt like "It's a big club and you ain't in it."

It was like; they couldn't believe how much work I was putting in to give away a product for free. I think it might have made some people uncomfortable even.

And although I am more honest and cynical now about my own intentions, I still think that 'making money' was not and is not the primary goal; it was always a secondary goal which I planned to attend to later if/when the conditions would be right.

I was literally just trying to get big companies to adopt so that other smaller companies would look at them and tell themselves "Look, it's OK, big company X is using the product, so I can use it too!"

My goal was not to sell anything, it was to dismantle systemic taboos which worked against me as a small contributor.

10 years later, the taboos are worse than before! I don't know how anyone can start an open source project without the badge of corporate sponsorship these days.

I was thinking this too, and also thinking about who even gets paid. Like say I start an open source project and work on it for a few years, build a reputation and user base, and the registry is paying me.

I decide to step down, and nominate a trusted contributor as the new maintainer. Do I deserve to still get part of those payments? If so, what percentage do I get, and what does the new maintainer get?

I recently actually did take over maintenance for a Rust crate that was unmaintained and archived (but still widely used). The two (former) maintainers are still active, working on a related piece of software. Would I then deserve to get a cut of payments? Should the original maintainers still get something? Sure, I'm putting in lots of time and work now, but in total I've spent less than 1% of the time they have.

I guess you could adopt what I'd think of as the employment-based method. Whoever is actively maintaining gets payments, and that's it. That feels unsatisfying somehow, though. Ultimately every project would have to decide how to divide the payments, and that feels hard to do equitably in many cases. That's going to create resentment and hurt feelings.

Not saying that invalidates the idea, but it does make it harder on people in practice.

Just have npm pay the owner of the package. Let the owner handle the money distribution. It doesn't have to be hippie BS all the way down to be better than what we have. You people sometimes.

KYC is the polar opposite of “hippie BS.”

It is bureaucracy BS

The active maintainer(s) get paid for doing ongoing work, the same as any other job. That creates incentive to be the maintainer of a project. If the maintainer(s) isn't/aren't active, then there should be incentive for someone else to take over. Same as any other job.

I feel like the main issue with projects switching between a permissive and less permissive license and back is that starting out as fully permissive in the first place was the main error.

If everybody would just agree to start their open source code as something like source-available or OpenRAIL -requiring companies with more than $5M in annual revenue to pay for the work - we wouldn't be in this situation.

https://fair.io/

Yeah its a bait and switch. People want the social credit, early adoption, and community embrace of being open source, but they also want a captive business model.

It's not a bait and switch because the old version of the software that was released with the old license can still be used as such. If you call this bait and switch then I suppose this means that you somehow feel entitled to future versions of the software having the same license, forever.

That’s the thing with software, you can automate most future updates, with LLMs and whatnot.

Also, the initial software probably didn’t have a lot of known cves when it was sold.

They won't do this, because starting out as non-free doesn't get the same traction. Now that I think about it, it's basically a form of enshitification: draw people in with one deal, then after they're onboard, change it to something less favorable.

Why is it enshittification if you only have to pay when you have >$5M in revenue? Is your world so shit if you cross that threshold?

I think the issue is more on how you audit such things. Governments struggle (partially by design, but still) to get proper audits on who uses what and how much money they make.

The theory is great, but I'm unsure how you execute this.

Well, that's even more reason to not complain about it.

It isn't about catching every last >5m business out.

It is about having a rule that can be enforced when it is obvious to do so.

Fair enough. I'm in support of it, but it seems like any company >5m is also going to give a big legal fight if and when they are challenged on such aspects.

But I'm all for a good attempt at taking our wealth back either way.

> any company >5m is also going to give a big legal fight

I don't know about any company doing that. I guess some would do so on principle. But I honestly suspect it'd be a cost/risk based decision.

Who knows. But there is seemingly no carrot to entice those with money to give some of it to support the project, so a stick it is.

I like the Blender way of, contribute money = your features requests get some priority. But that only works if the company needs something.

I think the maintainer is still better off if only 50% of companies that should be paying are actually paying. The alternative is to just get nothing.

And if the maintainer wants to, they can always try to go after some of the more egregious offenders.

I'm just observing the incentives. There is a reason these licenses have not taken off, especially for nascent projects.

Some pedantic points:

> Ruby Central, whose dependence on one big sponsor then produced the 2025 takeover

Ruby Central had two major sponsors at the time: Alpha Omega and Shopify. Also the events had much more to do with interpersonal conflicts than sponsors.

My report: https://rubycentral.org/news/rubygems-fracture-incident-repo...

That is the GitHub only portion, but the AWS root happened immediately after/during and has its own timeline https://rubycentral.org/news/rubygems-org-aws-root-access-ev...

> a depleted team

The named people we lost from the report: Sam was already way out the door. Andre was most of the way. Ellen wasn't doing that operational work. Deivid was only working on bundler and not the registry. Josef is the main operational loss, he removed himself. I'm unsure of which attack exactly Is being referenced, but Colby was promoted to full time (was planned before, just waiting on paperwork).

Other prior maintainers and security researchers did NOT leave. Maciej Mensfeld Was especially crucial. Jenny Shen. To name a few. These people are “the maintainers” too. We’ve (I’m a volunteer, came on in October 2025) brought on a number of in-kind engineers as well (companies donating engineer hours via letting employees work on company time).

I reached out to everyone unnamed that lost GitHub access. Of them, one asked for admin back (granted). None were active in operations.

Seldo’s overall point: about the fragility of all of this still stands. But I also believe the details and the nuance matter. I reached out to Laurie on bsky when this was first published but didn’t hear back.

Cannot edit to add: I left off Martin accidentally. Not intentionally. I don't actually know how involved he was with operations recently (he was a former acting OSS director for a short period a long while ago).

Glossing over that too long article, the main proposition seems to be :

> The registries should charge companies, and pay maintainers

They already centralize packages, centralizing money flows is bound to cause more issues. By the way, npm is owned by GitHub, and GitHub is owned by Microsoft. "Your payment for your leftpad package has been transferred to your Microsoft Wallet". No thanks.

I just think there's a fundamental disconnect between the goals here. If I write free software, I don't write it to get paid, I write it to benefit others. If someone takes my work without also contributing back, I will get upset. The solution is not to give me money, that's not the spirit. We should not force people to pay for OSS but we should force them to give back to the community.

That's why copyleft licences like GPL are superior. People licence their work under BSD-style licences that are the equivalent of putting a box of stuff on the side of the road with a "free, help yourself" sign and then get upset when people do. BSD-style licences take away as many rights from users and authors as they can. GPL-style licences give as many rights to the users as they can. That's basically completely opposite philosophies. Use the right licence folks.

The reason I dislike this is because of the game it creates. Let's say we have someone who developed a small, well-used dependency (say: xz) but there is now incentive to be "in the dependency chain." xz is open, LLMs are really good at stealing/recreating; what stops someone from publishing rxz (maybe a rust port, maybe a gnu-r port, maybe it's "Really fast" xz, maybe it's just hoping for a typo in a registry.) This new dependency adds very little over the original xz and xz could have just used a simple PR.

On the other side of things, does accepting a PR from someone grant the author the ability to collect royalties for that software project? If so, how would you quantify that? LOC seems like a quick but really bad answer for what it is incentivizing.

For many, the entire point of "F" in "FOSS" is not getting tangled up in this kind of mess. I personally would never want to add "am I opening myself up to a lawsuit if I don't pay someone for their PR" to enter my calculus of accepting a PR. Especially if this is because I reject payment at all on a project.

Finally, if a company/employee submits code to FOSS under this model, do they now expect a return?

This new dependency adds very little over the original xz and xz could have just used a simple PR.

I kind of like the incentives created by this competition. This "what if someone takes your software, adds one feature, and sells it" argument has been made many times and I think the answer is that you, as the original maintainer, are in the best position to add features and if you squander that position you deserve to lose.

Seriously imagine the consequences of this "eat or be eaten" approach. What it incentivizes is not feature development per se, but fragmentation for the sake of it. This in turn leads to less attentation toward maintaining the shared base of the fragmented forks, as it has been superseded with features X and Y in different, probably incompatible forks.

My point is that the original maintainer can defuse the forks by including the same features. That leaves users no reason to bother using the forks.

It's a good point, and it also depends on the feature being good and sensible and in demand enough to push users away from the default.

And then it incentivizes people to make good forks, like neovim vis-a-vis vim.

Why would this be implemented, though?

The author talks about how companies don't pay OSS maintainers because they don't have to. But they often pay registry maintainers because they do have to (or they have to run their own, which they don't want to, so they pay).

But why would the registry set up a system to pay maintainers? They don't have to, so why give up a part of their revenue stream? Either the registry's aims are profit, and they wouldn't want to do that, or their goal is to charge for operating costs to keep the lights on, and they wouldn't have the spare revenue to pay maintainers.

The bottom line is the same: if someone has to pay for something, and there are no alternatives (or the alternatives are costly in other ways), then they will pay. If they don't have to pay, then they won't.

If registries get developers to upload their code without paying them to do so, why would they voluntarily pay them?

I think I'm starting to forget, but could someone maybe tell me what the F in FOSS stands for?

"Free as in speech, not free as in beer."

I'm not reading an AI slop article, but there's nothing in either the Free Software Definition or the Open Source Definition restricting the selling of software. It does prevent you from restricting people from sharing that software once they've bought it, but you could always use a threshold pledge system to ensure you get enough money before releasing anything:

https://en.wikipedia.org/wiki/Threshold_pledge_system

> "Free as in speech, not free as in beer."

As I understand it, if you have the first, the second follows from it. So it's effectively the same.

Not the same at all. Free as in beer means you get nothing. Free as in speech allows you to get as much money as you can using a threshold pledge system. This isn't just theoretical: the famous 3D modelling software Blender was released this way, becoming Free Software only after a €100,000 payment.

Sorry, I phrased it badly. I meant that in practice free-as-in-speech implies free-as-in-beer for copies: once anyone can redistribute the code.

"We encourage people who redistribute free software to charge as much as they wish or can. ... So if you are redistributing copies of free software, you might as well charge a substantial fee and make some money. Redistributing free software is a good and legitimate activity; if you do it, you might as well make a profit from it. ... Distributing free software is an opportunity to raise funds for development. Don't waste it!" https://www.gnu.org/philosophy/selling.html

Indeed! While reading the original post, I was reminded of the old essays where RMS made it abundantly clear that charging for delivery media was absolutely ok - and if you wanted GNU updates, you should send in the stamps necessary to send them back to you.

Maintaining a popular registry is very hard work, hard enough that commercial entities would rather pay than having to do it themselves. It is literally SaaS. It could absolutely be monetized for the common good - although the gamification worry is real, and the governance would be really difficult to defend from sharks. But there might be clever ways to fix those issues.

The one thing you cannot fix is the cross-planet level playing field that registries provide. Today, a small African company can pull from a registry more or less in the same way as large US corporations. If you put a toll booth up, the toll will soon be too high for people in various parts of the world.

He confuses developer adoption with cloud infrastructure maintenance, and he fundamentally misreads what software maintainers actually want.

The forking tax is great, and it requires a permissible checkpoint in the repo, which might not be available at all if you start correctly. Then the forks they use are quite literally "theirs", people don't trust hyperscalers.

Companies like redhat, jfrog, etc. have a model that is different to what one would want. They are built not on excellence but rather on taking the indemnity clauses on themselves. Hiring people to have 24/7 rotations and support, and all this Jazz and overhead that has nothing to do with being an expert at your thing.

Registry cron job paying thing...

Highly flawed and lacks fundamental understanding of the world, business, economics, and, more importantly, the actual drivers of the behaviour of the hyperscalers and business models of high-tech companies.

They conveniently forget that they were the very first ones to do MIT, then they build a community, just to later rug-pull everybody with non-permissive licenses. Plenty of examples of companies thriving by doing proper licensing from the very get-go. And these very people lacking in ethics then go on to complain THE LOUDEST that hyperscalers are forking them. I can't fathom the heights of entitlement and incompetence.

This is a great proposal, but other than the gamification worry, I wonder if it also changes the contribution model?

Eg. how motivated are you to contribute an important set of fixes to an upstream package knowing that this package is getting lots of money for the maintainer, and would not get any for you? Would you instead fork hoping to get everybody to switch over to your fork (it could even be justified: "for quicker availability of fixes, here's my fork"), and then ride it out?

Certainly not everybody would approach it that way, but I am certain some would.

Others might not even want to contribute and would instead just file a bug expecting the maintainer to fix it (they are getting paid 30k a month by PyPI, they might as well fix it).

Basically, whenever money enters the picture, the core dynamics change, and it'd hold especially so for FOSS.

Isn't this similar to the anaconda model? (Except they keep the money instead of distributing it.)

Depending on how you count, in my research group we are like 10 and in my whoooole university we are like 60.000 employees. When they went from free to restriced for big organizations I just uninstaled it.

Yes, but anaconda has a free competitor (pypi).

If pypi started charging too, you'd have nowhere else to go.

> Because there are two games going on, and they have different winners. In the code game the resource is the software itself, and free wins every time, because anybody can copy code, so any attempt to charge for it invites a copy that doesn't. In the supply game the resource is not having to think about where the code comes from, and that game is won by whoever is the default.

This is, IMO misdiagnosing what's going on. Spending money is always friction. The number of ICs that can spend 4 figures of company money on a whim is much smaller than the number of ICs that can download libre software on a whim.

Then once the company knows they are using the libre software and it adds value, people who can spend large sums of company money will want to do so to protect that value.

One of the easiest ways to get paid for something is to to offer commercial support once something shifts to 'end of life' for community support. Can't get off of an old busted version - write a check for continued support! This sort of thing is reasonably easy to get through the accounting process.

Leaving a tip, paying for something free, trying to send money to a group that our infrastructure absolutely relies on - stupid hard. Commercial support, on the other hand, is very understandable to the bean counters.

I have always wondered about most common tools. How much should maintainer of say bash be paid per install? Or per use? Or per month a system runs? What about all other core tools or common tools? Even most of things in say Linux?

Surely those are much more important and more deserving than any service or whatever you run on them? You can't install that software without them.

Or does these payments end somewhere? So money does not end up with those who wrote and now maintain them?

> The evolutionarily stable strategy for a piece of software is "anybody may use this for anything, including commercially, for free." That's MIT, BSD, Apache, the licenses that ask for nothing. Every project that has tried to be a slightly less generous dove has lost to a project that stayed a full dove

Linux (GPLv2) seems like an obvious counterexample?

Arguably that happened because Linux was, in fact, the most generous option: the BSDs effectively refused to get contributors beyond their very small groups, and refused to incorporate patches to support "bad" hardware or nonfree blobs - meanwhile, Linux was built around modules that could contain anything regardless of license, and happily accepted new patches and unknown maintainers. You still see it today: Linux literally built its own distributed VCS (git), while some BSDs are still on the hyper-centralized CVS.

If there isn't an even more generous option is simply because building a mainstream OS is incredibly hard.

How open a platform is to external contributors is a very different axis than the legal permissiveness one the article describes.

It's the same axis: business-friendliness.

The legal permissiveness described is critical for most software because it enables business adoption. But for a kernel, which sits at the intersection of hardware and software, "free as in beer" is not enough, there is another critical factor: how easy it is to make it work with proprietary hardware. A free kernel that won't work with my custom chip and whose maintainers won't accept the necessary patches to fix this state of things, is just useless to my business.

Am I missing something, or are most of the comments here not really addressing the pros and cons and possibilities in OP’s proposal?

Yes, I don't feel like the top comments have actually read it. It was a bit too long unfortunately. They seem to be discussing their own ideas on FOSS funding.

Depends on what you're doing, the "source-available" model may not work. Because many software earns their money through just few tricks, maybe it's more user-friendly design, maybe it's better predictive algorithm etc. These tricks hidden deep in the logic so it's hard for the competitors to figure out in months time.

But if you made the source code available, the trick will be reveled in plan sight and you lose advantage quickly. After that, you turned software making a laborer's game (you need add laborer to add and/or steal ideas faster than your competitors), it's way less fun.

If you want to make money, you have to play the art of balance. How much do you want to make open, and how much advantage you want to withhold.

This is very interesting: it is a lot like the GLP (pun intended) solution: it doesn't try to "cure" the symptom, it just piggybacks onto the existing facts-on-the-ground and tries to make things better from there.

I'm not totally sure I understand the "distribution/registries" thing though? This also related to GitHub and HF, right? And Netflix. (You mentioned Spotify.) How they host stuff and then leverage that position to build add-ons and lock-in, lobby for laws. Companies PAY for this "bandwidth."

I always thought that BitTorrent would eventually take off and make these kinds of sites irrelevant, that it would democratize bandwidth, the last leg of the battle for universal accessibility.

I like your idea. I wish you luck.

This immediately falls apart when you realise that the registry is also a company that doesn't pay for FOSS and does not have the competitive incentives to ever do so.

I'm kind of disturbed that it took me 7 years to find out about the Feross incident: https://feross.org/funding-experiment-recap/

This guy is literally a high profile individual from my own niche Node.js open source community and I'm literally an open source developer from that exact same community and I had no idea.

MongoDB and Grafana seem to be doing fine. Idk that this logic holds up at face value. Like the HashiCorp, Elastic, and MinIO license changes pissed people because it was a rug pull on the community of people supporting and consuming those projects. If they had started as AGPL licensed and took the Mongo and Grafana approach, who knows what things would look like today.

I think it's a great idea and I hope someone inside the teams of popular registries sees this and they actually give it a go. I imagine the shitstorm of reactions that it's gonna cause from people who aren't even included in the "required to pay" group and I wish the registry maintainers strength to get through this

Other than charity and donations, the only two ways of getting paid for developing FOSS are: 1) support contracts and 2) crowdfunding the next release.

Digital goods live in a post-scarsity situation. Applying the same business model as real life products is crazy and it's the reason why we have Adobe&Co.

Software stacks are infrastructure. It makes sense to pay for infrastructure via taxes. That's why "Public Money, Public Code" is imho a great initiative. We should redirect the public money that we currently hand over to proprietary software vendors towards open source.

Our school system has been using FOSS products for years.

In effect, it is a donation to a non-profit organization.

However, I'm not aware of any of the creators reaping a tax deduction for their donation.

Donating a used car to a non-profit has a well established path to this end.

Are any FOSS authors using a similar method to attain some payback?

I'm not convinced a problem is actually here. I certainly wouldn't believe LLMs, an optional tool, make any part of this fundamentally worse. Maybe superficially for people who can't adapt.

Great proposal Laurie! It'd be great if YC would set up an Open Source endowment also, with say 0.5% of their companies' stock (voluntarily) endowed to open source software.

Hard pass, thanks. Just, don't expect to get paid for maintaining open source projects.

It's easy. Everyone knows the deal going in, and if somehow you missed that you're not going to get paid for this and you want out at any time -- you just stop.

If you made something of value someone else who cares enough will pick it up. Or it can languish and the earth will keep spinning. It's fine.

The lions share of the packages used by company X should get the lions share of their subscription too. This is where music subscription has failed.

Its the same reason why the people who do the actual hard and deadly work get paid the least.

This is true EVERYWHERE.

Why would you write such an important article with AI? I can't share this with people I know because they will lose trust if I send them AI articles. It's really, very easy to tell because it's filled with AI rhetoric and you don't sound like this in your writing from 2020 and before

> They sell insurance against the maintainer, when the maintainer is the one person in the chain who can actually make the code more secure, and she gets nothing while a company two layers up gets paid to tell you whether she did.

Damn, this is a really good line. It's the reason why existing tools like Snyk give so many false positives and miss so many actual vulnerabilities. They're kind of useless really.

They create false comfort and busy-work for staff whilst providing a ready-made "Snyk said it was secure" narrative to cover everyone's asses when things inevitably go belly-up.

And Snyk be like "We responded as fast as possible, so we fulfilled our part" yet what really counts is not even in the equation.

Personally, I stopped contributing my code open source. I still write it and I've built a major project I'd love to make public but I'm keeping it for myself. I'm waiting for communism or UBI to arrive, then I may resume publishing as open source.

If it takes too long, I will pass it down to my son and he will wait until communism arrives to make it public.

after reading Ford Foundation document [0] i'll go beyond and purpose FOSS not only limit commercial use but also forking [1] as it seems we have an endless stream of libraries which do the same thing, scattering even more this "fragile" ecosystem which would benefit so much of big tech's evergreen

[0] https://www.fordfoundation.org/learning/library/research-rep... [1] https://happort.org/constraining_freedom

Being able to fork your own version is a desirable goal and by design. The original author can and will probably not want to take his project in all kind of imaginable directions.

That is "source available", that is a fine decition if you like it. Just don't call it FOSS.

Nobody pays for free (& open source) software?

FOSS == Free Open Source Software, fyi.

There is nothing free in Android.

I don't understand why anyone takes this person seriously. He fell ass-backwards into a prominent company, got demoted after proving incapable of being the CTO, and then seemingly got promptly off-boarded after the acquisition and now just has a developer relations job. Not to denigrate that role, but it doesn't exactly confer authority for this to be the trajectory of your career.

how about making money from something else like hardware, to fund software (almost like IP is a fiction and people should be making money from tangible things rather than info)

I'm sure AI can also brainstorm more ideas for (F)OSS business models today

You seem to be forgetting the most important word in FOSS..

For them it is not the most important word, apparently.

But it is one of the words.

It can still be free for most people but paid for companies who make >$5M revenue.

Conditionally free is also free.

The Free in Foss is not "Free as in beer".

No, but "free as in speech" effectively precludes making money from sales of the software. As soon as you sell it to one person, that person can give it to others for less than he paid you (all the way down to free), so nobody has a reason to pay you any more. There's a reason FOSS survives on donations or service, rather than selling copies of the software.

The software still remains free, it's the registry that would become a paid service under such a model, that's what was proposed in the article. And even then, the registry would remain free for individuals, so it would merely be a price of convenience

Change the GPL and make the GPL only apply to NATURAL HUMANS and NOT CORPORATE HUMANS.

If the corporates want to use it, they can make a licensing agreement and put money into a trust of all who support it.

They don't want to pay? Too fucking bad.

Or, you know, just use a different license?

Honestly, the privilege and entitlement of some people. You made a thing, you did a lot of work, you gave it away for free. Nobody stole it from you. Nobody even asked you to make it. You created this situation yourself. And now you're upset that nobody paid you for the thing you make for free?

"But but but... companies are making money... off the thing... that I gave them for free!! How dare they!! There is no way I could have seen this coming!!" - Either you were ignorant and didn't realize people would sell the thing you gave away, or you knew about it and are now pretending to be outraged at the thing you knew was going to happen.

"But but but... they should pay me anyway, because they're profiting off my labor! It's what's fair!!" - What's fair is for someone to take you at your (and your software license's) word, to do exactly what you told them they could do (profit off it). What's not fair is to turn around after they're hooked on your free thing, and try to force them to pay you for it, after the fact.

The point of open source is only to open up the source code, allow people to contribute, collaborate, and share. If you want to get paid for it too, don't put an open source license on it. It's that simple. Add whatever terms you want. But don't make FOSS and then later say it's unfair for people to do exactly what your license said they could do.

Despite the submission title, I don't think I would call this proposal a way to force companies to pay for free software. They could choose not to pay if they don't want to use the software. If they've already downloaded the software, then they wouldn't need to pay unless they want to download it again, but they are free to make as many copies as they want so re-downloading is mostly going to be a matter of convenience I think.

I believe free software is better than proprietary software, so I think it's good to better incentivize the production and maintenance of free software.

Using nicer language doesn't change the argument. You're still suggesting that corporations be required to pay for the software, which is a reversal of the terms of the license.

Let's ignore for the moment that this is manipulative behavior (switching from free to paid after the fact, the same thing users complain about corporations doing). This is likely also illegal. The software license is a contract. Permissive FOSS licenses grant the use of the software in current and future forms without payment. To withhold the source code until receiving payment would be a violation of the contract terms. All of the copyright holders would have to agree to change the license to no longer be Open Source, and even then a judge may well find it illegal.

It's also a bad idea because it would split the community. I find this action so unethical that I would no longer contribute to or use any FOSS that required payment. I didn't get into this community to shake companies down for cash. If you want to make money off software, go do that somewhere else, or do it with services and support.

You don't need to change the license at all in order to do this. Withholding source code while providing an executable would violate some free licenses, but all free licenses allow withholding both an executable and corresponding source code simultaneously.

An action like this could split the community, but I don't think it would be very visible to people contributing to the software, since I imagine the source code would still be available on a public git repository with the same license, for the purpose of development. Do people complain about Krita being on Steam [1]? It's not exactly the same situation, since Krita never was on Steam before, but do you think the situation would be so different if Krita had been free-to-download on Steam and then they changed it?

[1] https://store.steampowered.com/app/280680/Krita/

FOSS licenses don't allow requiring payment for source code. Even if they did, they would have to do it for all users and not just corporate users, or they'd be violating their own terms against discrimination on fields of endeavor. What they can do is charge for binaries of the software, which is completely different. And they can't stop anyone else from redistributing it for free. So the first person who pays for it can just give it to corporations for free, and the copyright holder can't do squat about it. These are all features of the licenses, to prevent nasty developers from putting up roadblocks and gates to prevent the collaboration and sharing of the source code.

A corporation is a user too. Imagine if instead of corporate users, we were talking about rich users. Or imagine if 99% of the public used the code, and none of them paid, so people started talking about forcing the public to pay for the code.

Nobody asked the developers to make this code. Nobody asked them to put a FOSS license on it. Nobody ever promised payment. But now that they see dollar signs, the developers want theirs. It's greed, pure and simple.

FOSS was not created to give volunteer developers a living. It was created to give people freedom. No more, no less.

Free licenses all allow requiring payment. A license that disallows charging for the software as a whole would be a nonfree license. An example of a license condition that does this is the "Commons Clause" [1]. See the FAQ question on that page which says "Is this “Open Source”?" (short answer: "No.").

If someone decides to charge businesses more than individuals, that is arguably discrimination based on fields of endeavor, but if the discrimination isn't written into the license, the software could still be free. Corporations are still free to use free software however they wish, but they can't force software repositories to choose to distribute software to them directly.

It's true that someone could set up a different software repository that offers largely the same software to corporations at no charge, so the proposal only works if companies would prefer to pay the fee rather than set up a different repository. It sounds like companies already pay to use an intermediary repository, if I'm correctly understanding what Artifactory is, so maybe the proposal wouldn't actually work.

If 99% of the public used a piece of software, there's a good chance people really would be forced to pay for it through taxes. This apparently already happens with some proprietary software (though I didn't look into it); see "Public Money, Public Code" [2]. Taxes are a different situation though.

Software freedom can't exist without free software. The better funded free software is, the more free software will be able to compete with proprietary software, and the more free the world will be, with regards to software freedom. The proposed system of charging corporations could conceivably be better even from the perspective of the corporations, if it leads to free software becoming more reliable.

I know you don't mean "nobody" literally, but I actually have asked people to write free software and to license existing nonfree code with a free license. It might be true that you didn't ask for people to make free software, but would you prefer a world in which they didn't?

[1] https://commonsclause.com/ [2] https://publiccode.eu/

“we can force them to pay for free”

The usual pushback I get from FOSS zealots is that any time I mention things like money, popularity, increasing adoption etc. they just say none of that matters because it's "not a project goal."

In fact, often they don't even want money to be a thing at all, they think capitalism is inherently evil (cough innovation) and would prefer if everyone was just poor and lived in the woods or something.

Sorry... I like the world to be a little more interesting than that.

> money, popularity, increasing adoption

These are the currencies of the VC world, and many open source developers don't release their work for those reasons (myself included, limited though my contributions are). It seems strange to deride them as making the world uninteresting because of this.

>they think capitalism is inherently evil

Modern society has done a wonderful job proving that sentiment right. I can't blame them.

>would prefer if everyone was just poor and lived in the woods or something.

I'd prefer if everyone had proper control over the tools they used. Whether they choose to live in the woods to use such tools or use them to make society a worse place is the double edged of 'free' (as in freedom)

I completely understand those skeptical about perverse incentives from not making software 'free' (as in beer). It shouldn't be a surprise that adding monetary inventice changes the entire incentive structure.

The financialisation of everything is, frankly, fairly toxic, so it's reasonable argument.

Call it names all you want, under capitalism, we all need money to pay for food and rent and it's got to come from somewhere.

I’m not sure who is worse, the people who want everyone to be poor and live in the woods, or the ones who want to monetize every human interaction until you need a microtransaction to unlock your front door.

Maybe there’s a balance to be struck.

The funny thing is that some of these "FOSS zealots" misunderstood the point of FOSS and believe that it is required to work for free, after the source has been released.

Most of the "FOSS zealots" should know that Stallman supported capitalism and the commercialization of free software in the form of paid support which this model has worked for many years and Stallman made his own money from speaking fees thanks to the GNU project.

The truth is, FOSS only works if someone else is paying.

Reply on news.ycombinator.com