The Ultimate Paint Job: How Microsoft’s CTO Brought Doom to the World’s Most Basic Editor

In the long, storied history of "Will it run Doom?", enthusiasts have ported id Software’s 1993 masterpiece to everything from pregnancy tests and ATMs to tractors and oscilloscopes. Yet, the latest iteration, dubbed DoomPaint, strikes a unique chord in the tech community. Developed by Mark Russinovich, the Chief Technology Officer of Microsoft Azure and a legendary figure in the Windows internals community, DoomPaint turns the humble, often-maligned Microsoft Paint into a fully functional gaming viewport. It is a technical curiosity that marries cutting-edge cloud architecture expertise with the whimsical, retro-computing spirit of the early 90s.

The Core Concept: A Masterclass in OLE Manipulation

At its heart, DoomPaint is not a native port of the game in the traditional sense. Rather, it is a creative exercise in software interoperability. The project leverages the ViZDoom engine—a research platform based on the original Doom—to handle the heavy lifting of game logic, AI, and rendering.

However, instead of pushing frames to a dedicated graphics window, the project renders the game headlessly. Every frame is then captured, converted into a format suitable for the Windows clipboard, and programmatically "pasted" into an active instance of Microsoft Paint. By utilizing OLE (Object Linking and Embedding) automation, the software effectively turns the Paint canvas into a live, flickering stream of 1993-era pixelated gore.

According to Russinovich, the result is a bizarrely playable experience. While the frame rate fluctuates—often described by the author as "spreadsheet-tier"—it can hit a surprisingly smooth 35 frames per second (FPS) on capable hardware.

A Chronology of the "Doom-in-Everything" Phenomenon

The obsession with porting Doom began almost as soon as the game was released. Because the source code was eventually opened, the game became the "Hello World" of the hardware hacking community.

The Early Days: Modding for Hardware

In the mid-90s, the focus was on getting Doom to run on varying configurations of MS-DOS, Windows 95, and specialized hardware. By the early 2000s, as handheld devices like the Game Boy Advance and early PDAs became popular, the challenge shifted toward mobile platforms.

The Modern Era: The Absurdity Threshold

In the last decade, the trend moved from "can it run on a device" to "can it run on a surface that has no business displaying a 3D game." We saw Doom on a printer, a digital camera, and even inside the BIOS of a modern motherboard. DoomPaint arrives at a time when the community is looking for clever software-based hacks rather than just hardware adaptations. By targeting a standard Windows desktop application—specifically one synonymous with the operating system’s basic utility—Russinovich has effectively bridged the gap between modern corporate software and retro gaming culture.

Supporting Data: Performance and Technical Constraints

The technical specifications of DoomPaint are a testament to the efficiency of the original id Tech 1 engine, combined with the limitations of Windows’ clipboard architecture.

• Rendering Pipeline: The ViZDoom engine runs the original DOOM1.WAD shareware file. It performs the game logic, sound processing, and music playback in the background.
• The Clipboard Bottleneck: The primary bottleneck is the Windows clipboard. Copying and pasting data between processes is not designed for 35fps video streaming. The "fair pace" achieved by the project is a result of highly optimized memory buffers.
• Resolution: The game typically runs at 320 x 200 or 640 x 400, reflecting the resolution standards of the era.
• Sound and Music: Despite the visual medium being a static image editor, the port includes full audio, creating a surreal experience where the player hears the iconic screams of demons while watching the game "draw" itself onto a blank Paint canvas.

Russinovich has noted that the performance is "part of the charm." The jitter, the occasional lag, and the way the Paint UI flickers as it refreshes the canvas serve as a meta-commentary on the nature of software layering.

Official Commentary: "Paint Computes Nothing"

The creator’s own documentation provides the most humorous insight into the project. In the README file hosted on the project’s GitHub, Russinovich offers a candid, dry-witted breakdown of the utility.

"Paint renders the game but does not compute it," Russinovich writes. "Paint computes nothing. Paint has never computed anything. That’s the joke."

This statement serves as a critique of modern software bloat. In an era where applications often require massive amounts of RAM and high-end GPUs just to display a simple interface, DoomPaint highlights how far the industry has moved from the lean, efficient code of the 90s. By forcing Paint to "render" a game it was never intended to display, the CTO is pointing toward the hidden power—and the inherent limitations—of the Windows API.

Implications: The Intersection of Corporate Tech and Hobbyist Hacking

The existence of DoomPaint raises interesting questions about the role of the modern software engineer. Mark Russinovich is not a random hobbyist; he is a titan of the Windows ecosystem. Having transformed SysInternals into the backbone of Windows diagnostics and currently shaping the architecture and security of Microsoft Azure, his time is undoubtedly valuable.

Bridging the Professional-Hobbyist Divide

The fact that a CTO at the level of Microsoft Azure is spending his spare time coding an OLE-based Doom port suggests that the "hacker" ethos is still alive and well within the highest echelons of Big Tech. It signals that even those managing global-scale cloud infrastructure find value in the "low-level" tinkering that defined the early careers of so many computer scientists.

Criticizing the Modern OS

Furthermore, the project exists against the backdrop of Russinovich’s recent public discourse regarding the state of Windows 11. He has been vocal about the "ancient" code—some of it dating back to the mid-90s—that still forms the bedrock of modern Windows. DoomPaint serves as a living, breathing demonstration of that legacy. If a 30-year-old game engine can still be hooked into the clipboard functions of the latest Windows iteration to produce a working game, it proves just how persistent the architecture of the 90s remains today.

Technical Accessibility for the Enthusiast

For those interested in replicating this experiment, the project is hosted on GitHub under the MIT license. It provides a rare look at how Windows applications communicate via the clipboard and OLE. However, it is not merely a "click and play" executable. Users must be prepared to handle dependencies, understand the basics of the ViZDoom engine, and potentially troubleshoot the performance issues inherent in forcing an image editor to act as a real-time display buffer.

It is a project that rewards curiosity. By stripping away the "professional" exterior of a Microsoft executive, DoomPaint invites users to look at the Windows operating system not as a locked-down product, but as a vast, interconnected landscape of legacy code and surprising capabilities.

Conclusion: A Legacy of Innovation

DoomPaint is more than just a meme. It is a synthesis of high-level systems architecture and the raw, unadulterated joy of computer science. While it will never be the preferred way to play Doom—the latency of the clipboard alone makes precision shooting an exercise in frustration—it stands as a monument to what is possible when a skilled engineer decides to break the rules of conventional software design.

In the end, the project serves as a reminder of why we fell in love with computing in the first place: the ability to make a machine do things it was never meant to do, simply because we could. As the tech industry continues to push toward abstract cloud services and AI-driven interfaces, DoomPaint provides a grounded, pixelated moment of clarity. It reminds us that at the bottom of every cloud-native application, every complex microservice, and every bloated OS update, there is still the same fundamental hardware and the same simple, stubborn desire to see a game run on a screen—even if that screen is a blank canvas in Microsoft Paint.