If the name Linux makes you picture a black screen full of strange commands, that is fair. I used to imagine a few people in hoodies sitting in the dark and typing seventeen commands just to open a browser. Then I found out there was a more interesting story behind the terminal and the endless arguments about which distribution is best.
The story is about freedom. Not the kind that only sounds nice on a poster. It starts with a question. When a program is running on my computer, who should have the final say over it? Me, or the company that made it?
Free software has a clear answer. The device belongs to you, so you should be allowed to understand what its software does, change it, and share a copy. You may never do any of those things yourself, but the right should still be there.
Free as in freedom, not free snacks
The word free is doing two jobs in English. It can mean something costs nothing, or it can mean somebody has freedom. That is why Free Software sounds like a giant collection of apps that politely leave your bank card alone. A zero price is nice, but it is not the point.
Free software can be sold. People can charge for support, training, installation, customization, or development. What they cannot take away is the user’s freedom.
The idea is usually described with four freedoms. They are numbered from zero because programmers apparently cannot resist making ordinary counting slightly more exciting.
- You can run the program for any purpose.
- You can study how it works and change it for your needs.
- You can give other people a copy.
- You can share your changed version so other people benefit from it too.
Studying and changing a program obviously requires access to its source code. A compiled program is a bit like a ready made meal. You can eat it, but you cannot always tell what went into it. Source code is closer to the recipe. You still might not want to cook, but at least somebody can look at it and explain why the soup smells like wet socks.
I am not reading kernel code, so why should I care?
That is a completely reasonable question. Most users have neither the time nor the interest to read thousands of lines of code. Most programmers do not wake up and review a few kernel patches before making tea either.
Having a right is different from using that right every day. I may never open my car’s engine, but I do not want the hood welded shut so only the manufacturer can repair it. An independent mechanic helps me even if I cannot tell a crankshaft from a gearbox.
Free software works in a similar way. Maybe you will not change the code, but a developer, university, small company, or volunteer group can. If the original project shuts down, removes something important, or suddenly turns into a very enthusiastic data collection machine, everybody else is not completely stuck.
Open code does not magically remove every bug or suspicious decision. A public repository can still contain awful code and sit untouched for months. The difference is that the door is not permanently locked. Fixing a problem does not begin with asking the owner of the castle for permission to enter.
GNU started with a serious complaint
In the early 1980s, more software was becoming closed. Code that programmers once passed around was turning into something you could only receive as a finished product. You were not supposed to look inside or change it. Richard Stallman did not like where that was going, so he started the GNU project.
GNU had a very small and reasonable goal: build an entire operating system. Nothing ambitious there.
The name is a programmer joke. GNU stands for GNU’s Not Unix. GNU is not Unix, even though its design is similar to Unix. Yes, the name contains itself and the joke loops forever. Computer people had memes before we had a word for memes.
People working on GNU built compilers, shells, libraries, editors, command line tools, and many of the other pieces an operating system needs. Without those pieces, an operating system is less a useful room and more four empty walls with impressive wiring.
For Stallman, this was not only a clever way to build software. It was an ethical question. If software controls a big part of our lives, users should not be powerless in front of it. A program that cannot be studied, changed, or shared creates a very uneven relationship between its maker and its user.
So where does Linux enter the story?
This is where the names get mixed up. Linux is technically a kernel. The kernel is the part of an operating system that sits between programs and hardware and handles jobs such as memory, processors, storage, and devices. It is extremely important, but it is not the entire desktop you see on a laptop.
GNU had already built many parts of a free operating system, but its own kernel was not ready for ordinary use. Linus Torvalds created the Linux kernel, and that kernel was combined with GNU’s tools. The combination became the base of many distributions people use today.
That is why some people strongly prefer the name GNU/Linux. Their point is that the system is not only the Linux kernel, and GNU’s contribution should not vanish from the story. Other people say Linux is shorter and everybody understands it. Then the debate begins, the tea gets cold, and somebody mentions that they use Arch even though nobody asked.
The exact name matters, but understanding the relationship matters more. GNU brought the freedom focused project, licenses, and a large collection of tools. Linux brought a practical free kernel. Together they helped create a system that users can actually control on their own machines.
Copyleft means leaving the ladder in place
Making source code available is not always enough to preserve freedom. Somebody could take a free project, improve it, and put the new version behind a locked door again. Copyleft is one answer to that problem.
Copyleft uses copyright law to keep software free. Licenses such as the GPL let you use, change, and distribute a program. If you distribute a changed version, you have to give the next person the same freedoms. You can climb the ladder, but you cannot pull it up afterward and tell everybody else to figure something out.
This does not mean free software has no owner or rules. It still has copyright holders and a license. The license explains both your rights and your responsibilities. Copyleft just makes sure freedom does not stop with the first user in the chain.
Are free software and open source the same thing?
People use the two phrases interchangeably all the time, but they look at the subject from slightly different angles.
Open source usually emphasizes practical results. More people can inspect the code, collaboration gets easier, bugs have a better chance of being found, and a project can grow beyond one company. Those are real and useful benefits.
Free software takes one step back and asks what the relationship between a user and a program should be. Even if a closed program is fast, beautiful, and almost free of bugs, the user still depends on its maker for permission to understand or change it. From the free software point of view, that dependence is the main issue.
Freedom can still be messy
To be honest, free software does not always deliver a dream experience. Some projects have weak documentation. Some interfaces look as if they were last designed when monitors had enormous backs. Sometimes solving one problem requires three wiki pages, two ancient issue threads, and a comment from somebody with a dragon profile picture.
Freedom is not a promise that everything will be perfect. It means the path to changing an imperfect thing has not been permanently closed. You can report a problem, pay somebody to fix it, work on it yourself, or choose a different branch of the project.
Free projects also need people. Code on Git does not get up at night and fix its own bugs. Maintenance takes time, servers cost money, and developers also have electricity bills. A useful bug report, clearer documentation, a donation, or even a sincere thank you can all help.
If our entire understanding of free software is “great, I do not have to pay,” we have misplaced most of the philosophy somewhere under the sofa.
Why this still matters
Software no longer lives only inside a computer. It runs phones, cars, televisions, watches, routers, and household devices that used to have one honest on and off switch. When software is everywhere, control over software becomes part of control over everyday life.
Imagine a company ending support for a device that still works. Maybe it removes a feature with an update. Maybe it puts something you already bought behind a monthly subscription. If everything is closed, your choices quickly become accepting the change or buying another device.
Free software does not guarantee that somebody will rescue every abandoned project the next morning. It preserves the possibility. A community can fork a project, create an independent version, and continue in another direction. The important part is that all the power does not have to stay in one place.
It also changes trust. We do not have to blindly trust every unknown developer. Independent inspection is possible. The possibility of inspection is not the same as a completed audit, of course, but a window is still better than a concrete wall.
What I like about GNU and Linux
I do not like Linux only because it can be lightweight or because the terminal is powerful. Those things are nice, especially when the system does not decide to update in the middle of your work and then smile while saying please wait.
What I like more is the feeling of real ownership. I can choose how the system behaves. I can remove things I do not need. If a project heads in a strange direction, there is often another route. Behind many of these tools is a community that did not hide its knowledge and allowed the next person to continue where somebody else stopped.
There is no need to treat GNU or Linux as sacred. Both contain bugs, controversial decisions, disagreements, and real people. That is part of what makes the story good. The system did not fall out of the sky, and one company did not deliver it from behind closed doors. Thousands of people added pieces over many years.
For me, the philosophy comes down to one simple line. Tools should serve their users, not the other way around.
Maybe you will never open the source of a program you use. Maybe you only open the terminal when a tutorial says copy this command. That is fine. What matters is that if you ever decide to open the door, somebody else is not the only person holding the key.