For better or worse, the Microsoft Windows operating system is everywhere. It's at home, at work, at the bowling alley, at the bar, at the restaurant, at the pool, and, as we found out in dramatic fashion a couple of years ago, the airport. By "doing what it needs to do" for the vast majority of people, it has become a fundamental part of personal computing software, although various attempts to do the same thing, but for phones failed, in the face of stiff competition.

However, its history is not as documented or studied as many other influential projects, such as the Macintosh, and what little exists is often incomplete, inaccurate, or even misinformation. This is partially due to its sheer ubiquity, but also because it was generally considered to be "uncool" and (rather justifiably) something to be "resisted" for a large part of its rise to power, leading to historical accounts generally being less than kind to Windows. I intend to change this. Although I personally, like many in the technology community, dislike and may even despise the monopolistic techniques that Microsoft used to push Windows onto the masses and, even more so, the current state of the product that its billions of users have to deal with, it is still worth giving a fair assessment. After all, to have as many users as Windows was able to obtain, you have to do something right! Especially considering many of the progenitors are still alive, this is an opportunity to catalog the history and evolution of an operating system that has had a massive impact on how almost the entirety of humanity with a computer has lived, played, generated culture, and worked - an opportunity that almost no other area of history has. Based on never-before-seen interviews, emails, original source code and reverse engineering efforts, this blog post series hopes to provide you with a comprehensive early history of Windows, from a technical, cultural, business and human point of view.

The Origins

Microsoft was founded in 1975 by two upper-middle-class kids, Bill Gates and Paul Allen, from California after reading about an early microcomputer, the Altair 8800, at Harvard. Most of the pre- and early history of Microsoft is very-well documented and is not directly relevant to Windows; but to make a (very) long story short, Microsoft managed to both produce the standard implementation of the well-known language BASIC for many of the early microcomputer companies and convince IBM to license an operating system (that they had themselves bought from another company, Seattle Computer Products, for $75,000, in one of the best business deals in history) for their immensely successful and ultimately standards-setting Personal Computer, although this may have helped by the CEO of IBM serving on the board of the charitable United Way organisation alongside none other than Mary Gates, Bill's mother. Regardless of questions about how these deals were obtained, however, by 1982, Microsoft was well on its way to making its founders, and any of their employees who managed to obtain enough of the extremely lucrative employee stock options, rich (mostly) men.

However, most of their products were not particularly innovative or groundbreaking. The business model of Microsoft largely involved improving ideas put forth by other companies and research institutions. This is not unusual on its own, but when combined with Bill Gates' legendary ability to convince (some would say manipulate) people into doing what he wanted, commitment to standards-setting, and extreme competitive spirit, was enough to launch sales to $24.5 million by 1982. The products that Microsoft offered at this time involved a second-place spreadsheet (Multiplan, second to 1-2-3 after its release in 1983), implementations of various languages for various processors (Intel 8080, MOS 6502, Intel 8086, Motorola 6800) which ranged from excellent (BASIC) to passable (FORTRAN, PASCAL, LISP), a few games, a Z80 "SoftCard" intended to allow the Apple II to run CP/M applications, and a basic Disk Operating System which generated the vast majority of their revenue by being the virtue of being licensed out to anyone making a machine compatible with the IBM PC, which just so happened to have almost completely open and easily clonable parts and also be the by far the most popular PC around. Gates had insisted on having this ability in the license negotiations, and somehow hoodwinked IBM into allowing it. Their $75,000 deal turned into billions. There were also additional products in the pipeline, such as the "Word" word processor (later a standard), a new version of MS-DOS with various improvements such as subdirectory support, hard disk support, a device driver model, memory management APIs, redirection and a new API for background execution that was actually documented.

All of this software was command-line based, but Microsoft understood that graphical interfaces were coming. MS-DOS was also a very poor operating system with none of the features that were expected in higher-end operating systems, such as memory protection (although the CPUs of the era were not capable of it for microcomputers yet), support for multiple users, multitasking, paging (requiring nonexistent hardware support), virtual consoles, virtual memory or any other number of features. There was a need, if the company was to remain competitive in the future, to solve both of these problems. The first problem had a long-term solution: Microsoft licensed the well-known, although largely minicomputer based, operating system UNIX, renamed it to XENIX and ported it to Microsoft's various platforms. However, it was not yet feasible for use on PCs at a level that would sell large numbers of copies. For instance, it had entirely synchronous I/O and was entirely written in C for portability reasons. While these are good design choices, of which the principle was well-understood both inside and outside of Microsoft, computers of the era were so slow across the domains of CPU, video, peripheral, I/O, system bus and so on, especially the system bus and memory, as the Intel 8088, the 8086 variant used on most PCs, Bus Interface Unit having to wait two cycles on every 16-bit access despite being a 16-bit CPU due to its 8-bit external bus, that designing an OS "properly" (in the way that textbooks and so on would tell you) was simply out of the question for at least several more years. The 8086 was a 1978 CPU design that could not even address more than a megabyte of memory! Additionally, despite its general crappiness, MS-DOS had become so popular that application compatibility was required, and MS-DOS apps were very tuned to the quirks of the architecture that birthed it, especially its lack of memory-protection, which was often harnessed for various micro-optimisations. Virtualisation was also not feasible yet on PCs, which made the problem harder.

