Microsoft Azure CTO Releases Doom Running on Microsoft Paint as a Monitor at 35 FPS

Paint Becomes a Monitor for Doom

In a surprising and technically audacious release, Microsoft's Azure CTO has published a project that uses Microsoft Paint as a monitor to run the original Doom at up to 35 frames per second. The creation is not a video or a simulation; it loads the genuine shareware DOOM1.WAD and executes on the real Doom engine while displaying every frame on Paint's white canvas. By treating the humble image editor as a display device, the project turns a built-in Windows accessory into a low-latency screen. The release has already captured the attention of developers, who see it as both a playful homage to the game's legacy and a serious exercise in rethinking what everyday software can do. The very idea of using a program designed for image editing as a high-performance gaming monitor seems counterintuitive, yet it works well enough to play through the shareware episode comfortably, which is a testament to the ingenuity behind the implementation.

Doom's Long History of Impossibly Creative Ports

Since id Software unleashed Doom in 1993, the first-person shooter has served as the technology world's favorite stress test. Developers have ported it to calculators, ATMs, refrigerators, and even to inside PDF files and machine-readable barcodes. Every new port reinforces a cultural tradition: if a device, and sometimes a piece of software, can compute, it can likely run Doom. This Paint-based project adds another extraordinary chapter. Unlike most ports, which target hardware constraints, it exploits the capabilities of an existing desktop application, turning an image editor into a display. The effort is as much a commentary on software flexibility as it is a gaming experiment. It also speaks to the fact that Doom's famously accessible engine and its shareware distribution model have made it the perfect candidate for community-driven hacking projects for nearly three decades, and that tradition shows no sign of slowing down.

How the Hack Works Under the Hood

The project works by feeding Doom's rendered frames into Microsoft Paint's drawing surface, using the application's pixel-update routines to act as a display buffer. The game engine runs natively, handling player inputs, sound, and physics, while a custom bridge captures the framebuffer and relays it to Paint through a sequence of mouse and keyboard operations. Achieving 35 frames per second required careful performance tuning, including resolution scaling and event-loop synchronization. The developer explained that the core challenge was preventing Paint from interfering with its own interface while maintaining a steady update rate. The result is a fake but fully functional monitor, proving that even an editor with no display capabilities can become one with enough engineering diligence. Moreover, because Paint is not designed for real-time video, the bridge must carefully manage the Windows message queue to avoid input lag or dropped frames, making the underlying technique surprisingly delicate and informative for anyone studying inter-process communication on the Windows platform.

A Leader at Microsoft Takes the Helm

That the release comes from the Azure CTO adds a layer of corporate intrigue. A senior executive known for cloud-scale systems spent time to make a 30-year-old game run in a stock Windows app. In a statement, the CTO described the project as a constraint-driven exercise: “Watching Doom run on Paint is a reminder that technology is only limited by the imagination of its users. Sometimes, you need to build colossal cloud systems, but other times, the best way to learn is to bend a simple program to do something it was never designed to do.” The project is also a nod to the hacker ethos that has long existed inside Microsoft, where experimentation and fun are valued alongside enterprise reliability. The CTO's involvement gives the release unexpected credibility and encourages others at the company to share their own side projects, reinforcing the idea that innovation in large organizations often comes from moments of playful curiosity rather than structured roadmaps.

What This Means for Cloud Computing and Software Design

Although the project is a stunt, it carries practical implications. It demonstrates how existing, standardized components can be repurposed as rendering layers—similar to how virtual desktops or cloud gaming streams use generic protocols to deliver graphics. It also stresses the importance of real-time inter-process communication, a skill that underpins cloud services and latency-sensitive applications. By deeply understanding the event loops and messaging patterns inside a program like Paint, engineers can extract lessons about optimizing performance in environments where the underlying interface is not built for high-throughput I/O. The project thus serves as a compact case study for developers building on Windows and beyond. It also challenges the assumption that better performance always requires specialized hardware or bespoke software; sometimes the most creative solutions come from circumventing the limitations of a tool we already have, a mindset that can be directly applied to cloud resource optimization and legacy system integration.

The release also highlights the growing trend of using consumer-level applications as testbeds for professional engineering concepts. In a world where cloud computing is increasingly abstracted and virtualized, this project reminds us that the user interface itself is still a critical layer in the software stack. Whether it is a canvas in Paint or a terminal window in a cloud IDE, the way data moves from a rendering engine to a screen is a universal challenge, and mastering it in a constrained environment can yield a deeper understanding that transfers to large-scale distributed systems.

The Project's Open Source Release and Immediate Reception

The full source code has been released publicly on GitHub, complete with build instructions. Because the shareware episode of Doom is widely distributed, anyone with a Windows PC can quickly recreate the experience. Early developer feedback has praised the project's minimalistic design and its successful handling of input latency. Some have remarked that it feels like watching a clever hack from the 1990s being rediscovered in a modern context. The repository also includes notes on benchmark results across different machines, allowing future contributors to optimize further. Its immediate reception confirms that the developer community still celebrates absurd, well-executed experiments, especially those that run Doom. The public release also encourages peer review and improvement, which is likely to lead to even more impressive frame rates and new features in the coming weeks, as the community builds on the initial proof of concept.

What's Next for the Experimental Build

Community members have already proposed enhancements, including support for higher resolutions, mouse capture, and potentially multiplayer matches. While the Azure CTO has clarified that the project is not intended to be a production tool, its architecture leaves room for expansion. The underlying adapter that bridges Doom to Paint might be modified to support other games or other canvas-based applications, turning the concept into a general-purpose display method. At present, the project remains a fun engineering artifact, but its opensource nature invites others to take the seed of an idea and grow it into something even more ambitious. There is also an opportunity to leverage Windows UI Automation or accessibility APIs to make the render loop even more efficient, and one could imagine forks that bring the same trick to other built-in Windows apps, such as Notepad or even the desktop background itself, pushing the boundaries of what is considered a viable output device.

A Gift to the Spirit of Software Tinkering

Ultimately, running Doom on Microsoft Paint is a gift to the culture of engineering. It reminds us that software boundaries are not fixed; they are merely constraints that encourage creativity. The project transforms a blank canvas into a battlefield, connecting the game's hacker roots with the modern cloud era. For Microsoft, it is a gentle reminder that even the most basic tools can inspire the most profound innovations. And for the rest of us, it is yet another unforgettable entry in the eternal saga of Doom—a game that will apparently run on anything, including the very pixels we use to edit images. It is also a celebration of the joy of discovery, showing that after all these years, there are still new ways to surprise and delight the engineering community. The project may have no practical purpose beyond entertainment, but in a world driven by utility, that is precisely what makes it so valuable.