Free Software: The Key to Freedom
Mon, 1 Dec 2025
The road to proprietary software is frequently paved with good intentions.
In the discourse surrounding software freedom, a recurring archetype has appeared of late. This figure is someone that purports to value transparency, collaboration, and the sharing of source code - traits often associated with the "open source" philosophy - yet the person perceives a specific social injustice or a "bad actor" (e.g., a large corporation, a military entity, or a regime) and seeks to weaponize software licensing to address their grievance.
A pertinent manifestation of this archetype can be found in proposals that seek to introduce mechanisms to restrict or exclude. The proponents of these measures argue that it's a moral failing to allow one's code to be used by entities that harm society. They ask, "Why should my labor support 'the bad guys'?"
While the desire to punish "the bad guys" is emotionally resonant, it rests on a fundamental misunderstanding regarding the nature of software freedom and the function of software. The free software movement doesn't exist to police its users' morality; it exists to liberate them from the unjust power of developers. When a developer imposes restrictions on who may use the software or for what purpose, regardless of their good intentions, they cease to be a liberator and become a regulator, re-establishing the very power dynamic (developer control over user) that free software aims to dismantle.
They fail to recognize that by introducing these restrictions, they're not protecting the community; they're fracturing it. They're creating a "litmus test" for participation that transforms a movement for universal liberty into a club for those who adhere to a specific, and often transient, set of political or social views.
To understand why proposals like this emerge, one must interrogate the linguistic and philosophical divergence between "Free Software" and "Open Source." The term "Open Source" was coined specifically to sanitize the concept of software freedom of its ethical imperative, marketing it instead on "consumer values" like reliability, low cost, and development speed.
The "Open Source" philosophy allows - and arguably encourages - the view that the license is a transactional tool. If the value proposition is "getting better code," then the license is merely a contract to ensure contribution. From this utilitarian perspective, if you're not getting contributions back, then adding a clause to "stop the bad guys" seems like a logical contract adjustment. However, free software isn't a transaction; it's a matter of right and wrong.
The numerous proposals to restrict and exclude treat the software as a something to be gated rather than shared. It reflects an appeal to practical values rather than standing on the difficult principle that freedom applies even to those we despise.
The Free Software Definition isn't a loose guideline; it's a precise articulation of the freedoms necessary for a user to control their own computing. These are:
- Freedom 0: The freedom to run the program as you wish, for any purpose.
- Freedom 1: The freedom to study how the program works and change it.
- Freedom 2: The freedom to redistribute copies.
- Freedom 3: The freedom to distribute copies of your modified versions.
Freedom 0 is the bedrock of user rights. It states unequivocally that the developer has no right to dictate how the user applies the tool. The history of this freedom is instructive: it was explicitly numbered "0" and added later to emphasize its foundational status, ensuring that no prior assumption of "proper use" could supersede the user's agency.
When proposals to restrict or exclude "the bad guys" are made they're directly pushing against Freedom 0, even if they don't realize it. The assertion is that their judgment of "bad" overrides the user's judgment. This is the definition of proprietary control. A program that says "You may use this for peace, but not for war," or "You may use this for charity, but not for profit," is non-free. It's "proprietary software with a cause."
They often argue that Freedom 0 is a technicality that stands in the way of justice. They posit that the harm caused by "the bad guy" (e.g., a megacorp using the software to pollute the environment) outweighs the damage from restricting the software. This is a utilitarian calculation that fails to account for the systemic nature of software freedom. If we allow the developer to veto the user's purpose, we establish a precedent that all software use is subject to the developer's approval.
Consider the implications of this precedent in other domains. If a book author could forbid "bad people" from reading their text, or from applying their text in ways they don't like, or if a road builder could forbid people they don't like from using the highway, or for using it for purposes they don't approve of, society would collapse into a series of checkpoints where private entities constantly audit one's moral standing. Software's the infrastructure of the digital age; treating it as a privilege rather than a right creates a digital feudalism where the "lords" (developers) dictate the behavior of the "serfs" (users).
The proposal to stop "the bad guys" immediately invites the question: Who defines the bad guy?
- Is it a corporation with a certain amount of profit?
- Is it a government agency?
- Is it an individual with a specific political affiliation?
If the definition is left to the developer, the license becomes a projection of the developer's personal politics. Getting everyone to agree on political matters is difficult and unlikely to succeed, so we'd be left with many different views and licenses.
This subjectivity creates legal and existential uncertainty. Today, our computers consist of thousands of programs. A user can't be "free" if their right to use the software depends on remaining in the good graces of the various moral codes of the developers behind the programs that make up a modern system, some of which might even conflict or be incompatible. Software's the infrastructure of the contemporary world. By politicizing it, we risk making it unreliable. If every developer enforces their own distinct moral code, it becomes impossible to build a functioning system. They're effectively arguing for a Denial-of-Service attack against the complexity of the modern free software ecosystem.
True freedom requires neutrality. Just as the printing press doesn't judge the content of the book or who wrote it, and the road doesn't judge the the driver, their destination or their purpose, Free Software musn't judge the purpose of the computation or who is doing it.
The proposals to restrict or exclude "the bad guys" operate from a place of frustration with the state of the world. This is understandable. The world is full of injustice. However, the Free Software movement posits that software unfreedom is itself an injustice, and we can't fix one injustice by perpetrating another. If you want to stop oil drilling or surveillance, organize politically. Replacing democratic laws (which, ideally, are decided by society) with the fiat of individual software developers leads to a feudal internet.
To those considering this path, don't let your hatred of "the bad guys" close your eyes to their rights as users. When you build a cage to trap someone, you inevitably trap your neighbors. The Free Software definition was written to prevent anyone - corporation, government, or individual - from having unjust power over the user. By adding "ethical" restrictions, you're claiming that unjust power for yourself. You're appointing yourself the judge, jury, and executioner of your users.
I urge you to reject this impulse. Embrace the radical, challenging, and necessary path of software freedom. Let the software run. Let the users decide. And let's fight "the bad guys" not by becoming tyrants ourselves, but by empowering the world with software that no tyrant can control.