De focus keyphrase Doom in een SQL-database klinkt als een grap, maar het project SQLDoom bestaat echt. Volgens Ars Technica en maker Lukas Vogel draait de klassieker via een combinatie van database-tabellen, SQL-queries en een kleine Python-client die input, timing en beeldvorming afhandelt. Wat op het eerste gezicht een absurde demonstratie lijkt, is in de praktijk een vrij precies uitgewerkt experiment waarin Doom’s wereld, logica en rendering in relationele vorm zijn gegoten.

Meer technologienieuws vind je op de TostieTech Tech-nieuwspagina.
Hoe Doom in een SQL-database werkt
SQLDoom gebruikt CedarDB als onderlaag. De spelwereld is vertaald naar relationele tabellen waarin onder meer geometrie, levels en de game state worden bijgehouden. Ars Technica schrijft dat die stap relatief logisch uitpakt, omdat de klassieke WAD-bestanden van Doom al zijn opgebouwd uit losse onderdelen zoals vertices, lijnen en sectoren. Daardoor is de originele speldata niet als één monolithisch geheel opgeslagen, maar al opgedeeld in stukken die zich redelijk goed laten modelleren als tabellen en relaties.
De feitelijke spellogica zit niet in een traditionele game-engine, maar in ongeveer 1.300 regels SQL, verdeeld over 89 common table expressions. Die queries bepalen per frame wat er zichtbaar moet zijn en genereren 35 bitmap-framebuffers per seconde. Een kleine Python-client zit daar bovenop en neemt de praktische afhandeling voor zijn rekening: input verwerken, output tonen, timing beheren en elk frame op het scherm zetten. In de praktijk is SQLDoom dus geen puur SQL-programma, maar een combinatie van database, querylaag en dunne clientsoftware die samen het spel laten draaien.
Dat maakt het project ook interessant als voorbeeld van hoe ver je een relationeel datamodel kunt doortrekken. Waar een normale game-engine rekent in renderloops en spelobjecten, maakt SQLDoom gebruik van tabellen als actieve runtime-structuur. De gamewereld is daarmee niet alleen opgeslagen in de database, maar wordt ook vanuit die database iedere frame opnieuw opgebouwd en uitgelezen.

Prestaties en rendering van Doom in een SQL-database
SQLDoom is volgens Ars Technica een flinke stap verder dan Vogels eerdere DoomQL-project. Dat oudere experiment was bedoeld als een multiplayer Doom-achtige shooter die volledig in SQL zou draaien, maar strandde uiteindelijk op grayscale ASCII-graphics. De nieuwe versie maakt een veel overtuigender sprong: full-color beelden in 640×480 die sterk lijken op de originele Doom-uitvoer.
De rendering is daarbij niet blind brute-force. Vogel gebruikt onder meer een vooraf berekende sort_key per object. Die sleutel wordt bij het laden voor elke positie berekend en maakt het mogelijk om met een eenvoudige ORDER BY te bepalen welke muursegmenten in een bepaald frame zichtbaar zijn en welke niet. Daarmee wordt de bestaande opbouw van de database direct ingezet voor culling en zichtbaarheid, zonder dat daar een klassieke engine-structuur voor nodig is. Volgens Ars Technica versnelt juist dat de weergave aanzienlijk, omdat de database op basis van gesorteerde data efficiënter kan bepalen wat in beeld hoort.
Er zijn wel onderdelen die minder elegant in SQL passen. Vooral het tekenen van vloeren en plafonds blijkt lastig, omdat Doom daar in het origineel werkt met visplanes en andere state-mutaties die column-by-column verlopen. Voor SQLDoom gebruikt Vogel daarom een eigen alternatief dat hij zelf omschrijft als “pretty hacky”: een geordende lijst panelen die in een andere vorm dezelfde visuele taak moet vervullen. Het is geen elegante heruitvinding van Doom’s rendering, maar wel een werkbare manier om de klassieke beelden uit een relationele structuur te halen.
Qua snelheid meldt Vogel dat SQLDoom op een laptop met Ryzen 7 ongeveer 60 fps kan halen. In drukkere scènes zakt dat terug naar 35 fps. Dat is opvallend, omdat die prestaties worden gehaald ondanks de extra overhead van het lezen en schrijven naar SQL-tabellen voor vrijwel alles. De bron benadrukt daarmee vooral hoe ver de combinatie van goed gestructureerde gamegegevens, slimme sortering en een sterke database-onderlaag reikt.
Waarom een database hier toch nuttig kan zijn
Het project is in de eerste plaats een demonstratie van wat technisch mogelijk is, maar Vogel ziet volgens Ars Technica ook een concrete meerwaarde voor multiplayer. De database levert namelijk een consistente ‘reference snapshot’ van de spelstatus. Daardoor krijg je geen half toegepaste updates, geen physics-bugs en ook geen discussies over de vraag of een raket nu wel of niet echt raak was.
Juist op een server kan dat aantrekkelijk zijn, omdat gelijktijdige toegang en afhandeling van data al kernonderdelen zijn van een databasesysteem. SQLDoom gebruikt dus eigenschappen die normaal vooral nuttig zijn voor transactionele software, en past die toe op een game-omgeving. Dat maakt het niet per se sneller of handiger dan een gewone game-engine, maar wel een interessante manier om synchronisatieproblemen anders te benaderen.
Voor consumenten betekent dat niet dat Doom ineens beter speelt vanuit een database. De waarde zit vooral in de demonstratie zelf: het laat zien dat een relationeel systeem verrassend ver kan worden opgerekt als de spelwereld al voldoende gestructureerd is. Doom is daarvoor extra geschikt, juist omdat de klassieke levelopbouw uit duidelijk afgebakende onderdelen bestaat.

Zelf testen of opzetten
Wie SQLDoom zelf wil draaien, heeft volgens Ars Technica de GitHub-code, een kopie van CedarDB en een Doom WAD-bestand nodig. Er is daarnaast een gratis online demo beschikbaar waarmee je het project kunt uitproberen zonder de volledige setup lokaal uit te rollen. De verslaggeving van Ars Technica merkt wel op dat de prestaties in die online demo tegenvielen.
Daarmee blijft SQLDoom vooral een technisch curiosum, maar wel een opvallend goed uitgewerkt curiosum. Het project laat zien dat Doom niet alleen een dankbaar doelwit is voor allerlei ongebruikelijke ports, maar ook een bijzonder geschikte testcase voor database-architectuur. De combinatie van relationele tabellen, geordende queries en een kleine client maakt van Doom in een SQL-database een werkende demonstratie van hoe data, state en rendering ook buiten de gebruikelijke game-engine kunnen samenvallen.
TostieTech duiding
Dit project is interessant omdat het twee werelden samenbrengt die normaal ver uit elkaar liggen: een klassieke realtime game en relationele databanksoftware. De kern is niet dat SQL plotseling een betere game-engine wordt, maar dat Doom door zijn vrij gestructureerde levelopbouw uitzonderlijk goed te ontleden is in tabellen en queries. Daardoor is het hier mogelijk om veel logica declaratief te beschrijven in plaats van in een traditionele render- en physics-loop.
Voor consumenten is de praktische waarde beperkt; niemand gaat Doom waarschijnlijk zo spelen omdat het sneller of handiger is. Wel laat SQLDoom zien hoe robuust moderne databases kunnen zijn als je ze inzet voor consistente state, parallelle toegang en gecontroleerde updates. Dat maakt het project vooral een sterke demonstratie van database-architectuur, niet van game-optimalisatie.
Bron: Ars Technica
