The History of Operating Systems

By Victor Hoang · Updated Oct 21, 2026

In 1954, people who wrote programs for an IBM computer also ran them. The Software Preservation project at the Computer History Museum records that programmers sat at the console themselves and booked checkout time in short blocks. Each minute spent setting up the next job earned the machine nothing. The first operating systems fixed that waste.

The operating system began in the mid-1950s as a program that kept an expensive computer busy between jobs. A team at General Motors Research and North American Aviation built one for the IBM 704, where programmers had booked checkout time in six-minute blocks, and put it into production in 1956. Over seventy years it grew from a job queue into the layer that shares one machine among many users, hides hardware from programmers, and decides which software gets built. Each era made the machine easier to share.

Timeline at a Glance

The Console Years (1954-1961)

Programmers hand the machine to operators and a monitor

In 1954, programmers on the IBM 704 ran the console themselves, and a courier made hourly rounds from desk to desk, according to the archive page on GM-NAA I/O. The fix did not have a settled name yet. The same page says the design was done by General Motors Research and North American Aviation, with Robert L. Patrick on the conceptual design, George Ryckman leading the GM effort and Owen Mock leading North American. Patrick presented it at SHARE in Boston in November 1955, and it first ran production in 1956.

The system batched job decks through three phases, input translation, compute and output translation, so the 704 could move from one job to the next without a person in between. It also read a clock to supply accounting data, so users could be billed by time used and lines printed. The same page says the design assumed professional operators would run the machine, letting programmers stay at their desks, and that about 60 test jobs an hour became possible depending on test length. Twenty copies went to other 704 sites. The page describes the result with the phrase "operating system", though that wording comes from the archive's description and not a claim about who used the term first.

This is the precursor-versus-concept line worth drawing. Before 1955 there were programs and there were operators, but the idea that a resident program should manage the machine's time was new. The ancestors are set-up routines and human schedulers, and the named thing arrived with batch monitors like this one.

The era solved idle time. It created distance: programmers no longer touched the machine, and the courier's rounds became the new waiting time.

For teams today: if your most expensive resource sits idle between handoffs, automate the handoff first. Most early operating system gains came from removing the wait between jobs, not from making any one job faster.

The Time-Sharing Dream (1961-1969)

Many users share one machine, and the software gets huge

The turning point is MIT's demonstration of the Compatible Time-Sharing System in November 1961, on an IBM 709. By 1963, the Multics project's own chronology records CTSS running on a modified IBM 7094 with up to 30 remote users, and the ARPA contract for MIT's Project MAC was signed that July. The idea was to answer the batch queue directly: a user at a terminal, sharing one machine with others. The Computer History Museum timeline says CTSS ran until 1973.

Across the Atlantic, a different answer to the same problem was taking shape. The University of Manchester's Atlas, developed from 1957 to 1961 by a team led by Tom Kilburn, ran under a Supervisor that, per a 1962 Ferranti manual, stayed permanently in the machine, allocated storage to programs and data, and moved blocks between main store and drums or discs without the programmer planning it. Manchester called the concept the "one-level store". Today we call it virtual memory.

Then came the scale problem. IBM announced System/360 on April 7, 1964, a plan IBM itself calls a $5 billion gamble that replaced all its existing product lines with one compatible family. One family needed one operating system, and that is where things went wrong. IEEE Spectrum's account says the software staff was in disarray as early as 1963 and that OS/360 struggled to run more than one job at a time. Fred Brooks offered to help, IBM assigned 1,000 more people, and the article says that cost more for software in one year than was budgeted for the entire S/360 development. Adding people didn't fix it. Brooks wrote up the lesson in The Mythical Man-Month in 1975. The software still worked well enough to limit the shipping delay to one month.

Alongside it, IBM's Cambridge Scientific Center started something quieter. The z/VM history timeline lists CP-40 in 1964 as an experimental time-sharing research project for System/360, CP-67 in 1967 offered to key time-sharing customers, and VM/370 announced on August 2, 1972. The IBM page also mentions a 1972 video on how virtual machines work. One physical computer could now look like several.

The grandest plan of the decade was Multics. According to its timeline, GE was chosen as hardware vendor in May 1964, Bell Labs joined in November, and six papers at the 1965 Fall Joint Computer Conference described the system, with Fernando Corbató leading at MIT. The GE-645 reached Project MAC in January 1967, later than planned. In April 1969 Bell Labs withdrew, and in October 1969 MIT began offering Multics as a paid service. Multics did eventually work and reached its last shutdown in October 2000, but its reputation for delay is what pushed a small group at Bell Labs to try something else.

