TL;DR
Get backup power and energy gear delivered free with Prime
- Fast, free delivery on millions of items
- Prime Video, Amazon Music and more included
- Member-only deals all year
This article explains how Win16’s memory management works, focusing on segments, handles, and the mechanisms that allowed Windows to efficiently manage limited memory. It highlights confirmed technical details and ongoing uncertainties about the system’s full implementation.
Recent technical analysis has clarified how 16-bit Windows managed memory through segments and handles, revealing the underlying mechanisms that allowed Windows to operate efficiently within limited hardware constraints. This understanding matters because it sheds light on the foundational architecture of early Windows systems, which influenced later memory management models.
The core of Windows 16-bit memory management revolved around segments, which are contiguous blocks of memory up to 64KB in size. Unlike direct segment addresses used in pure 8086 programming, Windows identified segments via opaque handles—16-bit values that serve as references rather than direct addresses. These handles are akin to protected mode selectors but are used in real mode environments to enable Windows to move and discard segments without losing track of them.
Windows adopted and extended the ‘New Executable’ (NE) format, which stored segments separately on disk, allowing for individual loading, unloading, and relocation in memory. When a program needs to access a segment, it calls APIs like GlobalAlloc, which returns a handle, and GlobalLock, which provides a segment address and locks the segment in place. Unlocking with GlobalUnlock allows the segment to be moved again, with the handle remaining valid as a reference.
This handle-based system enabled Windows to implement a form of memory management that was flexible yet constrained by the hardware of the era. The design was inspired by Intel 286 protected mode, though Windows itself operated primarily in real mode, requiring additional discipline and API support to emulate protected mode features.
Why It Matters
This memory management approach was critical for Windows’ ability to run multiple applications simultaneously on limited hardware, effectively acting as an overlay manager. Understanding this system clarifies how early Windows overcame hardware limitations and laid the groundwork for modern memory management concepts. It also provides context for developers working with legacy systems or emulators.
Products Worth Considering
Samsung 48-Inch S90H OLED 4K Smart TV (2026)
Philips Hue Large Smart Light Tube, Black – White and Color Ambiance LED Color-Changing Light – 1 Pack
Bose S1 Pro+ Portable PA Speaker
As an affiliate, we earn on qualifying purchases.
Background
Windows 1.x and 2.x operated in a constrained environment where paging was unavailable, and memory was scarce. The adoption of the NE format and segment handles was a response to these limitations, enabling Windows to load, move, and unload application code dynamically. This architecture persisted through Windows 3.x, influencing later Windows versions, though the system evolved significantly with the advent of protected mode and 32-bit architectures.
“Handles serve as a level of indirection, allowing Windows to move segments around without breaking references.”
— Steve Wood, Windows 1.0 memory designer
What Remains Unclear
While the general principles of handle and segment management are understood, the detailed implementation, particularly how Windows optimized segment relocation and handle management in practice, remains partially undocumented. It is also unclear how these mechanisms evolved in later Windows versions beyond Windows 3.x.
What’s Next
Further research aims to uncover detailed source code or detailed documentation that clarifies the internal algorithms Windows used for segment relocation and handle management. Additionally, exploring how these legacy systems influenced modern memory management could provide valuable insights.
Key Questions
How did Windows manage to run multiple applications with limited memory?
Windows used segments and handles to load, move, and unload parts of applications dynamically, acting as an overlay manager that kept only active segments in physical memory.
What is the significance of the NE format in Windows memory management?
The NE format stored segments separately on disk, enabling Windows to load and unload segments individually, which was crucial for managing limited memory resources.
Are these memory management techniques still relevant today?
While modern systems use paging and virtual memory, the handle-based approach influenced later memory management models and remains a foundational concept in understanding legacy Windows systems.
What remains unknown about Windows 16-bit memory management?
Exact internal algorithms for segment relocation, handle management optimizations, and how these evolved in later Windows versions are still not fully documented or understood.
Source: Hacker News
