The First Linux Kernel Is Released Online

On September 17, 1991, a 21-year-old computer science student in Finland uploaded a small collection of source code to an Internet server.

His name was Linus Torvalds, and the software was version 0.01 of the Linux kernel.

It consisted of just 88 files and 10,239 lines of source code. It supported only a narrow range of Intel 386-based personal computers, required another operating system to prepare and compile it, and Torvalds himself warned that it was not a mature product.

Yet that modest upload became the beginning of one of the most important software projects in computing history.

Linux would eventually power servers, smartphones, supercomputers, embedded devices and countless other machines around the world.

A Student in Helsinki

In 1991, Linus Benedict Torvalds was studying computer science at the University of Helsinki in Finland.

He had been interested in computers since childhood and had developed a particular fascination with understanding how machines worked at a low level.

Early in 1991, Torvalds purchased a personal computer built around Intel's 80386 processor.

The 386 was a powerful processor for its time and included features such as protected mode, virtual memory support and hardware assistance for multitasking.

Torvalds wanted to explore those capabilities directly.

What began as an experiment in learning about the processor gradually evolved into something much larger.

Learning From MINIX

One of the operating systems Torvalds used was MINIX, a small Unix-like system created by computer scientist Andrew S. Tanenbaum primarily for teaching operating-system design.

MINIX allowed students to study the structure of a working operating system, but Torvalds became frustrated by some of its limitations.

Rather than simply modifying MINIX, he began writing his own software from scratch.

His earliest experiments were not intended to become a complete operating system.

He initially wrote a program that switched between two tasks on his 386 processor and later developed a terminal emulator so that he could connect to computers at the University of Helsinki.

As he added a disk driver, filesystem support and other capabilities, the project gradually began behaving like an operating-system kernel.

What Is a Kernel?

The distinction between a kernel and a complete operating system is important.

The kernel is the central software layer that manages fundamental resources such as processor time, memory, hardware devices and communication between programs.

By itself, however, a kernel is not enough for most users to perform useful work.

A complete working system also needs software such as command shells, compilers, libraries and utilities.

Torvalds understood this clearly.

In the release notes for Linux 0.01, he pointed out that a kernel alone would get a user nowhere and explained that many of the programs needed around Linux came from the GNU Project.

A Hobby Project

By the summer of 1991, Torvalds realized that his project had developed far beyond a simple terminal program.

On August 25, 1991, he posted a message to the Usenet discussion group comp.os.minix.

He told other users that he was working on a free operating system for 386 and 486 personal computers.

He famously described it as a hobby and suggested that it would not become large and professional.

The prediction would age spectacularly badly.

But at the time, there was little reason to imagine that a student's experimental kernel would become the foundation of a global software ecosystem.

Bash and GCC

One important sign that Torvalds's project was becoming useful was his ability to run existing Unix-style software on it.

By the time of his August announcement, he had already managed to run Bash, the GNU command shell, and GCC, the GNU C compiler.

This was crucial.

An operating system becomes far more useful when it can run programs that already exist rather than requiring every application to be written from scratch.

The combination of Torvalds's kernel with software produced by the GNU Project and other free-software developers would eventually become the foundation of many Linux-based operating systems.

September 17, 1991

A few weeks after his Usenet message, Torvalds reached another milestone.

On September 17, 1991, he prepared Linux version 0.01 and made its source code available through a public Internet server.

The files were placed on ftp.funet.fi, part of Finland's academic and research network.

In the days before the World Wide Web became a familiar way of downloading software, FTP, or File Transfer Protocol, was one of the standard methods for distributing files across the Internet.

Anyone with access to the server and the necessary technical knowledge could retrieve the source code and examine it.

Linux 0.01

The first release was tiny compared with modern software.

Linux 0.01 contained 88 files and 10,239 lines of source code.

Almost all of it had been written by Torvalds himself.

One notable exception was part of the vsprintf routine, written with assistance from his friend and fellow student Lars Wirzenius.

