The earliest DOS source code has finally surfaced after 45 years, released publicly on April 28, 2026 to mark the anniversary of 86-DOS 1.00’s original debut. Historians discovered the source code printed on continuous-feed assembler paper stacked in Tim Paterson’s garage, then transcribed and made compilable by researchers Yufeng Gao and Rich Cini, with support from Microsoft’s Stacey Haffner and Scott Hanselman.
Key Takeaways
- Earliest DOS source code found on 1981 printer paper in Tim Paterson’s garage after 45 years
- Released April 28, 2026 under MIT license on GitHub, freely accessible worldwide
- Includes 86-DOS 1.00 kernel, PC-DOS 1.00 snapshots, utilities like CHKDSK, and the assembler itself
- Transcribed by historians Gao and Cini with Microsoft team involvement and collaboration
- Printouts reveal the actual development timeline, showing bugs, fixes, and feature implementations predating modern version control
How 45-Year-Old Printouts Became Compilable Code
The earliest DOS source code exists because Tim Paterson, who authored 86-DOS, printed his work on continuous-feed paper using the assembler available at the time. No digital backups survived. Researchers faced the painstaking task of scanning these physical printouts, transcribing the assembly code by hand, and validating it against the original assembler tool to ensure accuracy. The result is a fully compilable codebase that runs on modern systems with the correct Seattle Computer Products’ ASM assembler from any 86-DOS or early MS-DOS release.
What makes this discovery historically significant is not just the code itself, but the annotations and edits visible on the paper. Paterson’s handwritten notes, crossed-out lines, and margin corrections show the actual development process—bugs introduced, caught, and fixed in real time. This paper trail predates GitHub by decades and offers historians a window into how operating system development actually worked before version control systems existed.
What’s Inside the Earliest DOS Source Code Release
The GitHub repository contains the 86-DOS 1.00 kernel sources, multiple development snapshots of the PC-DOS 1.00 kernel, and utilities including CHKDSK, the disk checking tool that became familiar to millions of PC users. Remarkably, the archive also includes listings of the assembler itself—the tool Paterson used to write DOS. This is unusual. Most historical software releases include only the application code, not the compiler or assembler used to build it.
The printouts provide a timeline of changes that shows how DOS evolved from its earliest conception. Feature implementations appear in sequence, alongside error corrections and refinements. This chronological view of development decisions offers researchers and retro computing enthusiasts a rare insight into low-level operating system design from the IBM PC era. Microsoft framed the release as part of a broader commitment to preserving historically important systems software, stating that these releases are about making early computing available for study, preservation, and curiosity.
Why This Matters Beyond Nostalgia
The earliest DOS source code release matters because it is the earliest verifiable record of DOS development from original 1981 materials, not later reconstructions or reverse engineering. For historians and computer scientists studying operating system design, this is primary source material. For retro computing enthusiasts building emulators or understanding how the IBM PC actually worked, having access to the actual kernel code—not documentation about it—changes what research is possible.
The project also demonstrates a shift in how major technology companies treat their oldest code. Microsoft could have kept these printouts archived or destroyed them. Instead, the company worked with historians to preserve and open-source them under MIT license, making them freely available to anyone on GitHub. This approach contrasts with the era when source code was treated as proprietary treasure. The earliest DOS source code is now as accessible as any modern open-source project.
Can You Actually Compile and Run This Code?
Yes, but with a specific requirement. The GitHub repository includes detailed instructions for compiling the earliest DOS source code using Seattle Computer Products’ ASM assembler, which is available in any 86-DOS or early MS-DOS release. Modern assemblers will not work without modification because the syntax and directives have evolved. This requirement actually adds authenticity—you are using the same toolchain Paterson used in 1981.
Running the compiled code is another matter. The resulting kernel requires compatible hardware or an emulator that can boot x86 real-mode code. Most retro computing enthusiasts use emulators like PCem or 86Box to test historical DOS code. The value is not necessarily in running it on bare metal, but in studying the code itself and understanding how it works.
How Does This Compare to Later DOS Versions?
86-DOS 1.00 was the foundation that became PC-DOS 1.00 after IBM licensed it from Seattle Computer Products. Comparing the earliest DOS source code to later versions reveals how quickly the operating system evolved. The printouts include several development snapshots of PC-DOS 1.00, showing the transition between Paterson’s original work and IBM’s commercialized version. Later DOS versions added features, improved memory management, and expanded filesystem support, but the core architecture visible in these 1981 printouts remained largely unchanged through the 1980s.
What Happens Next with the Earliest DOS Source Code?
The code is now public and immutable on GitHub under MIT license. Researchers can fork it, study it, build upon it, and create derivative projects. Some may use it to build more accurate emulators. Others might document the code with modern comments to make it accessible to developers who have never seen assembly language. The release is permanent and global—anyone with internet access can download the earliest DOS source code and examine the foundation of the personal computer era.
Why was the earliest DOS source code found on printer paper, not stored digitally?
In 1981, storage media was expensive and unreliable. Programmers often printed their code on continuous-feed paper as a backup and for code review. Tim Paterson kept these printouts, and they survived when digital copies were lost to hardware failures, format obsolescence, and the simple passage of time. Paper outlasted the storage technologies of the era.
Can I use the earliest DOS source code for commercial purposes?
Yes, the code is released under MIT license, which permits commercial use, modification, and distribution as long as you include the original license and copyright notice. This is one of the most permissive open-source licenses available.
How long did it take to transcribe the earliest DOS source code from the printouts?
The research brief does not specify the transcription timeline. Historians Yufeng Gao and Rich Cini, along with Microsoft’s team, completed the work in time for the April 28, 2026 release, marking the 45th anniversary of 86-DOS 1.00.
The release of the earliest DOS source code is a reminder that computing history is fragile. Without Paterson’s decision to keep those printouts, the foundational code of the IBM PC era would have been lost forever. Now, preserved on GitHub and accessible worldwide, the code belongs to everyone. For retro computing enthusiasts, operating system researchers, and anyone curious about how personal computers actually started, the earliest DOS source code is finally open for study.
This article was written with AI assistance and editorially reviewed.
Source: Tom's Hardware
