The Windows Story

The history of Windows represents the convergence of two distinct operating system architectures: the consumer-oriented 16/32-bit DOS/9x lineage, and the enterprise-grade 32/64-bit Windows NT architecture.

The DOS Era (1981 - 2000)

MS-DOS (Microsoft Disk Operating System) was designed as a single-tasking, single-user operating system for the Intel 8086 processor family.

• Execution Model: Programs executed sequentially in a single address space. The system did not support multi-threading or hardware-enforced memory isolation.
• Memory Limitations: Operating under the “Real Mode” of x86 processors, MS-DOS could only address up to 1 MB of physical RAM. The lower 640 KB was reserved for applications, while the upper 384 KB was reserved for system BIOS and memory-mapped hardware.
• The Shell: Windows versions 1.0 through 3.11 were not standalone operating systems. Instead, they operated as graphical user interface (GUI) environments executing on top of the MS-DOS filesystem and loader.

For example, configuration of device drivers and system parameters in this era was managed via flat configuration scripts:

rem Example: Classic CONFIG.SYS startup configuration in the MS-DOS era
DEVICE=C:\DOS\HIMEM.SYS
DEVICE=C:\DOS\EMM386.EXE NOEMS
BUFFERS=15
FILES=30
DOS=HIGH,UMB
LASTDRIVE=Z

The Secret Project: Windows NT

To address the instability of the consumer 9x lineage, Microsoft began development of a new operating system platform in 1989 under the code name “NT” (New Technology).

Microsoft hired Dave Cutler, who had earlier designed the VMS operating system for Digital Equipment Corporation. The goal of the project was to establish a modern kernel that was portable across different CPU architectures (such as x86, MIPS, and Alpha), supported symmetric multiprocessing (SMP), and enforced strict user-kernel memory separation.

Unlike the DOS-based systems, Windows NT utilized an object-oriented design where hardware resources and software state are encapsulated into objects managed by the NT Executive.

For example, native NT system routines rely on structured path variables such as UNICODE_STRING rather than standard null-terminated C-strings:

// Example: Using the native NT UNICODE_STRING structure in C
#include <windows.h>
#include <winternl.h>
#include <stdio.h>

void display_nt_path() {
    UNICODE_STRING ntPath;
    wchar_t pathBuffer[] = L"\\Device\\HarddiskVolume1\\Windows";
    
    // Initialize the structure fields
    ntPath.Buffer = pathBuffer;
    ntPath.Length = (USHORT)(wcslen(pathBuffer) * sizeof(wchar_t));
    ntPath.MaximumLength = sizeof(pathBuffer);
    
    printf("Native NT Object Path: %ls (Length: %u bytes)\n", ntPath.Buffer, ntPath.Length);
}

package "User Mode" {
[User Apps]
[Win32 Subsystem]
[POSIX Subsystem (obsolete)]
}
package "Kernel Mode" {
[Executive Services]
[Object Manager]
[Security Monitor]
[I/O Manager]
[Microkernel]
[HAL (Hardware Abstraction Layer)]
}
node "Hardware"
HAL -> Hardware

The Great Merger: Windows XP (2001)

Throughout the 1990s, Microsoft maintained two separate operating system tracks:

• Consumer Lineage (9x): High hardware compatibility for gaming and home applications, but high crash rates due to the underlying DOS foundation.
• Professional Lineage (NT 3.1 - 4.0, Windows 2000): Stable, multi-user systems designed for business servers and workstations, but lacking support for legacy consumer software.

Windows XP merged these branches by migrating the consumer features onto the NT 5.1 kernel structure. This transition replaced the DOS loader with the NT bootloader (NTLDR).

For example, system scripts in Windows XP could query version information to verify the underlying NT kernel version instead of the DOS execution level:

:: Example: Verifying system version properties in the command line
ver

:: Output on Windows XP:
:: Microsoft Windows XP [Version 5.1.2600]

Why Windows is “Different”

Several design decisions distinguish Windows from Unix-like systems.

The Registry

Rather than using text files (e.g., /etc/resolv.conf) distributed across a virtual file system, Windows stores configuration parameters inside a single transactional database called the Registry.

• Transactional Operations: Writing settings is atomic, reducing the risk of half-written configuration states.
• Structure: Grouped into hierarchical nodes called Keys containing data values.

Drive Letters vs. Unified Root

Windows mounts physical storage devices to individual drive letters (such as C: or D:). Unix uses a unified directory tree starting at a single root directory (/), mounting devices onto subfolders.

For example, network storage devices in Windows are mapped as network drives:

:: Example: Mapping a network share to a virtual disk letter
net use Z: \\fileserver\user_data /persistent:no

:: Display the mapping list
net use

Modern Windows: 7, 10, and 11

The NT kernel has evolved to meet modern security and update requirements.

• Windows 10: Transitioned to a rolling release model (“Windows as a Service”), delivering incremental kernel and OS updates through Windows Update rather than major version releases.
• Windows 11: Implemented stricter hardware constraints, requiring processors to support Trusted Platform Module (TPM) 2.0 to handle cryptography and secure boot states in hardware.

For example, security engineers can query the status of the TPM security module from a PowerShell console to verify compliance:

# Example: Query TPM hardware presence and status via PowerShell
Get-Tpm | Select-Object -Property TpmPresent, TpmReady, ManufacturerId

Today, the NT kernel extends beyond traditional desktop environments to run inside hypervisors (WSL2), IoT devices, Xbox consoles, and Microsoft Azure cloud servers.

:: From the Windows command prompt, query the active OS build version
ver

:: From the Windows command prompt, query the active OS build version

References & Further Reading

• Custer, H. (1993). Inside Windows NT. Microsoft Press.
• Zachary, G. P. (1994). Showstopper! The Breakneck Race to Create Windows NT and the Next Generation at Microsoft. Free Press.
• Russinovich, M. E., Ionescu, A., & Yosifovich, P. (2017). Windows Internals, Part 1: System architecture, processes, threads, memory management, and more (7th ed.). Microsoft Press.
• Microsoft Corporation. (n.d.). MS-DOS reference documentation. Microsoft Learn.