> ## Content Index
> Fetch the complete content index at: https://bitstales.eu/llms.txt
> Use this file to discover other available public pages before exploring further.

# Linus vs Tanenbaum: how a hobby that “won't be big and professional” became Linux
- URL: https://bitstales.eu/en/linus-vs-tanenbaum-birth-of-linux/
- Published: 2025-09-03T16:27:00.000Z
- Updated: 2025-09-03T16:27:00.000Z
- Description: MINIX, a 386 bought on instalments, “just a hobby” and the “LINUX is obsolete” flame war: microkernel versus monolithic, and how both sides ended up winning.
- Author: Vittorio
- Tags: Linux, #en

On 25 August Linux turned 34\. To celebrate, here is how it was born: a 21-year-old Finn, a bearded Dutch professor with very firm opinions, a Usenet newsgroup and one of the most famous flame wars in computing history. Spoiler: they were both right, and they both won. Sort of.

## Prequel: a professor, a book and 12,000 lines of C

In 1987 Andrew S. Tanenbaum, a professor at the Vrije Universiteit Amsterdam, has a teaching problem. Unix is the operating system worth studying, but from Version 7 onwards AT&T no longer allows its source code to be taught at universities. The famous Lions' Commentary, which explained the Unix V6 kernel line by line, circulates only as fourth-generation photocopies passed around almost in secret.

Tanenbaum's fix is pure engineering: *if I can't use Unix, I'll rewrite it*. The result is **MINIX** (*mini-Unix*): system-call compatible with Unix V7, about 12,000 lines of code, shipped together with the book *Operating Systems: Design and Implementation*. It runs on an IBM PC with an 8088, no MMU and, if you are lucky, 640 KB of RAM.

MINIX's defining feature is architectural: it is a **microkernel**. The kernel itself does very little (scheduling, interrupts, message passing), while the file system and the memory manager are *separate processes* that talk to each other through messages. It is clean, elegant and easy to explain in a lecture. It also has two limits. Tanenbaum wants it **small and educational**, so he turns down most patches. And the licence lets you read and study the code, but not redistribute modified versions.

## 1991: a 386, a modem and a sacrificed disk

On 5 January 1991 Linus Torvalds, a computer science student at the University of Helsinki, buys a PC on instalments: an **Intel 80386DX at 33 MHz**, 4 MB of RAM and a 40 MB hard disk. He installs MINIX (it arrived by post, on floppies, after weeks of waiting) and starts complaining. The terminal is weak, and he wants to really use the 386: 32-bit protected mode, paging and hardware task switching.

His first program is not an operating system. It is a test of the 386's task switching, written in assembly and booted directly, with no MINIX underneath. There are two tasks: one prints `A`, the other prints `B`, and a timer interrupt switches between them. The result is a screen full of `AAAABBBBAAAABBBB`, and anyone who has ever written a scheduler knows what a beautiful moment that is.

From there the project grows one piece at a time. The two tasks become a terminal emulator (one reads the keyboard and writes to the modem, the other reads the modem and writes to the screen) so Linus can reach the university server and read Usenet. Then he needs to download files, so he writes a disk driver. Then he needs a file system, and picks MINIX's so he can share data. At some point he notices that his terminal emulator looks more and more like a kernel.

According to Linus's own account, around this time he also makes a memorable mistake. He means to make the modem dial a number, but writes to the **disk** device instead, overwriting his MINIX partition with AT commands. The choice is now between reinstalling MINIX or making his kernel able to compile itself. Guess which one he picks.

## 25 August 1991: "just a hobby"

The message that announced Linux to the world, posted to the `comp.os.minix` newsgroup, is probably the most successful understatement in engineering history:

> 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've currently ported bash(1.08) and gcc(1.40), and things seem to work.

In the same post Linus adds that the system *"is NOT portable (uses 386 task switching etc), and it probably never will support anything other than AT-harddisks, as that's all I have :-("*. Today Linux runs on about twenty architectures, from microcontrollers to IBM Z mainframes, and on all 500 machines in the TOP500 supercomputer list. All according to plan, obviously.

On 17 September 1991 version **0.01** lands on the FTP server `ftp.funet.fi`. Linus wanted to call it **Freax** (*free* \+ *freak* \+ *x*) and thought "Linux" was too egotistical. Ari Lemmke, who ran the server, did not like "Freax" and created the directory `pub/OS/Linux`. The name stuck. That is roughly the story of every name in computing: whoever creates the directory decides.

