40 Years of Freedom

Sat, 4 Oct 2025

Today marks a milestone in the history of computing and the rights of all software users: the 40th anniversary of the Free Software Foundation (FSF). This 40th anniversary is a celebration of a global movement to promote computer user freedom.

This article traces the history of the essential software freedoms, from the initial spark to the four freedoms the FSF defends today.

Today, software is ubiquitous. It runs in the phone in your pocket, the car you drive, the television you watch, and even in life-sustaining medical devices. In a world so deeply intertwined with software, the question of who is in control of it becomes deeply fundamental.

The central argument has always been that proprietary software is fundamentally a social and ethical problem. It creates an unjust power dynamic, where the developer controls the user by keeping the software's inner workings secret and restricting what users can do with it. You, the user, must be the one who decides what the software in your life is doing.

To understand why free software is necessary, let's travel back to the late 1970s and early 1980s. The world of computing was changing. The early, collaborative "hacker" culture, where programmers freely shared their programs, was disappearing - in its place: proprietary software. People were legally prohibited from sharing. The spirit of community and cooperation was being replaced by control.

A single, powerful anecdote perfectly captures this shift. At MIT's Artificial Intelligence Lab, a programmer named Richard Stallman grew frustrated with the new Xerox laser printer. The printer frequently jammed. Stallman wanted to modify the code to automatically notify users on the network about the jam, saving everyone time and frustration. The problem? He wasn't allowed to. The source code was a secret.

He discovered that a programmer at another university had the code, but that programmer was bound by an NDA and refused to share it. This wasn't just an inconvenience; it was an ethical crisis in miniature. A simple, practical problem - fixing a jammed printer - had become impossible, not for technical reasons, but because of a barrier designed to deny users control over the software they used. It was this moment of profound frustration that illustrated the core injustice of proprietary software and ignited the spark for the free software movement.

Fueled by this, Richard Stallman didn't just complain: In 1983, he announced the GNU Project, a plan to create an entire operating system composed exclusively of free software. The name itself was a declaration of its purpose: GNU, a recursive acronym for "GNU's Not Unix," signaled that it would be a Unix-like system but built on the principles of freedom and community, not restriction and subjugation. Two years later, in 1985, he founded the Free Software Foundation (FSF) to provide the legal, organizational, and financial backbone.

This was the direct, ethical response to the creeping control of proprietary software. The goal was to build a complete digital world where users could live in freedom. By creating a completely free operating system, the GNU Project offered an escape route - a way for anyone, anywhere, to use a computer without surrendering their rights.

To restore control to the user, the early free software movement established two clear, powerful principles. The 1986 GNU Bulletin Volume 1 No. 1 laid them out for the first time:

"First, the freedom to copy a program and redistribute it to your neighbors..." This was the principle of community. It affirmed that sharing is a good thing and that software licenses should never force you to choose between being a good neighbor and obeying the law.
"Second, the freedom to change a program, so that you can control it instead of it controlling you..." This was the principle of user control. It demanded that the source code - the human-readable blueprint of the software - be available so you could understand, fix, or adapt the program to your own needs.

These two foundational ideas, community and control, were the bedrock of the movement. They were the first definitive statement that users deserved to be in control of the software, not the other way around.

As the GNU Project grew and the free software ecosystem matured, the definition evolved to capture a crucial aspect of the movement better. The GNU Bulletin, vol. 1, no. 21, from July 1996, formalized this next step by articulating three specific freedoms. While the original two principles covered sharing and modification, this new definition explicitly separated them to create a distinct third freedom: "the freedom to distribute a modified version and thus help build the community."

This was a clarification that highlighted that the ability to share your changes is just as critical as the ability to make them in the first place. While being able to modify the software yourself gives you control over your local copy, this principle ensures that when a user changes a program, the entire community can benefit. It guarantees that free software develops organically, under the collective control of its users.

In early 1999, one final, crucial clarification was added, with the definition expanded to the four freedoms we know today and the first time that the freedoms were numbered, starting with zero. A new freedom was explicitly added at the beginning. This was Freedom 0: The freedom to run the program, for any purpose.

At first glance, this might seem obvious. Why would you have a program you couldn't run? Richard Stallman recalls adding this freedom after a discussion with a lawyer made it clear that the other three freedoms didn't automatically guarantee the right to run the software.

