You use an operating system every single day and you almost never think about it. It sits between the machine and everything you do, quiet and out of sight, deciding what your computer, your server and your phone are allowed to do. The whole story is younger than most people guess: about seventy years.
Here is the idea that runs through all of it. Every time hardware gets cheaper and reaches more people, the operating system has to become easier to use. First it served an operator with punched cards, then a programmer, then an office worker, and now anyone holding a phone. That pressure, more than the calendar, is what shaped every system we still use today.
Why should you care about any of this? Because the system you are using right now is a pile of decisions made by other people, decades before you ever touched a keyboard. Knowing the order in which those decisions were made explains why your tools behave the way they do, and why a problem you chase at the surface usually started far below the screen.
What was the first operating system?
Before the 1950s there was nothing you could honestly call an operating system. Programs went in by hand, with switches and plugboards, and the machine did one job at a time with no manager watching over it. If something had to be loaded, a person loaded it.
The first operating system in history is usually named as GM-NAA I/O, written in 1956 by Robert L. Patrick and Owen Mock for an IBM 704. It was a small program with a big job: it loaded the next task automatically when the previous one finished, reading it from magnetic tape or punched cards. Out of that came the resident monitor, the piece that stayed in memory and chained jobs together while nobody stood in front of the machine. No menus, no windows, no icons. It simply stopped a person from babysitting every task by hand. Small change on paper, and the starting point for everything that came after.
Evolution by decade
Follow the decades and you watch the same trade happen over and over. New hardware arrives, the system has to catch up, and the number of people who use it grows.
The 1950s: the foundations
Two ideas appear in this decade. The resident monitor loads programs on its own, and temporary storage tries to overlap the loading of one program with the execution of the previous one, so no machine time goes to waste. Machine hours cost a fortune back then, so even the smallest saving counted. By the end of the decade the SHARE Operating System (1959), driven by IBM’s own users, proved that batch processing could be standardised and shared between computing centres.
The 1960s: power multiplies
The integrated circuit lets computers grow, and operating systems grow complicated with them. Techniques that are still alive today arrive: multiprogramming (several programs in memory while the system hands out resources), time-sharing (several users on one machine, each with a private session), real-time (for telecommunications, where a missed deadline is a failure) and multiprocessor management.
Two milestones change the scale. In 1961 MIT shows CTSS, the Compatible Time-Sharing System, and it is the first time-sharing system that truly works: several programmers use one machine at once, each from a terminal. In 1964 IBM announces the System/360 family, machines of different sizes running one operating system, OS/360. That is the birth of the modern mainframe and, on the way, the first great management disaster in the history of software, the project that pushed Fred Brooks to write The Mythical Man-Month.
The same push produces MULTICS, a joint project of MIT, General Electric and Bell Labs (1964-1969) that wanted to turn the computer into a public utility, like water or electricity, shared by many users at once. It was ambitious, expensive and hard, and it never won as a product. The ideas it left behind, security, file hierarchies and time-sharing among them, are still inside the system in front of you.
The 1970s: UNIX is born
This is the decade of systems for specialists, powerful and complicated. MULTICS arrives, and above all UNIX, which becomes the ancestor of half the world. In 1969 Ken Thompson and Dennis Ritchie wrote a small system for a PDP-7 at AT&T Bell Labs, half as an experiment. By 1971 it had its own manual, and in 1973 they rewrote it in the C language, which made it portable from one machine to another. That single detail, a system you can carry to a different computer without rewriting it from scratch, is what changed the industry. The Unix Heritage Society archive still keeps that original code.
BDOS and CP/M also appear, widely used on machines built around Intel microprocessors. CP/M, created by Gary Kildall in 1974 and sold by Digital Research from 1976, spent a few years as the best-selling system in the microcomputer world, until IBM knocked on a different door.
The 1980s: the computer comes home
Computing turns commercial and the audience changes. The users are no longer engineers. They are office workers and families, and the operating system has to be friendly, which is why menus and graphics arrive.
On 12 August 1981 IBM launches the IBM PC and, with it, MS-DOS. Microsoft had bought the rights to Seattle Computer Products’ 86-DOS, adapted it and licensed it to IBM. In 1984 Apple introduces the Macintosh on 24 January, with a graphical interface, windows and a mouse. At $2,495 it was a rarity of the time, and it would end up defining what people expect from a computer. In November 1985 Microsoft answers with Windows 1.0, a graphical layer sitting on top of MS-DOS. AmigaOS, SunOS and the ecosystem that would grow C++ live in the same decade.
The 1990s: the explosion
The systems we still use settle into their modern versions: GNU/Linux, based on UNIX and the flagship of free software, now dominant in supercomputing and servers, Solaris from Sun Microsystems for servers and workstations, and Windows as the mass-market commercial family.
Linux is born in 1991. Linus Torvalds, a Finnish student, posts a message on 25 August asking for help with a «hobby» kernel, and in September he releases version 0.01. Soon after he folds it into the GNU Project, running since 1983 and building a complete free system that was missing only a kernel. GNU/Linux comes out of that union. In 1992 Sun launches Solaris, heir to SunOS, and it carries Unix into the big servers of banking and telecommunications. Microsoft pushes ahead with Windows NT (1993) and, above all, Windows 95 on 24 August 1995, the leap onto the family desktop that sold in the millions.
The 2000s: the computer becomes personal (properly)
A crowd of systems finds its niche, with less media noise and plenty of life: Darwin, Haiku, OpenSolaris, MorphOS. The theme of the decade is maturity. The systems that rule the market are already standing, and what changes are the versions and the ecosystem around them.
Two launches define it. Mac OS X arrives on 24 March 2001 and abandons Apple’s classic system to rest on a UNIX kernel called Darwin, heir to NeXTSTEP. Today’s macOS is still a direct descendant of that move. Windows XP arrives in October 2001 and unifies Microsoft’s two families, the home one and the professional NT one, under an interface that lasted more than a decade. In parallel, Linux distributions become reasonable for ordinary users. Ubuntu appears in 2004.
Then 2007 and 2008 deliver the real blow. The iPhone on 29 June 2007 brings iOS, a touch system built for a finger. In 2008 Google ships the first commercial version of Android on a Linux kernel, with the T-Mobile G1 as the first phone that October. Within ten years the mobile phone becomes the dominant platform, and the personal computer stops being the centre of the story.
From 2010 to today: mobile and the cloud
The centre of gravity moves from the desk to the pocket. Android from Google and iOS from Apple split practically the entire mobile market. On the server side everything reorganises around the cloud, containers and free software. The operating system is still there, and almost nobody thinks about it any more. It sits where it always sat, underneath.
The big change in this stage is that the operating system becomes infrastructure. Docker (2013) popularises containers, which pack an application with its dependencies and isolate it from the rest without a full virtual machine. Kubernetes (2014) brings order to running hundreds of them at once. On the desktop, Windows 10 (2015), macOS on Apple Silicon (2020) and Windows 11 (2021) close the picture of a market fought over in the data centre, not in the user’s home.
What an operating system actually does
Strip away the decades and four jobs remain unchanged: share out the processor between programs, manage memory, organise storage into files and control who is allowed to do what. What changes is who runs those jobs and how comfortably. In the 1950s an operator with punched cards decided everything. Today the system decides on its own and you never notice.
The gap between one generation and the next almost always comes down to a single question: how many people can use the machine at once? A batch system served one job. Time-sharing served dozens of users. The personal computer served one person. The phone serves millions of people across millions of devices. Each step brought the system closer to someone who had no interest in how it worked inside.
That is why the system vanishes from view the moment it works. When you open an app, type a message or take a photo, those four services fire in sequence and none of them asks for your attention. The better an operating system does its job, the less you are supposed to notice that it is there at all.
Generations of operating systems
Five generations are usually counted, marked by the hardware of each era and by who got to sit in front of the machine.
| Generation | Era | Main idea |
|---|---|---|
| 1st | 1950s | Batch processing: the machine chains jobs with no human intervention |
| 2nd | 1960s | Multiprogramming and time-sharing: several programs and users at once |
| 3rd | 1970s | Powerful systems for specialists, and UNIX is born |
| 4th | 1980s-90s | Personal computer and graphical interface: the user is in charge |
| 5th | 2000-today | Mobile, cloud and containers: the system becomes invisible |
Read the table from top to bottom and the direction is clear. Each generation handed the next one a cheaper and faster machine, and each machine pulled in a new group of users who had never touched a computer before. The labels are handy, and the real history is messier than they suggest, because the generations overlap and no clean line separates one from the next.
UNIX: the ancestor that keeps having children
If this story has a protagonist, it is UNIX. It was born at Bell Labs in the late 1960s and its design, everything is a file and small programs that combine, has been copied without end. Linux is UNIX in spirit. macOS carries UNIX inside. Android rests on the Linux kernel. Even the systems mentioned earlier, Solaris among them, are its direct descendants.
Its greatest legacy is cultural as much as technical. It proved that an operating system could be modular and portable, able to run on very different machines without being rewritten from the ground up. That is what let one Unix end up on a supercomputer and on the phone in your pocket.
The proof that it is still alive shows up in daily use. Solaris was its enterprise branch, WSL2 puts a real Linux inside Windows, and the phone you are reading this on runs a kernel descended from that same idea. Not bad for an experiment two engineers started on a spare machine.
Frequently asked questions
What was the first operating system in history?
GM-NAA I/O, written in 1956 for the IBM 704. It loaded programs automatically from tape or cards, with no human intervention, and out of it came the resident monitor that is considered the first operating system.
How many generations of operating systems are there?
Five are usually distinguished, marked by the hardware of each era: batch processing (1950s), multiprogramming and time-sharing (60s), systems for specialists (70s), personal computer (80s-90s) and mobile and cloud (2000 onwards).
What is the difference between UNIX and Linux?
UNIX is the original system, proprietary, born in the 1970s. Linux is a free system inspired by it that reimplements its ideas from scratch. They share a philosophy and a set of tools, and they are not the same code.
Which is the oldest operating system still in use?
The descendants of UNIX (1969) are still alive in macOS, Linux and Android. The oldest one in production is IBM’s OS/360 line (1964), which continues today on mainframes under the name z/OS, sixty years without stopping.
Which operating system is used most today?
It depends on the arena. Windows dominates the desktop, Linux is the majority on servers and supercomputers, Android and iOS split mobile, and macOS occupies its niche in creative work. There is no single winner.
The bottom line
Sixty-odd years separate that resident monitor on the IBM 704 from the system in your pocket right now. That is a short run for how much has changed, and the trend has not reversed. Each stage let more people use computers without having to understand them.
If the historical curiosity has bitten, go read the history of computing in milestones, follow how phones have evolved, and pull one branch of this tree on its own with what Solaris was.