You know the feeling. You spent nights and weekends building a library. A trillion-dollar company ships it in their product. They don’t send a pull request. They don’t donate. They don’t even say thanks. They just take.
We’ve all been there. And we’ve all been told the same lie: it’s fine, because open source is about freedom. But freedom for whom? For the developers who get nothing? Or for the corporations who get everything?
Look at what actually happens. Every major tech company on the planet runs on FOSS. Not because they love the community — because it’s free. Free as in no invoice. Free as in no obligation. And free as in, if the project collapses, they’ll just fork it and move on.
This isn’t a bug in the system. It’s the design.
Every permissive license is a contract that says: take everything, give nothing back.
We wrote those contracts. We romanticized them. We called it “openness.” But from the other side of the table, it looks exactly like exploitation.
The proof? Look at the endless graveyard of abandoned open-source projects. Powerful frameworks, once loved, now crumbling because their maintainers burned out trying to fund a project that a trillion-dollar company depends on — but won’t pay for.
We don’t have a funding problem. We have a leverage problem.
See, when you release your code under MIT or Apache, you give up your only piece of leverage. You can’t say no. You can’t even ask politely. You set the default to “take it.” And corporations will always optimize for what’s free and available.
That’s the tragedy of the commons. It’s not that people are evil. It’s that incentives win. And we built incentives that reward extracting value without giving anything back.
So what do we do? Beg nicer? Hold another conference? Write another passionate blog post?
No. We change the license.
I’m serious. The only way to stop the heist is to stop leaving the door open.
The most interesting take from a recent essay by a longtime maintainer: “Nobody pays for FOSS, we can force them to.” That’s the shift. Not asking. Not hoping. Forcing.
How? By making the default not “free forever” but “source-available with strings attached.” Not open enough to let a megacorp take it and walk away. But open enough to let a real community form, test, and trust it.
Some projects already do this. They use commercial licenses, dual licensing, or OpenRAIL-style restrictions that bar certain uses. They get called “not truly open source.” And you know what? That’s fine. The label matters less than the survival of the people writing the code.
Freedom that starves the author is just exploitation with better branding.
The pushback always comes fast. The FOSS zealots will tell you that any restriction betrays the philosophy. That money isn’t a goal. That community is enough.
Really? Then why are those same zealots posting “support me on Patreon” links? Why are the big projects run by foundations begging for donations while their code ships inside commercial products?
The philosophy isn’t wrong. But it’s incomplete. Absolute freedom for code is meaningless if the people who write it can’t pay rent.
The time for being nice is over. The time for strategic, structural change is now.
Start your project with the license you actually need — not the one that makes you look generous. If you’re already permissive, consider a relicensing path. And if you’re building on someone else’s code, respect the new rules when they come.
We gave away the farm and called it generosity. Let’s take it back.
Not by shrinking the openness. But by making sure the people who build the commons aren’t the last ones left holding nothing.
Because the corporations won’t volunteer to pay. They never do. We have to make it impossible for them not to.
FAQ
Q: Doesn't restricting open source licenses betray the whole point of FOSS?
A: Only if you define the point as 'corporations get free labor.' The actual point is building tools that people can use and trust. If the maintainer starves, the project dies, and nobody gets anything. A license that keeps the author alive is more 'open' than a dead repository.
Q: What's the practical first step for a developer who wants to make this change?
A: Don't start with MIT or Apache. Start with source-available, paid-for-commercial-use, or a delayed open-source license. If you already have a permissive project, you can't just change the license on existing versions, but you can change it going forward. The key is to make sure corporate use requires a contribution.
Q: Won't big tech just fork the project and ignore you?
A: They might.But that's already happening today—and today they don't even pretend to give back. A restrictive license creates a real negotiation. If a company forks your source-available code, they're openly violating the terms, which gives you legal and moral leverage. Right now, you have none.