Talk Around Town: An MIT Student Claims He Got Doom Running on a Hand-Built FPGA CPU

What Folks Are Saying Down at the Feed Store

Word has drifted in from the internet holler that Armaan Gomes, who describes himself on his personal site as an MIT EECS student, says he and a collaborator named Liam built themselves a CPU from scratch — not from a kit, not from a starter chip, but from individual logic gates on up, like whittling a rifle from a raw pine log. According to Gomes's blog post on armaangomes.com, the two then deployed their design onto a field-programmable gate array, or FPGA, wired up some peripherals, and got the 1993 shooter Doom to actually run on the thing. That is the claim, and it is a doozy.

Gomes writes in his blog post that before tackling Doom, the team had only fed their custom machine programs they had written themselves — Pong and Mandelbrot sets, like a baby learning to walk before trying to outrun a lawnmower. According to the blog post, Doom was their first full published game to run on the hardware, which makes the leap feel about as big as going from fishing in a stock pond to deep-sea trawling.

What We Actually Know for Certain

What is confirmed is that the blog post exists, is technically detailed, and is internally consistent. Gomes lays out specific engineering obstacles in writing, and those technical details hold together like a good fence post — whether the fence itself is standing is another matter. The broader context is rock solid: the Doom Wiki and outlets like SlashGear have independently documented that running Doom on unusual hardware is a long-standing community tradition, with the Doom Wiki describing it as, in effect, computer science's most aggressive stand-in for a Hello World program. Ports have been documented on pregnancy tests, network switches, and graphics cards. A custom FPGA CPU would be a notable addition to that list.

The specific engineering challenges Gomes describes in his blog post are technically plausible and consistent with well-understood FPGA development constraints. He writes that the Doom shareware data file alone is 14 megabytes, while the FPGA's onboard block RAM offered less than one megabyte — a gap roughly as wide as a creek versus the Mississippi. According to the blog post, the team solved this by integrating external DDR3 RAM using Xilinx's Memory Interface Generator tool. He also writes that a USB host chip on the borrowed board failed to power a keyboard, so he rigged up a workaround: routing keystrokes from his laptop over a UART serial connection to the FPGA. Gomes himself calls it imperfect but functional.

What Nobody Has Been Able to Verify Yet

Here is where the mud gets thick, y'all. The claim that a nine-second video of Doom running on the custom CPU reached approximately 2 million views comes solely from Gomes's blog post. No independently linkable video URL appears in the post itself, no major tech outlet has covered this specific project, and a Hacker News discussion thread cited in the research signal returned a dead end. The viral reach of this project, as impressive as it sounds, cannot be confirmed by this publication at this time.

The blog post also does not specify how many frames per second Doom managed on the custom CPU. Gomes's own writing suggests the game moved slowly — he describes it as having crawled — but without a number or a verifiable video, the practical playability of the result is impossible to assess from the outside. Think of it like someone telling you their tractor will pull a stump: you want to see the stump come out before you start bragging at the county fair.

Gomes's blog post also mentions forward-looking ambitions, including implementing out-of-order processing, improved memory access patterns, a basic GPU, and potentially porting Quake 2. According to the blog post, the team is currently working on some of these. All of these plans are self-reported and speculative, and this publication has no way to evaluate their timeline or likelihood.

Analysis: Why This Would Matter If It Holds Up

This is analysis, not reporting. If the technical claims in Gomes's blog post are accurate, the project represents a genuinely impressive feat of educational hardware engineering. Building a pipelined CPU from the logic-gate level — not just writing HDL to describe one, but tracing the full design up from primitive gates — and then deploying it on real silicon to run a published, memory-hungry, input-dependent game is a different animal from typical university coursework. It is the difference between reading a recipe and actually cooking the hog.

The 'Can It Run Doom?' tradition matters here too, as analysis. The reason that question has persisted for thirty years is not nostalgia alone — it is that Doom's source code is open, its hardware demands are finite but real, and making it run on constrained hardware forces an engineer to solve the full stack: memory management, I/O, timing, and display. If Gomes and Liam genuinely cleared all of those hurdles on a self-designed CPU, that is the kind of project that tends to get people hired or admitted to very interesting programs. Whether the internet agreed to the tune of 2 million views, as the blog post claims, remains to be seen.