Linus Torvalds and friends tell <i>The Reg</i> how Linux solo act became a global jam session

From hobby project to global infrastructure

Linus Torvalds transformed Linux from a solo hobby into a collaborative global project by leveraging early internet mailing lists and a grassroots hardware fundraiser. What started as a post to a Minix Usenet group on August 25, 1991, now powers almost every device on Earth outside of the desktop PC and Mac markets.

Torvalds originally pitched the system as a simple tool for 386 and 486 AT clones. He explicitly told the community it was just a hobby and would not be "big and professional" like the GNU project. He worked on the kernel at the University of Helsinki alongside his friend Lars Wirzenius, tinkering with computer games and early social networking via Usenet.

The project began because Torvalds wanted to learn about operating systems and dial into local servers more effectively. He sought to build a more capable system than Minix, which was then the standard academic Unix clone. This technical curiosity led to the first public snapshot of the kernel, released on October 5, 1991.

Torvalds pushed Linux 0.02 to an FTP server with roughly 10,000 lines of code. His friend Ari Lemmke set up the first servers at nic.funet.fi in Finland to host the files. Without this initial infrastructure, the code might never have reached the developers who would eventually help build it.

The name "Linux" was actually an accident caused by Lemmke’s intervention. Torvalds wanted to call the operating system "Freax," a combination of "free," "freak," and the "x" from Unix. Lemmke disliked the name and labeled the project directory "Linux" on the FTP server instead.

The first installation was a nap

The early days of Linux lacked the automated installers and user-friendly interfaces found in modern distributions. Users had to be comfortable with compilers and manual patches just to get the system running. Torvalds developed the kernel on his own machine, which meant it grew on top of his existing Minix installation.

Lars Wirzenius owned the first computer to ever receive a fresh Linux installation. Because Torvalds only had one PC, he visited Wirzenius to test if the system could actually be installed on a clean machine. Wirzenius recalled that he simply took a nap while Torvalds performed the difficult manual labor of the installation.

Development decisions in the early 1990s were entirely driven by whatever Torvalds wanted to experiment with next. He focused on adding a virtual memory system and ensuring that Bash and GCC could run properly. The project only reached a turning point when the kernel became stable enough to recompile its own code.

The barrier to entry remained high because of the hardware requirements. Developers needed a 386 processor and a deep understanding of kernel internals. Despite these hurdles, a small group of volunteers began downloading the code and returning patches via email.

Torvalds accelerated growth by actively encouraging these outside contributions. He treated the kernel as a commons rather than a private project. This open attitude turned the software into a genuine collaborative effort within its first year of public existence.

Overcoming the slow early internet

Distributing software in 1991 was a massive technical challenge due to limited bandwidth. Theodore "Ted" Ts'o, a long-time Linux maintainer, noted that the connection between Finland and the US was only 64 kbps. This bottleneck made downloading even small source files a slow and unreliable process.

The Linux 0.11 source code was only 93K, but it still struggled to cross the Atlantic. Ts'o decided to use his position at MIT to help the project scale. He set up the first North American Linux mirror on a VAXstation 3100 sitting on his desk.

This server, known as tsx-11.mit.edu, utilized MIT’s high-speed microwave links. While most universities relied on 1.5 megabit T1 lines, MIT had 10 megabit connections to Harvard and Boston University. This increased bandwidth allowed North American developers to join the project in earnest.

Early contributions from this period included critical system libraries:

• imalloc.c: The first general-purpose kernel memory allocator for Linux.
• Virtual memory: Improvements to how the system handled RAM and swap space.
• Driver support: Initial code to help the kernel talk to various PC hardware components.
• GCC compatibility: Ensuring the GNU Compiler Collection could build the kernel reliably.

European developers like Dirk Hohndel also joined the effort during this phase. Hohndel noted that Torvalds initially struggled with delegation, often rewriting patches from scratch rather than merging them. Torvalds eventually shifted his approach to a managerial role to allow the project to scale.

Crowdsourcing a new computer

By 1992, the project had outgrown the hardware Torvalds used to create it. His 386 PC lacked the horsepower required for modern development, but as a student, he could not afford an upgrade. H. Peter Anvin organized what was essentially a pre-internet GoFundMe to solve the problem.

Anvin asked community members to send physical checks to his university mailbox to avoid high international banking fees. This required a high level of trust, as most of the developers had never met in person. Anvin collected the funds for a month before wiring the total to Finland.

The community successfully funded a 486DX/2 for Torvalds, which was a top-tier machine at the time. This hardware upgrade allowed for faster compilation times and more complex testing. It also solidified the bond between the lead developer and the growing community of contributors.

This fundraiser proved that the Linux community was more than just a collection of hobbyists. It was a functional organization capable of supporting its own infrastructure. The new hardware gave the team the confidence to speculate about the future of the platform.

With the 486, developers began joking that they could eventually build "real" terminals that were cheaper than professional enterprise hardware. None of them realized at the time that Linux would eventually displace those enterprise systems entirely. The hardware bottleneck had been the final major obstacle to rapid development.

The move to open source

A major structural change occurred in 1992 when Torvalds moved the kernel to the GNU General Public License (GPL). This legal shift ensured that the code would remain free for everyone to study and modify. It also mandated that any improvements made to the kernel must be shared back with the community.

The GPL allowed developers to bundle the Linux kernel with GNU tools to create complete operating systems. These early distributions, appearing between 1992 and 1993, made Linux accessible to non-programmers. Users no longer had to compile every component of their system from scratch.

By the fall of 1993, Linux had become a major topic at professional technology conferences. At the NLUUG conference in the Netherlands, Torvalds' presentation was so popular it created a fire hazard. People sat on the stairs and blocked the doors just to hear him speak.

The popularity of the talk was so overwhelming that the presenter in the adjacent room abandoned his own session. He and his entire audience moved into Torvalds' room because they preferred to hear about the new kernel. This moment marked the transition of Linux from an underground project to a mainstream industry force.

Today, Torvalds acts primarily as a manager rather than a coder, overseeing a massive ecosystem of maintainers. The project that began with 10,000 lines of code now contains millions. Its success stems from a few key factors that remain true 33 years later:

• Aggressive collaboration: Accepting and encouraging patches from global volunteers.
• Legal clarity: Using the GPL to protect the software's "commons" status.
• Distributed infrastructure: Relying on mirrors and mailing lists to bypass regional bottlenecks.
• Hardware accessibility: Designing for standard PC hardware rather than expensive proprietary systems.

The "hobby" project that Torvalds started in his dorm room now runs the world’s clouds, supercomputers, and mobile devices. It remains the most successful example of collaborative software development in history.