In a quiet act of technical defiance, a developer made Doom — the 1993 shooter that has become computing's universal proof of capability — run as a fully playable game inside an SQL database, a system designed exclusively for storing and retrieving data. The achievement is less about gaming and more about what it reveals: that the boundaries between what a system is built for and what it can actually do are far more permeable than we assume. Legacy infrastructure surrounds us, treated as fixed and purposeful, yet this experiment suggests latent possibility hides inside the most utilitarian of
Developer Successfully Runs Doom Inside SQL Database
The boundary between what a system is for and what it can do is far more porous than specifications suggest.
Mark
So someone actually got Doom running in SQL? Like, the game is executing queries?
Mimi
Essentially, yes. Every game state, every frame, every input—it's all being expressed and processed through database operations. It's not emulation or a wrapper. It's Doom, genuinely running inside the database architecture.
Luke
Do we know the performance? Like, is it playable or is it a technical demo that runs at one frame per second?
Mimi
The reporting doesn't specify frame rate or actual playability metrics. We know it works; we don't know how well.
Mark
Why would someone do this? What's the practical application?
Mimi
There probably isn't one. It's a demonstration of what's possible when you refuse to accept the stated purpose of a system. It's asking: what if we ignored what SQL databases are "for"?
Luke
But that's the thing—we don't actually know the developer's motivation. The source material doesn't include an interview or any explanation from them.
Mark
Does it matter? The fact itself is pretty wild.
Mimi
The fact is wild. But understanding why someone bothered tells you something different—whether this is pure curiosity, a commentary on system design, or something else entirely.
Luke
And we're missing that layer. We have the achievement but not the context around why it mattered enough to build.
Mark
Still, it does seem to say something about how much capability is locked inside systems we think we understand completely.
Mimi
That's the real story. Not that Doom runs in SQL, but that we're probably wrong about the limits of a lot of infrastructure we rely on.
Le Pouls
- A developer has made Doom fully playable inside an SQL database — a system with no graphics pipeline, no input handling, and no frame rate management whatsoever.
- Every frame, every bullet trajectory, every collision had to be expressed entirely through database query language, a constraint that would send most programmers walking away.
- The tension here is not technical absurdity but institutional blindness — legacy systems running critical global infrastructure are routinely assumed incapable of anything beyond their original mandate.
- Doom has become the cultural benchmark for Turing completeness, and its arrival in SQL is the latest provocation in a long tradition of developers asking 'what else can this do?'
- The experiment lands as an open question: will it remain a clever curiosity in a GitHub repository, or will it push engineers to look harder at the hidden capabilities of the systems they use every day?
In a quiet act of technical defiance, a developer made Doom — the 1993 shooter that has become computing's universal proof of capability — run as a fully playable game inside an SQL database, a system designed exclusively for storing and retrieving data. The achievement is less about gaming and more about what it reveals: that the boundaries between what a system is built for and what it can actually do are far more permeable than we assume. Legacy infrastructure surrounds us, treated as fixed and purposeful, yet this experiment suggests latent possibility hides inside the most utilitarian of tools. It is a small, strange reminder that in software, impossibility is usually just a question of patience.
Someone made Doom run inside an SQL database — not as a simulation or a theoretical exercise, but as an actual, playable version of the 1993 shooter that has defined computing's relationship with possibility. The announcement arrived quietly, as if the developer understood exactly how strange the thing they had done really was.
SQL databases are built for one purpose: storing and retrieving data with precision. They have no graphics pipeline, no input handling, no concept of a frame rate. Yet every calculation, every sprite, every bullet had to be expressed in the language of database operations. It is the kind of problem that lives at the intersection of technical mastery and creative stubbornness — the sort most programmers would laugh at before walking away.
What makes this more than a stunt is what it quietly implies about the systems we treat as fixed. Legacy infrastructure runs critical operations around the world, locked into original purposes by decades of accumulated code and institutional habit. This experiment suggests those systems often contain far more latent capability than anyone has bothered to explore.
Doom itself is not an accidental choice. The game has become a cultural shorthand — a way developers prove that a system is Turing complete, that mastery over unexpected hardware is possible. Running it in SQL is the latest chapter in that tradition, a reminder that the line between possible and impossible in software is almost always a matter of patience rather than physical law.
Whether this remains a clever proof of concept or inspires engineers to ask harder questions about the tools they use every day remains to be seen. But the mental map of what a database — or anything else — can become has quietly expanded.
Someone sat down and made Doom run inside an SQL database. Not as a novelty video playing in a corner of the screen, not as a simulation or a theoretical exercise, but as an actual, playable version of the 1993 shooter—the game that defined a generation and launched a thousand ports to increasingly absurd hardware. This time, the hardware was a relational database system.
The achievement arrived without fanfare, announced in a way that suggested the developer understood exactly how strange the accomplishment was: a classic video game, one of the most ported pieces of software in computing history, now executing within the structured query language architecture that powers everything from banking systems to e-commerce platforms. Doom has run on graphing calculators, on pregnancy tests, on smart refrigerators. But a database? That required a different kind of thinking.
What makes this noteworthy is not that it was done—the internet has proven that anything sufficiently determined can be done—but what it reveals about the flexibility of systems we treat as fixed. SQL databases are designed for one job: storing and retrieving data with precision and speed. They are not game engines. They have no graphics pipeline, no input handling, no frame rate management. They are, by design, optimized for queries and transactions, not for rendering sprites and calculating collision detection in real time.
Yet here was proof that the boundary between "what a system is for" and "what a system can do" is far more porous than the specifications suggest. The developer had to work within constraints that would make most programmers laugh and walk away. Every frame of animation, every input from the keyboard, every calculation of where a bullet travels and what it hits—all of it had to be expressed in the language of database operations. It is the kind of problem that exists at the intersection of technical mastery and creative stubbornness.
The broader implication sits quietly beneath the surface of this stunt. Legacy systems surround us. Decades-old infrastructure runs critical operations because replacing it would cost millions and risk catastrophic failure. Most of that infrastructure was built for specific purposes and locked into those purposes by years of accumulated code and institutional habit. But this experiment suggests that such systems often contain far more latent capability than anyone bothered to explore. A database is not a game console, but it turns out a database can be one if you ask it the right way.
There is also something almost defiant about the choice of Doom itself. The game has become a cultural shorthand for "we can run this on anything," a running joke that started as a genuine technical marvel and evolved into a meme. Porting Doom to new platforms is how developers prove their systems are Turing complete, how they demonstrate mastery over hardware that was never meant to play games. Running it in SQL is the latest chapter in that story—a reminder that the line between "possible" and "impossible" in software is almost always a matter of patience and ingenuity rather than fundamental physical law.
What happens next is unclear. This may remain a curiosity, a clever proof of concept that lives in a GitHub repository and gets shared among engineers who appreciate the audacity. Or it may inspire others to ask similar questions about the systems they work with every day: what else can this do? What capabilities are hiding in plain sight? The experiment does not change how databases work or how games are made. But it does expand the mental map of what either one is capable of becoming.
Envie de l'histoire complète ?
Lire l'original sur Google News ↗