Linux did not begin as a plan to dominate servers, power billions of phones, run cloud infrastructure, or become the operating-system family used across the world’s fastest supercomputers. It began with a university student, a 386 PC, a fascination with Unix, and a small kernel project that Linus Torvalds publicly described in 1991 as a hobby.
The remarkable part of Linux history is not simply that the project survived. It is how several independent developments came together at the right moment: Unix had established a powerful operating-system model; the GNU Project had built much of a free Unix-like userland; MINIX made operating-system internals accessible to students; inexpensive 386 PCs put capable hardware on desks; the Internet made global collaboration practical; and the GNU General Public License gave contributors a framework for sharing improvements.
The result was bigger than any one person or program. Linux became a kernel, an ecosystem, a development model, a commercial platform, and eventually a largely invisible layer underneath much of modern computing.
Quick answer
Linux began in 1991 when Finnish computer-science student Linus Torvalds started writing a Unix-like kernel for his Intel 386 PC at the University of Helsinki. He announced the project publicly on the comp.os.minix newsgroup in August 1991, and the first Linux 0.01 source release followed in September.
Linux did not appear in isolation. Unix had been developed at Bell Labs beginning in 1969. Richard Stallman announced the GNU Project in 1983 to build a free Unix-compatible operating system, and by the early 1990s GNU already provided compilers, libraries, shells and many other components. MINIX, released in 1987 for teaching, gave students such as Torvalds a system they could study and modify.
In 1992 Linux was re-released under the GNU General Public License. Linux plus GNU tools and other free software could then be assembled into complete operating systems. Distributions such as MCC Interim Linux, SLS, Slackware and Debian made installation practical. Linux 1.0 arrived in 1994, commercial vendors brought support and packaging, and the project expanded from PCs into servers, enterprise computing, embedded systems, Android devices, cloud infrastructure, containers, supercomputers and gaming.
As of September 2026, the Linux kernel remains under active development; kernel.org listed Linux 7.2.2 as the latest stable release when this guide was reviewed.
When to use this solution
This guide is for readers who want more than a date-and-name answer to the query “history of Linux.”
Use it when you want to understand:
- what existed before Linux;
- the difference between Unix, GNU, Linux and a Linux distribution;
- who created the Linux kernel and what other projects contributed to the complete system;
- why Linux was created;
- how the Internet and the GPL changed its development;
- which early distributions made Linux practical;
- why Linux became commercially important;
- how Linux moved from hobbyist PCs to servers, Android, cloud infrastructure, containers, supercomputers and gaming;
- why Linux remains important in 2026.
If you only need a short answer for a quiz, presentation or exam, jump to Faster alternative near the end.
Before you start
Three distinctions make the rest of Linux history much easier to understand.
- Linux is technically a kernel. A kernel is the core software layer that manages hardware, memory, processes, devices and other low-level resources.
- A Linux distribution is a complete operating system built around the Linux kernel. It normally includes system utilities, libraries, package management, an installer, applications and sometimes a graphical desktop.
- GNU and Linux are related but not identical. GNU began years before Linux and supplied many components used in early Linux-based systems. The GNU Project therefore prefers the name GNU/Linux when referring to systems that combine GNU software with the Linux kernel.
Kernel.org makes the first distinction explicit: a newcomer who wants to install Linux normally wants a distribution, not a raw kernel source tree.
Linux history timeline
The easiest way to see the full story is to place Linux inside the longer history of Unix, GNU, personal computing and open-source development.
| Year | Milestone | Why it matters |
|---|---|---|
| 1969 | Unix development begins at Bell Labs | Establishes the Unix model that later inspires Linux |
| 1970s | Unix spreads through universities and research institutions | Creates a generation of programmers familiar with Unix tools and ideas |
| 1983 | Richard Stallman announces the GNU Project | Starts the effort to build a free Unix-compatible operating system |
| 1984 | GNU development begins | Compilers, utilities, libraries and tools gradually form a free software system |
| 1987 | Andrew S. Tanenbaum releases MINIX | Makes a small Unix-like teaching system available with source code |
| 1991 | Linus Torvalds begins his kernel project | The Linux kernel is born on an Intel 386 PC |
| 25 Aug 1991 | Torvalds announces the project on comp.os.minix |
Opens the project to feedback from other users |
| 17 Sep 1991 | Linux 0.01 source release | First preserved Linux kernel release |
| 1992 | Linux is re-released under the GNU GPL | Makes Linux free software under a reciprocal license |
| 1992 | MCC Interim Linux and SLS help package usable systems | Early distributions simplify installation and software collection |
| 1993 | Slackware and Debian emerge | Two long-lived distribution traditions begin |
| 1994 | Linux 1.0 | A major maturity milestone for the kernel |
| 1994–1995 | Red Hat enters the market | Shows how Linux can support commercial products and services |
| 1996 | KDE is announced | Desktop Linux begins moving toward an integrated graphical experience |
| 1997 | GNOME is founded | Another major free desktop environment begins |
| 1998 | The term “open source” is coined and OSI is formed | Reframes collaborative software development for a broader technical and business audience |
| Late 1990s | Linux expands rapidly in Internet servers | Reliability, networking and low cost fit the growing web infrastructure |
| 2000–2001 | IBM commits major resources to Linux | Helps validate Linux for enterprise computing |
| 2004 | Ubuntu 4.10 launches | Makes Debian-based desktop Linux more approachable to a broad audience |
| 2005 | Linus Torvalds creates Git | Linux’s scale directly helps produce a new distributed version-control system |
| Late 2000s | Android adopts the Linux kernel | Linux reaches mass-market mobile devices |
| 2010s | Linux becomes central to cloud infrastructure | Virtualization, automation and open server platforms reinforce Linux |
| 2013 onward | Docker popularizes Linux containers | Kernel namespaces and cgroups become foundations for modern application deployment |
| 2014 onward | Kubernetes expands container orchestration | Linux resource-control primitives sit underneath much of the container ecosystem |
| 2020s | Linux remains dominant in supercomputing and cloud infrastructure | The former hobby kernel is now critical infrastructure |
| 2022 onward | Steam Deck and Proton raise Linux gaming visibility | Linux gains a major consumer-gaming platform |
| 2026 | Linux 7.x era | The kernel continues active development across many architectures and use cases |
The dates are useful, but the real story lies in the links between them. Linux succeeded because each stage removed a limitation that had constrained the previous one.
What exactly is Linux?
The word Linux is used in two ways.
Technically, Linux is the kernel originally written by Linus Torvalds and developed today by a large international community. The kernel sits between hardware and higher-level software. It schedules processes, manages virtual memory, communicates with devices, implements networking, provides filesystems and exposes system calls that user-space programs rely on.
In everyday speech, however, people often use “Linux” to mean an entire operating system such as Ubuntu, Debian, Fedora, Linux Mint, Arch Linux or openSUSE.
That everyday usage is convenient, but it can obscure the history.
A complete desktop or server installation usually contains software from many projects:
Applications
↓
Desktop / command-line tools
↓
Libraries and system utilities
↓
GNU components and many other projects
↓
Linux kernel
↓
HardwareThis is why saying “Linus Torvalds created the Linux operating system” is only partly accurate. Torvalds created the Linux kernel. The complete systems people ran in the early 1990s combined that kernel with GNU software and many other components assembled by distribution maintainers.
Kernel.org describes Linux as a Unix clone written from scratch, while also advising ordinary users to obtain a complete distribution rather than download the kernel itself.
Before Linux: why Unix matters
Linux history starts decades before Linux.
In 1969, Ken Thompson, Dennis Ritchie and colleagues at AT&T’s Bell Labs began developing what became Unix. The project grew out of lessons from the much larger Multics effort, but Unix pursued a smaller, more composable design.
Several Unix ideas became deeply influential:
- small tools that do one job well;
- text streams and pipes that let tools work together;
- a hierarchical filesystem;
- a strong multi-user model;
- process-based design;
- portability across different computers;
- a programming culture centered on C and command-line tools.
Unix became especially important after much of the system was rewritten in C, making it far easier to move to new hardware than operating systems tied closely to a single machine.
Universities and research institutions exposed generations of students to Unix. Different commercial and academic variants then emerged, including the Berkeley Software Distribution family and multiple proprietary Unix systems.
Linux would later imitate Unix interfaces and philosophy, but an important point is often lost in simplified histories:
Linux was not a copy of the Unix source tree.
Kernel.org describes Linux as having been written from scratch while aiming for Unix/POSIX compatibility. Linux belongs to the broader Unix-like tradition without being the original Unix code base.
GNU: the free operating-system project before Linux
By the early 1980s, software culture was changing. Proprietary software licensing and closed source code increasingly restricted the ability to study, modify and redistribute programs.
Richard Stallman responded by announcing the GNU Project on 27 September 1983. Development began in January 1984. GNU stood for “GNU’s Not Unix”: the goal was a Unix-compatible operating system implemented as free software.
The word free here referred primarily to user freedom, not merely price.
An operating system requires much more than a kernel. GNU and related projects developed or supplied major components including:
- GCC and other development tools;
- the GNU C Library and other libraries;
- Bash and shell utilities;
- text-processing tools;
- editors;
- build tools;
- command-line utilities;
- documentation;
- licensing infrastructure.
The Free Software Foundation was founded in 1985, and the GNU General Public License became one of the most important legal mechanisms in the free-software ecosystem.
By around 1990, GNU had assembled most of the major parts of its intended system, but its own kernel project, the GNU Hurd, was not ready for widespread everyday use.
That missing kernel created the opening into which Linux arrived.
MINIX and the PC that started Linux
A second key influence was MINIX.
Computer scientist Andrew S. Tanenbaum released MINIX in 1987 alongside his book Operating Systems: Design and Implementation. MINIX was a small Unix-like system designed primarily for teaching. Crucially, students could study its source code and understand how an operating system worked.
One of those students was Linus Torvalds.
The official MINIX history notes that Torvalds studied and modified MINIX before going on to write Linux. MINIX also had an active Usenet community, comp.os.minix, which became the place where Torvalds later announced his new project.
MINIX and Linux were not the same project and did not have the same design goals. Tanenbaum wanted MINIX to remain understandable for education; Torvalds increasingly wanted a practical system that took fuller advantage of his hardware.
The hardware mattered as well. Torvalds had acquired an Intel 80386-based PC, a processor powerful enough to support features associated with serious Unix-like systems, including protected mode and virtual-memory capabilities.
Linux was therefore born at the intersection of three things:
Unix ideas
+
MINIX as a learning environment
+
a capable 386 personal computerWhy Linus Torvalds created Linux
Torvalds did not initially set out to start a global movement.
He wanted to explore his new 386, learn more about operating systems and create a Unix-like environment that suited his own needs. Commercial Unix systems for PCs existed, but they were expensive and inaccessible to many students. MINIX was valuable for education, but it was deliberately constrained by its teaching goals.
Torvalds began experimenting with low-level programming, terminal handling and task switching. The experiments gradually turned into a kernel.
This is an important distinction in the history of Linux:
Linux did not begin as a business plan, a political campaign or a direct attempt to defeat Microsoft.
It began because one programmer wanted a system he could use and understand.
The famous announcement later summarized the modest expectations perfectly: Torvalds called it a “hobby” and said it would not be “big and professional.” The prediction turned out to be spectacularly wrong.
1991: Linux is born
Two dates matter in 1991.
25 August 1991: the public announcement
Torvalds posted to the comp.os.minix newsgroup explaining that he was working on a free operating system for 386/486 AT-compatible PCs and asking users what they liked or disliked about MINIX.
That post is often treated as Linux’s symbolic birthday because it is the moment the project was publicly introduced.
17 September 1991: Linux 0.01
The Linux Foundation’s kernel-history work traces the first source release, Linux 0.01, to 17 September 1991.
The scale is striking by modern standards. The 2020 Linux Kernel History Report records Linux 0.01 as:
- 88 files;
- 10,239 lines of code;
- support for a single architecture: i386.
Linux today spans many architectures and an enormous hardware ecosystem. The contrast illustrates how far the project travelled from its original scope.
At first, Linux was not a polished operating system for general users. Getting a working environment required assembling the kernel with compilers, libraries, shells and utilities from elsewhere—many of them from GNU.
Why Linux was almost called Freax
The name Linux was not Torvalds’ preferred final name.
He had considered Freax, combining ideas from “free,” “freak” and the Unix-like x naming convention.
When the project was made available on an FTP server at Finland’s FUNET network, Ari Lemmke used the directory name Linux instead. The name stuck.
The story matters because it illustrates how informal the early project was. There was no branding agency, corporate launch plan or product roadmap. A name chosen for an FTP directory became one of the best-known names in computing.
Linux and the GPL: the licensing decision that changed the project
The earliest Linux licensing terms were not the GNU GPL.
That changed in 1992, when Torvalds re-released Linux under the GNU General Public License. The GNU Project points specifically to Linux 0.12 as the key transition.
This decision was pivotal.
The GPL allowed people to:
- run the software;
- study the source;
- modify it;
- redistribute it;
- redistribute modified versions under the GPL’s reciprocal terms.
For Linux, that meant companies and individuals could build on the kernel without having to negotiate a proprietary source-code license. At the same time, redistributed modifications to GPL-covered code could not simply be turned into a closed derivative under incompatible terms.
The license did not magically create the community, but it gave the community a durable legal foundation.
This helps explain an apparent paradox that later became central to the Linux economy:
Companies could make money around Linux while the kernel itself remained collaboratively developed free software.
That model eventually supported distributions, consulting, support contracts, hardware certification, cloud services and enterprise platforms.
GNU, Linux and GNU/Linux: what is the difference?
This remains one of the most debated naming questions in computing, but the technical distinction is straightforward.
- Linux is the kernel.
- GNU is a much larger free-software operating-system project that began in 1983.
- Many traditional Linux distributions combine the Linux kernel with substantial GNU software plus components from many other projects.
- The GNU Project calls those systems GNU/Linux to acknowledge that composition.
- In common industry usage, people frequently call the entire system simply Linux.
Both historical perspectives matter.
Saying that “GNU created Linux” is wrong: Torvalds created the Linux kernel.
Saying that “Torvalds single-handedly created everything in a Linux operating system” is also wrong: complete Linux-based systems relied on a large pre-existing and rapidly expanding ecosystem, with GNU software playing a major role.
The most precise writing therefore uses the word according to context:
Linux kernel when discussing the kernel specifically; Linux distribution when discussing a complete packaged system; and GNU/Linux when the historical or compositional distinction is relevant.
The Internet turns Linux into a global project
The Internet was not just a place where Linux happened to be distributed. It changed how Linux could be built.
In earlier software projects, geographically dispersed collaboration was slower and more expensive. Linux emerged just as university networks, Usenet, email and FTP were making rapid international software exchange practical.
Developers could:
- download source code;
- compile it on their own machines;
- identify bugs;
- write patches;
- email those patches or post them publicly;
- review other people’s work;
- mirror source archives in other countries;
- repeat the cycle quickly.
This produced what the 2001 documentary The Code describes as a kind of distributed social machine: a project in which people who had never met could still work together continuously.
By early 1992, Torvalds could no longer personally know everyone using or modifying Linux. That was the moment Linux stopped being a small circle of acquaintances and became a networked community.
The governance model that followed was neither a simple democracy nor a conventional corporate hierarchy. Maintainers emerged around subsystems; trusted developers reviewed work; patches moved through chains of responsibility; and Torvalds remained the final integrator for the mainline kernel.
This model would influence open-source engineering far beyond Linux.
The first Linux distributions
A kernel plus a pile of separate utilities is not a convenient operating system.
Early Linux users often had to collect software from multiple FTP sites, resolve library mismatches, prepare disks manually and understand Unix well enough to recover when something failed.
Distributions solved that problem by packaging the kernel, user-space tools, libraries, installers and applications into coherent systems.
MCC Interim Linux
Owen Le Blanc at the Manchester Computing Centre created MCC Interim Linux, released in early 1992. It is commonly identified as the first Linux distribution aimed at making installation practical for users who were not already Unix experts.
Softlanding Linux System
Softlanding Linux System (SLS) followed in 1992 and offered a more comprehensive environment, including the X Window System. It became one of the most influential early distributions because it attempted to provide an integrated system rather than a minimal collection of boot tools.
Slackware
Patrick Volkerding developed Slackware from work originally based on SLS. Slackware was first released in 1993 and remains historically important as one of the oldest continuously maintained Linux distributions.
Debian
Ian Murdock founded the Debian Project on 16 August 1993. Debian was designed to be developed openly by a community and to assemble a carefully maintained distribution in the spirit of both Linux and GNU.
Red Hat and SUSE
Commercial distributions emerged as Linux moved beyond hobbyists. Red Hat and SUSE helped turn installation, packaging, support and hardware compatibility into products and services organizations could buy.
So what was the first Linux distribution?
There is no single answer unless “distribution” is defined carefully.
- Torvalds supplied early boot/root disk images.
- MCC Interim Linux is widely treated as the first recognizable Linux distribution for general installation.
- SLS became one of the first comprehensive and widely used distributions.
- Slackware is among the oldest surviving distribution projects.
- Debian is one of the oldest surviving community distributions and became the ancestor of Ubuntu and many others.
That nuance is more accurate than declaring one project “the first Linux OS” without defining the term.
1994: Linux 1.0 and the move toward serious use
Linux 1.0 was released in March 1994.
The version number was symbolic: Linux was no longer merely an experimental kernel passed around by a small community. It had become mature enough to serve as a stable reference point for broader use.
Linux 1.0 included features expected from a serious Unix-like system, including:
- multitasking;
- virtual memory;
- networking;
- filesystems;
- device support;
- process and user management.
The release did not instantly turn Linux into an enterprise standard, but it made commercial adoption easier to justify. Stable versioning mattered to vendors, administrators and developers who needed something more predictable than a rapidly changing experimental tree.
Kernel.org’s historical archive still preserves the Linux 1.0 source from March 1994.
Linux enters business
Open source did not prevent commercial Linux. In many ways, it created new commercial opportunities.
Companies did not need to own the kernel source code exclusively in order to build businesses. Instead, they could sell:
- tested distributions;
- packaged updates;
- technical support;
- consulting;
- hardware integration;
- training;
- certifications;
- lifecycle guarantees;
- enterprise management tools.
Red Hat became the most visible example. Marc Ewing’s early Red Hat Linux releases were joined with Bob Young’s business efforts, and Red Hat Software emerged as a company in the mid-1990s.
The important shift was conceptual:
Linux could be freely redistributable software and part of a profitable business model.
The late 1990s and early 2000s brought even stronger enterprise validation. IBM’s 2000 annual report said the company planned to redirect approximately $1 billion in 2001 toward Linux-related hardware, software, development, marketing and its Linux Technology Center.
That level of commitment signaled to corporate buyers that Linux was no longer merely a hobbyist alternative.
Free software becomes “open source”
The Linux story is closely connected to both free software and open source, but the terms are not identical.
The free-software movement emphasizes users’ freedoms and ethical rights around software.
In 1998, after Netscape announced plans to release browser source code, a group of advocates sought terminology that would present collaborative software development in more pragmatic and business-friendly terms. At a strategy session on 3 February 1998, the label open source was proposed, with Christine Peterson credited by the Open Source Initiative for suggesting the term.
The Open Source Initiative was then formed in 1998.
The software did not suddenly become different because the vocabulary changed. What changed was the framing.
Open source made it easier to discuss:
- peer review;
- rapid bug discovery;
- shared engineering costs;
- vendor collaboration;
- portability;
- transparency;
- business adoption.
Linux became one of the strongest demonstrations that open development could produce infrastructure-grade software.
Linux reaches the desktop
Server success did not automatically make Linux friendly for home users.
Early Linux systems could be difficult to install and configure, particularly for people without Unix experience. Graphical projects attempted to change that.
KDE
Matthias Ettrich announced KDE in 1996 as an integrated graphical desktop for Unix-like systems. KDE aimed to make the environment coherent and approachable rather than merely provide individual graphical applications.
GNOME
GNOME was founded in 1997 by Miguel de Icaza and Federico Mena, with a goal of creating a free desktop environment. GNOME became another major desktop platform used by Linux distributions.
Desktop Linux then grew through improvements in:
- graphical installers;
- hardware detection;
- package managers;
- desktop environments;
- office applications;
- web browsers;
- Wi-Fi and graphics support;
- laptop power management.
Yet Linux never displaced Windows on mainstream consumer PCs. Compatibility with commercial desktop software and games, OEM preinstallation, user familiarity, hardware support and network effects all favored Windows.
That did not prevent Linux from succeeding elsewhere. In fact, the most important Linux story increasingly moved away from the traditional desktop.
2001–2005: Linux grows beyond the original hacker community
By the early 2000s, Linux was entering a new phase.
The dot-com boom had made Linux visible. Enterprise vendors were investing. Servers were becoming a natural home for Linux. Distributions were professionalizing release engineering and support.
At the same time, the Linux project itself had become too large for its original development workflow.
For most of 1991–2002, kernel changes were exchanged as patches and archived files. In 2002 the project adopted BitKeeper, a proprietary distributed version-control system, to manage the growing scale of kernel development.
That choice was controversial, but it helped demonstrate what a distributed version-control system could do for a project as large as Linux.
The controversy would directly lead to another major piece of software history.
Ubuntu makes desktop Linux easier
Ubuntu’s first official release, Ubuntu 4.10 “Warty Warthog,” arrived in October 2004.
Ubuntu was built from Debian but emphasized:
- a comparatively simple installation experience;
- predictable six-month releases;
- a curated default software selection;
- free availability;
- desktop usability;
- security updates;
- community participation.
Ubuntu did not invent desktop Linux, but it gave a new generation of users a recognizable entry point.
Over time Ubuntu expanded beyond the desktop into servers, cloud images, containers and connected devices. Its success also demonstrates a recurring pattern in Linux history:
New distributions rarely replace the Linux ecosystem. They reorganize existing components around a different set of priorities.
Linus Torvalds creates Git
In 2005, the Linux kernel project’s relationship with BitKeeper’s developer broke down, and the free-of-charge arrangement used by kernel developers ended.
The kernel community needed another tool, but existing version-control systems did not satisfy Torvalds’ requirements for Linux-scale development.
He created Git.
According to the official Pro Git history, Git was designed around goals that included:
- speed;
- simple design;
- distributed operation;
- strong support for nonlinear development;
- the ability to handle very large projects efficiently.
This is one of the most important second-order effects of Linux.
Linux did not merely benefit from open-source collaboration. Its own scale forced the creation of infrastructure that later transformed software development far beyond the kernel.
Git became foundational to modern development workflows, GitHub, GitLab, CI/CD and DevOps.
Android puts Linux in billions of pockets
The desktop was never the only path to mass adoption.
Android changed the scale of Linux dramatically.
The Android Open Source Project documents that Android kernels are based on upstream Linux Long Term Supported (LTS) kernels, with Android-specific changes forming Android Common Kernels.
This means an Android phone is not “a normal desktop Linux distribution,” but Linux is still at the core of the operating system’s relationship with hardware, processes, memory, drivers and security boundaries.
The consequences are enormous.
Millions of people who have never installed Ubuntu, opened a terminal or heard of GNU use devices whose operating-system architecture depends on the Linux kernel.
Linux moved from being something enthusiasts deliberately installed to something consumers often used without knowing it was there.
Linux becomes a foundation of cloud computing
Linux was already strong on Internet servers before the modern cloud era. Cloud computing amplified those advantages.
Providers needed operating systems that could be:
- automated;
- replicated at massive scale;
- customized;
- run without graphical interfaces;
- integrated with open networking stacks;
- virtualized efficiently;
- managed remotely;
- deployed without per-machine proprietary licensing constraints.
Linux fit those requirements extremely well.
The same openness that had attracted students and hobbyists now appealed to infrastructure engineers. Providers could modify the kernel, tune distributions, build custom images, automate deployments and contribute improvements upstream.
Linux became deeply embedded in the infrastructure behind:
- public cloud services;
- hosting platforms;
- content-delivery systems;
- web servers;
- databases;
- distributed computing;
- software-as-a-service platforms.
The irony is striking: Linux never needed to win the consumer desktop to become one of the most economically important operating-system technologies in the world.
Containers change infrastructure
Containers are another example of Linux features becoming more important than the word “Linux” itself.
Linux kernel mechanisms such as namespaces and control groups (cgroups) allow processes to be isolated and resource usage to be constrained.
Docker’s documentation explains that when a container starts, Linux namespaces isolate process views and networking, while cgroups help manage resources. Kubernetes similarly relies on Linux cgroups through the kubelet and container runtime to enforce CPU and memory controls.
Docker did not invent every underlying container primitive, but its 2013 launch made containers dramatically easier for developers to package, distribute and run.
Kubernetes later provided orchestration at cluster scale.
The causal chain is important:
Linux process isolation and resource controls
↓
practical container runtimes
↓
Docker-style application packaging
↓
large-scale orchestration
↓
modern cloud-native infrastructureThis is why the history of Linux is also part of the history of modern cloud architecture.
Linux takes over supercomputing
Supercomputing provides one of the clearest measures of Linux’s transformation.
In 1998, Linux appeared on only a tiny fraction of the TOP500 list. Over the following two decades, its share rose until Linux became effectively universal in the ranking.
For the June 2026 TOP500 list, the TOP500 operating-system statistics record:
- 500 Linux-family systems;
- 100% share of the list.
That does not mean all 500 machines run the same distribution. Supercomputers often use highly customized Linux environments designed around specific hardware and workloads.
But the broad result is extraordinary:
1991
Linux 0.01
one i386 architecture
10,239 lines of code
↓ 35 years ↓
2026
Linux-family systems
500 of the TOP500 supercomputersA kernel written to explore a personal computer became the standard foundation for the world’s most powerful computing systems.
Linux in embedded devices, cars, routers and appliances
The 2001 documentary The Code ended with a perceptive idea: Linux might become less visible precisely because it would move into ordinary devices.
That is largely what happened.
Linux is well suited to embedded systems because vendors can:
- adapt it to many processor architectures;
- remove components they do not need;
- add custom drivers;
- integrate specialized hardware;
- build long-lived products around long-term-support kernels;
- inspect and modify source code.
As a result, Linux appears in many categories of devices, including:
- network routers;
- televisions and streaming devices;
- industrial controllers;
- automotive systems;
- storage appliances;
- smart-home products;
- development boards;
- communications equipment.
The exact software stack varies widely, and not every embedded device uses Linux. The important historical point is that Linux escaped the conventional definition of a “computer operating system” and became reusable infrastructure for many kinds of machines.
Linux gaming and the modern desktop
Gaming was once one of desktop Linux’s clearest disadvantages.
That changed significantly through Valve’s Linux work, Proton and the Steam Deck.
Steam Deck runs SteamOS 3, an Arch-based Linux system, with KDE Plasma available as its desktop environment. Valve describes Proton as a compatibility layer that allows many Windows-targeted games to run without a native Linux port.
This did not make every PC game work perfectly on Linux, and anti-cheat systems, launchers and proprietary middleware can still create compatibility problems.
But it changed the practical question from:
“Does this game have a Linux version?”
to, increasingly:
“Does this game run well through Proton?”
For Linux history, that matters because it shows the platform continuing to enter new consumer spaces decades after the original desktop projects began.
Why Linux succeeded
Linux history is often told as a sequence of dates. Dates alone do not explain success.
Linux succeeded because several reinforcing factors appeared together.
1. Unix had already proven the model
Linux did not need to invent every operating-system concept from scratch. Unix had established interfaces, tools, conventions and design ideas that programmers already understood.
2. The 386 made capable Unix-like computing affordable
A university student could own hardware powerful enough to experiment seriously with protected mode, multitasking and memory management.
3. GNU supplied critical user-space infrastructure
A kernel without compilers, libraries, shells and utilities is not a practical everyday operating system. GNU software filled major parts of that environment.
4. The GPL aligned sharing with continued openness
The license gave contributors and companies broad rights while preserving reciprocal source-sharing obligations for distributed derivative kernel code.
5. The Internet made distributed development fast enough
FTP, Usenet and email allowed code, patches and discussion to move internationally at a speed previous volunteer projects could not easily match.
6. Linux ran on increasingly broad hardware
What began on i386 expanded to many processor architectures, from embedded systems to mainframes and supercomputers.
7. Distributions solved the integration problem
Most users do not want a kernel source archive. They want an installable system. Distributions turned thousands of separate components into coherent products.
8. Commercial support removed organizational risk
Red Hat, SUSE, IBM and many others gave enterprises support contracts, certifications, hardware partnerships and predictable lifecycle management.
9. No single vendor controlled the entire ecosystem
Companies could compete while sharing a common kernel and upstream projects. That reduced dependence on one proprietary platform owner.
10. Linux adapted to new markets
Servers, embedded devices, smartphones, cloud systems, containers, supercomputers and gaming all rewarded different properties of Linux.
The key is the combination:
Unix-like architecture
+
GNU and other free software
+
GPL
+
Internet collaboration
+
distributions
+
commercial support
+
hardware portability
+
adaptability
=
Linux ecosystemWhat Linux changed beyond Linux
The impact of Linux extends beyond machines that directly run the kernel.
Distributed development became normal
Linux demonstrated that a geographically dispersed community could coordinate a huge engineering project over the Internet.
Open source became an enterprise strategy
Linux helped move collaborative software from academic and hobbyist circles into mainstream corporate infrastructure.
Git reshaped software engineering
The Linux project’s version-control problem produced Git, which now supports development workflows far beyond Linux.
Shared infrastructure became competitive infrastructure
Cloud providers, hardware companies and enterprise vendors learned that they could collaborate on foundational layers while competing higher in the stack.
DevOps inherited Linux assumptions
Automation, shell scripting, package management, process tools, remote administration and Unix-style composability became normal parts of modern infrastructure practice.
Source availability changed expectations
Linux reinforced the idea that critical infrastructure can be inspectable, modifiable and jointly maintained rather than controlled entirely by one vendor.
Linux’s most important legacy may therefore be cultural as much as technical.
Linux today
By September 2026, Linux is no longer accurately described as a niche alternative operating system.
Kernel.org listed Linux 7.2.2 as the latest stable release when this article was reviewed, with Linux 7.3 already in release-candidate development.
Modern Linux spans very different environments:
- servers running websites, databases and enterprise applications;
- cloud platforms operating virtual machines and containers;
- Android devices using Linux-based kernels;
- embedded systems inside networking, industrial and consumer hardware;
- supercomputers, where the June 2026 TOP500 list is entirely Linux-family;
- developer workstations and technical desktops;
- consumer gaming hardware such as Steam Deck;
- mainframes and specialized architectures;
- single-board computers and educational systems.
The kernel itself is still primarily written in C, with architecture-specific assembly and official support for writing some kernel code in Rust. It continues to evolve through a global maintainer and contributor network.
The most striking feature of modern Linux is that its success is often invisible.
A person may never consciously “choose Linux” and still depend on it every day through a phone, website, cloud service, router, car system or online platform.
Linux firsts at a glance
Some “first Linux” questions are more complicated than search snippets make them appear.
| Question | Best concise answer |
|---|---|
| Who created Linux? | Linus Torvalds created the Linux kernel; the broader ecosystem was built by thousands of contributors and many projects |
| When was Linux announced? | 25 August 1991 |
| When was Linux 0.01 released? | 17 September 1991 |
| What was Linux almost called? | Freax |
| What architecture did Linux 0.01 support? | Intel i386 |
| When did Linux become GPL-licensed free software? | 1992, beginning with the 0.12 era |
| What was the first Linux distribution? | MCC Interim Linux is commonly identified as the first recognizable general distribution; definitions vary for earlier boot/root images |
| What was the first comprehensive popular distribution? | SLS was one of the first comprehensive distributions and included X |
| Which early distributions still exist? | Slackware and Debian, both dating to 1993 |
| When was Linux 1.0 released? | March 1994 |
| When was KDE announced? | 1996 |
| When did GNOME begin? | 1997 |
| When was “open source” coined? | 1998 |
| When did Ubuntu first release? | Ubuntu 4.10 in October 2004 |
| When was Git created? | 2005 |
| Does Android use Linux? | Yes. Android kernels are based on upstream Linux LTS kernels |
| What is the latest stable kernel at this review date? | Linux 7.2.2, checked 1 September 2026 |
How Linux evolved: 12 steps from Unix to modern computing
The complete history can be reduced to a causal sequence.
1. Unix establishes a portable operating-system culture
Unix gives universities and programmers a shared model for processes, files, tools, networking and C-based systems programming.
2. Proprietary restrictions motivate GNU
GNU begins building a Unix-compatible system that users can study, modify and share.
3. MINIX makes operating systems teachable
Students gain access to a compact Unix-like system with source code, creating fertile ground for experimentation.
4. Torvalds gets a 386 and starts writing a kernel
A personal learning project becomes increasingly capable.
5. The project is announced online
Feedback arrives from people outside Torvalds’ immediate circle.
6. Linux 0.01 is released
The source becomes something other developers can inspect, compile and improve.
7. GPL licensing strengthens the commons
Linux becomes free software under a license designed to preserve redistribution and modification freedoms.
8. Distributions make the system installable
MCC, SLS, Slackware, Debian, Red Hat, SUSE and later many others turn components into usable operating systems.
9. The Internet scales the contributor community
Development becomes a continuous international feedback loop.
10. Businesses make Linux supportable
Commercial vendors provide packaging, maintenance, certification and enterprise services.
11. Linux moves beyond the PC
Servers, Android, embedded systems, cloud platforms, containers and supercomputers become larger parts of Linux’s impact than the traditional desktop.
12. Linux becomes infrastructure rather than a product
By the 2020s, much of Linux’s importance lies beneath services and devices whose users may never see the kernel directly.
That sequence explains Linux better than a list of releases because it shows why each stage made the next one possible.
Common mistakes
Mistake 1: saying Linus Torvalds created every part of Linux
Torvalds created the Linux kernel. Complete Linux systems include work from GNU and many other independent projects.
Mistake 2: saying Linux is copied Unix source code
Linux is Unix-like and Unix-inspired, but kernel.org describes it as written from scratch.
Mistake 3: treating GNU and Linux as the same project
GNU began in 1983; Linux began in 1991. They are historically distinct projects whose software is often combined.
Mistake 4: calling Linux 0.01 the first Linux distribution
Linux 0.01 was a kernel source release. A distribution packages a usable system around the kernel.
Mistake 5: assuming there is one Linux operating system
There is one mainline Linux kernel project, but thousands of Linux-based system configurations and many distributions.
Mistake 6: assuming “free software” means nobody can make money
Linux became the basis of major commercial businesses precisely because companies could sell integration, support, hardware, hosting and services without owning the kernel exclusively.
Mistake 7: treating “free software” and “open source” as perfect synonyms
The communities overlap heavily, but the terms emphasize different ideas: user freedom on one side, development and licensing methodology on the other.
Mistake 8: measuring Linux only by desktop market share
Desktop PCs are only one Linux use case. Servers, cloud systems, Android devices, embedded systems and supercomputers tell a much larger story.
Mistake 9: saying Linux is written in C++
The kernel is primarily written in C, with assembly where required and modern support for some Rust code. C++ is not the kernel’s primary implementation language.
Mistake 10: assuming Linux is automatically secure because it is open source
Open source enables inspection and collaboration, but security still depends on configuration, updates, permissions, applications, supply chains and operational practices.
Security, privacy and safety notes
This is a historical explainer, so you do not need to run any terminal commands to follow it.
If you decide to experiment with historical Linux releases, take precautions:
- Do not install obsolete kernels on an Internet-exposed production machine. Old releases contain decades of unpatched vulnerabilities and unsupported drivers.
- Use a virtual machine or isolated lab environment for historical software.
- Download historical source only from reputable archives such as kernel.org or established university mirrors.
- Verify signatures or checksums when they are available.
- Be cautious with random “old Linux ISO” download sites; historical software is an easy pretext for distributing modified images.
- Do not assume a modern Linux distribution is secure by default for every use case. Keep supported systems updated and understand the services you expose.
- Never paste destructive shell commands from historical tutorials into a modern system without understanding what they do.
Linux’s openness is an advantage for auditing and study, but it is not a substitute for secure maintenance.
Faster alternative
If you only need the history of Linux in a few lines, remember this sequence:
Unix began at Bell Labs in 1969. GNU began building a free Unix-like operating system in 1984. MINIX appeared in 1987 as a teaching system. Linus Torvalds began Linux in 1991 and released Linux 0.01 that September. Linux moved to the GNU GPL in 1992, early distributions made it usable, Linux 1.0 arrived in 1994, commercial and open-source adoption accelerated in the late 1990s, Ubuntu appeared in 2004, Git in 2005, Android brought the Linux kernel to mass-market mobile devices, and Linux later became foundational to cloud computing, containers, embedded systems and supercomputing.
What you lose with the short version is the most important part: why those events connected. The full article explains the chain of causes that turned a student project into global infrastructure.
FAQ
What is the history of Linux?
Linux began as a Unix-like kernel project created by Linus Torvalds in 1991 at the University of Helsinki. It grew by combining Internet-based collaborative development, GNU and other free-software components, GPL licensing, Linux distributions and eventually commercial support. Over the following decades it expanded from hobbyist PCs to servers, Android, cloud platforms, embedded systems, containers, supercomputers and gaming devices.
Who created Linux?
Linus Torvalds created the Linux kernel. However, a complete Linux operating-system environment includes software from thousands of other contributors and projects. GNU software was especially important in the earliest complete Linux-based systems.
When was Linux created?
Torvalds announced his kernel project publicly on 25 August 1991. The first Linux 0.01 source release is dated 17 September 1991.
Why was Linux created?
Torvalds wanted to learn more about operating systems and make better use of his Intel 386 PC with a practical Unix-like environment. Linux began as a personal technical project, not as a corporate product or an attempt to conquer the operating-system market.
What existed before Linux?
Unix had existed since 1969, GNU development began in 1984, MINIX appeared in 1987, and BSD and commercial Unix systems were already established. Linux entered an existing Unix-like software culture rather than creating that culture from nothing.
What was Linux originally called?
Torvalds considered the name Freax. Ari Lemmke used the name Linux for the FTP directory hosting the project, and that name became permanent.
Is Linux older than Windows?
No, if you compare the Linux project with the Microsoft Windows product line. Windows 1.0 was released in 1985, while Linux began in 1991. Unix, which strongly influenced Linux, is much older than Windows and dates to 1969.
What was the first version of Linux?
Linux 0.01, released in September 1991, is the first preserved source release commonly cited as the first Linux kernel version. It supported the Intel i386 architecture.
What was the first Linux distribution?
The answer depends on the definition. Early boot/root disk images preceded formal distributions. MCC Interim Linux, released in 1992, is widely described as the first recognizable Linux distribution aimed at easier installation. SLS soon followed as a more comprehensive system.
What was the first Linux distribution with a graphical environment?
The answer depends on what counts as a full graphical distribution. Softlanding Linux System (SLS) was one of the earliest comprehensive Linux distributions to include the X Window System in 1992. Later distributions dramatically improved graphical installation and integrated desktop environments.
What language was Linux written in?
The Linux kernel was historically written primarily in C, with assembly language where hardware-specific low-level code requires it. Modern Linux remains primarily C but also has official support for writing some kernel components in Rust.
What is the difference between Linux and GNU/Linux?
Linux is the kernel. GNU is a separate free-software project that provides many user-space tools, libraries and development components. The GNU Project uses GNU/Linux for complete systems combining the GNU system with the Linux kernel. Common industry usage often calls the entire distribution simply “Linux.”
Did Linux copy MINIX?
No. MINIX influenced Torvalds’ study of operating systems and provided the community where he announced Linux, but Linux was developed as a separate kernel. MINIX creator Andrew S. Tanenbaum has publicly rejected claims that Torvalds copied MINIX code wholesale.
Is Linux still used today?
Yes. Linux is actively developed and is used in servers, cloud infrastructure, Android kernels, embedded products, supercomputers, developer systems and consumer devices such as Steam Deck. At the time of this review, kernel.org listed Linux 7.2.2 as the latest stable kernel.
Does Android use Linux?
Yes. The Android Open Source Project states that Android kernels are based on upstream Linux Long Term Supported kernels, combined with Android-specific changes.
Why is Linux so important if most desktop PCs use Windows?
Because desktop market share measures only one part of computing. Linux became especially important in servers, cloud infrastructure, mobile devices, embedded hardware, containers and supercomputing—areas that underpin many services people use every day.
Why did Linux succeed when other Unix-like systems existed?
There was no single reason. Linux arrived when inexpensive 386 hardware, GNU software, Internet collaboration, GPL licensing and demand for an accessible Unix-like system aligned. Distributions then simplified installation, while commercial vendors reduced the risk of organizational adoption.
Last tested
Historical facts and current-status claims were reviewed against primary or authoritative sources including kernel.org, the GNU Project, MINIX, Debian, Slackware, Red Hat, the Open Source Initiative, Ubuntu, Android Open Source Project, Git documentation, TOP500 and official Linux kernel documentation.
Tested on:
- Linux Kernel Archives: stable Linux 7.2.2, checked 2026-09-01
- TOP500: June 2026 operating-system family statistics
- Android Open Source Project: current kernel overview
- Ubuntu Project: official history and first-release documentation
- Linux kernel documentation: current programming-language documentation
Last tested: 2026-09-01
Related guides
Carefully selected guides to help you understand the topic and complete the next useful step.
