New Fluxzy 2.0 just shipped. Electron is out, Tauri is in. Fresh design, 3x smaller install. Learn more

Still no more counting dollars we'll be counting GitHub stars?

Every time I showcase a new feature of Fluxzy on Reddit, I brace myself before opening the comments. Not (always!) because the feature is bad. Not because the idea is dumb. But because I already know what's coming. "Why isn't this MIT?" "GPL? Hard pass." "I won't use it unless you change the license."

And the thing that always gets me is that these comments rarely come from product owners or CTOs evaluating tools for their stack. They come from other developers. Fellow indie devs. People who, like me, are writing open source code on nights and weekends, on time that should probably be spent with their kids or, I don't know, trying to find a girlfriend.

Open source developers are some of the most passionate people on the planet. They are building things for free, for the love of it, pouring evenings into libraries that strangers will use without a second thought. And the first thing those strangers do is complain about the license. It's wild.

Let me be clear about what I'm not talking about. I'm not talking about Microsoft releasing .NET under MIT, or Google open-sourcing Kubernetes. Those companies made a calculated business decision. they looked at the spreadsheet, ran the numbers, and figured out that open-sourcing under a permissive license would generate more financial return than keeping things closed. That's fine. That's rational. That's a Fortune 500 doing Fortune 500 things.

I'm talking about the solo dev. The person with a day job and a dream. The one who made something useful and shared it. Why does the internet immediately demand they give it away with zero strings attached?

Here's where I should mention that I'm not some idealist living in a cave. In my day job, I'm a CTO of a modest company. I care about budgets. I care about transparency. When I see a great MIT-licensed tool, I'm happy. Free is nice. But I also regularly choose tools we have to pay for. And you know what? I sleep fine.

Coming from the .NET world before it went open source, paying for software was just how things worked. And the long-term results of that model were often surprisingly good. Paid tools tended to be well-maintained. They had proper support. They didn't randomly break on you because the solo maintainer got a new job and abandoned the repo.

Remember XZ Utils? One burned-out maintainer, working alone, for free, on a compression library that ships with basically every Linux box on the planet. A state actor spent three years earning his trust, got co-maintainer access, and slipped in a backdoor that would have owned every SSH server on earth. The only reason it didn't work is because a guy at Microsoft got mass nerd-sniped by a 500ms latency regression and wouldn't let it go. That's the margin. Half a second and one stubborn engineer. That's what stood between us and on of the worst supply chain compromise in history.

This is what happens when critical infrastructure depends on one exhausted person maintaining it for free. We didn't get lucky because the system works. We got lucky because one guy was unusually thorough about a performance regression.

And before you say "well that's an argument for more contributors, not against MIT," think about it. The reason there was only one maintainer is precisely because there's no money in it. The reason there's no money in it is because the license lets everyone take the code without giving anything back. The permissive license didn't cause the burnout directly, but it created the economic conditions where burnout was inevitable.

So let's ask the uncomfortable question: who actually profits from all this MIT?

A Harvard Business School study tried to put a number on it (on bottom for reference). They found that open source software has a demand-side value of $8.8 trillion. That's the amount companies would have to spend if they had to build all this software themselves instead of using it for free. And here's the part that should make you pause: 96% of that value is created by just 5% of developers.

Meanwhile, according to Tidelift's 2024 survey, 60% of open source maintainers are unpaid hobbyists. That number hasn't moved in years. And 60% have quit or considered quitting due to burnout. Unpaid maintainers are overwhelmingly solo: 61% of them work on their projects completely alone. The people generating trillions in value for corporations are doing it on evenings and weekends, for free, by themselves.

Let me put it differently. If open source were a country, its GDP would be larger than Japan's. But its workers earn less than street musicians.

So when someone tells you MIT is "good for the ecosystem," ask them: good for which part of the ecosystem? Because it's clearly not the part where a human being is sitting at their kitchen table at 11 PM triaging issues from strangers.

You might say developers benefit because they get free tools. Sure, short term. You might say it helps your career because your GitHub profile shows contributions. Okay, also short term. You might say it advances the glory of software. That's a beautiful sentiment. But I care about the people first.

Here's the reality nobody wants to say out loud: with permissive licensing, the value of writing code was already trending toward zero before AI showed up. AI just made it obvious. We've built a culture where the only thing worth paying for is hosting. Code itself? That should be free. The mass of human effort behind it? Doesn't count. Only means of production count.

And when the companies who benefit most from this arrangement feel like the deal isn't fair in the other direction? Watch how fast they change the rules.

