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

Archive filters

Tags

Counts show projects with this tag added, before any legacy result limit.

Selected tags
Popular tags
More filters
Authors (match any)

Virtual machine Doom ports

11 projectsShowing 1–10

  • Preview of Freedoom on AWS Lambda MicroVMs and Amazon Bedrock AgentCore

    Freedoom on AWS Lambda MicroVMs and Amazon Bedrock AgentCore

    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.

  • Preview of Doom Without Headers as port for Turing Complete game

    Doom Without Headers as port for Turing Complete game

    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.

  • Preview of Neural Doom

    Neural Doom

    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.

  • Preview of Doom on the Bicep CPU (Turing Complete)

    Doom on the Bicep CPU (Turing Complete)

    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.

  • Preview of Doom on TCMIPS

    Doom on TCMIPS

    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.

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

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

    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.

  • Preview of On an CPU in the Game - Turing Complete

    On an CPU in the Game - Turing Complete

    Turing complete is an education Game where you are led to build your own CPU step by step. After beating the Game I converted the LEG/Symphony CPU to 32-Bit and made it RISC-V compatible. I also added the M-Extension so it's officially an RV32IM CPU. I wrote a bootloader in assembly which reads one .ELF file from the "SSD" and loads it in the RAM. This meant I can compile and run C-Code on it. The next step was to make it run Doom. I used Doom Generic and added the necessary file where you can program your logic for keyboard inputs, what to do with the Screen Buffer and how timings and sleeps get handled. I also had to provide some standard C-Library functions for my architecture and I wrote an library for IO Stuff. In the end after a lot of trouble I got Doom compiling and running on the CPU. I used the save_breaker version btw.

  • Preview of Doom on Web assembly interpreter

    Doom on Web assembly interpreter

    Doom running on a Web Assembly interpreter written from scratch in Java. Uses Processing library for graphics.

  • Preview of Minecraft IRIS Redstone computer

    Minecraft IRIS Redstone computer

    Doom is running on the computer inside Minecraft. The screen uses retextured redstone dust and it takes about 23 seconds to render a single frame.