BuildNot yet confirmed elsewhere1 publisher3 min readPublished
Claude-written Rust port of Quake merged branches only after matching the original C engine
Solo developer ilreb used Anthropic's Claude Code to port id Software's 1996 Quake from C to safe Rust, playable in a browser. Every merge waited on a harness that diffs the port against id's original C engine, so the result is evidence for test-gated agent work where a runnable reference exists.
The Engineer · Build desk
What happened
- The human contributor set constraints, played the game, reported problems and directed work across the branches that Claude Code generated.
- Automated checks compare rendered 3D pixels, interface elements, audio output and game state during demo playback against the C build.
- According to the README, pixel comparisons cover hundreds of frames across all nine maps, at two sizes, with monsters active.
- The port keeps WinQuake's CPU software renderer and 8-bit palette, running as WebAssembly in a Web Worker that shares memory with the page for image and sound.
- Players can run the shareware episode with saves, console commands and keyboard, gamepad or touch controls, though multiplayer is not included.
Compiled by The EngineerSomething wrong?How this is made
Why it matters
- decision Teams trialling coding agents can copy the same gate: split work into branches, set explicit constraints and refuse merges until repeatable checks against a known implementation pass.
- constraint The gate needs a runnable original to diff against, so it offers little to teams replacing proprietary systems whose behavior, tests and data are unavailable.
- exposure Defects can still sit in gameplay paths and browsers the creator's own checks never exercised, so anyone shipping the port inherits a scoped result.
Merging was itself an agent's job. According to the project's README, a coordinating agent landed branches only after the full checks passed [5]. Those checks run against a headless build of id's own C source, running alongside the Rust port [6]. Claude is credited as the author of the code and its documentation [3]. Anthropic appears in the project materials only as the maker of the model [18]. Under that rule, a branch lands when it matches the C build on every output the harness measures, whoever or whatever wrote it.
The port keeps WinQuake's CPU renderer and the 8-bit palette [12]. I'd expect that choice is what keeps the pixel comparison meaningful. Both builds produce palette-indexed frames on the CPU, so a mismatch points at the port. A GPU renderer would add a second source of difference to rule out on every frame.
The harness keeps a list of known differences between the two engines [9]. That is good engineering. A written divergence list tells a reviewer where the port departs from the original on purpose, so any other mismatch can be treated as a failure. The default preset adds widescreen and uncapped display-refresh rendering, while a Classic preset switches those enhancements off and targets the original game's behavior [13]. Runtimewire's account does not say which preset the frame checks run under.
Nine maps at two sizes gives 18 map-and-size combinations for the frame checks [21]. For that coverage to stand in for correctness, the demos would have to reach the code paths players actually hit. Runtimewire notes that the checks are the creator's own [10]. It adds that agreement in the tested views does not establish that every gameplay path matches, or that the port is free of defects [10]. Browser coverage is scoped the same way. The README lists Linux (Chromium and Firefox), macOS (Chrome) and an Android phone (Chrome) as tested, and Safari, iPhone and iPad as untested [15].
The "safe Rust" label also has a precise scope. The Rust crates and the browser binary set forbid(unsafe_code), so explicit unsafe blocks are disallowed [11]. Runtimewire points out that the setting does not certify every aspect of software safety [11].
The project starts from the original WinQuake source and ships under GPL-2.0-or-later [16]. Its creator described starting from the original code as the default for a side project whose premise was "let's port quake" [17]. A 1996 game with public source that still builds headless is about the friendliest test subject a coding agent will ever get [1][6]. Runtimewire puts the limit there. In its account, faithfully porting an open-source game with good documentation is not the same job as adapting a proprietary system when its behavior, tests and data are not available [19].
What to watch
- An independent run of the pixel, audio and game-state checks by someone other than the creator.
- The same branch-and-gate workflow applied to a codebase with no runnable original to compare against.
- Multiplayer support arriving, since networking is currently outside both the port and its checks.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence40
- Adoption
- Insufficient
- Hype gap+5
- Incentives15
- Confidence45
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [1]
A solo developer used Anthropic's Claude Code to port id Software's 1996 game Quake from C to Rust and put the single-player engine in a browser.
- [2]
The project, Quake-SRP, runs without Rust's unsafe code and includes a test harness comparing its behavior with the original WinQuake implementation.
- [3]
The developer, who posted the launch as ilreb on Hacker News, describes Claude as the author of the code and documentation.
- [4]
The human contributor set constraints, played the game, reported problems and directed work across agent-generated branches.
- [5]
A coordinating agent merged branches only after the full checks passed, according to the project's README.
- [6]
The Rust port runs alongside a headless build of id's C source, which serves as a reference implementation.
- [7]
The project's checks compare rendered 3D pixels, elements of the interface, audio output and game state during demo playback.
- [8]
The README says the pixel comparisons include hundreds of frames across all nine maps, at two sizes and with monsters active.
- [9]
The comparison records known differences rather than claiming every behavior is identical.
- [10]
The checks are the creator's own and their scope has limits; pixel-level agreement in the tested views does not establish that every possible gameplay path is equivalent or that the port is free of defects.
- [11]
A forbid(unsafe_code) setting does not certify all aspects of software safety; it does show that the Rust crates and browser binary disallow explicit unsafe blocks.
- [12]
The port preserves WinQuake's CPU-based software renderer; in the browser a WebAssembly program runs in a Web Worker, the page passes input to it and shares memory for image and sound output, and the game keeps its 8-bit palette through rendering.
- [13]
The default preset adds widescreen and uncapped display-refresh rendering, while a Classic preset turns off the listed enhancements and targets the original game's behavior.
- [14]
Players can play the shareware episode in the browser with keyboard and mouse, gamepad or touch controls; the port supports saves, console commands and fullscreen play; multiplayer is not included.
- [15]
The README reports testing in Chromium and Firefox on Linux, Chrome on macOS and Chrome on an Android phone; it says Safari, iPhone and iPad have not been tested.
- [16]
Quake-SRP's code is published under GPL-2.0-or-later, and the project identifies the original WinQuake source as its starting point.
- [17]
In a post accompanying the release, its creator said the original code was the default choice for a side project framed as 'let's port quake.'
- [18]
Anthropic is identified as the maker of the coding model; the project materials do not describe it as a sponsor or funder.
- [19]
A faithful port of a well-documented, open-source game is a different task from adapting a proprietary system whose behavior, tests and data are unavailable.
- [20]
For developers evaluating coding agents, the workflow on display is to break a large port into branches, set explicit constraints, and require agents to pass repeatable checks before their work lands.
- [21]
The pixel checks span 18 map-and-size combinations.
Sources
1 independent publisher whose own reporting we read for this story.
- runtimewire.comClaude helped port Quake to safe Rust, with tests against the original
1 article · October 8, 2026
Topics and entities
Follow any of these and your For You feed starts watching them — no settings page required.
Topics
- Games in WebAssemblyFollow
- AI Coding AgentsFollow
- Code portingFollow
- Differential TestingFollow
Entities
- AnthropicFollow
- Claude CodeFollow
- id SoftwareFollow
- QuakeFollow
- WinQuakeFollow
- Quake-SRPFollow
- ilrebFollow
- RustFollow
- WebAssemblyFollow
- Hacker NewsFollow