The History of Operating Systems: From Mainframes to Modern Platforms

In the spring of 1955, engineers at General Motors Research Laboratories found themselves facing a frustrating problem with the IBM 704. This enormous machine could handle only one task at a time. When each job finished, a technician had to manually swap the stack of punched cards, reconfigure the switches, and load the next program. Between tasks, the computer just sat there waiting. Most of its computational power was being squandered on the time spent waiting for human hands.^[1]

From a small effort to solve that inefficiency, the history of the modern operating system began.

The World Before Operating Systems: Bare-Metal Programming

In the 1940s and early 1950s, computers operated with no operating system at all. Researchers entered machine-language instructions directly via panel switches or loaded programs through punched cards. While a program ran, the computer was entirely dedicated to that single job. When it finished or crashed, a person had to step in again.^[2]

Computers at the time were rare resources, each one sitting in a university lab or military research center. Users scheduled time slots in advance, entering the “computer room” to complete their calculations within a fixed window. A programming error meant that slot was wasted. Using a computer was nothing like today’s cloud services — it was tense, painstaking manual work.

The First Operating Systems: Batch Processing Monitors (1950s)

Engineers at General Motors Research Laboratories and North American Aviation developed a simple “monitor program” for the IBM 704 in 1955. This is recorded as the earliest concept of an operating system.^[1] The monitor could automatically load the next program between jobs without any human intervention.

This approach is called batch processing — a set of jobs is prepared in advance, and the computer works through them in sequence. Waiting time for human operators dropped dramatically, and machine utilization improved significantly.

During the 1960s, IBM took this concept further. The IBM System/360, announced in 1964, was the first family of computers designed to let machines of different performance levels run the same software.^[3] The accompanying OS/360 established the prototype of the modern operating system: a single piece of software managing job scheduling, memory management, and control of input/output devices.^[4]

Yet the development of OS/360 turned out to be far more complex and costly than anticipated. Fred Brooks, who led the project, later drew on this experience to write the software engineering classic The Mythical Man-Month. His central argument is disarmingly simple: “Adding manpower to a late software project makes it later.” It was a vivid demonstration of how easily the complexity of operating system development can be underestimated.^[5]

Batch processing was efficient, but it had one fundamental limitation: users still had to queue up one at a time in front of the machine. In the early 1960s, researchers at MIT approached this problem differently — with time-sharing. The idea was to slice the computer’s processing time into very short intervals and distribute them among multiple users in rapid rotation, giving each user the impression of exclusive access. MIT’s CTSS (Compatible Time-Sharing System), unveiled in 1961, was the first practical implementation of this concept.^[6] Time-sharing would go on to become one of the core principles behind Unix and modern operating systems.

The Birth of Unix: A Revolution Born of Simplicity (1969)

In the mid-1960s, Bell Labs was jointly developing an ambitious operating system project called Multics with MIT and GE. Multics aimed to be a time-sharing system that could support hundreds of simultaneous users on a single computer. But the project ballooned in scope and complexity, and Bell Labs ultimately withdrew in 1969.^[7]

After that, Ken Thompson and Dennis Ritchie set out to build something new, on a much smaller scale. The starting point was Thompson running a game called “Space Travel” on a PDP-7 minicomputer and deciding to write an operating system for that machine himself.^[8] In deliberate contrast to the sprawling Multics, they pursued a simple, modular design.

The system was initially called “Unics” — a pun on Multics implying a stripped-down simplification. The spelling later settled into Unix.^[8]

Unix’s lasting influence stemmed from two key decisions. First, in 1973 most of the code was rewritten in the C programming language.^[9] An operating system written in a high-level language rather than assembly could be ported to different hardware — a genuinely radical idea at the time. Second, because AT&T was barred from commercializing Unix under an antitrust consent decree, it distributed Unix to universities and research institutions cheaply, along with the source code.^[10] As a result, Unix spread across college campuses and became the textbook through which a generation of computer scientists learned the internals of an operating system firsthand.

The Microcomputer Era: CP/M and MS-DOS (1970s–1980s)

By the mid-1970s, computers were no longer the exclusive property of universities and large corporations. Intel’s microprocessors had made desktop-sized personal computers possible. But operating systems like Unix were far too heavy for these small machines.

The gap was filled by CP/M (Control Program/Monitor), developed by Gary Kildall in 1974. CP/M was the first commercial operating system for microcomputers based on the Intel 8080 processor.^[11] At its peak in 1981, it ran on more than 3,000 different machines, and Kildall’s company Digital Research was generating annual revenues of $5.4 million.^[11]

Then history took an unexpected turn. In 1980, IBM was looking for a supplier to provide an operating system for its new personal computer, the IBM PC. CP/M was the obvious front-runner. IBM attempted negotiations with Kildall, but the two sides could not agree on terms, and talks broke down.^[12]

