The OS Genealogy
Modern operating systems are the product of decades of collaborative development, commercial competition, legal disputes, and architectural iteration. The syntax of directory separators, the design of permission models, and the behavior of terminal commands in modern systems are inherited directly from their historical ancestors.
Understanding this genealogy clarifies the design patterns and differences between major systems today.
The Dawn of Modern OS (1960s)
In the early 1960s, computing was dominated by mainframe architectures executing batch processes. Users submitted physical decks of punched cards to human operators, with no direct, real-time interface to the hardware.
To enable interactive, multi-user access, MIT, General Electric, and Bell Labs initiated the Multics (Multiplexed Information and Computing Service) project. Multics introduced advanced operating system design concepts, including dynamic linking, a hierarchical directory layout, and hardware-enforced protection rings. However, the system was highly complex and resource-intensive for the hardware of its era, leading Bell Labs to withdraw from the project.
Seeking a simpler development environment, Bell Labs researchers Ken Thompson and Dennis Ritchie designed a streamlined, single-user system on a discarded PDP-7 computer. They named this new system UNIX—a deliberate pun on Multics, representing a single-user system rather than a multiplexed service.
While Multics was written in PL/I, UNIX was eventually rewritten in a new, portable programming language designed by Ritchie: C. This transition enabled UNIX to be ported to different hardware architectures with minimal assembly-level modifications.
An example of PL/I code structure used to build early Multics procedures demonstrates the language model that preceded UNIX’s C implementation:
/* A minimal PL/I procedure representing Multics application code */
hello: procedure options (main);
put list ('Hello, Multics World!');
end hello;
The Great Forking
Because AT&T (the parent company of Bell Labs) was barred by a 1956 antitrust consent decree from entering the commercial computer business, it distributed UNIX source code to universities under low-cost licenses. This open access allowed external developers to debug and modify the code.
As UNIX spread, it split into two primary architectural lineages:
- System V (AT&T): The commercialized release developed when regulatory restrictions on AT&T were lifted.
- Berkeley Software Distribution (BSD): An academic branch developed at the University of California, Berkeley. BSD introduced critical additions, including the virtual memory paging subsystem and the sockets API, which integrated the DARPA TCP/IP stack to form the foundation of the modern internet.
To demonstrate a visible legacy of this divergence, consider the arguments accepted by the system status command ps on modern distributions:
# System V style process listing (uses a leading dash for options)
ps -ef
# BSD style process listing (omits the leading dash and uses aux flags)
ps aux
The Rise of the PC (1980s)
The development of microprocessors in the late 1970s enabled the creation of personal computers (PCs). Gary Kildall developed CP/M (Control Program for Microcomputers), which became the standard operating system for 8-bit Intel 8080 computers.
When IBM developed its 16-bit Personal Computer (the IBM PC), they approached Microsoft for an operating system. Microsoft purchased QDOS (Quick and Dirty Operating System)—which cloned CP/M’s API and command structure—and modified it into MS-DOS (Microsoft Disk Operating System).
- MS-DOS: Designed for single-tasking and a single user. It lacked memory protection, running applications directly in the same address space as the operating system kernel.
- Windows 1.0 through 3.1: These releases were not standalone operating systems; they were graphical user interface (GUI) execution shells running on top of MS-DOS.
An example configuration file (CONFIG.SYS) from a typical 16-bit MS-DOS installation demonstrates how device drivers and system memory managers were manually loaded into upper memory blocks (UMBs) to conserve the base 640 KB conventional memory limit:
DEVICE=C:\DOS\HIMEM.SYS
DEVICE=C:\DOS\EMM386.EXE NOEMS
BUFFERS=15,0
FILES=30
DOS=HIGH,UMB
The Shift to NT (1990s)
To build a stable operating system for workstations and servers, Microsoft abandoned the MS-DOS architecture. In 1988, they hired Dave Cutler, the lead architect of Digital Equipment Corporation’s VMS (Virtual Memory System) operating system, to design a new, modern kernel from scratch.
This architecture was named Windows NT (New Technology). Unlike MS-DOS, Windows NT was a preemptive, multi-tasking, multi-user operating system with virtual memory support and hardware abstraction layers.
- Architecture Unification: Consumer Windows (95, 98, ME) remained on the unstable MS-DOS foundation. In 2001, Microsoft unified their consumer and professional product lines with Windows XP, moving all subsequent consumer versions of Windows (including 7, 10, and 11) to the NT kernel.
An example of a C program utilizing the Win32 API demonstrates how application developers interface with the Windows NT executive to write files:
#include <windows.h>
#include <stdio.h>
int main(void) {
HANDLE hFile = CreateFileW(
L"log.txt",
GENERIC_WRITE,
0,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (hFile == INVALID_HANDLE_VALUE) {
printf("Error creating file: %lu\n", GetLastError());
return 1;
}
CloseHandle(hFile);
return 0;
}
The Linux Revolution (1991)
In 1991, Linus Torvalds, a computer science student at the University of Helsinki, began developing a Unix-like kernel as a hobby project for his Intel 80386-based computer. He released his work under the GNU General Public License (GPL), which legally mandated that modifications to the source code must be shared openly.
To build a functional operating system, Torvalds combined his kernel with the compilers, shell utilities, and system libraries developed by Richard Stallman’s GNU Project. This combination resulted in GNU/Linux, which went on to run the majority of web servers, cloud datacenters, supercomputers, and mobile devices (via Android).
An example of a unified patch file (patch.diff) demonstrates the format Torvalds and the early Linux development community used to share source code modifications via newsgroups:
--- kernel/sched.c.orig 1991-10-05 12:00:00.000000000 +0200
+++ kernel/sched.c 1991-10-05 12:05:00.000000000 +0200
@@ -10,6 +10,7 @@
void schedule(void) {
int i, next, c;
struct task_struct **p;
+ /* Prioritize interactive tasks dynamically */
for(i = 0; i < NR_TASKS; i++) {
// Priority selection logic
}
The Resurgence of Apple (2001)
In 1997, Apple acquired Steve Jobs’ computer hardware and software company, NeXT. NeXT had developed NeXTSTEP, an object-oriented operating system based on the Mach microkernel and BSD user-space utilities.
Apple integrated this technology to create the Darwin operating system, which is centered around the XNU (X is Not Unix) hybrid kernel. XNU combines the Mach microkernel’s message-passing architecture with the BSD subsystem’s process model, networking capabilities, and POSIX compliance. Darwin serves as the core foundational layer for macOS, iOS, watchOS, and tvOS.
For example, a developer can run macOS command-line utilities to inspect the underlying Darwin kernel metrics directly:
sysctl kern.ostype kern.osrelease
This command returns details indicating the BSD/Darwin ancestry:
kern.ostype: Darwin
kern.osrelease: 23.4.0
The Modern Landscape
Today, the vast majority of consumer and enterprise computing platforms fall into three primary architectural categories:
- The NT Camp: Windows desktop, server, and Xbox platforms. This camp uses a proprietary, closed-source hybrid kernel.
- The Linux Camp: Linux distributions (Red Hat, Ubuntu, Debian), Android devices, ChromeOS, and enterprise cloud infrastructure. This camp uses an open-source, monolithic kernel.
- The Unix/BSD Camp: Apple macOS and iOS (based on Darwin/XNU), FreeBSD, OpenBSD, and NetBSD. This camp uses a combination of hybrid and monolithic architectures conforming to POSIX standards.
An example comparison of key architecture designs highlight the structural differences among these camps:
+------------+--------------------+---------------------+------------------+
| OS Family | Primary Kernel | Architecture Type | License Model |
+------------+--------------------+---------------------+------------------+
| Windows | NT | Hybrid | Proprietary |
| Linux | Linux | Monolithic | Open Source (GPL)|
| macOS/iOS | XNU (Mach/BSD) | Hybrid | Proprietary/APS |
| FreeBSD | FreeBSD | Monolithic | Open Source (BSD)|
+------------+--------------------+---------------------+------------------+
Regardless of their internal scheduling algorithms or memory management policies, all three camps trace their conceptual heritage back to the early time-sharing and protection systems developed in the 1960s.
Which operating system first introduced the concept of a hierarchical directory file system and hardware protection rings, directly influencing UNIX?
References & Further Reading
To practice or explore further, see the publications below for an example of research in these domains:
- Ritchie, D. M., & Thompson, K. (1974). The UNIX Time-Sharing System. Communications of the ACM, 17(7), 365-375.
- Corbato, F. J., & Vyssotsky, V. A. (1965). Introduction and Overview of the Multics System. In Proceedings of the November 30—December 1, 1965, Fall Joint Computer Conference, Part I (pp. 185-196).
- McKusick, M. K., Bostic, K., Karels, M. J., & Quarterman, J. S. (1996). The Design and Implementation of the 4.4BSD Operating System. Addison-Wesley.
- Russinovich, M. E., Solomon, D. A., & Ionescu, A. (2012). Windows Internals (6th ed.). Microsoft Press.
- Torvalds, L., & Diamond, D. (2001). Just for Fun: The Story of an Accidental Revolutionary. HarperCollins.
- Tanenbaum, A. S., & Bos, H. (2015). Modern Operating Systems (4th ed.). Pearson.
- Silberschatz, A., Galvin, P. B., & Gagne, G. (2018). Operating System Concepts (10th ed.). John Wiley & Sons.