Skip to content
Operating Systems

History of operating systems

OS history is usually told as a list of dates, and nothing follows from it. Here it is laid out differently: at every point in time something was scarce, and a system was the answer to that scarcity. When the scarcity changed, the systems changed too. The old ones did not disappear; they moved to where their answer is still right.

This is an appendix, not a module: there is no new mechanism here to understand. It exists to put in place what the course explains piece by piece, and to make it visible that almost everything we use is older than we are.

Six scarcities

Each era on the map is not a decade but an answer to the shortage of a specific resource. The boundaries are rough: the previous scarcity does not go away, it just stops being the main one.

1955—1964scarce: machine time
batch processing
1964—1975scarce: processor attention
multiprogramming, time-sharing
1975—1990scarce: hardware cost
a PC with no protection
1990—2002scarce: compatibility and networking
POSIX, free kernels, the internet
2002—2012scarce: server utilization
virtualization, then containers
2012—scarce: cores, battery, trust
parallelism, energy, isolation

The map

Time runs top to bottom. Each system is a vertical line from its appearance to its fading, and adjacent columns belong to one family. A solid line of descent means shared code; a dashed one means inherited ideas only: Linux contains not a single line of Unix, and Windows NT is not a descendant of VMS, even though it was written by the same people. Hover over or select a system to highlight its whole lineage, from ancestors to descendants.

Hover over a system or select it with the keyboard (Tab, then the arrow keys). This panel will show where it came from and what it led to.

