Xelckis

Gambiarra Labs

A 32-bit x86 hobby operating system with one job: boot a PC directly into Doom, with no Linux, DOS or external runtime underneath. A custom 16-bit MBR bootloader switches to VGA Mode 13h (320x200, 256 colors), enables A20, loads the kernel and the shareware WAD into extended memory via unreal mode, then jumps to protected mode. The kernel brings its own PS/2 keyboard driver, PIT/TSC timing and a minimal freestanding libc that serves doom1.wad from RAM. The engine is doomgeneric. The README says the codebase was built entirely with Kimi K3, in partnership with KIMI. Runs in QEMU (make run).

Github

YouTube

DoomOS: a bare-metal x86 hobby OS that boots straight into Doom

MPoupe

Doom for Casio Prizm graphing calculators. Made for the fx-CG20 and reported working on the fx-CG50.

Cemetech

CGdoom: Doom on Casio Prizm graphing calculators

Anton Aleksandrov

Freedoom running on AWS cloud compute and played in a web browser. Two projects run the game engine inside an AWS Lambda MicroVM and an Amazon Bedrock AgentCore Runtime session. Each game gets its own isolated microVM. The engine’s frames and sound are streamed to the browser over a WebSocket, and key presses are sent back.

FreeDoom on Lambda MicroVMs

FreeDoom on AgentCore Runtime

Freedoom on AWS Lambda MicroVMs and Amazon Bedrock AgentCore

Bitochi

GDOOM

GDOOM - Doom on garmin watch

raddit/Jackson Clayton

X/JKClayton_FN

A recreation of classic Doom inside Fortnite, built using Unreal Editor for Fortnite (UEFN). The demonstration combines Doom-style visuals with Fortnite’s building mechanics. Created as a learning exercise, the project recreates Doom’s appearance within Fortnite’s engine rather than running the original Doom engine.

reddit

Doom in Fortnite

FullExtraction

Doom running on the circular display of a Fellow Espresso Series 1 espresso machine, demonstrated by Reddit user FullExtraction. The machine’s existing controls are used to play: the scroll wheel turns the player, the brew button moves forward, and the steam button fires. According to the creator, dying returns the machine to its regular firmware. A follow-up demonstration shows the whole machine and an updated display layout adapted to its circular screen.

Demonstration

Follow-up demonstration

Fellow Espresso Series 1

@xwrtr

Doom runs on FABA+, a screen-free interactive audio player designed for children. Originally built to play stories, songs, and educational content using collectible characters, the device has been repurposed to run the classic first-person shooter.

Youtube

Doom on FABA+

Ed Iskandarov

A port of the original DOOM engine to Solidity, executing gameplay and software rendering entirely inside the Ethereum Virtual Machine. Runs on local Anvil with relaxed execution limits. Supports Freedoom, Ultimate DOOM, and DOOM II, with nine verified Episode One map completions. Interactive gameplay runs at approximately 0.55 FPS on an Apple M3 Pro.

github

article

DOOM on Ethereum Virtual Machine (EVM)

Piuppi

Doom-style FPS that runs on the Sonoff itself (engine, map, imps, doors, weapons) and is played from the device browser

sonoff-doom

Doom on Sonoff Basic R2

Erik Hougaard

DOOM running in Microsoft Dynamics 365 Business Central ERP Systemd - All code is translated into AL (Application Language)

Source Code

Video

Microsoft Dynamics 365 Business Central DOOM (ERP System)

Raiven Fair

DOOM port running on a Canon EOS 700D / Rebel T5i using Magic Lantern. The port is based on Doom550D and was adapted for the 700D/T5i with firmware 1.1.5. Tested on real camera hardware with video and audio working.

GitHub Repository

Hardware Demo

DOOM T5i / 700D

mixal-iirec

Doom is compiled without using the C standard library or any header files, relying solely on compiler built-ins and manually defined interfaces. The project demonstrates an extreme minimalist approach to building a fully functional Doom executable while eliminating traditional C dependencies.

