Right, so you want to understand how we got here, to this glorious, sprawling, slightly dysfunctional open-source universe we call home. It didn’t spring from the ether, fully formed like Athena from Zeus’s head. It started with a grumpy Finnish university student, a prohibitively expensive operating system, and a post to a Usenet newsgroup that would become legendary. Let’s rewind the tape.

To get why Linus Torvalds’s 1991 project was such a big deal, you have to understand the computing landscape at the time. The gold standard, the real operating system, was UNIX. But UNIX wasn’t for you and me. It was for universities, corporations, and governments who could afford the eye-watering licensing fees from AT&T (and later System V) or BSD. If you were a student tinkering at home on your measly 386 PC, your options were MS-DOS—a single-user, single-tasking toy—or MINIX.

The Predecessor: MINIX and the Educational Model

MINIX, created by Andrew Tanenbaum, was a brilliant, stripped-down, educational clone of UNIX. Its source code was available in a textbook (Operating Systems: Design and Implementation), which was its primary purpose: to teach. This was a huge deal. You could actually read how an OS worked. But Tanenbaum, rightly protective of his teaching tool, kept it deliberately limited and maintained a… let’s call it a “firm” grip on its development. You couldn’t just hack on it and redistribute your changes. This was the “open but not open” model that ultimately frustrated a young Linus. He wanted to fiddle with the hard drive and terminal emulation, and MINIX’s license and design made that a pain. Sound familiar? It’s the exact kind of friction that sparks a revolution.

The Infamous Usenet Post

So, on August 25, 1991, Linus sent a now-historic message to the comp.os.minix newsgroup. Let’s be clear: he wasn’t announcing a world-changing OS. He was basically asking for beta testers. The tone is classic Linus: understated, a little self-deprecatinging, and brutally honest. Here’s the crucial part:

From: torvalds@klaava.Helsinki.FI (Linus Torvalds)
Newsgroups: comp.os.minix
Subject: What would you like to see most in minix?
Summary: small poll for my new operating system
Message-ID: <1991Aug25.205708.9541@klaava.Helsinki.FI>
Date: 25 Aug 91 20:57:08 GMT

Hello everybody out there using minix -

I'm doing a (free) operating system (just a hobby, won't be big and
professional like gnu) for 386(486) AT clones...

I want you to savor the irony of that parenthetical “won’t be big and professional like gnu.” It’s the software equivalent of a rock band’s first garage demo tape. He was right about one thing: it was free. And he was very, very wrong about the other. The post goes on to detail the state of the code, what works (bash, gcc), what barely works (the floppy driver), and what doesn’t (porting, because “it’s mostly in C, but… you have to be a wizard to use it”). He was already a brilliant coder, but his marketing was pure, unvarnished truth.

Why It Took Off: GPL, GCC, and the GNU Hole

Here’s the critical bit most people miss: Linux was just the kernel. An OS needs shells, compilers, libraries, and utilities to be useful. Linus didn’t write ls, grep, bash, or gcc. He wrote the core that made them run.

This is where Richard Stallman’s Free Software Foundation (FSF) and the GNU Project come in. For years, Stallman and his crew had been building a complete, libre UNIX-like operating system… but they were missing the final, crucial piece: the kernel (their own kernel, Hurd, was perpetually delayed and is, to this day, a famously beautiful theoretical construct that proves God has a sense of humor).

Linux fell into this ecosystem like the last piece of a puzzle. And Linus’s masterstroke was licensing Linux under the GNU General Public License (GPL). This wasn’t an accident. He initially used a more restrictive license but was convinced by others to switch. The GPL is a genius piece of legal jujitsu. It says, “Yeah, you can use this, modify it, and distribute it, but any changes you make must be shared under the same license.” This viral clause prevented any company from taking Linux, privatizing it, and selling it as their own closed product. It forced collaboration. It meant that if Intel, IBM, or Google contributed a driver to make Linux run better on their hardware, that improvement benefited everyone. This created a positive feedback loop of development that proprietary models simply couldn’t match.

Building from Source: A Nod to the Past

We don’t build the kernel from source every day anymore, but the ritual is a direct link to 1991. Here’s how you’d get the source and configure it today, a process that would make Linus’s 386 weep.

# Install the dependencies needed to build the kernel on a Debian-based system
sudo apt install git build-essential libssl-dev ncurses-dev flex bison libelf-dev

# Clone the stable kernel tree (this is huge, go get coffee)
git clone git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git
cd linux-stable

# Copy your current config as a starting point. This is a best practice.
# It answers "yes" to every option it can to the `make oldconfig` command.
cp /boot/config-$(uname -r) .config

# Now run the configuration. This is where you'd spend 3 hours answering questions
# about obscure network protocols you've never heard of. We'll just update the old config.
make olddefconfig

# Now, build it. The `-j$(nproc)` tells make to use all your CPU cores.
# This will take a *long* time. This is the part Linus's post was about.
make -j$(nproc)

# Build the kernel modules (all the drivers)
make modules

# Install the modules
sudo make modules_install

# Install the kernel itself
sudo make install

After a reboot, your new, self-built kernel should be an option in the bootloader. It’s messy, it’s complex, and if you get a configuration option wrong, it might not boot. But that’s the point. This hands-on, “see-how-the-sausage-is-made” access is the entire ethos Linux inherited from its UNIX ancestors and the open-source revolution it ignited. It wasn’t handed to you on a silver platter; you built the platter yourself, from source.