Post all your "Can it run DooM?", "Let's run DooM on X", and "How can I get this running DooM?" questions/posts here. Anything outside of this sticky is going to be removed so please keep it contained here.
This is SQLDoom, the successor to DOOMQL, a Doom-inspired raycaster written in SQL. Unlike DOOMQL, which is closer in gameplay and visuals to Wolf 3D than Doom, SQLDoom recreates the entire engine and renderer entirely with SQL code, only using non-SQL code to retrieve inputs, display the rendered frame, and to run the SQL code indefinitely.
Quick update on the PixelRoot32 progress. The DOOM (1993) port is now complete. All levels can be played, and the main systems like the HUD, weapons, sound, save system, and menus are all working well.
We had to make some sacrifices to fit the game within the 4MB of flash memory on the original ESP32, mostly cutting down on music and larger assets. But if you want a clean build with every asset intact, the native build and future ESP32-S3 profile will handle that out of the box.
Super fun project to tinker with, and it's a great way to stress-test the engine.
An ESP32 is at the heart of my mod for this controller, so I couldn’t help myself to get Doom running as a little easter egg! The stock microcontroller on the LCD board in the controller is shorted and frozen, which allows the ESP32 to assume control over the LCD, and draw whatever it likes (in this case ESPDoom). For the controller inputs a RP2040 Zero board sniffs the USB data from exposed usb pads on the stock Duke controller board, and sends them to the ESP. Every board with usb power and signal is tied to a usb hub board which is then output to the Duke’s stock usb female breakout connector. The ESP also drives a SD reader for storage and an amp +28mm speaker which is glued in the back of the case.
DOOM has spread to another USB-C power meter! 😈
After getting DOOM running on the ChargerLAB POWER-Z KM003C, I ported it to the KOWSI KWS-X1!
What's new:
⚫ KWS-X1 — New port!
Full 240×135 widescreen support with an expanded field of view.
Full E1M1 version: Game assets streamed from a PC over USB due to limited onboard storage.
Standalone version: Runs without a PC, using a tiny one-room map! 😂
Game logic and rendering run natively on the meter's MCU.
🔴 KM003C — Upgraded!
Full 240×240 square-screen rendering with the complete DOOM HUD — no letterboxing or stretching.
Improved rendering performance from ~5.7 to ~9.6 FPS in the tested starting scene.
Added steady frame pacing for smoother gameplay.
Game assets stored in onboard NOR flash.
Both devices use an HC32F460 ARM Cortex-M4 running at 192 MHz.
Neither device is streaming video from a PC. Both run and render DOOM themselves!
Both meters support gameplay using their physical buttons, with optional PC controls. The PC-connected KWS-X1 version requires a PC for game assets, not for rendering.
Source code and experimental firmware are available for both devices, with flashing risks and recovery limitations documented.
Apparently, USB-C testers are becoming my new DOOM consoles. 😂
Full disclosure it was made with AI-assist, it is a buildup on kgws insane work on doom_ace, instead of loading a doom chocolate instance, the loader build a kind of scheduler that allows it to reuse the same process and data (modulo some patches and pointer mods) across multiple doom "instances". So it's basically a mini OS (without a standard lib) built through an exploit that allows depthed doom instance to run, with the last one looping to the first. It's still buggy as hell but lot of fun.
You can find an explaining article here: https://kodoque1.github.io/doom_ace/ and it ends with a small coding challenge (doable inbrowser if you want), with a selfcontained VM and tinydoom to try your hand at building a scheduler.
Two Apple IIGS machines (65816 CPU, 1986, with accelerator cards) playing Doom deathmatch and cooperative games against each other over the internet through Cloudflare. A ROM 01 with an AppleSqueezer on the left, a ROM 3 with a TransWarp GS on the right.
The Doom port is Webifi's, released last month, a rewrite of the engine in 65816 assembly for an accelerated IIGS: https://github.com/Webifi/iigs-doom. It runs about 4 FPS on a 12 MHz accelerator and plays the whole shareware episode with music on the Ensoniq chip.
What I added is the network multiplayer to Doom's own 1993 model. Each machine runs the whole game and only the 9-byte input records cross the wire, one per tic per player. Doom writes those bytes to slot registers the way it wrote to an IPX card in 1993, and a network card in that slot holds one TLS WebSocket open to a small lobby on Cloudflare that pairs two players and forwards frames between them. The slot bus is the 1977 Apple II bus at 1 MHz. The 65816 only ever does Doom.
To run it: an accelerated IIGS or an emulator, Webifi's requirements, plus a CoGS card for the network side (a2cogs.com). The disk image is a release at https://github.com/rperissi/iigs-doom (GPL, a branch of Webifi's repo, source included). Boot it, Esc for the menu, Network Game, pick deathmatch or cooperative, type a name, Find Players. The lobby and leaderboard are at https://lobby.a2cogs.com. Without the card the same image plays single player on any ProDOS block device.
Real DOOM, not a clone: the game logic is the original and recorded demos replay tic for tic as in the unmodified engine. 32 KB of RAM is less than one DOOM frame (64,000 bytes), so there is no frame buffer: the picture goes to the screen in strips and everything else streams from the meter's 4 MB SPI flash. About 29 fps in the shareware E1M5 demo.
It installs over USB without opening the meter, and the stock firmware can be put back. The DJI RC-N1 thinks the meter is an Android phone.
As far as I know, no port of id's DOOM has run with less RAM. The lowest I found before was Doom64KB on the Neo Geo, with 64 KB.
We have compiled doom to one of the hardest programming languages in the world: Brainfuck, creating the most complex BF program even. It runs at a blazing speed of 40 seconds per frame, and it took about 2 days to beat the first level.
Brainfuck is an esoteric programming language created in 1993 with the goal of having a really small compiler. As a result, the language is extremely minimal, consisting only of 8 unique instructions.
We used actuall DOOM source code, then replaced all calls to the operating system with our custom ones: doom.wad was hard-coded into the executable, the allocator was replaced and made to just use a buffer instead of requesting memory from the OS, the graphics were made to write raw image data to stdout, etc. Then we compiled it to a statically linked RISC-V executable, and converted that to brainfuck.
Link: highghlow .ru/doombf (can't be a link because reddit hates the web apparently)
Rules are pretty strict here. To make this happen: Force machine into a factory mode. Build a script to upload a custom firmware onto an empty slot on the ESP32. Use that new firmware to allow DOOM to be uploaded onto the original firmware slot.