The Linux kernel: 35 years of the heart that dominates the tech world
35 years and a few days have passed since that 25 August 1991, when a 21-year-old Finnish student named Linus Torvalds posted a message, now famous, on the Usenet forum comp.os.minix: "Hello everyone 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."
Nothing in that text, written in haste by an amateur, anticipated what was to come. Three and a half decades later, the Linux kernel, as it is now known, runs 100% of the planet's supercomputers, close to 70% of the world's mobile phones through Android, most of the public cloud and the Internet, and has even flown over Mars.
What began in a bedroom in Helsinki has become today the most widely deployed software in history. One that now, in September 2026, with version 7.2 just released and more than 40 million lines of code, remains the foundation on which modern technology rests.
The heart of GNU/Linux systems
Before the history, it is worth clarifying the protagonist. A kernel is the deepest layer of an operating system: the software that manages the CPU, memory, disks, networks and peripherals, and that allocates those resources among the programs the user runs. Windows has its kernel, macOS has its own (based on BSD), and Linux has the kernel Torvalds created.
What matters is that "Linux", as the complete system is popularly called, is strictly speaking the combination of two pieces of free software: the Linux kernel and the tools of the GNU project, started by Richard Stallman in 1983 to create a free alternative to Unix.
The GNU kernel, called Hurd, never matured; in fact, it is still in development, which is why Linux took its place. Hence purists insist on calling it "GNU/Linux", clarifying that GNU is the user interaction system (userspace) and Linux is the kernel (kernelspace).
Purism aside, Linux is a huge ecosystem today. The Linux Foundation, responsible for protecting the kernel's development, now puts the size of the core at around 40 million lines, of which some 30 million are real code, the rest being comments, whitespace and auxiliary files. 40 million lines written over 35 years of development, and that is only the beginning of this important piece of technology.
The story that gave birth to Linux is quite surprising. Torvalds was studying Computer Science at the University of Helsinki when, in 1991, he bought a PC with an Intel 80386 processor and grew frustrated with MINIX, Andrew Tanenbaum's educational system, since it did not allow modifications. He wanted a "free" operating system, in the sense of modifiable, that would take advantage of his new machine's features. So on 25 August he wrote his famous announcement on comp.os.minix, which is preserved in full in archives such as landley.net.
Torvalds' announcement of the development of the Linux kernel
The first code, version 0.01, was published on 17 September 1991, on the FTP server of the Finnish academic network FUNET. It was 10,239 lines of code, not even executable on their own: they needed MINIX to be compiled and tested. The first "official" version, 0.02, arrived on 5 October. In December, 0.11 was already self-contained: the system could compile itself while running on Linux.
The response was immediate. MINIX programmers and the nascent GNU community began sending code, and by 1993 more than a hundred developers were already working on the project. That same year the first distributions that still exist were born: Slackware and Debian. In 1994, Red Hat and SUSE were founded as companies around the system. Thus began commercial development around Linux.
The decision that changed everything: the GPL license
But amid all this avalanche, perhaps the most important decision in Linux's entire history was not technical, but a legal one. Torvalds published the first versions under his own license that prohibited commercial redistribution, even to cover costs. That made a sustainable business around the code impossible.
But in early 1992 he changed his mind and adopted the GNU General Public License version 2 (GPLv2), announced in the release notes for version 0.12 and effective from 1 February 1992; 0.95, published in March, was the first version under that license.
The GPL guaranteed that anyone could use, modify and redistribute the code, with one key condition: modifications had to be published under the same license. That "contagion" protected the project from a company privatizing it, while allowing companies to build businesses on top. Torvalds summed it up years later: "making Linux GPL'd was definitely the best thing I ever did".
The kernel remains GPL-2.0-only. In 2007 Torvalds rejected migrating to GPLv3 because of its "anti-tivoization" clause, which would require accepting modified software on any device with the code. Moreover, relicensing the kernel is practically almost impossible because copyright is spread among thousands of contributors without a centralized assignment agreement.
The debate with Tanenbaum
A few months after the announcement, Andrew Tanenbaum himself published on 29 January 1992 a message titled "LINUX is obsolete". He argued two things: that monolithic kernels (where drivers and file systems live in a single privileged space) were a 1970s design, while microkernels represented the future; and that Linux, tied to the Intel 386 processor, would never travel to other architectures. It was a direct attack on Linus Torvalds and his creation.
But history proved Torvalds right on both premises. First, portability was demonstrated with facts. Version 1.2 of March 1995 added support for Alpha, SPARC and MIPS, and since then Linux has been ported to dozens of architectures, from ARM to IBM z/Architecture mainframes. The monolithic design turned out to be pragmatic and efficient, and was nuanced with loadable modules.
By comparison, today no pure microkernel has Linux's adoption. Tanenbaum and his vision were wrong; the Linux kernel, monolithic as it is, swept everything before it.
And that history of successes can be summed up in a timeline of verifiable milestones, based on the official history of kernel.org and on the documentation of Linux history:
1991: Announcement (25 August) and first versions 0.01 (17 September) and 0.02 (5 October).
1992: Adoption of GPLv2 (February); the debate with Tanenbaum; version 0.96 (May) runs the X Window System graphical environment for the first time.
1994: Linux 1.0 (14 March), with some 176,250 lines, already considered production-ready.
1996: Linux 2.0 (9 June) introduces symmetric multiprocessing (SMP): a single kernel managing several CPUs. The mascot Tux, the penguin, is created.
1999: Linux 2.2 (20 January) improves SMP performance and adds 64-bit support for several platforms.
2001: Linux 2.4 (4 January) consolidates journaling file systems (ext3), USB and LVM: enterprise adoption soars.
2003: Linux 2.6 (17 December), a massive revision with the O(1) scheduler, NPTL (native POSIX threads) and better 64-bit support. This series would dominate for eight years.
2005: Gitis born. After the free license for BitKeeper (the proprietary version control system they used) was withdrawn, Torvalds wrote Git in a matter of weeks, in April 2005. Git not only saved the kernel: it became the most widely used version control tool on the planet and the basis of GitHub.
2007: Google announces Android (November), a mobile operating system built on the Linux kernel.
2011: Linux 3.0 (22 July) celebrates the 20th anniversary; Torvalds clarified that "3.0 is just a renumbering". The Big Kernel Lock (BKL) is removed, a bottleneck that had been on its way out for years.
2015: Linux 4.0 (12 April) introduces kernel live patching (kpatch), which allows security patches to be applied without rebooting.
2017: 100% of the 500 fastest supercomputers in the world (TOP500 list) run Linux, a position they have held ever since.
2018: Meltdown and Spectre, vulnerabilities in modern CPUs, are made public; the kernel becomes the first line of defense, with mitigations such as KPTI.
2019: Linux 5.0 (3 March). Torvalds joked: "5.0 doesn't mean anything more than I ran out of fingers to count the 4.x".
2022: Linux 6.0 (2 October) and, shortly after, the 6.1 integrates the first support for the Rust, language, aimed at writing drivers with memory safety guarantees.
2025: The kernel surpasses 40 million lines (January); version 6.18 (November) sets a record with 2,134 developers in a single cycle.
2026: Linux 7.0 (12 April) and Linux 7.2 (August 16), the current stable release, which already exceeds 40 million lines.
But it is worth making an important distinction here. The major version jumps (3.0, 4.0, 5.0, 6.0, 7.0) are not actually rewrites of the system. Torvalds bumps the first number when the second one becomes awkward for him, purely for preference, as he acknowledged when announcing 7.0 in February 2026.
However, there are genuinely transformative versions. The first of them was 2.0, when SMP or multiprocessing support arrived, and the second major release was 2.6, when Linux truly prepared for enterprise scale. Versions 3.0 and 4.0, while not as transformative, did add substantial changes, especially in hardware support and improvements in power management support. Beyond those, kernel versions have followed a very linear evolution, without major changes or upheavals.
A unique development model
Beyond the code, Linux's success lies in its governance and development model, as influential as the software itself.
Open, meritocratic development. The kernel is developed on public mailing lists, with a hierarchical maintainer model: subsystem maintainers review patches, the "lieutenants" group their work, and Torvalds makes the final decisions. Anyone can contribute.
Unprecedented scale. Each release cycle incorporates around 15,000 changes. In 2025, more than 5,000 developers participated over the LTS cycle, and companies (Intel at the top, followed by Google) contributed around 84% of the commits, a figure that reflects how much the industry depends on this code.
Support branches. In addition to the main release, the kernel maintains stable and long-term support (LTS) branches that receive fixes for years. In 2026 there are 6 active LTS branches , with support of between 3 and 6 years following the adjustment announced in February by Greg Kroah-Hartman.
Neutral governance. The Linux Foundation, born in 2007 from the merger of two consortia (OSDL and Free Standards Group), sponsors Torvalds and other maintainers and provides legal shelter and infrastructure without controlling the code.
It even changed version control. Git, the tool on which much of today's software industry is built, was born directly from the kernel's needs in 2005.
The arrival of Rust
This ecosystem, however, is not free of tensions. The integration of the Rust language sparked in February 2025 one of the tensest episodes in recent history: Asahi Linux project lead Hector Martin resigned citing frustration with the process, and DMA maintainer Christoph Hellwig stepped down from his area over his opposition to the Rust code.
Torvalds settled the debate with one of his most forceful replies: "if you think that as a maintainer you control who can use your code, YOU ARE WRONG," making clear that maintainers can ignore Rust but cannot veto it. The dispute underscores how difficult it is to govern a project of this magnitude.
The conquest of the world: servers, cloud, supercomputers and Android
The paradox of Linux is that it dominates the world without most people knowing. On the desktop, Linux consumers are a minority, with around 8% of the global market according to StatCounter, but in infrastructure and the mobile world, the shift is overwhelming.
Servers and the web. Linux runs around 51% of the global server operating system market (2026 estimate) and close to 62% of websites whose system can be identified, according to W3Techs. Among the million most important web servers, the figure rises to 96%. The four leading web servers (Nginx, Cloudflare, Apache and LiteSpeed) run primarily on Linux.
Cloud. The Linux Foundation estimates that around 90% of the public cloud runs on Linux. Even Microsoft acknowledges that more than 60% of customer cores in Azure run Linux, a striking figure coming from the company that in the 2000s called Linux "a cancer."
Supercomputing. The 100% of the 500 supercomputers of the world, have been running Linux since November 2017. Linux first appeared on the TOP500 list in 1998 with a single system; two decades later it dominates it completely.
Android and mobile. Android, the most widely used mobile operating system on the planet, is built on the Linux kernel. As the documentation of the Android Open Source Projectitself explains, the Android kernel is based on Linux LTS branches. With around 67-69% of the global mobile market and some 3.9 billion active smartphones, Android makes Linux the most widely deployed kernel in consumer devices in history.
Enterprises. According to 2025 data, 72.6% of Fortune 500 companies run critical workloads on Linux.
Current state of Linux adoption according to StatCounter Global Stats
Linux in space
If there is one example that sums up Linux's reliability, it is space. In February 2021, NASA's Perseverance rover landed on Mars and, in April of that year, the Ingenuity helicopter carried out the first controlled, powered flight on another planet.
Both used Linux. Jet Propulsion Laboratory (JPL) engineer Tim Canham confirmed to the press that it was "the first time we flew Linux on Mars," thanks to the open source framework F' (F Prime) developed by NASA. The Perseverance rover, for its part, recorded its landing with cameras controlled by a Linux PC.
In fact, NASA documented this experience in its technical repository, an example of how free software has made its way to the limits of human exploration.
40 million lines, Rust and the AI era
In September 2026, the kernel is more alive than ever. The stable version 7.2, released on August 16, exceeds 40 million lines (according to some counters, more than 42 million). AMD's graphics driver alone accounts for some 6.35 million lines, around 16% of the total, an example of how modern hardware demands increasingly extensive code.
And this trend is not going to change. Development has accelerated, and not only because of human activity. Torvalds has pointed to the growing use of AI-assisted bug detection and correction tools, which inflate the size of release candidates. It is a symptom of the era, as even the world's most collaborative software project is adapting to automation. At the same time, the commitment to Rust is advancing as a way to reduce the class of memory safety bugs, although the debate over its integration remains alive.
On top of all this, the immediate future is predictable in its pace: 7.3 will arrive in autumn 2026, and with it will exceed 41 million lines. Structurally, there are three trends that will shape the coming years: the consolidation of Rust in the kernel, the maturation of LTS branches as the basis for Android and for the industry, and the growing automation of development with AI.
The long-term threat is nothing other than its own success: Linux is so ubiquitous that its security and stability are, literally, the security and stability of global digital infrastructure. With 35 years of history and 40 million lines, a Helsinki student's "hobby" remains, against all odds, the heart of the tech world.