The era solved sharing. It created complexity, and OS/360 became the case study for how a large software project can swallow people without finishing sooner.

For teams today: when a plan keeps slipping, adding staff late is rarely the answer, and a smaller design with a clear owner often ships first. That is what the next era proved.

The Unix Years (1969-1980)

Two people with a spare computer outlast the giants

Dennis Ritchie opens his own account by correcting a date: in his paper he writes that Unix was born in 1969, not 1974. The Bell Labs group of Ken Thompson, Ritchie, Doug McIlroy and J. F. Ossanna had been among the last working on Multics, and their reason for staying was not the technology. In his words, they wanted "a system around which a fellowship could form". Management, he writes, had no appetite for another operating system effort, so their 1969 proposals for a new machine went nowhere.

So Thompson looked for a smaller machine. He had written a game called Space Travel, which on the company's big GECOS computer cost about $75 in CPU time per run, and he found a little-used PDP-7 with a good display. Ritchie recounts that Thompson then built the file system the group had sketched on blackboards, added processes, a few utilities and a command interpreter, and by assembling it on the PDP-7 itself the system could support itself. Brian Kernighan suggested the name Unix well into 1970, as a pun on Multics.

The first real users were not engineers. In the summer of 1971 the group offered a text-processing service to Bell Labs' Patent department, which was weighing a commercial system. According to Ritchie, they won partly because they supported Teletype Model 37 terminals that could print math symbols and quickly added line-numbered pages, a Patent Office requirement. In the last half of 1971 three patent typists worked on a PDP-11 with 24K bytes of memory and a half-megabyte disk, and the Patent department became the first of many groups at the Labs to adopt Unix. Pipes followed in 1972, at McIlroy's urging.

The decisive technical step came in 1973, when, per the Ritchie and Thompson CACM paper, the system was rewritten in the C language, which made it easier to understand and modify. The paper's closing perspective is candid about method. It says the goal was "a comfortable relationship with the machine" and credits the system's success partly to not being designed to meet any predefined objectives.

On IBM's side, VM/370 was announced in 1972, which put the idea of many virtual machines on one real one into a product.

The era solved two things: a simple design that small teams could understand, and a codebase written in a high-level language that was easier to modify. The paper says most installations went to education and document preparation, which put Unix in front of a generation of students.

For teams today: the Patent department is the whole lesson. Unix spread because it solved one real department's problem better than the incumbent, not because it was designed as a platform.

The CP/M and DOS Years (1974-1990)

Microcomputers get a standard system, then a licensed one

The turning point here was a floppy disk. The Computer History Museum says that Gary Kildall demonstrated CP/M in Pacific Grove, California, in 1974, and calls it the first commercially successful personal computer operating system. CP/M stands for Control Program for Microcomputers. Kildall and Glenn Ewing split out the hardware-specific code into a BIOS, so Intel-based machines from different makers could run CP/M unmodified, and the Museum says that helped create an independent software industry.

When IBM built its PC in 1980 and 1981, the operating system became the contested piece. The Museum's account is that IBM announced the PC on August 12, 1981, and that Bill Gates bought an operating system from Seattle Computer Products that imitated CP/M's look and feel, licensed it to IBM as PC DOS and kept the right to sell it as MS-DOS. Tim Paterson had written it as 86-DOS because, per the Museum's source code page, the 16-bit version of CP/M was late. Microsoft licensed 86-DOS for $25,000 in December 1980 and bought all rights for another $50,000 the following summer. PC-DOS 1.0 was finished in July 1981. The same page says SCP later sued and settled for almost $1 million. On price, the Museum says PC-DOS listed at $40 against $240 for CP/M, and most customers chose the cheaper one.

The other branch of the era was the interface (the full story is in the history of the mouse and GUI). The Museum's timeline says the Apple Lisa in 1983 was the first commercial personal computer with a graphical user interface, inspired by Xerox's Alto, and that the 1984 Macintosh was the first successful mouse-driven computer with a graphical interface. Microsoft's answer was Windows. The Museum records that Microsoft announced Windows on November 10, 1983, that it reached the public in 1985 after delays with pull-down menus, tiled windows and cooperative multitasking, and that the interface didn't gain general acceptance until version 3.0, which the software timeline places in 1990.

The era solved access and cost. It created a new kind of dependence: software written for one operating system's interfaces ran only there, so the choice of system became a choice of which applications you could run.

For teams today: the right to sell is part of the product. Microsoft licensed its system to IBM and kept the right to sell it too, and that clause shaped what came next.

The Linux Turn (1983-2006)

Free and open systems challenge the commercial ones

