The history of Unix and Linux, 1969 to now

The history of Unix and Linux, in short

The history of Unix and Linux is one long argument about who is allowed to own the source code. Unix started at Bell Labs in 1969. Linux started in Helsinki in 1991 and shares none of that original code. What travelled between them was a design and a set of published interfaces: files, processes, pipes, and a shell that joins small programs together. Unix spread through universities in the 1970s because a 1956 antitrust settlement barred AT&T (American Telephone and Telegraph) from selling software, so Bell Labs licensed the source cheaply instead. Unix ended up everywhere while belonging to nobody outside AT&T, and the licensing fights that followed decided which free Unix-like system ended up in your server rack.

1969: a spare PDP-7, and the ideas that stuck

Bell Labs pulled out of the Multics project in 1969. Multics (multiplexed information and computing service) was a large time-sharing system built with MIT and General Electric, and the Labs decided it was too big to finish. Ken Thompson kept the ideas he liked and dropped the rest, writing a small time-sharing system on a cast-off PDP-7 minicomputer. Dennis Ritchie joined him. The name Unix was a joke at Multics's expense.

In 1970 the system moved to a PDP-11 that the Labs bought for the patent department's typists, because a text processing tool was easier to fund than an operating system. That machine had 24 KB of core memory, split between the system and user programs. The funding accident is why the first Unix manual, dated November 1971, was a set of formatted documents, and it is why you still type man 5 crontab. The section numbers in that manual are the section numbers in yours.

Two changes made the design permanent. Pipes arrived in Version 3 in 1973, because Doug McIlroy had argued for years that you should be able to join programs end to end, and Thompson added the | operator so one program's output became the next program's input. Then Version 4, later in 1973, was rewritten in C. An operating system written in a portable language can move to hardware it was not written for, which is why Unix outlived every machine it started on.

Why Unix spread: AT&T was not allowed to sell it

A 1956 consent decree settled an antitrust case against AT&T. AT&T kept its telephone monopoly and accepted a limit in return: it would stay out of businesses other than telecommunications. Software was one of those businesses. So when universities asked for Unix, Bell Labs could not sell it as a product. It licensed the source for a nominal fee, with no support and no warranty.

The effect was large, and it was not what AT&T planned. Sixth Edition Unix, released in 1975, reached hundreds of computer science departments with full source. John Lions at the University of New South Wales printed that kernel source with a line-by-line commentary and taught from it. A generation learned how an operating system works by reading a real one.

Then the license changed. The Seventh Edition license in 1979 forbade using the source in classes, so the Lions commentary circulated as photocopies of photocopies. This is the shape of the whole story. Unix was everywhere and unfree at the same time, so every improvement anyone made was an improvement to somebody else's proprietary code.

Berkeley: the parts of Unix you actually type

Ken Thompson spent the 1975 to 1976 academic year at the University of California, Berkeley, and left a very active Unix group behind him. Berkeley's Computer Systems Research Group (CSRG) shipped tapes of local improvements, and those tapes became BSD, the Berkeley Software Distribution. Bill Joy wrote much of the early work: 1BSD in 1978, then 2BSD in 1979 carrying the vi editor and the C shell.

The C shell is where !! and !$ come from. Bash inherited that syntax, which is why bash history expansion still surprises people who type an exclamation mark inside double quotes forty-odd years later.

DARPA (the US Defense Advanced Research Projects Agency) then paid Berkeley to put the new internet protocols into Unix. 4.2BSD, released in August 1983, shipped TCP/IP (transmission control protocol over internet protocol) and the socket application programming interface. Every network service on your server still calls socket(), bind(), listen() and accept() in that order, because Berkeley picked those names in 1983.

One detail decided the next decade. A BSD tape was not a complete system. It was a set of additions to AT&T's Unix, and you needed a valid AT&T source license to run it legally. Berkeley replaced the AT&T parts with its own code over several years, file by file. Whether that replacement was truly complete is the question that later went to court.

1984: the breakup, then the Unix wars

The Bell System was broken up on 1 January 1984, and the consent decree that had kept AT&T out of the software business went with it. AT&T could now sell Unix as a product, and it did. Commercial source licenses got expensive, so Unix stopped being the cheap thing a university handed to students.

The vendors had already forked it. Every workstation company shipped its own Unix on its own hardware, so by the late 1980s a program written for one needed porting to the next. The industry split into two standards camps in 1988, the Open Software Foundation on one side and Unix International on the other, and spent years shipping incompatible systems while arguing about whose Unix was the real one.

