A History of Linux: From a 1991 Hobby Project to Global Infrastructure

The history of Linux began in earnest in 1991 when Finnish university student Linus Torvalds created a kernel to use on personal computers. However, the Linux environment we use today is not an operating system completed by a single person; it is the result of decades of combination of the Linux kernel, GNU tools, distributions, and a worldwide developer community.

First thing to know: Linux is a kernel

How are the Linux kernel and the entire operating system different?

Strictly speaking, Linux is the kernel, the core of the operating system. The kernel manages hardware resources like the processor, memory, and storage, and coordinates in between so that applications can safely use the hardware.

The distributions that users actually install, like Ubuntu, Debian, and Rocky Linux, are complete user environments that bundle the Linux kernel with a shell, system tools, libraries, package managers, and applications. For this reason, the whole system is commonly referred to as 'Linux,' but when emphasizing the historical components, the name 'GNU/Linux' is also used. The GNU project's explanation of Linux and GNU goes into detail about the relationship between the two terms.

What exactly does the kernel do?

The kernel lies between the regular programs that users run and the hardware. Tasks such as a web browser reading a file or a server program sending network packets are ultimately handled through system calls provided by the kernel. To understand the history of Linux, it is helpful to first distinguish the following four roles.

• Process Management: Allocates CPU time to multiple programs and coordinates the execution order.
• Memory Management: Divides memory space for each program and protects them from overlapping.
• Device Management: Controls storage devices, network cards, graphics devices, and peripherals through drivers.
• File and Network Handling: Provides common interfaces necessary for file systems and network communication.

Therefore, changes in support for new hardware, performance, security, power management, and server scalability are mostly connected to the kernel's history. In contrast, desktop screens, package installation commands, and basic applications are more related to the history of distributions or user-space software.

Before Linux: The design of UNIX and the GNU Project

Linux is a Unix-like kernel designed to operate similarly to UNIX. UNIX's multi-user and multitasking model, the method of combining small tools, and its file-centric interface had a significant impact on later operating system designs. However, Linux is not a product derived from UNIX source code; it is an independently developed kernel.

In 1983, Richard Stallman announced the GNU project, which aimed to create a UNIX-compatible free operating system that anyone could run, study, modify, and distribute. The development began in 1984, and by around 1990, the main components such as the compiler, shell, editor, and various commands were in place, but a practical kernel had not yet been completed. This background can be found in the official history of the GNU system.

1991: A small personal project is made public

Linus Torvalds, a student at the University of Helsinki, began developing an operating system kernel for Intel 386 PCs as a personal project around April 1991. On August 25 of the same year, he introduced the free operating system he was developing to a Usenet newsgroup for MINIX users and solicited feedback.

According to the 2020 Linux Kernel History Report by the Linux Foundation, the first public version, Linux 0.01, was released on September 17, 1991. At that time, the code consisted of 88 files and 10,239 lines, and it ran on only one type of hardware architecture, the i386. It was not a general-purpose system from the beginning.

1992–1994: Free Software Meets Distributions

The GNU GPL Changed the Terms of Collaboration

In 1992, Linux was redistributed under the GNU General Public License (GNU GPL), allowing users to view, modify, and share the source code under the same conditions. The Linux kernel combined with pre-existing GNU tools, and with the emergence of distributions responsible for installation and software management, it developed into a usable operating system environment.

Debian, started by Ian Murdock in August 1993, developed a model of community-built distributions created openly together. According to the official history of the Debian project, Debian aimed for a consistent distribution and systematic package management from the very beginning. Around the same time, distributions combining commercial support also grew, laying the foundation for not only individual users but also businesses to adopt Linux.

On March 13, 1994, Linux 1.0 was released. The Linux 1.0 archive on kernel.org preserves the source and change history from that time. The version number 1.0 was a symbolic milestone that indicated Linux was starting to establish itself as stable open-source software beyond just an experimental project.

Distributions made Linux usable as a product

Early users had to gather and configure the kernel and various tools themselves. Distributions replaced this complex process by providing installers, pre-built software packages, dependency information, and update repositories. Even when using the same Linux kernel, different distributions are created depending on which software is chosen, how long updates are provided, and how configurations are managed.

