Windows CE represented Microsoft’s bold entry into embedded and mobile computing. Unlike Windows NT or Windows 9x, CE was built from the ground up for resource-constrained devices. Understanding its architecture provides crucial insight into why PocketPC devices worked the way they did.
Modular Kernel Design
Windows CE’s most innovative feature was its componentized architecture. Rather than shipping a monolithic operating system, Microsoft created a catalog of modules that OEMs could select from:
Windows CE Component Hierarchy:
┌─────────────────────────────────────────�
â”? Applications (Shell, Apps) â”?
├─────────────────────────────────────────�
â”? Win32 API Subset (COREDLL) â”?
├─────────────────────────────────────────�
â”? Graphics (GWE) â”? Communications â”?
├───────────────────┼─────────────────────�
â”? OEM Adaptation Layer (OAL) â”?
├─────────────────────────────────────────�
â”? Kernel (NK.EXE) â”?
└─────────────────────────────────────────�
This modularity enabled Windows CE to scale from 256KB ROM devices to full-featured PocketPCs with megabytes of storage.
Memory Architecture
Windows CE employed a unique memory model optimized for devices without hard drives:
Execute-in-Place (XIP)
Applications could run directly from ROM without being copied to RAM first. This dramatically reduced memory requirements:
- ROM: Stored the OS and built-in applications
- RAM: Used for running applications and user data
- Object Store: A RAM-based filesystem for user files
Slot-Based Virtual Memory
The original Windows CE (through version 5.0) divided virtual memory into 32 slots of 32 MB each:
| Slots | Purpose |
|---|---|
| 0 | Current running process |
| 1 | Active ROM DLLs |
| 2-31 | Other processes (max 32 simultaneous) |
This architecture limited individual processes to 32 MB of virtual address space—a constraint that Windows Mobile developers had to carefully work around.
Platform Builder
Microsoft’s Platform Builder tool allowed OEMs to construct custom Windows CE images. The process involved:
- Component Selection: Choose required features from the catalog
- BSP Integration: Add Board Support Package for specific hardware
- Configuration: Set locale, drivers, and default applications
- Build: Compile the custom OS image
- Testing: Validate on target hardware
This flexibility enabled Windows CE to power everything from Compaq iPAQs to automotive navigation systems and industrial controllers.
The Win32 API Subset
Windows CE implemented a carefully chosen subset of the Win32 API. This allowed existing Windows developers to target mobile devices with familiar tools, though significant differences existed:
Supported Features
- Window management (HWND, messages)
- GDI graphics (basic drawing, fonts)
- File I/O (CreateFile, ReadFile)
- Registry access
- Threading and synchronization
- Winsock networking
Notable Omissions
- Memory-mapped files (initially)
- Console applications
- Many advanced GDI features
- Full COM support
Microsoft documented these differences extensively, and tools like eMbedded Visual C++ provided compatibility checking.
Graphics Architecture (GWE)
The Graphics, Windowing, and Events subsystem handled all user interface operations. Unlike desktop Windows, GWE was tightly integrated:
- Display drivers communicated directly with hardware
- Window manager optimized for stylus input
- Font rendering used bitmap fonts for speed
- Transparency and layering were limited
Later versions added support for hardware acceleration through DirectDraw, enabling devices like the Dell Axim X51v to deliver impressive graphics performance.
Real-Time Capabilities
Windows CE was designed as a real-time operating system (RTOS), supporting:
- 256 priority levels for threads
- Guaranteed interrupt latency (sub-millisecond)
- Priority inheritance to prevent inversion
- Nested interrupts for responsive I/O
These capabilities made Windows CE suitable for industrial automation, medical devices, and automotive systems—markets where Linux and proprietary RTOSes competed.
Evolution Through Versions
| Version | Year | Key Features |
|---|---|---|
| CE 1.0 | 1996 | Initial release, HPC devices |
| CE 2.0 | 1997 | Palm-size PC support |
| CE 3.0 | 2000 | PocketPC 2000, improved multimedia |
| CE 4.0 | 2002 | .NET Compact Framework support |
| CE 5.0 | 2004 | DirectX support, enhanced security |
| CE 6.0 | 2006 | Unified kernel, 32K processes |
Legacy and Influence
Windows CE’s architecture influenced subsequent Microsoft platforms:
- Windows Phone 7/8 inherited CE concepts
- Windows 10 IoT carries forward embedded traditions
- UWP sandboxing echoes CE’s process isolation
For those studying the history of Windows CE, understanding the architecture reveals why certain design decisions were made and how they shaped mobile computing.