POSIX (portable operating system interface) came out of that mess. IEEE 1003.1 was published in 1988, and it wrote down what a Unix-like system must do: the system calls, the shell behaviour, the standard utilities, and the C library interfaces. This matters more than it sounds, because a standard is a specification and no license covers it. Three years later a student wrote a kernel against those documents.

Minix, and the gap it left

Andrew Tanenbaum released Minix in 1987 as the teaching system for his operating systems textbook. Minix was a small Unix-like system, the source came with the book, and it ran on the cheap PCs students actually owned. It was legal to read in a classroom, which Seventh Edition Unix no longer was.

Minix stayed small on purpose, because it had to be explainable in a book, and Tanenbaum turned down patches that would have made it a production system. The license was not free either: you bought the book, and redistributing your modified Minix was not your decision to make. So by 1991 a student could read a working Unix-like kernel and could not build anything lasting on it.

GNU had everything except a kernel

Richard Stallman announced the GNU project in September 1983, aiming at a complete free Unix-like system. By 1991 GNU had produced most of the parts that surround a kernel: the GCC compiler, the GNU C library, the binary utilities, and bash, the shell Brian Fox wrote in 1989 and the shell your server still starts you in. The GNU kernel, Hurd, was the piece that kept slipping.

The GNU General Public License version 2 was published in June 1991. Its rule is short. You may use the code and change it, and if you distribute the result, you must distribute the source under the same terms. That rule becomes the hinge of this story two sections from now.

August 1991: the post to comp.os.minix

On 25 August 1991 a student in Helsinki posted to the Usenet group comp.os.minix:

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.

Version 0.01 went out in September 1991. It shared code with neither Unix nor Minix. It was a new kernel for the 386, developed on a Minix machine, written against the POSIX interfaces, and paired with the GNU tools that already existed. Tanenbaum told Torvalds in January 1992 that a monolithic kernel was an obsolete design. He had a real point about design, and Torvalds was answering a different question: what runs well on the one cheap computer a student owns.

In February 1992, version 0.12 was relicensed under the GPL. Torvalds has since called that his best decision. The original Linux license forbade any money changing hands, which would have blocked the CD vendors and the support companies that came next. The GPL allowed commerce while forcing every distributed change back into the same shared tree.

The lawsuit: April 1992 to February 1994

Berkeley released Networking Release 2 (Net/2) in June 1991: nearly a complete BSD system, with the AT&T-derived files taken out. Six kernel files were missing. Bill and Lynne Jolitz wrote replacements and released 386BSD 0.0 in March 1992, then 386BSD 0.1 on 14 July 1992. A free, complete, mature BSD for the 386 now existed, at the same moment Linux was still a hobby kernel. Berkeley Software Design, Inc. (BSDi) sold a supported commercial build, BSD/386, and advertised it with the telephone number 1-800-ITS-UNIX.

In April 1992, Unix System Laboratories (USL), the AT&T subsidiary that then owned Unix, sued BSDi in federal court in New Jersey over trade secrets and the Unix trademark. The suit was later amended to add the Regents of the University of California. The University countersued in California in 1993, arguing that AT&T had shipped Berkeley code inside System V without the credit its own license required.

The legal core came apart in 1993. Judge Dickinson Debevoise refused USL a preliminary injunction, taking the view that USL's copyright claim over the older 32V code was probably invalid, because AT&T had distributed that code for years without copyright notices. Novell bought USL from AT&T in mid-1993, and Novell's management wanted the fight finished. The case settled in February 1994. Of roughly 18,000 files in the Berkeley distribution, three were removed and about seventy gained USL copyright notices.

Berkeley shipped 4.4BSD-Lite in June 1994 and it was legally clean. FreeBSD and NetBSD, both founded in 1993 on the disputed Net/2 code, then had to rebuild their systems on the new base, which took most of the rest of 1994. Linux 1.0 was released in March 1994, in the middle of that rebuild.

Why did Linux take the server and not BSD?

The lawsuit is the popular answer, and it is part of the answer. Between April 1992 and February 1994, anyone choosing a free Unix for a product had to weigh a live claim by AT&T's lawyers against a kernel from a Finnish student that no one could sue over. That was the exact window when the web arrived and when the first Linux distributions appeared: Slackware in July 1993, Debian in August 1993, then Red Hat and SUSE.

Four other things mattered as much as the court case.