Doom Without Headers as port for Turing Complete game

D3thAdd3r

ebenupton

MegaDoom is a wireframe demake of deathmatch Doom for the Uzebox open source 8 bit games console. It features up to 4 players via Uzenet, two display modes, multiple levels and the ability to play with either a joypad or in "suoer mouse" mode using both a joypad and a SNES mouse. It features all the SFX from the PC original and music if you have at least 4 MB SPI RAM.

uzebox.org

MegaDoom - wireframe deathmatch Doom on the Uzebox open source 8 bit console

github.com/dc336

Running doom natively on an EoL mitel phone with support for USB gamepad, speakers/headset, LEDs, and keypad. Game is 100% completable and no external kernel modules or drivers were necessary

Broadcom BCM11107KFBG SOC 400MHz
256mb DDR2
480x272 Framebuffered LCD

GitHub

Doom on an IP485G Mitel phone

Vincent Brand

Oxid-DB the neurosymbolic database plays doom

website

Oxid-DB Plays Doom

IIgs Doom

Download IIgs Doom

Play IIgs Doom

Lukas Vogel

The original Doom's game logic and renderer, both implemented as SQL queries.

Blog post

SQLDoom

dennishilk

youtube

Cisco CP-9951

Lior Bass

A 35K-parameter Mamba neural network that learned the execution manifold of a bare-metal RISC-V and ARMv4 CPU, running DOOM in-browser at native 35 FPS through neural basic-block prediction.

Github Pages

Neural Doom

Andreas Grech

Although Kunos hasn't officially released modding support for UI apps yet, I started digging around to see if I can get something working myself, primarily because I really wanted some form of pedal telemetry while driving because that helps me a lot. After some excavations, I discovered that EVO's UI is primarly driven via JavaScript so once I knew that, I started trying to write my own pedal graph widget and when I added it to the hud.html of the game and packed it to kspkg and placed in the mods folder, it worked! And that's the pedal graph you see at the bottom-center of the screen (in the video it's running with a demo 'attract' option so you can see it working automatically because I'm not on my rig atm).

Some issues arose when I tried adding multiple ui apps because I discovered that only one mod can overwrite the hud.html and that's a no-go for multiple apps to run together. Because of this, I had to roll my own custom ui mod loader which acts as the single ui mod loaded in the game which then itself can handle multiple JavaScript apps running at the same time.

Anyways, once I wrote both the pedal graph app and then a dev console app, I decided to push further and try the de-facto standard: DOOM. I found a webassembly version of it at https://github.com/jacobenget/doom.wasm and tried running it directly as a ui app running with my custom ui mod loader but there I encountered an issue because the Coherent Labs Gameface Cohtml engine that's shipped with EVO doesn't support running webassembly (presdumably due to --noexpose_wasm).

To get around this webassembly issue, I used wasm2js to convert it to plain JavaScript and with that, DOOM was then running (without sound) inside EVO as a ui app running with the ui mod loader in conjunction with the two other custom ui apps.

Adding sound proved to be a bit more of an issue because I couldn't figure out a way of triggering custom sounds from the code of the ui apps. I tried with AudioContext but that was undefined so there's no support for Web Audio, and also tried <audio> but couldn't get that working either; <video> didn't work either because of no available demuxers so basically I couldn't play a wav or ogg or an mp3 like a browser would. After that I looked at stock game sounds in the game and I managed to play the inbuilt HUD sound effects (things like menu select and menu cancel and some other sfx) but the only I managed to get any form of custom sound working was by modifying the game's audio banks themselves, and I picked gui.bank for that (the livery editor was using most of the sfx here) and I patched it to replace the inbuilt sounds with the custom doom ones. Unfortunately I only found space for seven sounds inside that bank so I had to be very restrictive in the sound department. But once I patched the custom sounds in, it worked. And for the music I also had to use one of those previously aforementioned slots too to fit it in and had to settle with just one track.

