The Unix Story: The Operating System That Ate the World

The World Before Unix: Multics and the Overreach

In the mid-1960s, the most ambitious software project in history was underway at MIT, Bell Labs, and General Electric. Multics — Multiplexed Information and Computing Service — was designed to be a utility as reliable and universal as the electrical grid: a time-sharing system that would provide computing power to an entire city from a single machine, handling hundreds of simultaneous users with sophisticated security, dynamic linking, and online file storage.

Multics was technically visionary and practically catastrophic. The specification grew to thousands of pages. The system required a specially designed GE-645 mainframe. It was years behind schedule, vastly over budget, and consumed enormous resources from all three institutions. In 1969, Bell Labs — the research arm of AT&T — made the decision to withdraw from the Multics project.

The lesson its alumni drew was not that the goal was wrong but that the approach was. Multics had failed because it tried to do everything at once.

The Closet Project: 1969

Ken Thompson was a programmer at Bell Labs who had worked on Multics and was deeply frustrated by its absence. He missed having a comfortable, interactive computing environment. He also had a half-finished space travel simulation — a program that calculated the orbits of planets and let you navigate a spaceship through the solar system — that he needed a machine to run on.

In the summer of 1969, he found an underused PDP-7 in a corner of Bell Labs’ Murray Hill, New Jersey facility. It had 8 kilobytes of memory and no operating system worth using. Thompson spent three weeks writing one. The first week: a kernel. The second week: a shell. The third week: an assembler and basic utilities.

His colleague Dennis Ritchie described the speed of the work in characteristic understatement: “Ken alone created Unix.”

What Thompson had built was, by any objective measure, far less capable than Multics. It ran on a single user at a time, on modest hardware, with minimal features. But where Multics was a cathedral — complex, hierarchical, designed for maximum capability — Thompson’s system was something different: a collection of small, sharp tools that composed cleanly together. He named it Unix, a pun on Multics — one rather than many.

The Philosophy: Small Tools, Sharp Edges

Unix was built around a handful of ideas that, in retrospect, look like design principles but were in practice instincts:

Everything is a file. Disk files, keyboard input, terminal output, network connections — all were represented as streams of bytes, accessed through the same read/write interface. A program that could read from a file could, with no modification, read from a keyboard or a network socket.

Pipes. In 1972, Doug McIlroy — Thompson’s colleague and the head of Bell Labs’ computing research center — proposed that programs should be able to connect their outputs to each other’s inputs, like physical pipes. A text file could be sorted, filtered for lines matching a pattern, and counted, in a single command:

sort names.txt | grep "Smith" | wc -l

Each program did one thing well. The intelligence was in the composition.

The shell as a programming language. The shell — the command interpreter — was not bolted on but designed from the start to be scriptable. Sequences of commands could be stored in files and executed as programs. The line between “commands” and “programs” did not exist.

These ideas were not invented by Thompson and Ritchie — they had intellectual roots in earlier systems. But Unix was the first environment where they cohered into a complete, usable whole. The Unix philosophy — articulated most clearly by McIlroy as “write programs that do one thing and do it well; write programs that work together; write programs that handle text streams, because that is a universal interface” — was less a manifesto than a description of what had naturally emerged.

Dennis Ritchie and the C Language

The PDP-7 was a specific machine with a specific instruction set. A Unix written in assembly language for it was useless on any other hardware. This was a fundamental limitation if Unix was to spread.

The solution was a new programming language. Dennis Ritchie, working from an earlier language called B that Thompson had adapted from BCPL, designed C (1972): a language that provided high-level constructs — functions, structured control flow, type declarations — while retaining direct access to memory via pointers and support for low-level bit manipulation. C was close enough to the hardware to be efficient; abstract enough to be portable.

In 1973, Thompson and Ritchie rewrote the Unix kernel in C. It was the first operating system written primarily in a high-level language. The result was transformative: the same Unix could now run on different hardware simply by recompiling the source code. Portability, previously a theoretical goal, had become practical.

The relationship between Unix and C was symbiotic. C was designed to write Unix; Unix was written in C; the spread of Unix carried C into every computing environment it touched. By the 1980s, C had become the universal language of systems programming. Its fuller story is told in The Evolution of Language.

The University Years: Version 6 and the BSD Fork

AT&T, as a regulated telephone monopoly, was legally prohibited from competing in the computer market. This meant Unix could not be sold commercially. Instead, Bell Labs licensed it to universities for a nominal fee — often just the cost of the magnetic tape it was shipped on.

The effect was an explosion of Unix adoption in academic computing. By the mid-1970s, Unix ran at virtually every major computer science department in the United States. An entire generation of researchers, students, and eventually industry programmers learned computing on Unix systems.

At the University of California, Berkeley, a computer science graduate student named Bill Joy received a copy of Unix Version 6 in 1975. Joy was a programmer of extraordinary ability — he would later co-found Sun Microsystems and lead the development of Java. At Berkeley, he began modifying and extending Unix, producing a series of software distributions that he sent, on tape, to other universities: the Berkeley Software Distribution (BSD).

Joy’s contributions were substantial:

• vi (1976): A visual text editor that became the standard Unix editing environment and remains in use today.
• csh (the C shell): An interactive shell with history and job control.
• Fast file system: A rewrite of Unix’s storage layer that dramatically improved disk performance.
• TCP/IP integration (1983): BSD Unix was the vehicle through which the ARPANET protocols reached the academic world. When ARPA funded BSD to integrate TCP/IP into its Unix distribution, it ensured that the internet’s protocol suite would spread with the most popular academic operating system. The broader story of this transition is told in The Connected World.