Debian has developed a model in which a volunteer community manages policies and package systems together. In contrast, Red Hat pioneered a path that links the results of open development to stable enterprise products and technical support. The official Red Hat history explains the process from CD distribution in the 1990s to enterprise subscription models and community distributions. With these different models coexisting, Linux could be widely used from personal learning to enterprise servers that need long-term operation.

Key Timeline of Linux History

From 1.0 to 2.6: How the PC kernel grew into a general-purpose base

Linux 1.0 was primarily used on Intel 386-based PCs, but later versions rapidly expanded to support more processors and devices. Instead of embedding all device functionalities within the kernel, it became possible to load necessary features as modules, making it easier to handle various hardware combinations.

Linux 2.0 in 1996 supported Symmetric Multiprocessing (SMP), which allows multiple processors to be used together, marking an important step in its growth as a server operating system. In the subsequent 2.4 and 2.6 series, support for new devices, scheduling, memory management, and large-scale system scalability continued to improve. By looking at the 2.6 archive on kernel.org, you can see that after 2.6.0 was released in December 2003, the stable and long-term support versions continued.

During this period, Linux established itself as a general-purpose kernel that runs on various architectures, going beyond just ‘using a UNIX-like environment on inexpensive PCs.’ With hardware manufacturers contributing drivers and companies participating in performance and stability improvements, a structure was formed where the community and commercial interests meet in a single mainline kernel.

In 2005, Git was created to handle the scale of development.

The kernel community needed a new version control tool.

As Linux's code grew and more people participated, it became important to manage who made which changes and how to merge the various development streams. The kernel community used a version control tool called BitKeeper for a while, but when the free usage agreement ended in 2005, a new tool was needed.

Linus Torvalds created Git, focusing on fast change tracking, distributed work, and large-scale merging. The official Git documentation's short history explains that Git originated from the needs of the Linux kernel development community. Since then, Git has become a representative version control system used across software development beyond the kernel.

How are changes to the current kernel merged?

Changes written by developers are released in the form of patches and reviewed by the people responsible for the relevant subsystems and other developers. Verified changes from specialized repositories such as network, file system, drivers, and processor architecture are gradually merged into the mainline. Immediately after a new version is released, a merge period for major features opens, and then during the release candidate stage, the focus is on fixing regression errors and stability issues.

This structure does not allow anyone to immediately put code into the final kernel. While public participation is possible, quality is managed through reviews, testing, responsible maintainers, and step-by-step integration procedures. The Linux Kernel Development HOWTO explains the mainline, stable versions, subsystem trees, and patch submission process.

From servers to mobile and cloud

Grew in the server and enterprise market

Since the late 1990s, Linux has rapidly grown in the server sector based on stability, network capabilities, and support for various hardware. Distribution vendors provided long-term updates and technical support, enabling enterprises to adopt Linux for web servers, databases, and business systems.

In the 2000s, as virtualization and cloud computing spread, the advantages of Linux, which is easy to automate and customizable to needs, became even more important. Containers also developed based on Linux's process isolation and resource control capabilities. Today's kernel development is conducted not by a single organization creating all the code, but through a distributed collaborative structure where subsystem maintainers review and integrate patches. The latest development procedures can be found in the official Linux kernel development documentation.

Why did containers and the cloud match well with Linux?

Virtual machines generally run a separate operating system kernel for each instance, while containers share the host's Linux kernel while isolating processes. Namespaces divide the user, network, filesystem, and process ID ranges seen by processes, and control groups (cgroups) bundle CPU, memory, and I/O resource usage to limit or measure them.

A container is not the same as a single Linux kernel feature. It requires an image format, execution tools, and management of networks and storage together. However, because the core foundation of isolation and resource control was included in the kernel, an ecosystem for rapidly deploying applications on large-scale servers could develop. Detailed operations can be found in the Linux kernel's cgroup v2 documentation.

Expanded to mobile and embedded devices

Linux did not remain only on PCs and servers. It was ported to routers, cars, industrial equipment, and various embedded devices, and deeply entered smartphones. For example, according to the Android Open Source Project's kernel description, the Android kernel is based on the upstream Linux long-term support (LTS) kernel.

Corporate participation did not contradict open development