Version 0.01 has about 10,000 lines of code. You need MINIX to build it, and the kernel cannot yet be used on its own. The announcement of 0.02, on 5 October, already has the right tone, though:

> Do you pine for the nice days of minix-1.1, when men were men and wrote their own device drivers?

## How it was built, technically

Linux 0.01 is a **monolithic kernel** in the most literal sense. The scheduler, memory management, the file system and the keyboard, console, serial and disk drivers all run in the same address space, in ring 0 of the 386, and call each other through plain C function calls. A few details that make people smile today:

- context switches use the 386's **hardware task switching** directly (a TSS and an `ljmp` to the task's selector), a choice Linux later dropped once software context switching turned out to be faster;
- the number of processes is fixed: `NR_TASKS` is 64, and it is a static array;
- memory is split into 64 MB segments per process, using the 386's segmentation together with paging;
- the keyboard is set up for the Finnish/Swedish layout, because that is what Linus had on his desk.

The difference from MINIX is easy to see if you follow a simple `read()`. In Linux the whole path stays inside the kernel:

```c
/* Linux (monolithic): one trap, then just function calls */
read(fd, buf, n)
  └─ int 0x80            /* enter the kernel, ring 0 */
     └─ sys_read()
        └─ file_read()   /* file system, same memory */
           └─ bread()    /* buffer cache */
              └─ ll_rw_block()   /* disk driver: just another function */
```

In MINIX the same operation is an exchange of messages between separate processes:

```c
/* MINIX (microkernel): libc packs a message */
message m;
m.m_type = READ;
m.m1_i1  = fd;  m.m1_i2 = n;  m.m1_p1 = buf;
sendrec(FS, &m);   /* trap: the kernel copies the message to the FS process */
/* FS (user process) -> sendrec to the disk task -> interrupt -> reply
   -> the kernel copies the data -> reply to the user.
   Every arrow is a context switch and a message copy. */
```

In the first case each step costs about as much as a `call`. In the second it costs a trip through the kernel, a copy and a context switch. On a 1991 386, with no L2 cache worth mentioning and TLBs flushed on every address-space switch, that is a huge difference. This is where the fight begins.

## 29 January 1992: "LINUX is obsolete"

Tanenbaum, who knows a thing or two about operating systems, looks at the kernel taking over the newsgroup of *his* operating system and posts a message with an unambiguous subject line: **"LINUX is obsolete"**. He makes two criticisms, both serious:

1. **Architecture.** In Tanenbaum's view the microkernel versus monolithic debate has been settled for years, and microkernels won. A monolithic kernel in 1991 is *"a giant step back into the 1970s"*.
2. **Portability.** Tying an operating system to one CPU, and a weird one like the x86 at that, is for him *"basically wrong"*. The future is RISC: SPARC, MIPS and friends. He even makes a very specific prediction: five years from now everyone will be running free GNU on a 200-MIPS, 64 MB SPARCstation-5.

In a later post he adds the line everyone remembers: *"Be thankful you are not my student. You would not get a high grade for such a design :-)"*. In other words: you fail, but with a smiley.

Linus is 22, with all the diplomacy that implies. His reply opens with *"Well, with a subject like this, I'm afraid I'll have to reply"*. He admits that *"from a theoretical (and aesthetical) standpoint linux looses"*, but argues that Linux beats MINIX in almost everything that matters in practice. Then comes the line that became legend: *"Your job is being a professor and researcher: That's one hell of a good excuse for some of the brain-damages of minix"*.

Ken Thompson, one of the creators of Unix, joins the discussion, along with many others. The thread runs for weeks. In the end Linus apologises for his tone, Tanenbaum keeps his opinion, and everyone goes back to writing code. Today Usenet flame wars are called "GitHub discussions" and work exactly the same way.

## So who was right?

Technically: both of them, in different ways.

**Tanenbaum was right about the principles.** Isolating drivers in separate processes makes a system more robust, and it is true that most crashes in monolithic kernels come from drivers. Modern microkernels have also shown that IPC does not have to be slow. In 1993 Jochen Liedtke's L4 cut the cost of IPC to a fraction of Mach's, and in 2009 **seL4** became the first general-purpose kernel with a formal proof of correctness. QNX, a microkernel, has run safety-critical systems and cars for decades.

