History of Operating Systems: From Batch Processing to Modern OS

An operating system (OS) is the software layer that manages a computer’s hardware and runs your programs. The story of operating systems runs from 1950s mainframes that handled one job at a time, through interactive time-sharing and Unix, to the personal-computer and mobile systems that now control billions of devices. This guide walks that timeline era by era, with the dates and technical firsts that define each step.

What Is an Operating System?

An operating system is the software that manages hardware resources and provides shared services to every application you run:

• Core jobs: process scheduling, memory management, file systems, device input/output, and the user interface.
• Why it exists: without an OS, each program must drive the hardware directly, which scales to only one program at a time.
• Where it sits: between the processor and other hardware below it and your applications above it.

The OS Timeline at a Glance

Operating systems advanced in clear jumps, each one removing the limit of the last. Read this timeline top to bottom to see how one era led to the next:

• 1940s , No OS. Early machines (ENIAC) run one job at a time; operators wire and load everything by hand.
• 1950s , Batch processing. A resident monitor loads the next punched-card job automatically; GM-NAA I/O (1956) is widely cited as the first.
• 1961 , Time-sharing (CTSS). MIT’s CTSS lets up to 30 users share one machine interactively, slashing cost per user.
• 1965-1969 , Multics. MIT, Bell Labs, and GE build an influential time-sharing OS; MIT begins service in 1969.
• 1969 , Unix. Ken Thompson and Dennis Ritchie build Unix at Bell Labs on a PDP-7; rewritten in C in 1972 for portability.
• 1974 , CP/M. Gary Kildall’s CP/M becomes the standard OS for early 8-bit personal computers.
• 1981 , MS-DOS. Microsoft’s command-line OS ships with the IBM PC and takes over the desktop.
• 1984 , Mac System. The Apple Macintosh brings the first mass-market graphical user interface (GUI).
• 1985 , Windows 1.0. A graphical shell over MS-DOS begins Microsoft’s long GUI line (Nov 20, 1985).
• 1991 , Linux. Linus Torvalds releases the open-source Linux kernel (Sep 17, 1991); now dominant on servers.
• 2007-2008 , Mobile. iOS ships with the iPhone (Jun 29, 2007); Android 1.0 follows on the HTC Dream (Sep 23, 2008).

Batch Processing Era: 1950s

The first operating systems were batch monitors that automated job sequencing on mainframes so the machine never sat idle between jobs:

• Before batch: operators loaded each program by hand, wasting expensive machine time between runs.
• The IBM 704 (1954) ran punched-card jobs with no interactive access; jobs queued, ran in order, and printed to paper.
• First monitor: General Motors Research wrote the first recognizable OS monitor for the IBM 701 in 1956, loading the next job automatically.
• Job control: IBM’s SHARE Operating System (1959) formalized batch work with job control language (JCL), still visible in IBM mainframe JCL today.

Time-Sharing Systems: 1960s

Time-sharing let many users interact with one computer at the same time, dropping the cost per user sharply:

CTSS (Compatible Time-Sharing System), operational at MIT in 1961, was the first practical interactive time-sharing OS:

• Hardware: an IBM 7090 modified with a second memory bank.
• Capacity: up to 30 simultaneous users, each given a 200-millisecond time slice.
• Firsts: first OS to support online text editing and electronic mail (1965).
• Multics (from 1964): a joint MIT, Bell Labs, and GE project on GE 645 hardware (up to 55 users) that introduced hierarchical file systems, dynamic linking, and ring-based protection – ideas in every modern OS.

Unix Origins: 1969

Unix was created at Bell Labs in 1969 by Ken Thompson, and the C language (1972) made it portable across hardware:

• Version 1 (1971) ran on a PDP-11 with just 24KB of memory.
• Design philosophy: small, composable tools connected by pipes – a principle that shaped every OS since.
• C rewrite (1972): Dennis Ritchie’s C let Unix move between machines instead of being tied to one.

Unix milestones that fed straight into modern systems:

• 1973: Unix licensed to universities; Berkeley received Version 6 in 1975.
• 1977: BSD (Berkeley Software Distribution) first released.
• 1983: BSD 4.2 added TCP/IP networking – a foundation of the Internet.
• 1991: Linux kernel 0.01 released by Linus Torvalds (covered below).
• 2024: the Linux kernel 6.x contains roughly 33 million lines of code.

Early Personal Computer OSes: CP/M and MS-DOS