Map of operating systems: 55 systems in five families, time running top to bottom from 1955 to today, with lines of descent MainframesMainframesUnix and heirsUnix and heirsLinuxLinuxPersonalPersonalEmbedded andEmbedded andresearchresearchscarce: machine timescarce: processor attentionscarce: hardware costscarce: compatibility and networkingscarce: server utilizationscarce: cores, battery, trust1960197019801990200020102020GM-NAA I/O, 1956—1962. The first program that managed other programs: it read the next job from the queue by itself, and the operator was no longer needed between jobs.GM-NAA I/OCTSS, 1961—1973. The first working time-sharing system. Several terminals get processor quanta so often that each one believes the machine is its own.CTSSAtlas Supervisor, 1962—1971. Paged virtual memory and swapping to a drum, for the first time and right away in the form they still work in today.Atlas SupervisorOS/360, 1966—1974. One OS for a whole line of machines instead of a separate one for each model. The price was a schedule slip that led to “The Mythical Man-Month.”OS/360CP/CMS, 1968—1972. Instead of sharing one OS among users, each user got a virtual machine of their own. Virtualization here is over half a century old.CP/CMSMultics, 1969—2000. Protection rings, segmentation, file permissions, dynamic linking. Almost everything we consider ordinary is already here, and almost all of it too late.MulticsVM/370 → z/VM, 1972—present. A hypervisor in production use since 1972. Banking systems still run on it.VM/370 → z/VMMVS, 1974—2000. Every job gets its own address space. The name says exactly that: Multiple Virtual Storage.MVSVAX/VMS → OpenVMS, 1977—present. A tidy commercial OS from DEC. Its architect later went to Microsoft and built the NT kernel there. The kinship shows even in the subsystem names.VAX/VMS → OpenVMSz/OS, 2001—present. A direct continuation of OS/360 in the 2020s. An architecture laid down in the punch-card era processes card payments today.z/OSResearch Unix, 1969—1990. A reaction to the complexity of Multics: small programs, text as the interface, everything is a file. In 1973 the kernel was rewritten in C and moved on to other people’s hardware.Research UnixBSD, 1978—1995. The Berkeley branch. The source of sockets, virtual memory with paging to disk, and the TCP/IP stack that later spread absolutely everywhere.BSDXenix, 1980—1989. Unix from Microsoft, and in the early 1980s the most widespread Unix in the world. The company traded it for DOS and came back to Unix compatibility only in 2016.XenixSunOS, 1982—1994. A workstation for which the network is the normal mode, not an add-on. NFS and mmap in their modern form come from here.SunOSSystem V, 1983—1995. The commercial AT&T branch. The System V versus BSD split is why there are still two incompatible sets of ps flags and two styles of init.System VHP-UX, 1984—present. One of the classic commercial Unixes. Still alive, but only on the vendor’s own hardware.HP-UXMach, 1985—1994. An attempt to move everything possible out of the kernel, leaving memory and message passing. The microkernel turned out slow, but the idea went further than the code.MachAIX, 1986—present. Unix from IBM. This is where the first commercial journaling file system, JFS, appeared in 1990.AIXMINIX, 1987—present. Tanenbaum’s teaching microkernel. Its limitations are exactly what made a student in Helsinki start writing his own kernel.MINIXNEXTSTEP, 1989—1996. The Mach microkernel, a BSD environment and graphics in Objective-C. It failed commercially, and that is exactly why it became the basis of macOS.NEXTSTEP386BSD, 1992—1994. A port of BSD to the cheap 386. An AT&T lawsuit froze it for exactly the two years in which Linux managed to grow up.386BSDSolaris, 1992—present. ZFS, DTrace, zones. Three things the rest of the world spent the next fifteen years reproducing.SolarisFreeBSD, 1993—present. The kernel and userland are developed in one tree. This is where jail appeared: isolation without a virtual machine, thirteen years before Docker.FreeBSDNetBSD, 1993—present. Aims to run anywhere. The best proof that the line between OS and hardware can be kept clean.NetBSDOpenBSD, 1996—present. A fork for the sake of security. The source of OpenSSH, and also of pledge and unveil, an attempt to limit a program to exactly what it really needs.OpenBSDMac OS X → macOS, 2001—present. Mach and BSD in one kernel address space. The most widespread certified Unix on the planet, and few of its users know it.Mac OS X → macOSiOS, 2007—present. The same kernel, but every app is locked in a sandbox, and access to the camera or files is requested from the user. The mainframe permission model did not fit here.iOSLinux kernel, 1991—present. Written from scratch, without a single line from Unix, and that is exactly why it survived the lawsuits. A monolithic kernel with modules loaded on the fly.Linux kernelSlackware, 1993—present. The oldest distribution still alive. Deliberately without automation: it is put together as if package managers had not been invented yet.SlackwareDebian, 1993—present. Showed that a distribution is above all a package manager and a social contract, not a set of files.DebianRed Hat Linux, 1994—2004. RPM and the idea that you can charge money for a free kernel: for support, not for the code.Red Hat LinuxSUSE, 1994—present. The European branch that grew out of a German build of Slackware and stayed in the enterprise market.SUSEArch, 2002—present. A rolling release and a system assembled by hand from a minimum. The shortest way to see what a distribution is actually made of.ArchRHEL, 2002—present. A ten-year support cycle and SELinux by default. What lets banks write Linux into their official procedures.RHELFedora, 2003—present. The proving ground where systemd, Wayland and cgroups v2 become the default earlier than anywhere else.FedoraUbuntu, 2004—present. Debian with a predictable release schedule. The distribution most people start with and most servers end up on.UbuntuAlpine, 2006—present. musl instead of glibc, BusyBox instead of coreutils: an image of a few megabytes. Thanks to containers it became one of the most widespread userlands in the world.AlpineAndroid, 2008—present. The Linux kernel without the GNU environment. Every app is a separate kernel user: classic Unix permissions put to work as a sandbox.AndroidChromeOS, 2011—present. A read-only root partition, verified boot, two partitions for updates. Repairability was traded for being hard to break.ChromeOSCP/M, 1974—1988. The first OS that did not depend on the microcomputer maker. It set both the A: drive format and the very idea of an operating system sold separately for a personal computer.CP/MMS-DOS, 1981—2000. One user, one program, no memory protection. Any program could write anywhere, and did.MS-DOSMac System → Mac OS 9, 1984—2001. Graphics for everyone, but with cooperative multitasking: a program gave up the processor on its own. One hangs, they all hang.Mac System → Mac OS 9Windows 1.0 → 3.11, 1985—1995. A shell on top of DOS, not a system. Protection and preemptive multitasking arrived piecemeal, and only in the protected mode of the 386.Windows 1.0 → 3.11OS/2, 1987—2006. A joint attempt by IBM and Microsoft to finally build a protected system for the PC. A technical success, a market failure.OS/2Windows NT → 11, 1993—present. A hybrid kernel written from scratch by people from DEC: memory protection, preemption, access control lists. All of modern Windows is this kernel.Windows NT → 11Windows 95 → Me, 1995—2001. A compromise: a new shell and preemption on top of old 16-bit code, for the sake of compatibility with games. The blue screen as an everyday thing comes from here.Windows 95 → MeXerox Alto, 1973—1981. Windows, a mouse, on-screen fonts and a network, ten years before any of it became a product. Xerox sold nothing but showed it to everyone.Xerox AltoQNX, 1982—present. A microkernel still at work today, in cars and medical devices. Proof that the idea of Mach was not wrong, just early.QNXVxWorks, 1987—present. Hard real-time: what matters is not speed but a guaranteed upper bound on latency. It flies on Mars rovers.VxWorksPlan 9, 1992—2015. The same authors took “everything is a file” all the way: the network, windows and processes became file systems. The ideas spread around the world; the system did not.Plan 9L4, 1993—present. A microkernel rewritten for fast message passing. It lives in billions of devices, inside mobile phone modems.L4FreeRTOS, 2003—present. A scheduler of a few kilobytes for a microcontroller. Here the OS is a library built into a single image together with the program.FreeRTOSseL4, 2009—present. The first kernel with a mathematical proof that the implementation matches the specification. Not “no bugs were found” but “there are none.”seL4Zephyr, 2016—present. A modern answer to FreeRTOS: the same niche, but with drivers, networking and a device tree out of the box.ZephyrFuchsia, 2016—present. The Zircon microkernel with no Unix legacy: no global namespace, no POSIX by default. The most serious attempt to start with a clean slate.Fuchsia

