Can MS Paint Run Doom? The Clipboard Trick Explained

Can MS Paint run Doom? Yes, technically, though the honest answer takes some unpacking. Doom is fully playable inside Microsoft Paint right now, complete with sound, music, and a frame rate that hits 35 fps at the game's native resolution (The Verge, today). The project is called DoomPaint, built by Mark Russinovich, Microsoft Azure's CTO and a Technical Fellow (Windows Central, today). It loads the genuine shareware DOOM1.WAD file and sustains Doom's classic 35 tics-per-second cadence at 320×200 (Tom's Hardware, two days ago).

Russinovich is blunt about the catch. "Paint renders the game but does not compute it. Paint computes nothing. Paint has never computed anything. That's the joke," he wrote (TechSpot, yesterday). That line is the honest core of the demo. What follows walks through what "runs" actually means here, how the clipboard pipeline pulls it off, and why the engineering underneath deserves more attention than the joke usually gets.

Can MS Paint run Doom?

Not in the way the question implies. Paint isn't executing any of Doom's code. It's displaying a rapid sequence of pictures that another program keeps handing it, roughly 35 times a second, while the game itself runs somewhere else entirely, out of sight.

That somewhere else is ViZDoom, a ZDoom-based platform originally built for AI research. It runs Doom's simulation, physics, and rendering headlessly, meaning with no visible window of its own, and hands off each finished frame to DoomPaint's automation layer (TechSpot, yesterday). DoomPaint converts that frame into a bitmap, copies it to the Windows clipboard as OLE data (the format Windows uses to move rich content like images between applications), and pastes it into an open Paint canvas (TechEBlog, yesterday).

Think of Paint as a picture frame on a wall. Someone behind it keeps swapping in a new photo every fraction of a second, fast enough that the sequence reads as motion. The frame does the work of displaying each photo, but it never decides what's in the picture, and it never takes the photo itself.

That's the boundary the rest of this piece respects. "Yes, Doom runs in MS Paint" is a true statement, but only once you're specific about which program is doing what.

How Doom runs in Paint

The gameplay itself is real, not a looped recording. DoomPaint supports movement, turning, strafing, firing, running, and opening doors, so a person at the keyboard is genuinely playing a level, not watching a recording dressed up as interactivity (LavX News, two days ago).

Making that work required solving a problem most people never think about. Paint has its own keyboard shortcuts, and WASD or arrow-key presses would normally just trigger menu commands. DoomPaint intercepts movement and fire keys at a low level, before they reach Paint's own input handling, so gameplay never collides with the app's controls (TechSpot, yesterday).

Audio gets the same treatment. Sound effects run through an OpenAL layer, and the original Bobby Prince soundtrack is converted on the fly from Doom's native MUS format into MIDI, so Windows' built-in sequencer can play it (TechEBlog, yesterday).

The hardest problem, though, wasn't input or audio. It was timing. An early version let the clipboard get overwritten mid-read, corrupting frames as they arrived (TechSpot, yesterday). Russinovich fixed it by publishing a single persistent OLE data object and updating its underlying bytes only when Paint actually requested them, effectively turning Paint's own read operation into a synchronization signal that keeps the two programs from stepping on each other (TechSpot, yesterday).

That fix sets a ceiling on performance, not Paint's drawing speed. Doom's engine runs on its own thread at a fixed 35 Hz tic rate, so the simulation itself never exceeds that pace. What viewers actually see depends on how fast Paint can process and composite each pasted image, which sometimes falls short of 35 fps, a slowdown Russinovich calls "spreadsheet-tier" (TechSpot, yesterday).

One small giveaway of what's really happening: because ViZDoom boots straight into a map rather than through Doom's usual startup sequence, there's no title screen, demo loop, or in-game menu (TechSpot, yesterday). It's a quiet reminder that Paint is just the display end of a much longer pipeline.

The Microsoft Paint Doom experiment's side effects

Every incoming frame lands in Paint as an ordinary document edit, the same action triggered by pasting a screenshot manually. Paint has no special mode for this. It simply doesn't know it's displaying a game (TechSpot, yesterday).

Each paste creates what Paint calls a floating selection, a temporary layer that hasn't been committed to the canvas yet. The next paste commits that prior selection and creates a fresh undo step, which means pressing Ctrl+Z during gameplay genuinely steps backward through previous frames, one paste at a time (LavX News, two days ago).

Saving works on the same logic. Choosing File > Save produces a plain PNG of whatever frame happens to be on screen, because as far as Paint knows, the player just finished drawing a picture (TechEBlog, yesterday).

There's even a setup trick before play begins. DoomPaint shrinks the canvas to a single pixel, then lets the first incoming frame expand it automatically. From there, Paint's own fit-to-window setting decides how large the game appears on screen (LavX News, two days ago). None of this is a special feature built into DoomPaint. It's just what happens when a drawing app treats a video game as ordinary content.

Who built DoomPaint?

Mark Russinovich is Microsoft Azure's CTO and a Technical Fellow (Windows Central, today). Before joining Microsoft, he co-founded Sysinternals, a well-known suite of Windows diagnostic tools that Microsoft acquired when he came aboard in 2006 (LavX News, two days ago).

DoomPaint's full source is posted on GitHub under an MIT license, and a bundled batch file sets up a Python virtual environment and installs the necessary dependencies automatically, so running it doesn't require much setup work (TechSpot, yesterday).

The bundled game content ships with the freely distributable shareware DOOM1.WAD. Players who want more can supply their own owned copies of Doom or Doom II, or use the BSD-licensed Freedoom WADs (TechSpot, yesterday).

What DoomPaint actually demonstrates

The real accomplishment here isn't getting Doom onto a new platform. It's the clipboard synchronization fix and the input-hooking work that make an ordinary drawing app behave like a display, all without Paint ever running a single line of game logic (TechSpot, yesterday).

Because the project is openly licensed on GitHub, curious readers and developers can download it, run it, and read the code themselves rather than take any of this on faith. The same clipboard-and-automation approach could, in principle, turn almost any Windows application that accepts pasted images into a display for something else entirely (LavX News, two days ago).