Before we dive into the kernel itself, we have to talk about the soul of the system. And that soul, for better and for worse, is largely the work of one brilliant, stubborn, and ideologically pure programmer: Richard Stallman. His story isn’t just a footnote; it’s the foundational myth, the Genesis, of the entire open-source operating system you’re using.

In the early 1980s, Stallman was working in the MIT AI Lab, a classic hacker paradise where code was freely shared and improved upon. Then proprietary, closed-source software started rolling in, and the culture began to die. printers that would jam and not notify anyone because the source code for the driver was a secret. This kind of thing drove Stallman, who values user freedom above all else, absolutely bananas. So, in 1983, he announced the GNU Project (GNU stands for “GNU’s Not Unix”—a classic programmer’s recursive acronym, a joke that never stops compiling). His goal was unbelievably ambitious: to create a complete, Unix-compatible operating system that was entirely free software.

Notice I said operating system, not kernel. The kernel (which would later be Linux) is just one piece, albeit a critical one. An OS needs editors, compilers, shells, libraries, and a thousand other utilities. Stallman started building all of it, from the ground up, largely by himself.

The Philosophy of Free Software

This is where most people’s eyes glaze over, but stick with me because it matters. For Stallman, “free” as in “free speech,” not “free beer.” It’s about liberty, not price. He codified this into the Four Essential Freedoms, through the Free Software Foundation (FSF) he founded in 1985:

  1. The freedom to run the program as you wish, for any purpose.
  2. The freedom to study how the program works, and change it so it does your computing as you wish.
  3. The freedom to redistribute copies so you can help others.
  4. The freedom to distribute copies of your modified versions to others.

The key to enforcing this philosophically is the copyleft mechanism, most famously implemented in the GNU General Public License (GPL). Copyright is used to take away freedoms; copyleft uses copyright law to guarantee them. It says, “You can use, modify, and distribute this code, but any code you distribute that contains this must also be under the GPL.” It’s viral, and it’s designed to prevent companies from taking free software, modifying it, and selling it as a proprietary product. This infuriates some people and is celebrated by others. Love it or hate it, it’s the reason we have Linux at all.

The Tools That Built the World

While the Hurd kernel (GNU’s original kernel) languished in development hell, Stallman and the GNU Project built the tools that became the backbone of the entire software world. The most important one by far is GCC, the GNU Compiler Collection.

Before GCC, you’re often at the mercy of expensive, proprietary compilers from vendors like AT&T. They’d charge you an arm and a leg for a tool that might produce suboptimal code for your specific machine. GCC changed everything. It was a high-quality, optimizing compiler that you could fix yourself if it didn’t work right. It’s the reason you can compile code on practically any architecture today. Let’s see it in action, because it’s probably on your system right now.

# Let's take a simple C program
cat > hello.c << 'EOF'
#include <stdio.h>
int main() {
    printf("Hello, World. You are using GCC version %d.%d.%d\\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
    return 0;
}
EOF

# Compile it with GCC. The -o flag specifies the output file name.
gcc -o hello hello.c

# Now run the compiled program
./hello

This should output something like Hello, World. You are using GCC version 11.3.0. You just used a tool directly created by the GNU Project to build software. Feel the history!

Other monumental creations include GNU make (which manages the build process), the Bash shell (your command-line interface), the GNU C library (glibc, which is the bridge between applications and the kernel), and core utilities like cp, ls, and rm (the GNU versions are on your system, and they’re packed with more features than the classic BSD ones).

The Great Naming Debate

Here’s the bit that makes RMS (as he’s known) understandably grumpy. By the early 90s, GNU had everything except a working kernel. Along came Linus Torvalds with Linux, which was just a kernel. People combined Linux with the vast suite of GNU tools and utilities to create a complete, working operating system.

But what did they call it? “Linux.”

Imagine spending a decade meticulously crafting the engine, chassis, transmission, and interior of a car, and then someone comes along, bolts on a steering wheel, and everyone starts calling it a “Steering-wheel-mobile.” You’d be a little miffed too. The FSF insists on the term “GNU/Linux” to give the Project its due credit. Technically, they’{{< bibleref “Revelation 100 ” >}}% correct. Culturally, it’s a losing battle. It’s the most pedantic hill in software history to die on, but you have to respect the principle behind it.

The takeaway? When you use a modern Linux distribution, you’re running a kernel written by Linus and his community, but you’re interacting almost exclusively with tools written by RMS and the GNU community. It’s a symbiotic relationship, even if the founders aren’t always best buddies. Understanding this history is understanding the philosophical and practical bedrock that everything else is built upon.