The opportunity fell to Bill Gates. Microsoft bought 86-DOS — developed by Seattle Computer Products — for just $50,000, polished it up, and delivered it to IBM. The IBM PC version was released in 1981 as PC-DOS; the version for other manufacturers was called MS-DOS.^[13]

The decisive factor was price. PC-DOS cost $40 on the IBM PC, while CP/M-86 cost $240. Most consumers naturally chose the cheaper option.^[12] That price gap altered Microsoft’s destiny and pushed Kildall’s CP/M to the margins of history. It was a case where the winner was determined not by technical superiority, but by negotiation and pricing structure.

The Graphical Revolution: The Age of Icons and Windows (1980s)

In the DOS era, when every command had to be typed in by hand, using a computer was still the domain of specialists. The turning point came from an unexpected direction.

In the early 1970s, researchers at Xerox’s PARC laboratory were developing an entirely new kind of interface: one controlled with icons, windows, and a mouse. The Xerox Alto, completed in 1973, was the first computer to bring all of these elements together. But the Alto remained a research prototype and never reached commercial production.^[14]

In 1979, Steve Jobs visited Xerox PARC and witnessed the technology firsthand. He immediately grasped that this was the future of computing. That experience led to the Apple Lisa in 1983 and the Apple Macintosh in 1984.^[15]

The Macintosh was the first personal computer to bring a graphical user interface (GUI) to a mass consumer audience in a practical way. Clicking icons and dragging files showed the general public, for the first time, that a computer could be used without memorizing commands.^[16]

Microsoft followed suit. Windows 1.0 launched in November 1985, but the initial reception was lukewarm.^[17] The real turning point came with Windows 95. It introduced the Start menu, the taskbar, and Windows Explorer, and it drew the personal computer into everyday home life.^[18]

Linux: Free Software and an Open Kernel (1991)

On August 25, 1991, Linus Torvalds — a 21-year-old student at the University of Helsinki in Finland — posted a short note to a Usenet group: “I’m doing a (free) operating system (just a hobby, won’t be big and professional like gnu).” Neither he nor anyone else anticipated that this modest announcement would become a turning point in history.^[19]

Linus’s kernel was inspired by Minix, a small educational operating system. After building it himself, he relicensed it under the GNU General Public License (GPL) in 1992, allowing anyone to view, modify, and redistribute the code.^[20]

Richard Stallman’s GNU Project, launched in 1983, had been working toward a free Unix-compatible operating system, but its central component — the kernel — was not yet complete. Linus’s kernel filled that gap, and the combination of GNU tools and the Linux kernel produced a fully functional free system.^[21]

The spread of Linux reflects something distinctive about its character. No single entity owns Linux. Thousands of developers around the world voluntarily contribute code, and companies build commercial services on top of it. Today, Linux powers the vast majority of the world’s servers and 100% of the world’s supercomputers. Through Android smartphones, it also holds a dominant position in the mobile market.^[22]

Operating Systems in the Mobile Age (2007–Present)

On January 9, 2007, Steve Jobs stepped onto a stage and announced “three revolutionary products.” A widescreen iPod. A revolutionary phone. And an internet communicator. “It’s one device,” he said — and the audience erupted in laughter. It was the iPhone.^[23]

The iOS that came with the iPhone was an operating system optimized for a touchscreen interface. When the App Store opened in 2008, the concept of an operating system changed fundamentally. It was no longer just software that managed hardware. It had become a platform on which hundreds of thousands of applications ran.^[24]

That same year, Google unveiled Android. Android was built on the Linux kernel and maintained an open-source ecosystem, allowing manufacturers of all kinds to adopt it freely.^[25] That openness is what made Android the dominant operating system in the global smartphone market.

Today, operating systems are embedded in smartwatches, automobiles, refrigerators, and industrial robots. Rather than a single dominant desktop OS, we now live in a distributed world: Linux for cloud servers, iOS and Android for smartphones, and lightweight operating systems for IoT devices — each sustaining its own ecosystem.^[26]

Conclusion: A History of Code and Ownership

Looking back at the history of operating systems, one consistent thread stands out: efficiency has always been the engine of progress. Operating systems have evolved to reduce human waiting time, to let multiple users share a single resource, and to make computers accessible to ever-broader audiences.

But equally important to technical advancement was the set of choices made around ownership. Unix became open because of a legal constraint; Linux became open because of a philosophical conviction. Without either of those two moments of openness, the server infrastructure that underpins today’s internet — and the billions of Android devices in people’s hands — would look entirely different. The history of operating systems is a history of code, but it is equally a history of choices about who owns technology and who chooses to share it.