Redis was BSD-licensed for years. AWS took it, wrapped it in a managed service, called it ElastiCache, and made billions. Redis Labs, the company actually maintaining the software, saw almost none of that money. In 2024, they finally snapped and changed the license. What happened next? AWS didn't shrug and accept it. They forked Redis into Valkey under the Linux Foundation in what felt like five minutes. The message was clear: we'll take your work for free, and if you try to stop us, we'll just take a snapshot and keep going without you.

Elastic had the exact same experience. They changed their license to stop AWS from selling Elasticsearch as a service without contributing back. AWS responded by forking it into OpenSearch. One year later, Redis had lost most of its external contributors. And the most revealing part? After all that community damage, Redis eventually came back and added AGPL as a license option. Not BSD. Not MIT. AGPL, a copyleft license. Because they learned the hard way that permissive licensing, for anyone trying to sustain a project, is handing your competitors a free weapon.

These aren't hypotheticals. This is the pattern. Build something valuable, give it away under MIT, watch a trillion-dollar company wrap a managed service around it, and then get told you should be grateful for the exposure.

Now, am I saying everything should be locked down? No. There are things that absolutely should be MIT. Core infrastructure, the stuff that isn't specific to any business. JSON parsers, HTTP clients, date libraries. These should be open and permissive. If you don't write them, a big corp will (and already has), specifically to make developers faster to publish on their cloud. That's fine. That's the foundation.

But the thing you spent six months building? The tool that solves a real problem in a specific domain? The one you maintain on weekends? Maybe it's okay to not hand that over with zero conditions. Maybe GPL or a commercial license or even just asking for money isn't a moral failing. Maybe it's just reasonable.

There's a deeper irony that I think about a lot. The "GPL kills adoption" crowd assumes the goal of every project is maximum adoption. But what if it isn't? What if the goal is building something sustainable? Something you can maintain for ten years without burning out? Something that lets you, I don't know, feed your family from your own work?

Maximum adoption with zero revenue is not success. It's a trap. It's how you end up as the sole maintainer of something that half the internet depends on, answering GitHub issues at midnight, wondering why you started this in the first place. We know where that story ends. It ends with a burned-out maintainer getting socially engineered by a state actor because they're too exhausted to vet the "helpful" new contributor who spent two years gaining their trust.

I might be wrong about this. But I think these permissive license expectations are something unique to programming culture. People point to academics as a counterexample. "They share their work freely too!" Sure. But look at the structure. Academics have salaries, grants, tenure tracks, institutions, peer review systems, sabbaticals. An entire civilization of funding exists so they can share knowledge freely. The sharing is the output. The funding is the input. There's a loop.

For indie open source developers, there is no loop. There's no grant. There's no institution. There's GitHub Sponsors, which is basically a tip jar that most people walk past without looking.

Every other creative profession has figured out that people need to get paid for their work. Musicians have royalties, licensing deals, and entire organizations that collect money on their behalf. Authors have advances. Filmmakers have studios. Architects have fees. Even the music industry, which went through its own "everything should be free" phase with Napster and Pirate Bay, eventually rebuilt around models where creators get compensated. It was painful. It took years. But they did it because the alternative was watching an entire creative class go bankrupt.

Nobody asks Taylor Swift to release her albums under Creative Commons. Nobody goes to a concert and yells "why isn't this MIT licensed?" The idea is absurd. But somehow, in software, we've normalized the expectation that individuals should hand over their most valuable creative work for nothing, and that anyone who puts conditions on it is being unreasonable. We are the only creative field where protecting your work is treated as a character flaw.

And if you're still building things by passion, GPL is still pure passion. It just says: I'm sharing this with people who share my convictions. Use it, improve it, give back. The most successful open source project in history is GPL. Linux runs 96% of the top million web servers, all 500 of the world's fastest supercomputers, and the kernel underneath Android's 72% smartphone market share. Not MIT. Not BSD. GPL.

Meanwhile, BSD gave us the permissive dream. Apple loved it. They took FreeBSD's networking stack, its userland, chunks of its kernel, built macOS on top, and never looked back. macOS is now a multi-billion dollar ecosystem. FreeBSD sits at 0.3% market share (and unusable for common people). The permissive license made it trivially easy to take the work and close the door behind you. Linux, behind its "restrictive" GPL, built an empire that belongs to everyone. BSD, behind its "freedom," became the foundation of someone else's empire.

This is just a personal take. I don't have all the answers. But the next time you open someone's repo and your first instinct is to complain about the license, think about what you're really asking. You're asking someone who built something valuable, on their own time, to hand it to you and to AWS and to Google and to Microsoft, with no strings attached, forever.

And if that person says "no, here are my terms," maybe the right response isn't outrage. Maybe it's respect.

References:

ESC
↑↓ Navigate ↵ Select ESC Close