So a solution had to be devised, at least in the interim period before computers would be fast enough for XENIX to take over. The initial plan was called XEDOS, but after various permutations development started in earnest on a multitasking version of MS-DOS, intended to run in less memory and effectively be a "single-user XENIX", in January of 1983. This is its own story I have partially covered here (I will finish it, don't worry!). That blog post deals with problem #1; this one, with problem #2. Ultimately, Microsoft's solution to problem #2 ate up its solution for problem #1 (although it solved certain aspects in a worse way, as we will see), and Multitasking DOS morphed into OS/2, which never really went anywhere, or at least to nearly the extent that its creators intended it to go. (Sorry OS/2 fans!)

Microsoft, as well as Apple and one of the founders of what later became Sun Microsystems, had been demoed the famous Xerox PARC Smalltalk-based GUI systems, the Alto and later Star, which cost $20,000 and were largely discrete-logic TTL machines, and were therefore not particularly suitable to be marketed (which Xerox found out when they tried to market it), but were incredible advancements for the era. Xerox machines innovated on, although did not exactly invent, many technologies that we now take for granted, such as WYSIWYG (What You See Is What You Get) document production, email, bitmap editing, just-in-time (JIT) compiling and local-area networking. Although other systems, such as the PLATO collaboration system, existed with more advanced e.g. networking features, but Xerox's machines had a more integrated experience. Many of the people who saw the Xerox machine were immediately inspired by it and attempted to capitalise on it; both Apple and Microsoft hired many of those PARC engineers who wished for a more product-focused rather than research-focused lifestyle. Microsoft also had, since 1981, had been intimately involved with (as one of the largest PC software companies of the era), and was developing applications for an Apple Motorola 68000 and GUI-based computer project code-named "Macintosh", and Apple employees alleged that at some point Microsoft started asking extremely detailed questions about the technical implementation of the Mac, and copied certain elements of the design to the point of bug-compatibility, although actual historical evidence of this is presently lacking. Bill Gates later likened the situation to breaking into a rich neighbours' house to steal a nice television, but finding that it had already been stolen; in reality, both the final Mac and Windows OSes were quite evolved from the original Xerox PARC graphical interfaces,

However, just because Microsoft had become aware of graphical user interfaces does not mean that they were immediately to start developing one. of the factors hamstringing development of graphical applications on the early PC was the lack of standardization around how graphics were to be drawn. By 1983, IBM's Color Graphics Adapter and Van Suwannukul's Hercules Graphics Card were already available, and in the next few years, an explosion of options arrived, including IBM's own Enhanced Graphics Adapter and the IBM PCjr graphics (subsequently cloned into the Tandy 1000), to a litany of other "Super CGA" adapters. With there being no standardized programming model for graphics, developers had to directly program the hardware of every display adapter that they wanted to support, creating a heavy burden. In reality, this meant that more niche display adapters tended to have little to no software at all (or in the case of most of the "Super CGA" adapters, it meant that they could run software, but only in CGA compatibility mode, and without any of their additional capabilities). Other issues included Microsoft's limited resources (they had only 100 programmers in 1983, which had to be split across many, many projects). However, there were existing projects that could be used as a base. In 2022, retro community member jb881122 managed to get into contact with various early Windows developers. I'm not sure if they want their names to be public (since they have suffered from intrusion by the media at various points for merely being associated with Microsoft, such as when Bill and Melinda Gates divorced). Nevertheless, I will transcribe what they said to the best of my ability. In early 1982, a "C guy" was hired to develop an implementation of a graphics standard (there were many attempts to create standards for computer graphics, most of which ultimately failed) , and in the middle of 1982 he was hired to join him, largely to convert the existing code into assembly to use less memory and run faster. The exact standard that was being implemented by these two developers is unknown, although the developer recalled that it was probably "European". The most likely culprit is the Graphical Kernel System, a standard for two-dimensional vector graphics, which was being ratified by the ISO during this era, and IBM was working on an implementation of at the time and later became the base for the graphics system of GEM. He also described it as vector-based and "not yet standardised", which are further points in favour of GKS. Other possibiities include the IGES system. Regardless of the exact system being implemented, primary goals included device independence (requiring an extensive driver model) due to the aforementioned hardware incompatibility issues, the ability to print graphics objects onto paper and have them look correct, and both raster and vector graphics support, since almost all of the graphics standards of the IBM PC were raster-based.

Another Microsoft project around at the same time in early 1982 was Interface Manager, which was an internal library for text-based user interfaces (TUI) which was used across the then-new Microsoft Applications division, which developed everything that was not hardware (which was in its own, smaller division), operating systems or languages. Apps was set up in response to complaints that Microsoft's applications developers were provided information about the working of Microsoft's operating systems that external developers were not privy too, and Bill Gates claimed that creating the Apps division would set up a "Chinese Wall" which would prevent this. This was a lie, as future developments would illuminate. However, it appears to have satisfied most of the developers at the time (check this). Apps was, at that time, developing Multiplan, Word and various other applications, and wanted them to have a shared UI, which became a project by the name of Interface Manager. It is not entirely known if any app ended up with Interface Manager, but Microsoft's apps of the time (1982-1983) have a "control bar" at the bottom with a list of context-dependent options for the user, which could be activated by pressing the first letter of the key. This is very similar to the early 1983 builds of Windows. (IMAGE HERE); rather interestingly, many of the apps that have this UI, such as Multiplan, have ".DAT" files (in this specific case, the files are MP40.DAT for 40-column displays and MP80.DAT for 80) that have UI elements. This is evidence in favour of these apps using some sort of library (possibly Interface Manager, since Windows has a similar format), but this is not proven. There is also a MP.LOD and MP.SYS file, which is presumably loaded by MP.COM; in Multiplan 2.0, some reorganisation occurred and the code and data segments became MP.COD, MP.HLP and MP.DAT. Further evidence in favour of this being Interface Manager, or at least some kind of shared library, is that Microsoft Word for DOS (Beta Test X1.06) shares a very similar structure, with MW.COD and MW.DAT files, as well as a new (>64K) MW.PGM. However, extensive reverse engineering would likely be needed to ascertain if code from the framework used by Multiplan, or any other platform ever actually ended up in Windows. It would be hard to port Interface Manager code to Windows, since the entire screen model was immediately obsoleted.

In any case, around the summer of 1982, the two projects had been merged. The new charter was to create a windowing manager; the decision to take this new path may or may not have had to do with rumours of the impending announcement of VisiCorp Visi On, a competing windowing system, although it failed after its release in 1983, as, despite being a high-quality product with some interesting ideas, it ultimately failed due to extreme corporate infighting (extremely autocratic maangement led to numerous employees leaving, including directly leading to the founding of Lotus Development Corporation), requiring a UNIX workstation to develop for and costing an exorbitrant amount of money not only did package cost $495, the mouse that was generally optimal to use cost $295 and the level of specifications required to run the OS (512 KB of RAM and a hard drive) cost approximately $7,500, almost as much as the faster and itself failed Apple Lisa. Microsoft may also have been aware of the existence of the tragically misconceived, but well engineered, largely text-based IBM "TopView" product which was released in 1984.

Early Development

The early development of Windows after the merger of GDI and TopView is quite obscure and not much can be ascertained for sure, although it is known, per testimony from the original developers, that the originally intended release date was late 1983 and that various features, such as bit blits, lines, splines, rectangles and pens as a way of defining how graphics drawing is done, were already included. (Let me know how the developers go). The product was developed on a network of IBM PC XTs initially; each developer had a dev machine and a test machine, and these machines were networked together using Ethernet and various other. However, it does not seem that the original intention was to create the almost full operating system that was ultimately developed; the oldest code files in the source archives are dated March 1984, shortly before Development Release 1. indicating extensive rewrites occurred, and there is evidence of several large refactors, including fundamental API changes, functionality additions, rewrites of the memory manager as late as early 1985 and several different executable formats. It is known from talking to early developers that USER, GDI and KERNEL existed by late 1983 especially KERNEL was very incomplete. (blah blah development here)

Development

Overview

Windows 1.01, excluding Write (which was not included in the provided source code archives), is compiled from 3,040 source files. The source files are written in a mixture of C and Intel 8086 assembly language (no features from newer CPUs are used, even if these CPUs are detected). Additionally, there is a very small amount of Pascal source used for providing Pascal application development support for WIndows. Not all of these files are actually used in the final product; for instance, there are many internal / test apps that are not in the final build, and some files are only used in specific configurations of the final build such as the Software Development Kit. The source files use a custom build system, which is a mixture of batch scripts and makefiles. The assembler used is a beta of Microsoft Macro Assembler 4.0 ("3.50"), as well as Microsoft C 3.0, with certain patches; in Windows 1.03, the final version of Microsoft Macro Assembler 4.0 is used and the C compiler is updated to Microsoft C 4.0. The source code is compiled into approximately 191 different output files, most of which are executables. The source tree is structured as follows:

• KERNEL: Implements a cooperative scheduler, a segmented memory manage (with the ability to move around segments, share code segments, flush segments to and load from disk based on an LRU algorithm modelled off the behaviour of the Intel 80286 memory management unit (MMU), and various other low-level features) system initialisation, some DOS compatibility, system configuration, a string hashtable ("atoms") to prevent loading strings from disk, application resource management, dynamic linking of New Executable (NE) format executables, file management and some other features. It is the core of the operating system, and one of the Iris forks has a functionality to allow the KERNEL to run standalone as a command-line operating system for running early builds of Lotus Notes.