Linus Torvalds and the accidental kernel

Field note. Every game server we run is a Linux process. The kernel decides who gets CPU when fifty players join at once. Knowing where the kernel came from helps when you're tuning it.

In August 1991, a 21-year-old Finnish computer science student posted a message to a Usenet newsgroup:

Hello everybody out there using minix —

I'm doing a (free) operating system (just a hobby, won't be big and professional like gnu) for 386(486) AT clones.

The "free operating system" the student was building, almost as an afterthought to his university studies, became Linux. Within 15 years, it would run most of the world's servers. By 2026, in some form, it runs most of the computers ever made.

This is the story of how that happened, and why.

The setup: GNU and the missing kernel

By 1991, Richard Stallman's GNU Project had been working for eight years on a free UNIX clone. They had produced essential tools:

• GCC (GNU Compiler Collection).
• Emacs (the editor).
• Bash (the shell).
• GNU coreutils (ls, cat, etc.).
• Many other userland tools.

What they didn't have: a working kernel. GNU's own kernel project, the Hurd, was technically ambitious and slow. By 1991, after years of work, the Hurd wasn't usable.

The free-software movement had everything except the most important piece: the kernel that talks to hardware and runs everything else.

The kid in Helsinki

Linus Benedict Torvalds was born in Helsinki, Finland in 1969. By 1991 he was studying computer science at the University of Helsinki and using MINIX, a small UNIX-like teaching OS written by Andrew Tanenbaum.

MINIX was useful but Linus found it limiting. He had an Intel 386 PC at home and wanted to use its hardware capabilities (protected mode, multitasking) that MINIX couldn't access.

He started writing his own kernel. Initially just experiments: task switching, basic I/O. Over months, it grew into a small but functional system.

In August 1991 he announced it to the MINIX community as a hobby project. He posted source code under a custom license; in early 1992 he switched to the GNU General Public License (GPL), the same license GNU used. This was a critical decision. The GPL meant the code was free to use and modify, with the condition that derivatives also had to be GPL.

Combined with GNU's tools (the missing puzzle piece), Linus's kernel produced a complete free UNIX-like operating system: GNU/Linux, usually just called Linux.

Why Linux grew

Several factors made Linux succeed where the Hurd struggled:

Pragmatic design. The Hurd was technically pure (microkernel architecture). Linux was monolithic and "good enough." Less elegant but more practical.

Worked on common hardware. Linus targeted the 386 PC, the dominant home computer. The Hurd was less hardware-focused.

Available and improving. You could download Linux and use it. Slow at first, but improving rapidly.

The GPL plus internet collaboration. Anyone could download Linux, modify it, submit patches. The internet was already enabling distributed development.

Linus's leadership. Torvalds was a coordinator and benevolent dictator. He kept the project focused, integrated patches, made tough technical decisions.

Network effects. As more people used Linux, more drivers got written, more software got ported, the value compounded.

By 1994, Linux 1.0 was released. It was useful for real work. Linux distributions (Slackware in 1993, Debian in 1993, Red Hat in 1995) packaged the kernel with GNU tools and other software for easy installation.

The dot-com era and Linux's first wave

In the late 1990s, the dot-com boom drove demand for cheap, capable servers. Linux fit:

• Free (versus expensive UNIX vendors).
• Worked on commodity x86 hardware.
• Performed well.
• Open-source meant anyone could fix bugs or add features.

Companies started running Linux for web servers, mail servers, databases. Apache (web server) became dominant on Linux. The "LAMP stack" (Linux, Apache, MySQL, PHP/Perl/Python) was the default for early web applications.

By 2000, Linux was the dominant server OS for new internet companies. Commercial UNIX vendors (Sun, IBM, HP) felt the pressure. By the mid-2000s, even IBM was promoting Linux heavily.

Linus's coordination

Linus's role evolved as the project grew. Initially he was the only programmer. Then a few collaborators. By the late 1990s, hundreds. By 2010s, thousands.

His role: code review, merging, technical leadership, occasionally famously blunt feedback.

The Linux kernel development process is one of the most-studied open-source projects:

• Patches flow up through subsystem maintainers (network, filesystems, drivers).
• Subsystem maintainers send "pull requests" to Linus.
• Linus reviews and merges into the main tree.
• Periodic releases (every ~9-10 weeks) named after kernel version numbers.

The process is rigorous. Code quality is high. The result: a kernel that runs reliably on everything from supercomputers to embedded devices.

Torvalds creates Git

In 2005, Linux's main version-control system (BitKeeper) had a licensing dispute. The Linux community needed an alternative. Linus took a few weeks to write one himself.

That was Git. We have a dedicated article on it later in this series.

Briefly: Git became the dominant version-control system in software development. Most projects (open and closed source) use Git in 2026. Once again, Linus's pragmatic, focused engineering produced something the world adopted.

Linux everywhere

Linux's reach has been expanding for 30 years:

