Open-source doesn’t owe us anything. That probably sounds harsher than I mean it, so let’s be clear from the start: I’m not talking about money. Developers deserve to be paid if they want to be paid. Maintainers deserve support, and contributors deserve respect for the work they do. Anyone giving their time, skill, patience, and creativity to the tools we depend on shouldn’t be treated like invisible machinery that exists for our convenience.
That’s not the point here. The point is that open-source doesn’t owe anyone obedience; not shareholders, investors, quarterly growth targets, market pressure, reputation, return on investment, or a boardroom’s idea of whatever evils users should tolerate next. Because of this, the way is clear for open-source to be driven not by profit, but by principle.
Still Made by Human Beings
Does this always play out perfectly? Far from it, at least if we’re being honest. After all, software is made by human beings, and human beings have biases, intentions, motives, ideas, flaws, shortcomings, and limited perspectives. We’re brilliant experts at getting things wrong. But getting it wrong doesn’t mean the underlying principles behind the open-source software are broken. It simply means the framework itself doesn’t have the power, authority, or responsibility to make human beings better actors in their own play.
And that’s fine, because that was never the responsibility of the framework in the first place.
The Real Issue Is Obligation
Open-source is a tool and a means of implementing outcomes. It’s not the driving force behind them, but a framework, it has one serious advantage: it doesn’t rely on a system where only those with certain kinds of resources get the say and carry the sway. In fact, if anything, it flips the charge around.
Even when open-source contributors are paid, they’re often being paid to work toward the common public good, not the ultimate profit of a non-living entity (a company). This isn’t to say that for-profit companies are bad. Companies are just another form of human interaction and endeavour. Many for-profit companies are the chief architects and maintainers of some of the world’s biggest and most used open-source applications and frameworks.
So the real issue isn’t whether a company is driven by profit or not; the issue is obligation.
A person or company producing products solely for the sake of pleasing investors is beholden to those investors, whether we like it or not. As the saying goes, the borrower is the servant (indebted) to the lender.
But with open-source as an underlying framework, even when investment enters the picture, the conversation changes, because it doesn’t create debtors in that same sense. It has an outcome, and those who pour into the overall flow towards it. It facilitates exchange: ideas, investment, labour, time, code, and more. But it doesn’t enforce that exchange, demand it, or prevent others from continuing when that relationship sours somewhere along the line.
Tech Insight: The product isn’t the recipe
This is where open-source not owing us anything becomes a strength. It doesn’t have to be held back by our inability to pay for it, nor shut down services and lock the door because someone else’s priorities changed. We’ve seen what happens when companies shutter and suddenly a game, service, online platform, or other digital product vanishes with them. People who’ve invested money, loyalty, and countless hours into a thing can no longer continue, nor can they always get back what they had, used, or lost.
The same thing happens when a newer version of software, hardware, or a service replaces the older one.
Without an open framework, you usually can’t go back upstream and resume from where things stopped. The primary producer held the sway, and it owed you something in exchange for your investment, whether that investment was money, loyalty, time, or reliance. But the moment it decided to change direction, poof.
There goes the thing you depended on, and tough luck getting it back.
Even if you could get it back, you probably couldn’t improve on it even if you wanted to. With many products, what you receive is the end result, not the recipe. The component parts, whether literal or figurative, may be proprietary, lost to time, patented, or undocumented, and they were simply never yours for the taking in the first place. Slim chance of improving, recreating, or extending what you once relied on.
Not so with the open-source model. Since it doesn’t owe you anything in that same transactional sense, it doesn’t have an olibgation (or frankly a right) to restrict your access when its “obligations” end. It’s not protecting you from itself, nor protecting itself from you in quite the same way. Its obligations end the moment it exists under the terms that made it open in the first place.
Its only real “obligation” is to exist, and to abide by the license under which it was made available. That narrow obligation creates a wider freedom, and it’s only made possible by the fact that it owes us nothing.
Practical Tip: Know what you’re depending on
This week, consider an app you currently rely on and ask:
“If this disappeared tomorrow, what would I actually have left?”
- Could you still access and make real use of your files?
- Could you export your data to another format?
- Could someone else keep the tool alive?
- Could you move elsewhere without losing years of work?
This doesn’t mean every tool you use has to be open-source. Sometimes proprietary software is useful, practical, or simply the right fit. But if that software doesn’t guarantee your rights in the long term, it might be time to consider openness not just as a philosophy, but as a tool of long-term preservation.
Here’s what I’ve published recently:
ADMIN IT
- Building a Persistent Local AI Stack with Ollama and Open WebUI
A practical guide to setting up a persistent local AI stack with Ollama, Open WebUI, and Docker Compose, with models and app data kept safe across updates.
If you want to stay in this lane
I’ve written some related articles in this series that you might find interesting if you liked this one:
- Open Software is More Than a Philosophy - The Roll Out
A deeper look at why open-source matters beyond ideals, and how transparency, compatibility, and continuity make open software a form of technological resilience. - What happens when open-source takes itself seriously?
A look at how open-source is raising its standards through better usability, governance, infrastructure, packaging, and professional expectations. - Making “Open Standards” Meaningful - The Roll Out
A look at why openness needs to work in practice, not just in principle, especially when real users and real workflows are involved. - The Social Side of Software Trust - The Roll Out
A look at how software trust is shaped by perception, social pressure, and the stories people repeat about open-source tools.
Working with us
At RolandiXor Media Inc., we blend design and open-source thinking for our clients.
Elsewhere
- Mastodon: mastodon.social/@rolandixor
- Threads: @rolandixor
- X: @rolandixor
Support this work
If this writing has been useful and you’d like to help sustain it:
→ https://ko-fi.com/rolandixor
Catch you in the next Roll Out!
Comments