The entire archive was small enough that today it would represent an insignificant download.

But the size concealed something important.

The code was a functioning kernel capable of managing processes, memory, a filesystem and basic computer hardware.

Not Ready for Ordinary Users

Torvalds made no attempt to pretend that version 0.01 was ready for everyday use.

In the accompanying release notes, he described it as a pre-alpha release.

It supported only a limited selection of hardware, including Intel 386-based AT computers, VGA or EGA displays, certain hard-disk controllers, keyboards and serial connections.

Some important system calls were incomplete.

Even mounting and unmounting filesystems had not yet been implemented.

Torvalds wrote that the release was intended largely for people interested in reading the source code and seeing what Linux looked like at that stage.

You Still Needed MINIX

There was another major limitation.

Linux 0.01 could not yet exist completely independently.

Although the kernel itself contained no MINIX source code, users still generally needed MINIX to compile and prepare Linux.

Torvalds had developed the kernel under MINIX and used a compatible filesystem partly for practical reasons.

The first release therefore represented an important transition rather than a finished replacement.

Linux was becoming its own system, but it had not yet become fully self-hosting.

Built Specifically for the 386

Linux 0.01 was closely tied to the Intel 80386 processor.

Torvalds deliberately used features provided by the chip rather than designing the kernel to run immediately on many different types of computer.

This allowed him to take advantage of the hardware's memory management and task-switching capabilities.

It also made the young kernel extremely difficult to move to other processor architectures.

Torvalds even suggested in his early messages that Linux might never support hardware other than the computers he personally owned.

That prediction would prove as temporary as his expectation that the project would remain small.

A Finnish Keyboard Problem

Linux 0.01 contained reminders that this was still the personal project of one student.

One of the most charming examples was the keyboard driver.

The kernel was configured for a Finnish keyboard because that was the keyboard Torvalds owned.

He acknowledged in the release notes that American users could use a U.S. keyboard, but doing so would require some practice.

He invited anyone willing to create a proper keyboard modification to contribute one.

This small detail illustrates how different Linux was from a commercial software product.

There was no large engineering department testing dozens of hardware configurations.

There was one programmer with one computer, openly asking other people to help improve what he had built.

Source Code for Everyone to Inspect

Perhaps the most important characteristic of the release was that the source code was available.

Programmers could download Linux, read how it worked, modify it and communicate directly with Torvalds.

That created the conditions for collaboration.

Instead of waiting for a company to decide which features should be added, programmers could identify problems, write improvements and send their work back to the project.

This development model would eventually become one of Linux's defining characteristics.

It Was Not Yet Under the GPL

There is another historical detail that is often overlooked.

The first Linux release was free to redistribute, but it was not yet licensed under the GNU General Public License.

Torvalds's original license required that the source code remain freely available and prohibited distributing Linux for a fee.

That restriction meant the early license did not provide all of the freedoms later associated with Linux.

In early 1992, beginning with Linux 0.12, Torvalds adopted the GNU General Public License.

The change allowed commercial distribution while requiring modified versions distributed under the license to preserve corresponding source-code freedoms.

It became one of the most consequential decisions in the project's history.

Why Was It Called Linux?

Torvalds had not originally intended to give his project the name by which it became famous.

He had considered calling it Freax, combining ideas of free, freak and the traditional x associated with Unix-like systems.

When the project was placed on the Finnish FTP server, administrator Ari Lemmke preferred another name.

The directory was created under the name Linux.

The combination of Linus and Unix was simple, memorable and, despite Torvalds's initial concern that it sounded too self-important, it stayed.

The First Release Was Almost Invisible

The September 17 upload should not be confused with a polished product launch.

There was no press conference, advertising campaign or commercial release.

Torvalds did not even broadly announce version 0.01 to the public.

He privately informed only a small number of interested people.

For that reason, several different dates are sometimes described as the birthday of Linux.

August 25, 1991, marks Torvalds's famous public message describing the project.

September 17 marks the release of Linux 0.01.

