Linux Kernel: From Hobby Project to Core Infrastructure

Linus Torvalds’ 1991 hobby project became the kernel behind Linux, Android, servers, and embedded systems.

What began as a student project in Helsinki in 1991 is now one of the most widely deployed pieces of software ever written. The Linux kernel first appeared on 5 October 1991 as version 0.02, and it has since grown into the core of a huge family of operating systems, from servers to phones to industrial devices.

The scale is easy to underestimate because the kernel sits below the apps people actually see. But the version history tells the story clearly: version 0.11 became self-hosted in December 1991, version 0.12 switched to GPLv2 in January 1992, Linux 1.0.0 arrived in March 1994 with 176,250 lines of code, and 2.6.0 landed in December 2003 after a long run of feature growth.

How Linux started as a side project

Linus Torvalds was a computer science student at the University of Helsinki when he started building an operating system inspired by Unix. He began with a task switcher and a terminal driver, then posted about the project to comp.os.minix on 25 August 1991, saying he was working on a free operating system for 386 AT clones.

The early releases were tiny by modern standards and very rough around the edges. Version 0.01 was uploaded on 17 September 1991, but it was not even executable on its own because it still needed MINIX to compile and test it.

That detail matters because it shows how Linux grew: not from a polished product launch, but from a sequence of practical steps that kept making the system a little more useful. By 5 October 1991, Torvalds announced version 0.02, and by December that year the kernel could compile itself.

• 25 August 1991: Torvalds posted the first public message about the project
• 17 September 1991: version 0.01 was uploaded to FUNET
• 5 October 1991: version 0.02 was announced as the first official release
• December 1991: version 0.11 became self-hosted

Why the license choice changed everything

Linux might have stayed a hobby project if Torvalds had kept his original license. In January 1992, he moved the kernel to GPLv2, which allowed source code sharing and commercial redistribution under clear rules. That decision made Linux much easier to adopt, patch, and ship inside other systems.

“Linux is just a hobby, won't be big and professional like gnu” — Linus Torvalds, comp.os.minix, 25 August 1991

The quote is famous because the prediction was so far off. The GNU Project had already built many userland components for a free Unix replacement, but its kernel, GNU Hurd, was not ready. Linux filled that gap, and the combination became the basis for many GNU/Linux systems.

This is where the kernel’s technical design met its legal design. Linux exposed Unix-like system calls, followed POSIX APIs through the C library, and stayed open enough for hardware vendors and distributors to build around it. That mix turned it into a practical base for both hobbyists and large companies.

What Linux added over time

The kernel did not grow in a straight line. Each major release added support that widened its reach: 2.0 brought symmetric multiprocessing, 2.2 improved locking and added 64-bit platform support, 2.4 added USB and PC Card support, and 2.6 expanded architecture support, file systems, preemption, and security integration.

By the 2.6 era, Linux had become a very broad compatibility layer for hardware and storage. It supported file systems such as ext4, Btrfs, FUSE, XFS, and older formats from other operating systems. It also gained support for huge user and process limits, better 64-bit behavior, and in-kernel preemption.

Here is the practical takeaway: Linux won because it kept absorbing the needs of real hardware and real deployments. Not every feature was elegant, but enough of them were useful, and that mattered more.

• 2.0: symmetric multiprocessing and more processor support
• 2.2: improved locking, SMP management, and 64-bit platform support
• 2.4: USB, PC Card, Bluetooth, RAID, and ext3 support
• 2.6: preemption, SELinux integration, NPTL, and broader architecture support

Why Linux still matters in 2026

Linux is everywhere because it became the default base layer for systems that need control, portability, and a huge developer ecosystem. It powers Android, a large share of servers, embedded devices, and specialized hardware. It also benefits from a development model that mixes community contributions with strong maintainership from Torvalds and subsystem maintainers.

The codebase now includes C, assembly, and Rust, which is a sign of how the project has adapted without abandoning its roots. The kernel also moved through major tooling changes: BitKeeper was used briefly in 2002, then Git was created in 2005 after support was revoked, and Git became the version control system that now defines modern distributed development.

If you want to understand why Linux still dominates so many infrastructure stacks, the answer is less about ideology and more about endurance. It has survived because it keeps accepting new hardware, new security requirements, and new programming tools without breaking the old contract: stable enough to ship, open enough to inspect, and flexible enough to keep moving.

For a deeper history of open-source infrastructure, see how Git changed software development.

What to watch next

The next big question is not whether Linux stays relevant. It is how far Rust adoption, live patching, and kernel hardening can go before they change the way vendors build systems on top of it. With Android, cloud servers, and embedded hardware still tied to the kernel, even small changes in Linux development affect a huge amount of software.

That is why Linux remains one of the most important open-source projects in computing: not because it is old, but because it keeps absorbing new constraints without losing its role as the base layer millions of devices depend on every day.