All in all, it was a very fun experiment and there are still improvements to be had (for example sometimes I'm still getting hitches here and there as you can see from the video) but it works.

I will eventually be releasing the source code of everything I mentioned here (ACEUIModLoader, ACEPedalGraph, ACEDevConsole and ACEDOOM) on my github if anyone's interested in tinkering or creating their own ui apps.

Doom in Assetto Corsa EVO

Sjoerd Brandsma

Doom on Squeezebox Radio

https://www.youtube.com/shorts/ob8TCDBMM-8

Doom on Squeezebox Radio

This is a full port of doom that is theoretically completable (only tested first level). SoC MDM9207 is ARM Cortex-A7 processor with a 1.3GHz clock. $20 device with 128x128 SPI based LCD, drawn with the framebuffer. Previous entry for this device was demo-only, this port runs the game natively.

GitHub Repo

Gameplay.mp4

(FULL port) Orbic RC400L Hotspot

KilobyteNight

DOOM in Cloud Storage

u/ImmediateAdvantage52

Doom runs on a custom 32-bit Bicep CPU built inside Turing Complete. The project extends the game's LEG architecture, adds a RISC-V to Bicep translator, and compiles EmDoom to run on the virtual processor, with real-time performance achievable through Verilog export.

Reddit

Doom on the Bicep CPU (Turing Complete)

Zhang Jiantao

Doom runs on TCMIPS, a custom MIPS32 CPU and LLVM-based toolchain built entirely inside the game Turing Complete. The project demonstrates a complete software stack—from custom CPU and compiler to runtime—capable of running real C/C++ applications, including Doom, on a virtual processor.

Bilibili.com

Doom on TCMIPS

carywalkin

Doom runs entirely inside Microsoft Excel, using spreadsheet cells as pixels and VBA to drive the game’s rendering and input. The project turns a standard workbook into a surprisingly playable Doom engine.

Doom in Microsoft Excel

Equalo

Doom runs on a TI-84 Plus graphing calculator powered entirely by a giant potato battery. After a failed attempt to power a Raspberry Pi, creator Equalo wired hundreds of boiled potato slices together to generate enough electricity to play Doom.

hackaday.com

Potato-Powered Doom

Patrick Trainer

DuckDB-DOOM runs Doom entirely inside DuckDB by expressing the game loop as SQL queries executed through DuckDB-Wasm in the browser. It demonstrates that a modern analytical database engine can serve as an unconventional runtime for a classic game.

duckdb-doom

hey.earth.com

DuckDB-DOOM

Angaisb_

Doom on GPT-5.6 Sol’s Custom CPU

Mark Russinovich

DoomPaint turns Microsoft Paint into a playable Doom display by rendering every game frame onto the Windows clipboard and pasting it directly onto the Paint canvas. The real Doom engine runs in the background with working sound and music, while Paint acts as a surprisingly functional “monitor”—complete with the ability to rewind gameplay one frame at a time using Undo.

    DoomPaint

Tom's Hardware

Microsoft Paint Runs Doom

Devin Shwagginz

Doo-cr is simply a source port of doom based on PureDoom and Linux Doom that is written in Crystal Lang. It isn't just a renderer like some people do when porting doom out of c, it is the whole package.

Github Source

E1M1 playthrough

Doom in Crystal (doo-cr)

Eric Burel

Doom running in your favorite AI platform.
Implemented via MCP Apps extension, through mcp-use framework and doom-wasm.
Distributed with freedoom1.wad for a fully open source demo. Game works but mouse and keyboard interactions are not yet correct due to interference with the wrapping iframe.

mcp-use-doom

Doom in Claude

THE_EPICSUPER

Doom for regular DVD player made from scratch made with dvdstyler

from scratch no source code

DVD Player

Doom-for-dvd-players

Regular DVD player

B0nam

DOCKER-DOOM offers a hassle-free way to enjoy DOOM by encapsulating it within a Docker container, made accessible through noVNC. Whether you prefer building the container based on our Dockerfile or running it directly from a pre-built image.

github/DOCKER-DOOM

Doom in Docker

Bas Lichtjaar

DOOM running natively on a Canon EOS 550D camera

I ported Doom to the Canon EOS 550D as a Magic Lantern module. It runs directly on the camera hardware with camera-button controls, sound, save/load support and selectable IWADs.

Video: https://www.youtube.com/watch?v=G8sIcxkxpmQ
Source/release: https://github.com/lauris-nl/doom550d

Doom 550D

12-Year-Old Kick Plays DOOM on a Canon 550D Camera?!

Canon EOS 550D / Rebel T2i / Kiss X4 — Doom550D via Magic Lantern

anachrohack

Controlling doom guy with an under-desk bicycle. Unfortunately I've lost the original source code since then

Desk cycle

Artem Lytkin

A computer whose only instruction is a global regex substitution. The entire
machine is one 96.6 MB string: registers, RAM, the framebuffer and the DOOM
engine all live in it as plain text. A driver applies a fixed, ordered set of
544 find-and-replace rules in a loop; the first rule that matches fires once,
and that is one step. Nothing else computes. DOOM is compiled onto the machine
via doomgeneric and ELVM. One frame of E1M1 is 13,994,067 substitutions and
comes out byte-identical (SHA-256) to natively compiled DOOM.

Interactive site

Regex find-and-replace (a 544-rule Markov machine)

mark russinovich

Doom in MS PAint again, but now via Copy/paste faster,

Github Repo

hackerNews

DoomPaint

simpansoftware

Source code

@4lvaret

Play it in SVG

DOOM in a SVG

Talkative-Banana

Constexpr-Doom is a C++20 project that interprets a WebAssembly (WASM) build of Doom entirely inside a constexpr evaluation — meaning the game executes at compile time, and the rendered ASCII art frame is baked into the binary as a compile-time constant.

Constexpr-Doom

Constexpr Doom

Parker Reed

Parker Reed once again brought Doom to a Linux-based CaptionCall desk phone after the original exploit was patched. By dumping the firmware, recovering root access, and remapping the phone’s keypad into Doom controls, the project turns an assistive telephone into a surprisingly playable Doom machine.

Gist.github

CaptionCall Phone

nnonickreal

What if your headphones were also a gaming console? DOOMcore is a Doom port for the Soundcore Life Q35, running directly on the BES2300P SoC with the headset buttons mapped as game controls.

@nnonickreal/DOOMcore

Soundcore Life Q35 headphones

nand2mario

Doom running on hardware that never existed in the 1990s: a modern FPGA-based recreation of the Intel i386. This port showcases protected-mode DOS gaming on the open-source z386 CPU core.

@nand2mario/z386

nand2mario.blog

hackster.io

The z386 - an FPGA Re-implementation of Intel's i386

Derrick Yao

@insta360-luna...

DOOM Running on Insta360 Luna Ultra

iThorgrim

A WarcraftXL module that plays Doom inside the running 3.3.5a client.

WarcraftXL

Doom in World of Warcraft : Wrath of the Lich King

El_isra (Matias Israelson)

Arawn Davies

this is the PS2 DOOM port modification by Arawn Davies. which I modified to run on the NAMCO SYSTEM246 (should also boot on SYSTEM256, SUPER256 and KONAMI Python1.

initial release takes input from regular PS2 controller. as time passes, DOOM will be modified to take JVS inputs and behave and look like a totally legit SYSTEM246 game

NAMCO SYSTEM246 (Arcade PS2)

Sander van de Velde

Microsoft Fabric is a SaaS platform, known for its low-code no-code data engineering and visualization. Using the recent Fabric Apps support, pro-code apps can be hosted and deployed with full Onelake data layer support, secured by EntraID.
Let's add a little mischief and run a JavaScript version of Doom on it. First to be surprised, next to understand that 3rd-party apps can be hosted too.

Can It Run Doom? The Ultimate Doom Port Archive. Devices running Doom.

CGdoom: Doom on Casio Prizm graphing calculators

Source code (1)