• Hardware. Linux targeted the commodity 386 PC from its first line of code, and that is the hardware that became cheap. BSD's centre of gravity was the VAX and the workstation, and the 386 port was an outside effort by two people.
• The license. The GPL requires a company shipping a modified kernel to publish its changes, so vendor work flowed back into one tree. The BSD license lets a company keep its changes private, and companies did keep them.
• The development model. Torvalds merged patches from strangers quickly and released constantly. 386BSD released slowly enough that its own users forked it twice in 1993, into NetBSD and FreeBSD, and again into OpenBSD in 1995.
• Momentum. Developers go where the other developers already are, and drivers get written for the system that has the most users.

Be honest about the technical question. BSD in 1994 was the more finished system, with a coherent base, a documented history, and networking code that Linux spent years catching up with. Nobody picked Linux in 1994 because it was better. People picked it because it was available, unencumbered, running on hardware they already owned, and improving every week.

What BSD kept, and where it runs now

BSD kept going. What it lost was the default position. The clearest evidence sits on your own machine: the OpenBSD project wrote OpenSSH in 1999, and it is the SSH server on nearly every Linux system shipped today, which is why the SSH key habits worth learning are identical on both families.

Netflix serves video from FreeBSD appliances. Junos, the operating system on Juniper routers, is FreeBSD underneath. The PlayStation system software descends from FreeBSD. Apple's macOS and iOS carry BSD code in the kernel and across the userland. The permissive license that cost BSD the shared server tree put BSD code inside a great deal of hardware that never mentions it.

If you are choosing today, the question is practical rather than historical. Comparing Linux and FreeBSD as a server comes down to ZFS, jails, the ports tree, and how much third party software assumes Linux underneath. FreeBSD 15 as a server is a current, maintained system rather than a museum exhibit. And Linux against Windows Server is a separate question with an answer that depends on your application stack.

The 1969 design you use on a VPS today

Each of these is older than most of the people using it.

• The pipe. who | wc -l counts logged-in users because Version 3 Unix in 1973 let one program's output become another program's input.
• The manual sections. man 1 ls and man 5 crontab use the numbering scheme from the November 1971 manual.
• The filesystem split. /usr exists because the root disk on that PDP-11 filled up in 1971 and the developers moved files onto the second disk pack. Distributions have since undone the split: run ls -ld /bin on Ubuntu 24.04 or Debian 13 and you get a symbolic link to usr/bin.
• The socket calls. Berkeley wrote them for 4.2BSD in 1983, and every network daemon still uses them.
• POSIX. A #!/bin/sh script written against the standard runs unchanged on Linux, on FreeBSD, on macOS, and on Solaris, because the standard is the thing all of them implemented.

When you rent a virtual private server and log in, you are typing at an interface designed for a machine with 24 KB of memory and a patent department to serve. It survived because the interface was published, argued over, standardised, and then reimplemented from scratch by people who were never allowed to see the original code.

FAQ

Does Linux contain any original Unix code?

No. Linus Torvalds wrote the kernel from scratch starting in 1991, targeting the POSIX interfaces rather than any AT&T source. The Unix inheritance is a design and a published interface: files, processes, pipes, and the system call names. The GNU tools around the kernel were also written from scratch, starting in 1983. That independence is the reason the AT&T litigation over BSD code never touched Linux at all.

When was the AT&T lawsuit against BSD, and did it kill BSD?

USL, the AT&T subsidiary that owned Unix, sued BSDi in April 1992 and later added the University of California as a defendant. In 1993 the judge refused a preliminary injunction, holding that the copyright claim over the older 32V code was likely invalid. Novell bought USL in mid-1993 and settled the case in February 1994, with three files out of about 18,000 removed and roughly seventy given new copyright notices. It did not kill BSD. It froze BSD adoption during the two years when the world was choosing a free Unix.

Why did Linux take over servers instead of BSD?

Legal certainty was one reason: through 1992 and 1993, Linux carried no lawsuit and BSD carried one. The others were the 386 as a target from day one, the GPL pulling vendor changes back into a single tree, and a merge process fast enough to keep contributors interested while 386BSD forked three ways. Technical merit was not the deciding factor, because BSD was the more finished system in 1994.

Is FreeBSD still worth running today?

Yes, and for concrete reasons: ZFS integrated with the base system, jails as a mature isolation model, a base system developed as one coherent unit, and documentation that stays accurate. The cost is compatibility work, because most third party server software, container tooling, and vendor support assume Linux. Pick FreeBSD when its storage and networking work earns that cost, rather than out of loyalty to the older lineage.