Open source software will save humanity

Proprietary software operates on a simple premise: code is property, knowledge should be controlled, and the way to extract value from software is to restrict access to it. You build something useful, lock it down, and charge people for the privilege of using it. This model dominates commercial software development and seems natural to most people in the industry.

Open source rejects this entirely. It says software should be a commons, that code should be freely available to study and modify, and that collaboration produces better results than proprietary control. After spending years in proprietary code development and now trying to to open source projects, I'm convinced open source isn't just an alternative model. It's a superior one.

The practical benefits are undeniable

Start with the obvious: open source software runs the modern world. Linux powers the vast majority of servers, Android runs on billions of devices, and countless critical systems depend on open source components. The internet itself is built on open protocols and open source implementations.

This isn't accidental. Open source has concrete advantages over proprietary alternatives:

Security through transparency. When source code is public, vulnerabilities can be identified and fixed by anyone. The "many eyes make bugs shallow" principle actually works. Proprietary software relies on security through obscurity, hoping nobody discovers the flaws. Open source assumes flaws will be found and creates processes for addressing them.

Longevity and maintenance. Proprietary software dies when the company behind it loses interest or goes bankrupt. Open source projects can be forked and maintained by anyone who depends on them. You're not at the mercy of a vendor's roadmap or business decisions.

Customization and control. With access to source code, you can modify software to fit your needs exactly. No waiting for vendors to implement features. No working around arbitrary limitations. If you need it to do something different, you can make it do that.

Interoperability. Open standards and open implementations mean software can actually work together. Proprietary systems build walls around themselves to create lock-in. Open source projects build bridges because collaboration benefits everyone.

Cost. Yes, open source is often free to use. But the real cost savings come from not being locked into vendor pricing, not paying for features you don't need, and being able to fix problems yourself instead of waiting for support.

These aren't theoretical advantages. They're why most serious infrastructure runs on open source. When reliability and control matter, proprietary solutions consistently lose.

The development model works better

Beyond the practical benefits of using open source, the development model itself produces better software.

Proprietary development is constrained by the resources and perspective of a single organization. You have the developers the company hired, working on the priorities the company set, with the knowledge base the company has accumulated. Innovation is limited by organizational boundaries.

Open source development can draw on a global pool of contributors. Anyone who finds a bug can fix it. Anyone who needs a feature can implement it. Anyone with expertise can review code and suggest improvements. The project benefits from diverse perspectives and use cases.

This isn't just about getting free labor (though that certainly helps). It's about the quality of the development process. Open source projects with active communities get more thorough code review, more diverse testing, and more real-world feedback than most proprietary software ever receives.

Look at projects like Rust, PostgreSQL, or Linux. The quality of these codebases and the rigor of their development processes exceeds most proprietary alternatives. This isn't because open source developers are inherently better. It's because the open development model enables better practices.

Knowledge should be shared

Here's the fundamental philosophical point: software is knowledge, and knowledge becomes more valuable when shared, not when hoarded.

When you write code and keep it proprietary, you're preventing others from learning from your work, building on it, or improving it. You're artificially restricting the growth of collective knowledge for private benefit. This might make business sense in a capitalist framework, but it's fundamentally wasteful from a societal perspective.

Open source recognizes that software development is inherently collaborative and cumulative. Every program builds on decades of prior work: programming languages, libraries, algorithms, design patterns, and accumulated wisdom. Treating the final product as purely individual property ignores this collective foundation.

The argument for proprietary software is that people won't invest time developing software if they can't extract rent from controlling it. But open source demonstrates this is false. Developers contribute to open source for many reasons: solving problems they face, building reputation, learning from others, or simply because it's satisfying to create something useful that others can benefit from.

The existence of thriving open source ecosystems proves you don't need artificial scarcity and property rights to incentivize software development. What you need is developers who have reasons to write code, and those reasons can be as simple as "I need this tool to exist" or "I want to improve my skills."

Commons versus enclosure

There's a direct parallel to historical commons and enclosure movements. Shared grazing lands, forests, and fisheries were productive resources managed collectively by communities. Enclosure movements privatized these commons, concentrating benefits in fewer hands while dispossessing communities of shared resources.

Proprietary software is digital enclosure. Knowledge that could be a shared resource gets locked behind licenses and paywalls. Tools that could benefit everyone get restricted to paying customers. The collective productivity gain from shared software gets captured privately instead of distributed broadly.