Personal computing needed a small OS for cheap hardware: CP/M defined the 8-bit era, then MS-DOS took over the 16-bit IBM PC.

CP/M (Control Program for Microcomputers), by Gary Kildall of Digital Research in 1974, ran on Intel 8080 machines:

• Architecture: 8-bit, addressing up to 64KB of memory.
• File system: a flat directory with the 8.3 filename format.
• Peak: around 3,000 software titles across millions of machines.

MS-DOS (Microsoft Disk Operating System), shipped August 1981 with the IBM PC and bought as QDOS from Seattle Computer Products for $75,000:

• Architecture: 16-bit, single process only – no multitasking.
• Interface: command line only, with a 640KB conventional-memory ceiling.
• End of line: the final version was MS-DOS 6.22 (1994).

Graphical User Interface OSes: 1984 Onward

The GUI replaced typed commands with a mouse-driven desktop of windows, icons, and menus, starting with the 1984 Macintosh:

• Macintosh System Software shipped January 24, 1984 – the first commercially successful GUI OS.
• Windows followed in 1985 as a graphical shell over MS-DOS and grew into the dominant desktop line.
• The shift: point-and-click made computers usable without memorizing commands, opening the PC to a mass audience.

Windows evolution from 1985 to today:

• Windows 1.0 (1985): GUI shell over MS-DOS with tiled (not overlapping) windows.
• Windows 3.1 (1992): first widely adopted version, 3 million copies in 2 months.
• Windows 95 (1995): first 32-bit consumer Windows – Start menu, taskbar, preemptive multitasking.
• Windows XP (2001): unified consumer/business NT line, 400 million licenses by 2004.
• Windows 7 (2009): refined Vista, 630 million licenses by 2011.
• Windows 10 (2015): free upgrade, unified device family.
• Windows 11 (2021): TPM 2.0 requirement, redesigned UI, DirectStorage.

Linux: 1991 to the Dominant Server OS

Linux is an open-source, Unix-like kernel that started as a 1991 hobby project and now runs most of the world’s servers.

Linus Torvalds released Linux kernel 0.01 on September 17, 1991 – just 10,239 lines of code, announced on Usenet as a hobby that “won’t be big and professional like gnu”:

• 1994: Linux 1.0 – stable kernel at 176,250 lines of code.
• 1996: Linux 2.0 – SMP (multiprocessor) support.
• 2003: Linux 2.6 – production-grade enterprise features.
• 2015: Linux 4.0 – live kernel patching.
• 2024: Linux 6.x – roughly 33 million lines and 4,000+ contributors per release.

Where Linux runs today (2024):

Mobile Operating Systems: iOS and Android

Mobile OSes put a full operating system in your pocket: iOS shipped with the iPhone in 2007, and Linux-based Android followed in 2008:

• iOS 1.0 launched with the original iPhone on June 29, 2007 – a touch-first interface.
• Android 1.0 launched September 23, 2008 on the HTC Dream (T-Mobile G1), built on the Linux kernel.
• Scale today: Android holds 71.8% and iOS 27.6% of global mobile share, across roughly 6.8 billion devices.

OS Milestones Comparison Table

This table lines up the defining operating systems by year, technical first, and platform:

Last Thoughts on the History of Operating Systems

OS history spans 70 years — from a 1956 batch monitor that automated job loading, to kernels managing billions of concurrent devices. Three lineages dominate modern computing: the Windows NT family (desktop/enterprise), the Linux/Unix family (servers, supercomputers, Android), and the BSD-derived Darwin kernel (macOS, iOS). The Linux kernel alone grew from 10,239 lines in 1991 to 33 million lines in 2024 — a 3,226x increase in code volume.

Key Takeaways:

• The first OS monitor appeared in 1956 for the IBM 701; it automated job sequencing without any interactive capability.
• CTSS (1961) at MIT was the first interactive time-sharing system, supporting up to 30 simultaneous users.
• Unix (1969) introduced portability via C (1972) and pipe-based composability — the architectural foundation of Linux, macOS, and Android.
• MS-DOS (1981) was 16-bit, single-tasking, command-line only; Windows 95 (1995) delivered the first mainstream 32-bit consumer multitasking OS.
• Linux kernel 0.01 (1991) had 10,239 lines of code; the 2024 kernel has approximately 33 million lines.
• Linux runs 100% of the TOP500 supercomputers and powers 96.3% of the top 1 million web servers.

Frequently Asked Questions (FAQs)