The early growth of Linux relied heavily on the participation of individual developers and university/hobby communities. As the scope of use expanded, server manufacturers, semiconductor companies, distribution vendors, and cloud providers also began to develop functions necessary for their products and incorporate them into the mainline. This is because code included in the mainline can be delivered to various distributions and users and receive joint review and maintenance.

In 2000, the Open Source Development Labs (OSDL) was established to support enterprise adoption and development of Linux. In 2007, OSDL merged with the Free Standards Group to launch the Linux Foundation. According to the Linux Foundation's organizational history explanation, this organization supports the kernel community to continue independent development while providing development infrastructure, standardization, events, education, and legal and trademark support.

The structure does not transfer all copyright of the code to a single company. Official kernel development documents explain that code included in the mainline remains the property of the original copyright holder. The entire Linux kernel is provided under the GNU GPL version 2 only terms, and individual source files may be under compatible licenses or dual licenses.

Looking at Linux history in three layers helps reduce confusion.

These three layers are closely related but not the same. For example, a kernel security fix can commonly affect multiple distributions, but package versions and support periods may differ depending on the distribution. Android also uses the Linux kernel, but its user space and application structure differ from general desktop GNU/Linux distributions.

The reason Linux has been able to grow for a long time

• Open Source Code: Anyone can review the code, fix issues, or propose support for new hardware.
• Clear License: The GNU GPL provides conditions for modification and redistribution, forming the legal basis for collaborative development.
• Internet-Based Collaboration: Mailing lists, maintainers, and public review processes have enabled development beyond regional and organizational boundaries.
• Distribution Ecosystem: Installation tools, packages, update policies, and technical support tailored to different purposes are provided.
• Wide Portability: It can be used on various hardware, from personal computers to servers, smartphones, and embedded devices.

What Linux History Shows

The growth of Linux cannot be explained by the success of an outstanding kernel alone. It has thrived for a long time because the proven design of UNIX systems, GNU tools and the free software movement, integration work by distributions, corporate investment, and the public collaboration of developers worldwide have all interlocked.

Therefore, the core of Linux history goes beyond "who made what in 1991." It is most accurate to understand it as the process by which a development method—where the community reviews, improves, and reconfigures publicly released technology for different purposes—grew into critical infrastructure in the real world.

Frequently Asked Questions

Who created Linux?

The Linux kernel was started by Linus Torvalds in 1991. Since then, individual developers and companies around the world have contributed to the code, developing it into a large-scale collaborative project.

Are Linux and UNIX the same operating system?

No, they are not the same. Linux is a Unix-like kernel that follows the design and usage of UNIX but was developed independently. UNIX is a historical family of operating systems and also has the meaning of a certified trademark.

What is the difference between Linux and GNU/Linux?

Linux strictly refers to the kernel. GNU/Linux is a name that emphasizes the entire operating system composed of the Linux kernel and GNU tools. In everyday usage, distributions and the whole system are also commonly referred to as Linux.

Why are distributions needed?

With just the kernel, it is difficult for ordinary users to use a complete computing environment. Distributions provide an operating system suitable for the purpose by bundling installers, system tools, package managers, update policies, and applications.

Can a company sell the open-source Linux?

Yes, it is possible. The 'freedom' in free software does not necessarily mean a free price. Companies can provide software for a fee by bundling distribution, long-term updates, security certifications, technical support, and operational tools. However, when modifying and distributing the Linux kernel code, they must comply with the license requirements, such as providing the source code as required by the GNU GPL.

Does one company own Linux?

No single company exclusively owns and controls Linux kernel development. Linus Torvalds manages the mainline, and maintainers in each area integrate changes, but the copyright of the code is distributed among numerous contributors. The Linux Foundation supports the development environment and ecosystem, but it is not an organization that owns the entire kernel like a company product.

References

• History of the GNU System
• Linux Foundation 2020 Linux Kernel History Report
• kernel.org Linux 1.0 Archive
• kernel.org Linux 2.0 Archive
• kernel.org Linux 2.6 Archive
• Debian Project History
• Red Hat Official History
• Linux Kernel Development Process
• Linux Kernel License Rules
• Linux Kernel cgroup v2 Documentation
• A Brief History of Git
• The Role and History of the Linux Foundation
• Overview of the Android Kernel