And October 5 marks the public announcement of Linux 0.02 to a wider audience.

Linux 0.02

Version 0.02 followed only weeks later.

On October 5, Torvalds announced that the system had reached a stage where other people could actually begin experimenting with it more seriously.

Programs including Bash, GCC, GNU Make and other familiar Unix tools could run under the system.

Early users began downloading the software, finding bugs and sending suggestions and improvements.

The solitary project was beginning to become a community.

The Internet Changes Software Development

The timing of Linux was crucial.

Programmers had collaborated electronically before 1991, but growing university and research networks made it increasingly practical for developers in different countries to exchange source code rapidly.

Linux did not require everyone working on it to be employed by the same company or even live on the same continent.

A programmer could download the source, experiment with it at home or at a university, and send a patch back through the Internet.

Torvalds could review the change and include it in another release.

This cycle happened repeatedly.

The Internet was not simply where Linux was distributed.

It became the environment in which Linux itself was developed.

From One Programmer to Thousands

The contrast between Linux 0.01 and the project that followed is extraordinary.

The first release contained roughly ten thousand lines of code written almost entirely by one person.

Over the following decades, thousands of programmers from individuals, universities and technology companies would contribute to the kernel.

Support expanded far beyond the Intel 386.

Linux was adapted to processor architectures ranging from tiny embedded devices to enormous computing systems.

Features that would have seemed impossibly sophisticated in 1991 were gradually added through continuous development.

Linux Is Not Just a Desktop Operating System

For many people, the word Linux evokes a desktop computer running a distribution such as Ubuntu, Debian, Fedora or another Unix-like operating system.

But the Linux kernel's influence extends much further.

It is widely used in Internet servers, network equipment, cloud infrastructure, televisions, industrial systems, automobiles and embedded electronics.

Android, the operating system used by billions of mobile devices, is built around the Linux kernel.

Linux also became the dominant operating-system kernel in high-performance supercomputing.

Many people therefore use Linux every day without ever seeing a traditional Linux desktop.

Linux and the Open-Source Movement

Linux also became one of the defining examples of collaborative software development.

The project demonstrated that extremely complicated infrastructure software could be developed openly by a community spread across companies and countries.

The source code could be inspected, modified and redistributed under its license rather than remaining hidden inside a single corporation.

That model helped accelerate broader adoption of what later became commonly known as open-source software.

Linux did not create the free-software movement, which already had an important history before 1991.

But its enormous practical success became one of the movement's most visible demonstrations.

A Kernel That Outgrew Every Prediction

Few aspects of Linux's early history are more striking than the difference between Torvalds's expectations and what actually happened.

He expected the project to remain a hobby.

He thought it would probably remain tied to Intel 386-class computers.

Version 0.01 was distributed primarily so technically curious people could read the source.

Yet the decision to place that source code on a network where others could examine and improve it allowed the project to grow in ways that no individual developer could have planned.

The Original Code Still Exists

The historical Linux 0.01 source tree has been preserved.

Anyone interested in the beginnings of the project can still download the archive and inspect the code.

It provides a remarkable contrast with the enormous modern kernel.

Files dealing with memory management, process scheduling, filesystems and hardware drivers reveal the architecture of a young operating system before decades of development transformed it.

Some fragments of code originating in those earliest releases even survived, in modified form, far into later versions of the kernel.

September 17, 1991

On September 17, 1991, there was little reason for anyone outside a small community of computer enthusiasts to notice what had appeared on a Finnish FTP server.

Linux 0.01 was only a pre-alpha kernel.

It supported a narrow range of hardware, depended on MINIX during its preparation and contained only about ten thousand lines of source code.

Even its creator described the larger project as a hobby.

But the most important ingredient was already there.

The source code was available for other people to study, test, change and improve.

That simple act turned a personal experiment into something that could become a collaborative project.

From 88 files uploaded to an FTP server grew a kernel that would eventually operate machines across almost every part of modern computing.

The software released on September 17, 1991, was tiny.

Its influence would be anything but.