Open source is the digital commons. It creates shared resources that everyone can benefit from and contribute to. The value isn't extracted and concentrated; it's distributed and multiplied.

The standard objection is that commons get depleted or degraded without property rights to manage them (the "tragedy of the commons"). But software doesn't deplete with use. Knowledge doesn't degrade when shared. The tragedy of the commons doesn't apply to non-rivalrous goods.

What we see instead is that well-maintained open source commons create enormous value. Projects like Linux or Python or Git have generated far more total value than any proprietary operating system, language, or version control system. That value is distributed broadly instead of captured by shareholders, which is exactly the point.

The corporate problem

The biggest threat to open source isn't lack of contributors or technical challenges. It's corporations attempting to capture and enclose the commons.

We see this pattern repeatedly. A company builds a business around open source software, then tries to restrict it once they have market power. They change licenses to prevent competitors from using the code. They develop proprietary extensions that fragment the ecosystem. They embrace, extend, and attempt to extinguish.

Sometimes this works (see: pretty much everything Google has touched). Sometimes the community successfully resists (see: the various MySQL/MariaDB, OpenOffice/LibreOffice, and Hudson/Jenkins forks). But the pressure is constant.

The solution isn't to abandon open source or accept corporate control. It's to use licenses that prevent enclosure. Copyleft licenses like GPL require that derivative works remain open. They prevent companies from taking open code, improving it, and then releasing proprietary versions. They keep the commons open.

Strong copyleft gets criticized for being "restrictive" or "anti-business." But that's the point. The goal is to prevent the enclosure of shared resources. If you want to build on the commons, you have to contribute back to it. That's not restriction; that's maintaining the commons.

Real freedom requires access

Proprietary software advocates talk about freedom: freedom to choose vendors, freedom to use software as you wish, freedom to innovate. But these freedoms are illusory when you don't control the software you depend on.

You're not free to fix bugs in proprietary software. You're not free to add features you need. You're not free to understand how it works. You're not free to ensure it isn't spying on you or manipulating you. You're not even free to keep using it if the vendor decides to discontinue it or change the terms.

Real freedom requires access to source code. It requires the ability to study, modify, and redistribute software. It requires knowing what the software you run is actually doing. Open source provides these freedoms. Proprietary software denies them.

This matters for individual autonomy, but it also matters for society. When critical infrastructure runs on proprietary software, we're dependent on vendors for basic functionality. When governments use proprietary systems, citizens can't verify what those systems do. When educational institutions teach with proprietary tools, students learn to be consumers rather than creators.

Open source means nobody controls your computing but you. That's not just practically valuable; it's politically essential.

Why I want to contribute

My decision to focus on open source contributions, particularly to projects like Astral's Rust tools, comes from recognizing that this is where meaningful work happens.

Proprietary development produces tools that enrich shareholders. Most of it is pointless: yet another SaaS product, yet another internal tool that will be abandoned in two years, yet another feature nobody asked for to justify a subscription increase.

Open source development produces tools that benefit everyone who uses them. The code I want to write for uv or ruff potentially helps thousands of developers. The improvements I make are improvements everyone gets. The knowledge I share becomes part of the commons.

This isn't altruism. It's recognizing where effort produces value. Contributing to a widely-used open source tool generates more total value than building proprietary software for a niche market, even if I personally capture less of it.

And practically, working in open source is better for learning and growth. I get code review from experienced developers. I see how large, well-designed codebases are structured. I learn best practices from communities that care about code quality. Proprietary development rarely provides this kind of learning environment.

It matters

Open source has proven itself. The question now is how to expand it and defend it against enclosure.

We need stronger copyleft adoption to prevent corporate capture. We need funding models that support maintainers without requiring privatization. We need cultural recognition that maintaining open source infrastructure is valuable work deserving support.

We need to push back against the narrative that proprietary development is normal and open source is a special case. It should be the reverse: shared knowledge should be the default, and artificial restrictions on knowledge should require justification.

We need education systems that teach with open source tools and teach students to contribute to them. We need governments to mandate open source for public infrastructure. We need resistance to software patents and other mechanisms that enclose the digital commons.

Most importantly, we need more developers to recognize that their skills and time are better spent building commons than building walls. Every proprietary codebase you work on is knowledge locked away. Every open source contribution is knowledge shared.

The choice isn't just about business models or licensing. It's about whether software serves private interests or collective benefit. Open source demonstrates that collective benefit is achievable and sustainable. The question is whether we'll defend and extend it or allow it to be enclosed and privatized.

I know which side I'm on.