Life & fun · alternatives · 2026

24 alternatives to I built a RISC-V emulator that runs DOOM

Demo: https://www.youtube.com/watch?v=f5uygzEmdLw Hi HN, I built a RISC-V emulator that implements the RV32IM instruction set and a minimal syscall interface to run DOOM. A few weeks ago, I got my first output with a simple hello world assembly program. Since then I have been working tirelessly to get DOOM to run. I needed to figure out how to run C programs first, and came across newlib, which allows the underlying environment to implement the syscall stubs one by one until the programs run. I have also added ELF loading, but currently only a single `PT_LOAD` segment is…

This is a RISC-V emulator that supports the RV32IM instruction set and runs the classic game DOOM. Built by an individual developer, it implements ELF loading and a minimal syscall interface using newlib to execute C… Below are 24 products that do a similar job, ranked by how close each is in meaning and then by launch-day votes.

1
I made a Doom-like game fit inside a QR code▲531
I sometimes pick up random projects just because I can, this was one of those times. I made it as a week long project a while back this year but never shared here, so thought to go for it haha. I created a game inspired by Doom and the backrooms called The Backdooms under 2.4kb in minified html. (for reference, this entire post would be around 1.8kB haha) I had to use a not popular way of using GZip with Zlib headers (had to write my own script for compressing it, also in the repo) to eventually convert it a size 40 QR code that works right in your browser using Decompressionstream API. This…
2025 · github.com · its alternatives →
2D1
Doom (1993) in a PDF▲369
I made a Doom source port that runs within a PDF file. I was inspired by the recent HN post about Tetris in a PDF (https://news.ycombinator.com/item?id=42645218) and I wondered if I could get Doom to run using a similar method. It turns out that old versions of Emscripten can compile C to asm.js code that will happily run inside the limited JS runtime of the PDF engine. I used the doomgeneric (https://github.com/ozkl/doomgeneric) fork of the original Doom source, as that made writing the IO fairly easy. All I had to do was implement a framebuffer and…
2025 · doompdf.pages.dev · its alternatives →
3
My from-scratch OS kernel that runs DOOM▲320
Hi there! I've been on-and-off working on TacOS for a few months, which follows some UNIX-derived concepts (exec/fork, unix-style VFS, etc) and is now able to run a port of Doom, with a fairly small amount of modifications, using my from-scratch libc. The performance is actually decent compared to what I expected. Very interested to hear your thoughts. Thank you!
2025 · github.com · its alternatives →
4
C++17 RISC-V RV32GC / RV64GC userspace emulator library▲31
The fastest RVA23 RISC-V sandbox. Contribute to libriscv/libriscv development by creating an account on GitHub.
2020 · github.com · its alternatives →
5
I wrote my own RTS game engine in C▲1,102
An OpenGL RTS game engine written in C. Contribute to eduard-permyakov/permafrost-engine development by creating an account on GitHub.
2021 · github.com · its alternatives →
6
A port of DOOM that runs (almost) entirely on the GPU▲8
I've been recently working on porting standard C library functions to work on the GPU https://libc.llvm.org/gpu/. A colleague of mine suggested using it to run DOOM, so that's what I did. It runs on both AMD and NVIDIA GPUs and it is completely playable. This works by targeting C code directly for the GPU via cross-compilation in clang, looks something like this https://godbolt.org/z/hh44a6vKr. The LLVM C library will provide the headers, C library functions, and the kernel that calls the main function, so we only need to compile the DOOM source code…
2024 · github.com · its alternatives →
7
Minimax – A Compressed-First, Microcoded RISC-V CPU▲171
RISC-V's compressed instruction (RVC) extension is intended as an add-on to the regular, 32-bit instruction set, not a replacement or competitor. Its designers intended RVC instructions to be expanded into regular 32-bit RV32I equivalents via a pre-decoder. What happens if we explicitly architect a RISC-V CPU to execute RVC instructions, and "mop up" any RV32I instructions that aren't convenient via a microcode layer? What architectural optimizations are unlocked as a result? "Minimax" is an experimental RISC-V implementation intended to establish if an RVC-optimized CPU is, in practice, any…
2022 · github.com · its alternatives →
8
A simple Unix-like operating system that runs Doom▲233
A Simple Unix-like operating system. Contribute to ozkl/soso development by creating an account on GitHub.
2019 · github.com · its alternatives →
9
RISC-V assembly tabletop board game (hack your opponent)▲400
I made this game to teach my daughter how buffer overflows work. I want her to look at programs as things she can change, and make them do whatever she wants. Building your exploit in memory and jumping to it feels so cool. I hope this game teaches kids and programmers (who seem to have forgotten what computers actually are) that its quite fun to mess with programs. We used to have that excitement few years ago, just break into softice and change a branch into a nop and ignore the serial number check, or go to a different game level because this one is too annoying. While working on the game…
2023 · punkx.org · its alternatives →
10
RetroTick – Run classic Windows EXEs in the browser▲195
RetroTick parses PE/NE/MZ binaries, emulates an x86 CPU, and stubs enough Win32/Win16/DOS APIs to run classics like FreeCell, Minesweeper, Solitaire and QBasic, entirely in the browser. Built with Preact + Vite + TypeScript. Demo: https://retrotick.com GitHub: https://github.com/lqs/retrotick
Feb 2026 · retrotick.com · its alternatives →
11KR
KiDoom – Running DOOM on PCB Traces▲362
I got DOOM running in KiCad by rendering it with PCB traces and footprints instead of pixels. Walls are rendered as PCB_TRACK traces, and entities (enemies, items, player) are actual component footprints - SOT-23 for small items, SOIC-8 for decorations, QFP-64 for enemies and the player. How I did it: Started by patching DOOM's source code to extract vector data directly from the engine. Instead of trying to render 64,000 pixels (which would be impossibly slow), I grab the geometry DOOM already calculates internally - the drawsegs[] array for walls and vissprites[] for entities. Added a…
Nov 2025 · mikeayles.com · its alternatives →
12
Libriscv – RISC-V userspace emulator library▲40
The fastest RVA23 RISC-V sandbox. Contribute to libriscv/libriscv development by creating an account on GitHub.
2022 · github.com · its alternatives →
13
I made a programmable computer from NAND gates▲420
I am proud to present my solo hobby project NAND. This year-long undertaking follows the completed Nand to Tetris course, but ported to the web with its own runtime, user interface, and IDE. Using the "Load example program" selector, you can try out some programs I wrote on NAND's emulated hardware such as 2048, a genetic algorithm, and a manual stack overflow to corrupt the screen. Check out NAND at https://nand.arhan.sh Additionally, I've authored an extensive writeup about the project. Read about it on the GitHub repository's readme.
2024 · github.com · its alternatives →
14
Llama 3.1 70B on a single RTX 3090 via NVMe-to-GPU bypassing the CPU▲395
Hi everyone, I'm kinda involved in some retrogaming and with some experiments I ran into the following question: "It would be possible to run transformer models bypassing the cpu/ram, connecting the gpu to the nvme?" This is the result of that question itself and some weekend vibecoding (it has the linked library repository in the readme as well), it seems to work, even on consumer gpus, it should work better on professional ones tho
Feb 2026 · github.com · its alternatives →
15
Twitch Installs Arch Linux – A cooperative text-based horror game▲802
2015 · twitchinstalls.com · its alternatives →
16
Doom port to pure Go – Gore▲148
Hi HN, I’ve been working on Gore – a port of the classic Doom engine written in pure Go, based on a ccgo C-to-Go translation of Doom Generic. It loads original WAD files, uses a software renderer (no SDL or CGO, or Go dependencies outside the standard library). Still has a bit of unsafe code that I'm trying to get rid of, and various other caveats. In the examples is a terminal-based renderer, which is entertaining, even though it's very hard to play with terminal-style input/output. The goal is a clean, cross-platform, Go-native take on the Doom engine – fun to hack on, easy to read,…
2025 · github.com · its alternatives →
17
A Project Oberon System version running on RISC-V instead of RISC-5▲121
Modified version of the original from http://www.projectoberon.com/ for use with the Oberon IDE - GitHub - rochus-keller/OberonSystem at op2-rv32
Aug 2026 · github.com · its alternatives →
18
A DOS-like hobby OS written in Rust and x86 assembly▲207
To try it out, simply build the project yourself from source, or use attached bootable ISO image of the system (in Releases on Github) and run it in QEMU. https://blog.vxn.dev/rou2exos-rusted-edition
2025 · github.com · its alternatives →
19
New RISC-V emulator for Computer Science education▲71
Just released EGG, an emulator created for teaching Assembly and microprocessors (designed to suit the needs of the Microprocessors classes, at Universidade Federal do Paraná, Brazil). The emulator will support multiple architetures in the future, but currently only RISC-V is implemented.
2024 · github.com · its alternatives →
20
RISC-V core written in 600 lines of C89▲190
32-bit RISC-V CPU in ~800 lines of C89. Contribute to mnurzia/rv development by creating an account on GitHub.
2023 · github.com · its alternatives →
21
LocalGPT – A local-first AI assistant in Rust with persistent memory▲331
I built LocalGPT over 4 nights as a Rust reimagining of the OpenClaw assistant pattern (markdown-based persistent memory, autonomous heartbeat tasks, skills system). It compiles to a single ~27MB binary — no Node.js, Docker, or Python required. Key features: - Persistent memory via markdown files (MEMORY, HEARTBEAT, SOUL markdown files) — compatible with OpenClaw's format - Full-text search (SQLite FTS5) + semantic search (local embeddings, no API key needed) - Autonomous heartbeat runner that checks tasks on a configurable interval - CLI + web interface + desktop GUI - Multi-provider:…
Feb 2026 · github.com · its alternatives →
22
I integrated my from-scratch TCP/IP stack into the xv6-riscv OS▲147
Hi HN, To truly understand how operating systems and network protocols work, I decided to combine two classic learning tools: the xv6 teaching OS and a from-scratch TCP/IP stack. I'm excited to share the result: my own from-scratch TCP/IP networking stack running directly inside the xv6-riscv (https://github.com/pandax381/xv6-riscv-net) kernel. The project uses a modern virtio-net driver, allowing it to run seamlessly in QEMU and communicate with the host machine. Key features: - From-Scratch Stack: The core is powered by microps…
2025 · github.com · its alternatives →
23OC
Onramp Can Compile Doom▲79
2024 · ludocode.com · its alternatives →
24MP
My platforming game written in C 89▲127
I have been working on this game somewhat sparsely for the past three years or so. However, it is still in a very early stage, and there is a lot of work to do. One of my friends encouraged me to post about it here, since he felt people might find interesting how I don’t use any libraries for it. The game can be played on a browser by virtue of WebAssembly. There are native ports using either MiniFB or SDL2, but you have to build those yourself. I decided to write the game in C because I feel like it is a simple language that a lot of people can understand well enough, and I didn’t think I…
2023 · zamfofex.neocities.org · its alternatives →

Also compare

Ranked by how close each launch is in meaning, then by votes. Prices were read from each product’s own site when checked and can change. Refine with your own description →