On a narrow screen the map is wider than the screen; you can scroll it sideways.

The most striking thing on the map is not how many systems died, but how many living lines start before 1995. Of everything that runs today on servers, phones, and in cars, almost nothing was designed in this century: the implementations changed, the decisions did not.

Where things came from

The mechanisms the course takes apart module by module did not appear where we meet them. The "Module" column leads to where the mechanism is properly explained: the appendix gives the date, the course gives the explanation.

WhatWhenFirst inModule
Batch monitor1956GM-NAA I/O1. What an OS is and why it exists
Time-sharing1961CTSS7. CPU scheduling
Paged virtual memory1962Atlas11. Paging
Virtual machine1968CP/CMS17. Virtualization and containers
Protection rings and segmentation1969Multics16. Protection and security
Kernel in a high-level language1973Unix V4 in C3. The kernel and the user/kernel boundary
Pipes as a way to compose programs1973Unix6. Processes
Sockets as the network interface19834.2BSD13. The I/O subsystem
Microkernel1985Mach, then L4 (1993)3. The kernel and the user/kernel boundary
POSIX as a written standard1988IEEE 1003.14. Unix, Linux, distributions
File system journaling1990JFS in AIX15. File systems
Threads in a standard1995POSIX threads8. Threads and concurrency
Isolation without a virtual machine2000FreeBSD jail, then cgroups (2007)17. Virtualization and containers
Formally verified kernel2009seL418. Where operating systems are heading
Kernel programmability without modules2014eBPF in Linux18. Where operating systems are heading

Three lines that survived

Of all the variety on the map, three lineages made it to mass use, and each answered its own question.

Unix won on portability. A kernel written in a high-level language in 1973 made it possible to move the system between machines. After that the branch split into BSD and System V, and through NEXTSTEP it reached macOS and iOS. A modern Mac is a certified Unix, not "something like it".

Linux won on license and pace. It contains no Unix code. It has a Unix interface written from scratch, and the GPL, which makes it more worthwhile to send contributions upstream than to keep them in a fork. Today it is the same kernel on a supercomputer, in a phone, and in a coffee maker; only the configuration and the surroundings differ.

Windows NT won on compatibility. The DOS line with Windows 9x ended in 2001, and today's Windows is a kernel written from scratch in 1993, drawing on the VMS experience, with memory protection and access control lists from the first version. That it still runs programs from 1995 is not an accident but a commitment that shaped its architecture.

The fourth line on the map did not win, but it did not disappear either: microkernels. Mach turned out too slow for a desktop machine, but L4 lives in the modems of billions of phones, QNX in cars, and seL4 became the first kernel with a mathematical proof of correctness. Where this is heading is covered inmodule 18.

Sources

  • The Unix Heritage Society: archives of Research Unix code and documentation
  • Salus, A Quarter Century of UNIX: the BSD and System V split, firsthand
  • Brooks, The Mythical Man-Month: OS/360 through the eyes of its manager
  • Multicians.org: Multics, collected by the people who built it
  • Torvalds, Diamond, Just for Fun: the early years of Linux
  • Computer History Museum: dates, machines, and oral histories

Course by Michael Veselovski —Easy Tech Blog ·personal site ·LinkedIn

Text: CC BY-SA 4.0. Lab code: MIT.