There are numbers you don’t comprehend — you only marvel at them.
The Android smartphone in your pocket runs on Linux. The server delivering this webpage runs on Linux. Your bank’s cash machines, the city’s traffic systems, your TV provider’s set-top box, the ISS orbiting overhead — Linux. Current estimates put the number of active Linux installations above four billion. No other operating system on Earth comes even close.
No proprietary product, no corporation, no marketing machine has ever achieved that. A collective of volunteers, on the other hand, did. Free of charge. Freely accessible. Without central authority.
How could that happen?
To understand, we have to go back. To 1991. To a bedroom in Helsinki.
The student and the kernel
Linus Torvalds was twenty-one years old, a computer science student at the University of Helsinki, and frustrated. His new 386 PC came with MS-DOS, an operating system that barely utilised the machine. Minix — a teaching kernel by Andrew Tanenbaum — was available, but deliberately limited: Tanenbaum wanted his students to study the code, not improve it. Linus wanted more.
On 25 August 1991 he wrote a message to the newsgroup comp.os.minix:
Hello everybody. I’m doing (just a hobby, won’t be big and professional) a free operating system for 386(486) AT clones. […] I’d like to know what people mostly like/dislike about minix. […] It is PORTABLE (with some changes).
Portable. That was the point where everything began. Not as a plan, but as an aside. A student casually mentioning that his hobby kernel is portable, and thirty years later it runs on rockets, pacemakers, and supercomputers.
The first version — Linux 0.01, September 1991 — had 10,239 lines of code. Today there are over thirty million. But the beginning was modest: a student, a PC, a newsgroup, an idea.
GNU — the other half of the story
But Linux did not emerge in a vacuum. There was already a movement, and it had a prophet.
Richard Stallman was at MIT in 1983 when he did something that seemed utterly bizarre at the time: he announced he would develop a complete operating system that would give every user the freedom to study, modify, and redistribute it. He called it GNU — recursively for “GNU’s Not Unix”.
Stallman’s philosophy was not technical but ethical. For him, software you were not allowed to study or change was an instrument of control. Freedom meant concrete capabilities: using the program for any purpose, understanding how it works, distributing copies, passing on improvements. Without these freedoms, you were in his eyes not free.
By 1991 the GNU movement had developed nearly an entire operating system — compiler (GCC), text editor (Emacs), shell (bash), core utilities, build systems. What was missing was the core: the kernel. GNU Hurd, the own kernel project, was stuck in architectural difficulties and not ready for use.
That is where Linux met GNU. Torvalds’ kernel filled the gap GNU had been unable to close for eight years. The combination of GNU tools and the Linux kernel produced the first complete, free operating system: GNU/Linux.
That is why the distinction matters. When we say “Linux” today, we usually mean the whole system — kernel, userspace, distribution, ecosystem. Strictly speaking, Linux is only the kernel. What most users actually use — the shell, the tools, the compiler — comes substantially from the GNU project. Stallman emphasised this distinction throughout his life, often uncomfortably, often pedantically, but factually correctly.
Without GNU, Linux could never have become an operating system. Without Linux, GNU would have remained incomplete to this day. The story of Linux is inseparable from the story of two projects that together became greater than their parts.
Growth — and why open source was the key
Linux grew because it was open. Anyone could see the code, improve it, pass it on. Every university, every research institute, every interested tinkerer could contribute. There was no licence fee, no contract, no access control. If you felt like it, you downloaded the source code and got going.
In 1992 Linus released Linux under the GNU General Public License (GPL) — a licence ensuring all derivatives remain free as well. This decision was pivotal. Had he placed Linux under a proprietary licence, it would likely have sunk into obscurity. The GPL guaranteed that every contribution, every improvement, every patch benefited everyone — while simultaneously preventing anyone from privatising and enclosing the code.
This principle — copyleft — created an ecosystem where collaboration was rational. Companies using Linux could contribute improvements without fearing a competitor would shut them out. Individuals submitting patches knew their work would not vanish. The licence structured incentives so that cooperation became the dominant strategy.
And it worked. By the mid-nineties Linux ran at universities worldwide. By the end of the decade it ran in first companies. In 1998 the Gartner Group published a study calling Linux “practical.” In 2000 IBM announced it would invest one billion dollars in Linux. The world had noticed the dinosaur — and the dinosaur was no dinosaur, but a hummingbird faster than anything that preceded it.
The server conquers the world
Where Linux first dominated was not the desktop. It was the server.
Apache, the dominant web server software, ran most naturally on Linux. MySQL and PostgreSQL stored the data. PHP, Perl, Python generated the pages. The LAMP stack — Linux, Apache, MySQL, PHP/Perl/Python — became the engine of the early web. Yahoo, Amazon, Google — all built on Linux. Not out of idealism, but because it was better. Faster, cheaper, more adaptable, and with one quality no proprietary system offered: transparency.
Whoever administered a Linux server could trace every process, read every configuration, track every problem back to its source. With Windows NT you relied on black-box diagnostics. With Linux you could read the code. In a world where uptime decided profit or loss, that was not luxury. It was survival.
Today the majority of all servers worldwide run Linux. The largest cloud platforms — AWS, Google Cloud, Azure — are built on Linux. All 500 fastest supercomputers in the world run Linux. Since 2017. All of them. Not one. All.
The desktop — a history of mockery and breakthrough
On the server, Linux was successful. On the desktop, it was a punchline.
“The year of the Linux desktop” became a running gag, older than some distributions. Predicted every year since the late nineties, never arrived. And honestly: for a long time the mockery was deserved.
The desktop environments were fragmented. KDE and GNOME argued over design philosophies. XFree86, the graphics server, was sluggish, buggy, and notoriously difficult to configure. Getting a printer working under Linux in 2001 meant spending weekend days with configuration files that looked like cryptograms. Audio? ALSA, OSS, aRts, ESD — four competing sound systems blocking each other. Wi-Fi sticks needed NDISwrapper, a wrapper loading Windows drivers under Linux — when it worked. Which it usually did not.
It was a time when Linux on the desktop was a project for people who treated problems as a hobby. For normal users it was an imposition.
But the community did not give up. Bit by bit the construction sites were repaired. XFree86 was replaced by X.Org. PulseAudio unified audio. systemd brought (controversial but effective) order to the boot process. Wayland modernised graphics output. PipeWire superseded PulseAudio and finally made audio trouble-free. Flatpak and Snap brought sandboxed applications. Distributions like Ubuntu, Fedora, and Linux Mint delivered finished desktops that worked — not perfectly, but finished.
Today the Linux desktop is at a point where it no longer needs apologising. GNOME and KDE are fully grown desktop environments. Hardware is detected out of the box. Steam Deck proved Linux is a viable gaming platform. Desktop market share grows — not explosively, but steadily. And in 2026, amid the Windows 12 hardware crisis, more and more people are discovering that Linux is an option that works.
Strengths — and why they astound
Linux is not just an operating system. It is a phenomenon. Its strengths are so varied they can hardly be captured in a list.
Scalability. Linux runs on watches, routers, smartphones, tablets, laptops, desktops, servers, mainframes, and supercomputers. The same codebase, adapted through configuration, not rewriting. No other operating system spans this range.
Longevity. Linux supports hardware a decade old without complaint. While Windows 12 declares fully functional PCs obsolete, Linux runs on them effortlessly. That saves money, reduces e-waste, and extends investment cycles.
Security. Linux is not immune to vulnerabilities. But its architecture — strict separation of user privileges, signed package management, rapid patch culture, open auditability — makes it structurally more resilient than systems attempting security through secrecy.
Transparency. Anyone can read the code. Anyone can hunt for vulnerabilities. Anyone can trace what their system does. There are no backdoors nobody controls — because anyone can check.
Speed. Linux boots in seconds. It idles with minimal resource consumption. It squeezes more performance from the same hardware than most alternatives.
Diversity. Hundreds of distributions, dozens of desktop environments, thousands of packages. Linux is not a monolith — it is a spectrum. Who wants a minimalist window manager can have one. Who wants a full desktop environment can have one. The choice belongs to the user.
Cost. Linux costs nothing. No licence fees, no subscription traps, no artificial editions. That is not the most important argument — but it is true.
Community. Behind Linux stands no single company. A worldwide community of developers, administrators, security researchers, and users. When a problem is discovered, hundreds work on it — openly, traceably, documented.
Weaknesses — honestly assessed
But Linux is not perfect. Claiming otherwise harms the cause.
Specialised hardware. Professional audio interfaces, certain MIDI controllers, highly specific industrial equipment — Linux can struggle here. Not because the kernel is poor, but because manufacturers often supply no Linux drivers and release no specifications allowing the community to write them.
Games with anti-cheat. Titles with kernel-level anti-cheat systems often do not work. Manufacturers do not support Linux, and Wine/Proton cannot fully replicate kernel-level mechanisms. It improves — Valve pushes massively — but it is not universally solved.
Proprietary standard software. Adobe Creative Suite, Microsoft Office, various CAD programs — unavailable natively for Linux. If dependent on these tools, you resort to virtualisation, Wine, or alternatives. LibreOffice is good, but it is not Microsoft Office. GIMP is powerful, but it is not Photoshop.
Fragmentation. The diversity of distributions is a strength — and a weakness. Software packaged for Ubuntu does not necessarily run on Arch. Package formats (deb, rpm, Flatpak, Snap, AppImage) compete. For developers distributing software for Linux, this is a burden. For users needing support, it can be irritating when every distribution has its own configuration.
The learning curve. Linux has become more accessible — but going deeper, sooner or later you hit the terminal. The curve flattens, but it exists. Willing to learn, you gain control no proprietary system offers. Unwilling, you eventually hit a wall.
BSD — the cousin who lives differently
There is another free operating system often mentioned alongside Linux: BSD — the Berkeley Software Distribution.
BSD’s story begins even earlier than Linux’s. In the late seventies the University of California, Berkeley developed enhancements for AT&T’s Unix. From these emerged an independent system, released in 1993 — after legal disputes with AT&T — as free software: FreeBSD, NetBSD, OpenBSD.
Technically BSD and Linux are related. Both are Unix-like. Both are open source. But they differ fundamentally in structure and culture.
Development. With the Linux kernel, kernel and userspace develop separately. Distributions (Ubuntu, Debian, Fedora) assemble kernel, GNU tools, and their own software into a complete package. With BSD, the entire system — kernel, userspace, base utilities — is developed as a unit. That makes BSD more consistent but less modular.
Licence. Linux uses the GPL — copyleft, infectious. BSD uses the BSD licence — permissive. Take BSD code, use it proprietarily, no disclosure required. Consequences: parts of macOS (the Darwin kernel, the networking stack) derive from FreeBSD. PlayStation OS uses BSD components. Netflix’s CDN runs on FreeBSD. BSD code is everywhere — but often invisibly, because the licence forces no disclosure.
Culture. The Linux community is large, loud, diverse, sometimes chaotic. The BSD community is smaller, more focused, more traditional. BSD people tend to write code slower but more carefully. Linux people tend to ship faster and fix later. Both approaches have merit.
Market penetration. Linux dominates the server market. BSD holds niches — firewalls (pfSense), storage (FreeNAS/ZFS), embedded (Netflix CDN) — but nothing comparable in breadth. Setting up a server today, you typically choose Linux. Choosing BSD, you choose for specific reasons: ZFS integration, pf firewall, security focus (OpenBSD), or simply preference for the coherence of a complete system.
Both are legitimate paths. Both are free. But they illustrate how different licences and cultures produce different ecosystems.
The lifestyle dimension — freedom as a guiding principle
Linux is more than an operating system. For many people it became a guiding principle.
Choosing free software means adopting an attitude: that knowledge should be open, that tools should belong to those who use them, that collaboration is stronger than control. That is not romantic glorification — it is a practical ethic expressed in daily decisions.
People who use Linux tend to demand sovereignty over their infrastructure. They want to know what their devices do. They want to decide when to update. They do not want to be surveilled. They do not want their hardware rendered useless by planned obsolescence. They do not want dependence on a single vendor.
From this attitude grew a movement reaching far beyond Linux: self-hosting, open source hardware, right-to-repair, privacy as a fundamental right, digital sovereignty as a political goal. All these themes share a root — the idea that people using technology should have the right to understand and control it.
Linux was proof that this idea works. Not in theory, but in practice. Four billion installations. Billions in economic value. The infrastructure of the modern world. Built by people who believed freedom beats control.
A personal story — 2001, SuSE 6.4, and the beginning of a journey
I have to get personal here.
In 2001 I bought a box. An actual box, from a shop, with a manual, CDs, and a sticker. SuSE Linux 6.4 — not OpenSUSE, which did not exist yet. SuSE, capital S, at the time still an independent German company, before Novell acquired it and later passed it to Micro Focus.
I was young, curious, and had no idea what I was getting into.
Installation was an adventure. YaST, the installer, worked — mostly. But hardware detection was rudimentary. My graphics card was detected, but resolution was wrong. My monitor was not detected, so I had to hand-write modeline entries — cryptic strings describing horizontal and vertical frequencies, where a typo could damage the monitor. Yes, back then a wrong modeline could destroy a monitor.
XFree86 was the graphics server. Anyone annoyed by Wayland or X.Org today should have met XFree86. It was slow, buggy, and configuration was a blend of science and witchcraft. The XF86Config file was so complex that entire websites existed solely to explain it. Hours I spent configuring my mouse. Hours. For a mouse.
Audio? No better. ALSA existed, but was complicated. OSS was simpler, but more limited. aRts (the KDE sound server) and ESD (the GNOME sound server) fought over the sound card, and when both ran, you got either silence or noise. Rarely what you wanted to hear.
Wi-Fi? A dream. My Wi-Fi stick was not detected. NDISwrapper was the hope — a tool loading Windows drivers under Linux. Sometimes it worked. Mostly not. When it worked, it broke on the next kernel update. When it did not, you spent days in forums where people with the same problem discussed without a solution.
Printing? CUPS existed, but my printer was unsupported. Scanning? SANE existed, but not for my scanner. Modem? Let’s not.
It was frustrating. Time-consuming. Sometimes demoralising. Week after week I battled through configuration files, forum posts, outdated howtos, and IRC channels where some people were helpful and others dismissed you as a beginner not worthy of help.
But — and this is the point — it was also incredibly fascinating.
Every problem I solved taught me something about the system. Every configuration file I understood opened a door. Every time something worked — the mouse, the sound, the Wi-Fi, the printer — it was not just success. It was victory. I had understood the system. I had controlled it. I had made it work, not because a manufacturer had configured it for me, but because I had done it myself.
That taste of control — the feeling of truly understanding your own machine — was addictive. Not pathologically, but in the best way: you wanted more. More understanding, more control, more learning.
The obstacles were not pleasant. But they were educational. Every hour with XFree86 taught me how graphics output works. Every hour with ALSA taught me how audio systems think. Every hour with NDISwrapper taught me how drivers work — and why proprietary drivers are a problem. The struggle was the education. And the education was free, stubborn, and irreversible.
I fought my way through. Not because I was particularly intelligent, but because I was stubborn. And because the reward — control, understanding, freedom — was worth the effort.
From this journey grew something that shapes my professional life to this day. Not just the technical knowledge — but the conviction that free software is not merely a technological choice, but a principled one. That people should have the right to understand the tools they use. That transparency beats secrecy. That collaboration is stronger than control. That infrastructure you understand can be defended — and infrastructure you merely operate cannot.
That is perhaps the most important principle in modern IT. Not cloud. Not Kubernetes. Not AI. But the simple idea that people using technology deserve the right to understand it. Linux was proof that this idea works. And in 2001, in a bedroom with a SuSE 6.4 box and a monitor you could destroy with a wrong modeline, my journey with it began.
Why Linux may be the most important open source project ever
There are thousands of important open source projects. GCC. Emacs. Apache. PostgreSQL. Python. Git. Each changed the world. But Linux is different.
Linux is not just a program. It is the foundation on which the other programs run. It is the ground beneath everything. If Linux disappeared, the digital world would collapse. No servers, no cloud, no smartphones, no supercomputers, no internet infrastructure. One blow, and everything stops.
No other open source project has this systemic significance. No other is woven so deeply into the functioning of modern civilisation. Linux is not a building block of the digital world — it is the ground the blocks stand on.
And it is free. Not just gratis. Free in the sense of liberty. Anyone can study it, improve it, pass it on. Anyone can adapt it to their needs. Anyone can understand it. That is not just a technical advantage — it is a political one. In a world where infrastructure is increasingly wielded as an instrument of power, a free foundation is the strongest guarantee of independence there is.
Linux proved that a collective of volunteers, an open licence, and a simple idea — that code belonging to everyone is better than code belonging to one — can change the world. Not through marketing, not through lobbying, not through market dominance. Through sheer, demonstrable, decades-long superiority.
That is the story of Linux. The story of an idea that reshaped the world. And which, told properly, still astounds.
If you wonder whether Linux is the right choice for your use case — servers, desktops, embedded, infrastructure: write to contact@libcom.de. We take an honest inventory. Without sales pressure. With a view to what lasts long-term.