Servers. Most internet servers run Linux. Estimates: 70-90 percent of public-facing web servers.

Cloud. AWS, Azure, GCP all run Linux internally for most workloads. Most virtual machines launched on these platforms are Linux.

Android. Google's mobile OS uses the Linux kernel. ~70 percent of smartphones globally. About 3 billion active devices.

Embedded systems. Routers (most), smart TVs, cars, IoT devices. Linux is everywhere.

Supercomputers. All of the top 500 supercomputers worldwide run Linux.

ChromeOS. Google's lightweight desktop OS. Linux under the hood.

Steam Deck and game consoles. Some, including Valve's Steam Deck.

Specialized systems. Mars rovers (the Linux-based Curiosity, Perseverance), space telescopes, particle accelerators.

By any measure (total devices, total installations, total compute hours), Linux is the most-deployed operating system in history. Microsoft's Windows is on more desktops; Linux is on far more devices overall.

The open-source model

Linux is the most successful open-source project ever, by orders of magnitude. Its success demonstrated:

Distributed development works. Thousands of contributors across continents can build a coherent OS kernel.

Pragmatism beats purity. Linus's "good enough, ship it" philosophy beat the Hurd's perfection-seeking design.

Permissive coordination matters. Linus is firm but not micromanaging. Subsystem maintainers have real authority.

The GPL works. Companies that benefit from Linux contribute back (because the license requires it for derivatives). Major contributors include Intel, IBM, Google, Red Hat, Samsung.

Quality emerges from review. Patches face intense scrutiny. Many are rejected. The result is a high-quality codebase.

These lessons informed countless other projects. Open source went from niche to dominant in the 25 years after Linux's emergence.

The Linus controversies

Linus has been outspoken and occasionally inflammatory. His mailing-list posts have sometimes been crude or aggressive. In 2018, after a years-long pattern of criticism for this style, he stepped back briefly and a code of conduct was adopted for the kernel community.

His role since 2018 has been more measured. He still leads kernel development but with stricter community norms.

The Linus persona is part of Linux's culture: technically sharp, impatient with sloppiness, willing to call things bad. It worked for decades but had real costs (some contributors felt unwelcome). The reform was significant.

The ecosystem

Beyond the kernel, Linux has produced ecosystems:

Distributions. Debian, Ubuntu, Fedora, Red Hat Enterprise Linux, SUSE, Arch, many others. Each combines the kernel with curated software in different ways.

Package managers. dpkg/apt (Debian/Ubuntu), rpm/dnf (Red Hat/Fedora), pacman (Arch). Software-installation tools that made Linux manageable.

Containerization. Docker (2013), Kubernetes (2014) are Linux-native. The container revolution is a Linux phenomenon.

Embedded distros. OpenWrt for routers, Yocto for embedded products, AOSP (Android Open Source Project).

Cloud platforms. Tightly integrated with Linux.

The cumulative ecosystem is enormous. A modern infrastructure engineer might use Linux dozens of times daily, often without consciously thinking about it.

What Linux failed to do

Linux on the desktop. Despite 30 years of trying, Linux remains a minority desktop OS. Windows and macOS dominate. Even Linux enthusiasts often use Macs for their primary work.

Why? Application compatibility, hardware support (especially graphics drivers, historically), and the inertia of installed software. The Linux desktop is fine for users willing to invest, but never reached the easy-default status of Windows or macOS.

ChromeOS is the closest thing to "Linux desktop success," but it's Linux-the-kernel, not the desktop environment most Linux users mean.

This is the asterisk on Linux's universal dominance. Most of the world: yes. Desktops: not really.

A 21-year-old's hobby project

Looking back, it's striking how unlikely Linux's success was. Linus was an unknown student. He had no industry credentials. The project started as a hobby. The GNU Project had been working on a comparable goal for almost a decade with no working result.

Within 35 years, his "won't be big and professional" project ran most of the computers in the world.

The combination that made it possible:

• Existing GNU tools needed only a kernel.
• The 386 PC was a standard hardware target.
• The internet enabled distributed contribution.
• The GPL aligned incentives.
• Linus's pragmatic leadership.

Each piece mattered. Without any of them, Linux might have been a curiosity.

Conclusion

Linus Torvalds didn't set out to change computing. He wanted a better OS for his personal computer. The combination of his work, GNU's tools, the GPL, the internet, and decades of community effort produced the most-deployed operating system in history.

The implications go beyond Linux itself. Linux proved that open-source development could produce world-class systems. It enabled the cloud era. It powered the smartphone revolution. It provides infrastructure for almost every internet service.

When you use the internet, you're using Linux. Probably many times in any given interaction. This is the legacy of a 21-year-old's hobby project from Helsinki.

Coming up

Next: GNU and Stallman. The free-software movement that gave Linux its tools and its license. The complex story of the philosopher-programmer who insisted "free" had to mean "freedom," and the movement he built around that conviction.