Leaving the Cage Behind

Note: The analogy comparing ecosystem migration to
escaping a cage was sparked by a conversation with a good
friend, who deserves the credit for framing the issue this
way.

One of the most common objections raised when considering
a move to free software goes something like "I can't switch,
because my favorite program isn't available on GNU/Linux."
They perceive the inability to run a specific piece of
proprietary software as a technical deficiency of the free
system. They see it as a bug. This reaction misunderstands
the point of the transition: They're judging the free world
by its ability to replicate the prison walls they just
left.

The goal of switching to free software is to gain full
control over your computing, not to remain under the control
of a proprietary software developer. The aim is to break free
from that restrictive relationship entirely. When viewed this
way, the fact that proprietary software doesn't follow you
isn't a failure - it's evidence that the transition to
freedom is happening.

To understand why this reaction is a fallacy, we must
examine how they handle migration between different
proprietary systems. When we examine these scenarios, it
becomes immediately clear that the free software is being
held to a uniquely impossible standard - a double standard
that users would never apply to Apple, Microsoft, or
Nintendo.

People already accept this reality everywhere else. If
someone moves from macOS to Windows, they don't expect their
Apple-only tools to come along for the ride magically. Final
Cut Pro, Logic Pro, and Xcode aren't available outside
Apple's ecosystem. Likewise, moving from Windows to macOS
means leaving behind certain Microsoft-centric tools that
exist only within Microsoft's ecosystem. What is the user's
reaction to this discovery? Do they declare that Windows is a
"broken" operating system? Do they post angry tirades on
forums claiming that Microsoft is "not ready for the desktop"
because it failed to run an Apple binary? Nobody interprets
this as a moral failing on the part of the destination
platform. It's understood as a basic fact of switching
ecosystems. They do not blame the destination for the baggage
they left behind.

Yet when the destination is GNU/Linux, this same reality
is suddenly framed as evidence that free software is
"lacking," "immature," or "unusable."

This is the core of the double standard. Free software
isn't about copying proprietary operating systems at no cost.
It's about ending the abusive relationships with proprietary
software developers. Free software exists to free users from
those relationships, not to replicate them.

If your proprietary application ran unchanged on your new
system, that would mean you brought the cage with you. Losing
proprietary software isn't a loss of freedom - it's the
recovery of it. When people say, "I can't use my old software
anymore," what they're often experiencing is the discomfort
of losing familiarity, not the loss of capability.

That discomfort is real. But it's also transitional.

What you're actually shedding is:

• Forced upgrade cycles

• File formats designed to trap your data

• DRM, telemetry, and activation servers

• The threat that tomorrow's update removes yesterday's
functionality

These things were never neutral conveniences. They were
mechanisms of control. Free software removes them by
design.

None of this is about punishing users for liking familiar
tools, or pretending that migration costs don't exist. It's
about being honest about the tradeoff: Short-term convenience
versus long-term autonomy. Free software asks users to put in
effort now to regain control later - over their tools, their
data, and their freedom. This investment is essential for
long-term autonomy. It's not a flaw; it's the entire
point.

So the correct question isn't: "Why doesn't my proprietary
application run on GNU/Linux?" It's: "What tools exist in
this ecosystem that solve my problem without placing me back
under that abusive relationship?"

Once you ask that question, the conversation changes. You
stop measuring free software by how well it preserves
dependency and start evaluating it by how effectively it
restores freedom.

Escaping unethical control is rarely comfortable at first.
But if Apple, Microsoft, or any other proprietary vendor no
longer decides what you can run, how long it works, or
whether you're allowed to access your own data, then
something important has already been achieved. It's the sound
of the door closing behind you - and staying closed.

Copyright © 2026 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.