History of Operating Systems: From Batch Processing to Modern OS

Operating systems evolved from simple batch job managers running on 1950s mainframes to the kernel-based, multitasking, networked systems controlling billions of devices today. This guide covers OS history decade by decade, with key dates, technical firsts, and the specifications that define each era.

What Is an Operating System?

An operating system is software that manages computer hardware resources and provides services for application programs. Core functions include process scheduling, memory management, file system management, device I/O abstraction, and user interface. Without an OS, each application must directly control hardware — an approach that scales to only one program at a time.

Batch Processing Era: 1950s

The first OSes were batch processing monitors that automated job sequencing on mainframes. Before batch monitors, operators manually loaded each program, wasting expensive machine time between jobs.

The IBM 704, released in 1954, ran jobs submitted on punched cards. There was no interactive access.

Jobs queued, ran sequentially, and output printed to paper. The General Motors Research Laboratories wrote the first recognizable OS monitor for the IBM 701 in 1956 — a simple program that loaded the next job automatically when the previous one finished.

IBM’s SHARE Operating System (SOS), developed cooperatively by IBM users in 1959, formalized batch processing with job control language (JCL) — a scripting approach still visible in IBM mainframe JCL today.

Time-Sharing Systems: 1960s

Time-sharing systems allowed multiple users to interact with a single computer simultaneously, dramatically reducing computing costs per user.

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

• Hardware: IBM 7090 modified with a second memory bank
• Simultaneous users: up to 30
• Time slice: 200 milliseconds per user
• First OS to support online text editing and electronic mail (1965)

Multics (Multiplexed Information and Computing Service), begun in 1964 as a joint project of MIT, Bell Labs, and GE, introduced concepts used in every modern OS: hierarchical file systems, dynamic linking, ring-based protection, and online reconfiguration. Multics ran on GE 645 hardware and supported up to 55 simultaneous users.

Unix Origins: 1969

Unix was created at Bell Labs in 1969 by Ken Thompson, with Dennis Ritchie contributing the C programming language (1972) that made Unix portable across hardware platforms.

Unix Version 1 (1971) ran on a PDP-11 with 24KB of memory. Unix introduced the philosophy of small, composable tools connected by pipes — a design principle that influenced every subsequent OS.

Unix milestones:

• 1972: C language developed by Dennis Ritchie; Unix rewritten in C
• 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 — foundation of the Internet
• 1991: Linux kernel 0.01 released by Linus Torvalds (see below)
• 2024: Linux kernel 6.x contains approximately 33 million lines of code

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

CP/M (Control Program for Microcomputers) was created by Gary Kildall of Digital Research in 1974. It ran on Intel 8080-based 8-bit machines and became the standard OS for early personal computers.

CP/M specifications:

• Architecture: 8-bit
• Maximum addressable memory: 64KB
• File system: flat directory structure, 8.3 filename format
• Market peak: approximately 3,000 software titles, millions of machines

MS-DOS (Microsoft Disk Operating System), released August 1981 with the IBM PC, replaced CP/M as the dominant PC OS. MS-DOS was based on QDOS (Quick and Dirty Operating System), purchased by Microsoft from Seattle Computer Products for $75,000.

MS-DOS characteristics:

• Architecture: 16-bit
• Multitasking: none — single process only
• Interface: command line only
• Maximum conventional memory: 640KB
• Final version: MS-DOS 6.22 (1994)

Graphical User Interface OSes: 1984 Onward

Apple released the Macintosh System Software (later Mac OS) on January 24, 1984 — the first commercially successful GUI-based OS. It used a mouse-driven desktop with icons, windows, and menus instead of command-line input.

Windows evolution from 1985 to present:

• Windows 1.0 (1985): GUI shell over MS-DOS, tiled (not overlapping) windows
• Windows 3.1 (1992): first widely adopted version, 3 million copies sold in 2 months
• Windows 95 (1995): first 32-bit consumer Windows, Start menu, taskbar, preemptive multitasking
• Windows XP (2001): unified consumer/business line, NT kernel, 400 million licenses by 2004
• Windows Vista (2007): UAC, Aero Glass — criticized for performance overhead
• Windows 7 (2009): refined Vista, 630 million licenses by 2011
• Windows 10 (2015): free upgrade, unified device family, 1 billion device target
• Windows 11 (2021): TPM 2.0 requirement, redesigned UI, DirectStorage API

Linux: 1991 to the Dominant Server OS

Linus Torvalds released Linux kernel 0.01 on September 17, 1991. The initial kernel was 10,239 lines of code. Torvalds announced it as a hobby project on a Usenet post: “I’m doing a (free) operating system (just a hobby, won’t be big and professional like gnu).”

Linux adoption milestones:

• 1994: Linux 1.0 — stable kernel, 176,250 lines of code
• 1996: Linux 2.0 — SMP (multiprocessor) support
• 2003: Linux 2.6 — production-grade enterprise features
• 2011: Linux 3.0 — renamed for simplicity, not an architectural break
• 2015: Linux 4.0 — live kernel patching
• 2019: Linux 5.0
• 2022: Linux 6.0
• 2024: Linux 6.x — approximately 33 million lines of code, 4,000+ active contributors per release

Market share by segment (2024):

• Web servers: Linux powers 96.3% of the top 1 million web servers (W3Techs)
• Supercomputers: Linux runs 100% of the TOP500 supercomputers
• Mobile (Android): Linux kernel — 3.6 billion active Android devices
• Desktop: Linux holds approximately 3–4% desktop market share

Mobile Operating Systems: iOS and Android

Apple released iOS 1.0 with the original iPhone on June 29, 2007. Android 1.0 launched on September 23, 2008 on the HTC Dream (T-Mobile G1).

Mobile OS market share (2024, Statcounter):

• Android: 71.8% global mobile OS market share
• iOS: 27.6% global mobile OS market share
• Combined mobile OS users: approximately 6.8 billion unique devices

OS Milestones Comparison Table

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.