**He was wrong about the CPU.** The x86 did not disappear: it ate the RISC workstations, and then the servers. GNU did not arrive either: the Hurd kernel, a microkernel built on Mach, still has not reached version 1.0 in 2025\. Meanwhile Linux, born "not portable", became the most widely ported kernel in history.

**Linus was right about engineering.** A system that works today, on hardware people actually own, with an open development model, beats an elegant system that does not accept patches. The kernel stayed monolithic but became modular. It got loadable modules in the mid-1990s and, over the years, quietly borrowed a few microkernel ideas:

- **FUSE** (2005): file systems in user space, which is exactly what MINIX did;
- **UIO/VFIO**: user-space drivers, used by DPDK and by virtual machines with device passthrough;
- **eBPF**: code loaded into the kernel at runtime, but verified before it runs;
- **sched\_ext** (6.12, 2024): schedulers written as BPF programs and swappable at runtime.

For that matter, the famous "monolithic" kernels are not entirely monolithic either. XNU (macOS/iOS) is Mach plus BSD in a single address space, and Windows NT calls itself "hybrid". The debate never really ended: everyone took something from the others.

## The real plot twist: the GPL

If there is one reason Linux won, it is legal rather than technical. The first Linux licence banned any commercial use, even charging for a copy on floppy disks. With version **0.12**, in early 1992, Linus announced the move to the **GNU GPL v2**: anyone can use, modify and redistribute the code, as long as their changes stay free.

That was the missing piece. The GNU project already had the compiler, the shell, the coreutils and the C library, but no working kernel. Linux had the kernel but nothing else. Together they made a complete operating system, and the distributions followed: SLS, then Slackware and Debian in 1993\. MINIX, meanwhile, remained an educational system with a restrictive licence (it only became free software in 2000, under a BSD licence).

On 14 March 1994 **Linux 1.0** is released, with about 176,000 lines of code. Today, with 6.16 released at the end of July, the kernel has more than 30 million, thousands of contributors per release and a new version every nine or ten weeks. Not bad for a hobby that was never going to be big and professional.

## Epilogue: who laughs last

In 1996 Linux picks a mascot: a penguin drawn by Larry Ewing in GIMP. Linus says he was once nipped by a penguin at a zoo in Australia, and has been fond of them ever since. The penguin is named Tux.

MINIX, on the other hand, gets an ending worthy of a novel. In 2005 Tanenbaum releases **MINIX 3**, a microkernel built for reliability: if a driver crashes, a "reincarnation" server restarts it without stopping the system. Since 2015 MINIX 3 has been running, unknown to almost everyone, inside the **Intel Management Engine**, the hidden microcontroller in Intel chipsets. In 2017 Tanenbaum wrote an open letter to Intel saying he would have liked to be told, and that MINIX is very probably *the most widely used operating system on x86 computers in the world*.

So if you own a recent Intel PC, it runs two operating systems: Linux (or whichever one you prefer) and, hidden underneath, MINIX. Thirty years later, Tanenbaum and Linus share the same machine. Tanenbaum even got the more privileged ring.

## TL;DR for the scrollers

| Date        | Event                                         | Comment                                    |
| ----------- | --------------------------------------------- | ------------------------------------------ |
| 1987        | MINIX 1.0 + Tanenbaum's book                  | Teaching Unix, microkernel, 12k lines      |
| Jan 1991    | Linus buys a 386                              | Hardware task switching, first love        |
| 25 Aug 1991 | "just a hobby, won't be big and professional" | Least accurate prediction ever             |
| 17 Sep 1991 | Linux 0.01 on ftp.funet.fi                    | Was supposed to be called Freax            |
| 29 Jan 1992 | "LINUX is obsolete"                           | The most quoted flame war of all time      |
| Early 1992  | Linux 0.12 → GPL v2                           | The real reason it won                     |
| 14 Mar 1994 | Linux 1.0                                     | 176k lines, more than 30 million today     |
| 2015–2017   | MINIX 3 inside Intel ME                       | Tanenbaum runs on more x86 CPUs than Linus |

The engineering moral: you can be right in theory and wrong in practice, or the other way round, and sometimes both in the same thread. And every time you start a container, you are using the namespaces of a monolithic kernel that has been "obsolete" since 1992.

See you at the next bit's tale. 🐧