This addition addresses the most basic requirement for using a computer. At its core, computing is running programs. If you're not able to run software for the purposes you need, for the jobs you need, then at a fundamental level, you can't have control of your computing. Freedom 0 establishes that you must have this control, and prevents licenses that might say "for non-commercial use only," or "not for use by this organization," or "cannot be used to criticize the developer." Freedom 0 establishes an unconditional right to use the program, for any purpose, even if that's something the original developer never thought of or would disapprove of. It's the basic beginning to be able to use a computer at all.

If you think about it, it's these specific four freedoms, and not different ones, that are the concrete necessities for anyone who wants to be in control of their computing. If you can only run a program but can't study or modify it, you're limited to doing - or not doing - whatever the developer decided you could do. If you can't use the software for any purpose you want, if you can't change it so that it does (or doesn't do) what you wish, then who is that device taking its orders from? Certainly not you. At that point, your computer begins acting as an agent for someone else, enforcing their rules and agendas - not yours. Unless you control the software, the software will control you.

This is happening right now. Consider these real-world examples:

Your Hardware, Their Rules: Some laptops will refuse to boot if you replace the WiFi card with a model not on the manufacturer's approved list. You bought the computer, but they decide what parts you're "allowed" to use with it. Imagine the kinds of control that become possible when the manufacturer can decide what you're "allowed" to plug into your computer.
Invisible Surveillance: Certain color printers print nearly invisible tracking dots on every page, encoding the printer's serial number and the date and time of the printout - a surveillance feature you can't disable.
Books That Vanish: An online bookseller famously reached into users' e-readers and remotely deleted copies of books they had already purchased.

These aren't bugs; they're features designed to exert control. The four freedoms are the complete antidote to this injustice. They guarantee that you can remove anti-features, fix bugs, and study what a program is doing. They ensure that you can use your computers for your purposes, not someone else's. In short, they make sure that your computer takes its orders from you, and only you.

While the free software movement established the four freedoms to defend against proprietary software, a new, more insidious threat to user freedom emerged from the vague and distracting buzzword of "cloud computing." This threat is Service as a Software Substitute, or SaaSS.

SaaSS means using a service on someone else's server to do your computing. Think of using a website that translates text for you. While convenient, this practice represents an even more profound loss of control than traditional proprietary software.

With proprietary software, you typically get an executable file on your machine, with no source code. It's a black box, but perhaps there's an opportunity for reverse engineering to make a free replacement program. With SaaSS, you don't even have that. The software runs on a server you can't see or touch. It's therefore impossible for you to study what it does, and impossible to change it. You have completely ceded control of the computing task to the total power of the server operator.

The dangers of SaaSS aren't theoretical; they're inherent in its very existence. There's no need to build spyware in; It operates like that by design because you send your data to the server operator yourself. The server operator can also change the software running on their server at any time, for any reason, without your knowledge or consent. This gives them the power to silently impose changes on how your computing gets done, a power even more absolute than that of a proprietary software developer. It fundamentally wrests control from the user, making it a practice we must reject for our freedom's sake.

Looking back over the past four decades, the achievements of the free software movement are nothing short of remarkable. From the initial vision of a completely free operating system, the GNU Project has blossomed into the GNU/Linux system, empowering millions worldwide to reclaim control over their computing. Thousands upon thousands of free software applications now exist, covering many areas. This success is built upon the foundational philosophical infrastructure created and championed by the Free Software Foundation.

The journey from the initial two freedoms in the first GNU Bulletin to the four freedoms we know and defend today is a testament to the movement's enduring adaptability and unwavering commitment to the rights of the users. The challenges may evolve, from the original struggle with a jammed Xerox printer to the dangers of SaaSS, but the core principle remains as vital as ever.

The goal of software freedom for all users is a future we can all actively build. I invite you to join in this ongoing mission:

Embrace Freedom: Take the empowering step to use free software. Install an entirely free GNU/Linux distribution and discover the world of applications that respect your rights.
Become a Steward: Get involved in the vibrant free software community. Contribute your skills to existing projects, whether it's through coding, testing, documentation, translation, or simply offering support. Consider joining a local LibrePlanet group to connect with fellow freedom advocates.
Support the Foundation: Reinforce the crucial work of the Free Software Foundation. Your support enables the FSF to continue defending our freedoms, developing essential infrastructure, and advocating for a future where all technology empowers its users.

Let's carry the spirit and the principles of the past 40 years forward with renewed vigor. Together, we can ensure a future where software serves the users, where the four freedoms are a reality for everyone, and where each individual has genuine control over their computing. The fight for freedom continues, and the future is free.