Free Software: The Key to Freedom

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.

Copyright © 2025 Jason Self. Unless otherwise noted
material on this site is licensed under the GNU General Public
License as published by the Free Software Foundation, either
version 3 of the License, or (at your option) any later
version. A copy of the license is included at gpl-3.0.shtml. Please copy and
share.