This era overlaps the last one, because the free-software movement began while DOS was still winning. The Computer History Museum's software timeline records Richard Stallman developing GNU in 1983 with the aim of a free, Unix-like system, and Torvalds releasing the Linux kernel in 1991. It also lists Windows NT in 1993, developed by a team led by Dave Cutler, and Windows 95 on August 24, 1995.

The scene Torvalds set is documented in his own words. His post to comp.os.minix is dated 25 Aug 91 and begins "Hello everybody out there using minix". He wrote that he was doing a free operating system, "just a hobby, won't be big and professional like gnu". The Museum's timeline notes that GNU tools later became a large part of Linux.

Parallel to this, the Unix idea came back into the mainstream. The timeline lists FreeBSD launching in 1993 and Mac OS X in 2001, built on FreeBSD, NetBSD and NeXTSTEP, and Windows XP the same year on the NT kernel. The era solved the question of who gets to see and change the system. It created a new one: when the operating system is free, what do vendors sell?

For teams today: open source is now a procurement fact. When you pick a platform, you are also picking its governance, its contributors and what happens if a vendor changes course.

The Pocket and Cloud Era (2006-present)

The operating system disappears into phones and rented servers

AWS launched publicly on March 14, 2006 with one service, S3 storage, with EC2 servers following a few months later. Amazon notes that before this, a startup had to buy its own physical machines, estimate capacity and make a large upfront hardware investment. The idea echoes CP-67 and VM/370: a layer sits between users and hardware, so many people share one pool. This time the sharing is sold by usage, and the story of that shift continues in the history of cloud computing.

Phones followed, a story told in full in the history of the smartphone. Apple announced the iPhone on January 9, 2007. On November 5, 2007, a Google-led alliance of 34 companies announced Android in a press release, calling it "the first truly open and comprehensive platform for mobile devices", a package covering the operating system, middleware, user interface and applications. Then the phone's operating system became a marketplace. On March 6, 2008, Apple released a beta of its iPhone SDK and announced the App Store, with developers keeping 70 percent of revenue and partners describing "the iPhone OS" as a development platform.

On a phone, people meet apps first. The system underneath sets which apps can exist and how they are paid for, which is why the 70 percent figure matters. The languages used to write those apps have their own story in the history of programming languages.

The era solved reach and delivery. It created dependence: a team's tools, data and workflows now sit on someone else's operating system layer, whether a phone platform or a cloud account.

For teams today: the question has moved from "which operating system?" to "who controls the layer our work runs on?" Treat that as a dependency to be tracked, not a background detail.

Key People

Key Facts

Key Facts: Operating Systems

• GM-NAA I/O first ran production in 1956, and twenty copies went to other IBM 704 sites.
• IBM assigned 1,000 more people to OS/360, and the software still limited System/360's shipping delay to one month.
• Ritchie wrote that Unix was born in 1969, not 1974.
• The Computer History Museum calls CP/M the first commercially successful personal computer operating system; PC-DOS listed at $40 against $240 for CP/M.
• Microsoft announced Windows on November 10, 1983 and it reached the public in 1985.
• Torvalds's first Linux post is dated 25 Aug 91.

The Pattern Behind the History

Looking across the six eras, the same four moves repeat. We call the sequence the Share-Hide-Open Loop. It's our synthesis of the milestones above, not a research finding.

1. Waste appears. Idle machines, queued users, one program at a time. Every era starts from a visible, expensive inefficiency.
2. A layer shares the machine. Batch monitors, time-sharing, virtual memory, virtual machines and cloud accounts each let more people use the same hardware.
3. The layer hides the hardware. BIOS, C, graphical interfaces and app stores let people use the machine without knowing it.
4. Whoever opens the layer to builders wins. CP/M's BIOS, licensed DOS, Unix source, Linux and app stores all won by letting others build on them.

What It Teaches Teams Today

• Find the idle time first. The first operating systems paid for themselves by removing waiting between jobs. Look for the same gap between your own handoffs.
• Add people carefully to a late project. OS/360 is still the cautionary tale: more people didn't make it ship sooner.
• Start with a real user. Unix grew by serving the Patent department, not by designing for the future.
• Pick platforms by who builds on them. Cheap, licensable and open systems beat better-designed closed ones again and again.
• Track the layer you depend on. Your tools now run on an operating system or cloud account you don't control. Know the terms.

The history of operating systems is a record of who got to use the machine, and on whose terms. For more of the surrounding story, start with The History of Computers, the dated Computer Timeline and the generations of computers, and for how the machines got connected, read The History of the Internet and the Internet Timeline. The arguments over credit are in Who Invented the Computer?.