Fifty Years of Freedom: A History of Unix

Diagram of Unix history

The Roots of Software Freedom

The beginnings of the software freedom movement can be traced backed to the 1970s with the birth of UNIX.

Researchers at Bell Labs were creating a new operating system and, with it, an innovative approach to computing now known as the Unix Philosophy.

At the time, software freedom had not been formally defined. Unix itself was funded and owned by AT&T. Due to a court order, however, AT&T was legally forbidden to conduct any business not related to telephony. As a result, AT&T decided to distribute Unix to academic and research institutions for merely the cost of media. Each Unix installation included complete source code. Thanks to AT&T's benign neglect, academic users were given the ability to study the code, modify it, and create new works. And so, the software freedom movement was born.

What made Unix special was how its philosophy was a perfect match for the free software community. Unlike many other commercial operating systems, Unix was designed from the beginning to be fully programmable by its users. In Unix, users could combine simple components together to create a highly programmable system. Each installation of the operating system came with complete source code, written in a powerful, high-level language designed for portability: C. A simplified, uniform filesystem made it easy to work with peripherals. Programs were written to work with text streams, making it easy to reuse existing programs for novel purposes. Taken together, these design choices made it easy for users to understand, modify, and extend their system.

The Unix philosophy encouraged users to explore, experiment, and create -- often in ways not envisioned by the original Bell Labs creators. If there was a missing program, the user could create a shell script by stringing together smaller components in long pipelines. If there was a missing feature, the user could modify the program's source code on the spot. At the time, many operating systems were written in assembly or other low-level languages. With Unix, full source code and a compiler was provided so that users could make these changes. In fact, the system was even ported to new hardware without consulting the original authors. The net result was users could quickly add features. New text editors, new shells, even a new filesystem and a complete networking stack were added outside of Bell Labs.

For the first time, the user community was able to obtain such power to create code with Unix. Academic and research institutions received this for the trivial cost of media. Unix's users now had a powerful platform that could be used to create new tools that exceeded the designs of its original authors.

The Right to Code

The Unix kernel itself was less than 10,000 lines, making it 10x to 100x smaller than proprietary operating system kernels at the time. In fact, Unix's small size was not a coincidence, but a virtue. For the free and open source community, simple code meant students could understand and contribute code. Unix users were able to read, understand, and contribute to the operating system without decades of professional training. UNIX Sixth Edition was released in 1975; by 1977, John Lions had published the source code with his commentary, and the book was widely circulated by researchers in universities around the world (John Lions' A Commentary on the Sixth Edition Unix).

Because of Unix's open nature, its users immediately began to write new software that its creators did not anticipate. At USENIX groups, users shared software freely with one another and made improvements to the system's performance and features. By 1977, Tom Lyon at Princeton ported parts of Unix to a new architecture without involvement from the Bell Labs team. In 1980, two university students at Duke created a public domain version of Netnews and provided it to be freely distributed on USENIX tapes. This would quickly grow to be Usenet.

The University of California, Berkeley had licensed Unix Sixth Edition, and right away it began to work on its own customized version, the Berkeley Software Distribution (BSD). In 1977, Bill Joy wrote vi, the first Unix text editor to use an entire screen. The next year, he began distributing the C shell bundled in free copies of BSD. By 1980, networking features were added to BSD, becoming the first free TCP/IP implementation for Unix. Other innovations included job control and curses.

In 1984, Richard Stallman at MIT began porting Emacs to Unix. During this time, he published the GNU manifesto for software freedom, which clearly stated that users ought to have the right to freely use, study, share, and fork their software. Stallman went on to create one of the first free C compilers for UNIX, the GNU C Compiler (gcc). The movement for software freedom was in full swing.

Software Independence

When AT&T's lawyers noticed Unix's success, it tried to clamp down and restrict their previously generous terms. By late 1978, it was no longer possible to purchase the Sixth edition code with commentary. By 1981, AT&T's UNIX System III no longer came with source code. Universities were no longer allowed to freely redistribute source code for teaching. But by this time, Unix's users had been deeply steeped in software freedom. It was too late to suppress what had been openly shared for years.

Users resisted the changes. Bootlegged photocopies of Lions' commentary on Sixth Edition Unix continued to circulate widely throughout academia. Many users continued to purchase either Unix V7 or BSD, where they still had access to the source code. Still others were determined to create a free Unix clone.

When Andy Tanenbaum discovered he could no longer use Unix freely for teaching, he decided to write his own clone: Minix. This Unix-compatible clone targeted the upcoming architecture, IBM-compatible PCs, which became popular in the 1990s. MINIX contained no AT&T code but emulated UNIX, came with its own C compiler, a Bourne-like shell, and text editors. It was available for educational use by 1987.

Meanwhile, the Computer Systems Research Group (CSRG) at Berkeley continued distributing new improvements to BSD. The CSRG worked to remove all references to the original AT&T source code. By 1988, a BSD release was completed which had no AT&T source code, which could be redistributed freely over FTP.

Finally, in 1991, Linus Torvalds uploaded version 0.01 of his kernel, to complete the most famous Unix-like clone in history. With the Linux kernel in place, and GNU userland, the Linux operating system quickly became the Unix clone of choice for the free community.

From 1990 to 2020, the world witnessed these Unix-like clones take over the Internet. The free and open source movement succeeded because of the triumph of the UNIX philosophy.

The Unix Philosophy

It is no coincidence that Unix provided such fertile ground for software freedom. Although other attempts were made at software freedom, none of them had the same impact as the Unix-like clones, because the Unix philosophy in particular works in harmony with the ideals of the free software movement. With Unix, users are involved with writing code for their own system. Software development is simpler, easier to maintain, and accessible for users. Software that ignores this philosophy often becomes too complex for users to code for.

The ability for you, the user, to be able to personally modify your software and to create new programs has always been an essential pillar of software freedom.

Plan 9

While Unix was achieving success in the free user community, researchers from the Bell Labs team were brainstorming ways to make a better operating system. They invented a new system called Plan 9, to carry the Unix philosophy to new heights.