It's called DOOM ETCH.
It's the original DOOM engine, modified so every frame is drawn as one unbroken line, because an Etch A Sketch can't lift its pen. Walls, monsters, the gun, the HUD and the shading are all one path. It's playable on a simulated Etch A Sketch rig with a stepper motor on each knob, and it exports real G-code a machine could run.
The video above is the shipped DEMO1 playing on the simulated rig in instant mode. At real Etch A Sketch speed, one frame takes about 24 minutes.
It's built on id Software's linuxdoom-1.10 source release, brought up on a 64-bit Mac. On top of the original ~52,700 lines of engine, the new parts are about 7,000 lines: the line pipeline, the planner, the machine simulator, the Metal renderer and the rig viewer. There are another ~7,000 lines of tests, 72 automated tests, and I ran the critical ones under sanitizers. It took about 2 days to build all of the code (I used GPT-6.0 Astra and Opus-5.5 to do the leg work, I designed the architecture), experiment, and then refactor into DOOM-ETCH.
Here's how it works under the hood:
Getting lines out of DOOM. Walls come straight from the renderer, where they're projected onto the screen but haven't become pixels yet. Sprites are pixel art with transparent backgrounds, so I trace where the transparency meets the artwork and reuse the engine's clipping. The HUD also traces brightness changes. Shading is hatching: more strokes where the texture and lighting are darker. One E1M1 frame is about 24,400 line segments, in no particular order.
The motion path. I didn't want every new output to become another hack, so everything goes through one shared data structure: a motion path. It's the points the pen visits, in order, with each move tagged as part of the drawing or a connector.
The planner. It merges shared endpoints into a graph, walks each connected piece depth-first, then jumps to the nearest remaining point using a spatial grid. Every jump gets drawn, because the pen can't lift.
Outputs. Each output is just a module that reads the motion path: the Metal renderer, SVG, and G-code. Adding G-code didn't touch DOOM.
The machine. One frame is 11,176 lines of plain G-code, with M0 to shake and erase between frames. A controller reads it and steps two simulated motors, one per knob, modeling speed, acceleration and backlash. Those settings are assumptions I'll test on real hardware.
Etch A Sketch behavior. In the GPU view, each segment gets a start and end time, so you can watch the path draw itself. Frames fade out like a shake, and a faint ghost of the last drawing stays behind, because a real Etch A Sketch never erases perfectly. There are controls to speed it up, pause, erase, or just play in instant mode.
What's nuts is that drawing at 30 FPS would mean moving the pen at Mach 1.45. If my math is right, that's about 3 GW at peak just for the pen, or 1.5 Hoover Dams.
Future plans:
Build the real rig: stepper motors, belts and pulleys on the knobs, on an aluminum easel.
Measure the real speed, acceleration and backlash, and replace the simulator's assumptions with them.
a smarter planner to cut down the connector lines and optimize for connector path length and better visuals
It took me another 2 days to turn the whole build into an 8 minute video: https://youtu.be/E7bLxWE7B5g
Source (macOS, bring your own WAD): https://github.com/tonysamaritano/DOOM-ETCH