The Commercial Wave: Sun, HP, IBM, and the Workstation Era

By the early 1980s, Unix had acquired a second constituency alongside universities: the nascent workstation industry.

Sun Microsystems, founded in 1982 by Joy and three Stanford colleagues, built its entire business on a Unix workstation. SunOS — based on BSD — was shipped on every Sun machine. Sun’s bet was that scientists and engineers needed more computing power than a personal computer could provide but did not need (and could not afford) a mainframe. A Unix workstation, costing $10,000–$30,000, occupied the middle ground.

Sun was not alone. By the mid-1980s, every major computer vendor had its own Unix variant:

• HP-UX (Hewlett-Packard)
• AIX (IBM)
• Ultrix and Digital Unix (Digital Equipment Corporation)
• IRIX (Silicon Graphics)
• Solaris (Sun, from the early 1990s)

Unix had become the operating system of serious technical computing. It powered the workstations that designed aircraft, ran financial models, and hosted the early internet’s servers.

Dead End: Multics and Plan 9

Unix’s success threw its predecessor’s failure into sharp relief. Multics — the project Unix reacted against — did eventually ship and run, at MIT and a handful of other sites, through the 1980s. It was, by many technical measures, more sophisticated than Unix: stronger security, a more elegant file system, better support for concurrent processes. None of this mattered. Multics was too expensive, too hardware-specific, and too complex to program for. The last Multics installation was shut down in 2000. The system that tried to do everything had been displaced by the system that tried to do as little as possible.

Bell Labs’ own successor to Unix fared no better. Plan 9 (1992), designed by Thompson, Ritchie, and others, extended Unix’s “everything is a file” principle to its logical conclusion: network resources, user interfaces, and inter-process communication were all unified as file-system operations. The design was elegant. The disruption cost — relearning tools, rebuilding ecosystems — was not worth it for an industry already deeply committed to Unix. Plan 9 influenced later systems (including Go, the programming language Thompson eventually helped design at Google) but never achieved adoption.

The Unix Wars and the Legal Crisis

Through the 1980s, the proliferation of Unix variants became a liability. Programs written for SunOS required modification to run on HP-UX; scripts that worked on BSD needed adjustment for AIX. The industry attempted standardization through committees — POSIX (Portable Operating System Interface), X/Open, the OSF (Open Software Foundation) — but produced specifications that each vendor interpreted selectively.

Then came the legal crisis. AT&T, deregulated in 1984, was now free to compete commercially. Its Unix Systems Laboratories (USL) began asserting that BSD Unix contained AT&T proprietary code that the Berkeley developers had incorporated without a valid license. In 1992, USL filed suit against the University of California.

The lawsuit froze BSD Unix development for nearly two years. Organizations that might have standardized around a free BSD waited. The vacuum was filled by Linus Torvalds’ Linux kernel, released in 1991 and gaining momentum precisely during the period BSD was legally paralyzed. When the suit settled in 1994 — with most BSD code cleared — Linux had become the rallying point for the community that would have otherwise backed BSD. The story of how Linux filled that vacuum is told in The Open Source Revolution.

Legacy: The Unix That Won by Disappearing

Unix did not win the operating system wars in any conventional sense. The commercial Unix variants — SunOS, HP-UX, AIX, IRIX — are either dead or irrelevant to the modern industry. AT&T’s own Unix lineage ended with SCO’s failed attempts to monetize Unix patents in the 2000s.

And yet Unix is everywhere.

macOS is built on Darwin, a BSD-derived Unix kernel developed by Apple after Steve Jobs returned from NeXT — a company whose operating system, NeXTSTEP, was itself a BSD Unix variant. Every Mac, iPhone, and iPad runs a direct descendant of the code Ken Thompson wrote on that PDP-7 in 1969.

Linux is architecturally Unix — same file hierarchy, same shell, same philosophy — even though it shares no code with the original. It runs the majority of the world’s servers, all of Android, and most of the cloud infrastructure through which modern computing flows.

The Unix philosophy — composable tools, text interfaces, separation of mechanism from policy — shaped the design of Python, the architecture of the internet’s service layer, and the culture of the open source movement.

Thompson and Ritchie received the Turing Award in 1983, the first time it was awarded for work on an operating system. Ritchie died in 2011; Thompson, now in his eighties, worked at Google until recently, where he co-designed the programming language Go.

The space travel game, incidentally, was completed. It ran on Unix. Thompson was reported to have found the simulation somewhat unsatisfying — the physics were not quite right — but the operating system he wrote to run it changed everything.

For the programming language Unix was written in, see The Evolution of Language. For the movement Unix directly enabled, see The Open Source Revolution.

📚 Sources

• Ritchie, Dennis M. & Thompson, Ken: “The UNIX Time-Sharing System” — Communications of the ACM, Vol. 17, No. 7 (1974)
• Salus, Peter H.: A Quarter Century of UNIX (1994), Addison-Wesley
• Kernighan, Brian W.: UNIX: A History and a Memoir (2019), self-published via Kindle Direct
• McIlroy, M. D.; Pinson, E. N. & Tague, B. A.: “UNIX Time-Sharing System: Foreword” — Bell System Technical Journal, Vol. 57, No. 6 (1978)
• Berkeley Software Distribution — Wikipedia
• Ritchie, Dennis M.: “The Development of the C Language” — ACM SIGPLAN Notices, Vol. 28, No. 3 (1993)