One WAD. One demo. Every language measured on frame rate, RAM, binary size, and lines of code.
Unified 3-engine comparison on DOOM1.WAD DEMO1 (5,026 tics, 320×200 software). Highlighted cells indicate the best measured result on each metric.
| Category | Benchmark | Loading... | Loading... | Loading... |
|---|
Direct head-to-head comparison across all four measured dimensions on the identical DOOM1.WAD DEMO1 workload.
Click once to run kazad/doom.ic (2.4 KB WebAssembly) locally in your browser, verify the deterministic checksum, and post your CPU score to the live table. Have a faster DOOM engine? Suggest a GitHub repo to benchmark →
kazad/doom.ic compiled to WebAssembly (/doom_ic_kernel.wasm) locally in your browser, then lets you post your verified score below.| Rank | Handle | Machine / Hardware | Build / Runtime | Throughput | DOOM-ST | Source |
|---|
Verified standalone stress workloads measured independently from the 3-engine DEMO1 leaderboard above.
| Workload | kazad Instacalc | reference Next Best | Advantage | Verification |
|---|
Actual Frame 0 rendered directly from the live kazad/doom.ic DEMO1 engine alongside a verbatim excerpt from render.ic.
DOOM1.WAD DEMO1 (E1M5, skill 2) with textured walls, flats, sky, weapon sprite, monsters, and live status bar. Verified hashes: fb_hash=0x1d3148d5 · audio_chk=0x6f93af49.
104 | @hot fast_check_bbox(
105 | vx, vy, cos_a, sin_a, btop, bbot, bleft, bright: i32,
106 | solid_mask: const u64[], solid_count: i32
107 | ) -> i32 = {
108 | let vis: i32 = 1
109 | if (!(vx >= bleft && vx <= bright && vy >= bbot && vy <= btop)) {
110 | let (dxl, dxr, dyb, dyt): i32 = (bleft - vx, bright - vx, bbot - vy, btop - vy)
111 | let (zxl, zxr): i32 = (fast_fixed_mul(dxl, cos_a), fast_fixed_mul(dxr, cos_a))
112 | let (zyb, zyt): i32 = (fast_fixed_mul(dyb, sin_a), fast_fixed_mul(dyt, sin_a))
113 | let (tz00, tz10, tz01, tz11): i32 = (zxl + zyb, zxr + zyb, zxl + zyt, zxr + zyt)
114 | let z_near: i32 = 1048576
115 | if (tz00 < z_near && tz10 < z_near && tz01 < z_near && tz11 < z_near) {
116 | vis = 0
117 | } else {
118 | let (xxl, xxr): i32 = (fast_fixed_mul(dxl, sin_a), fast_fixed_mul(dxr, sin_a))
119 | let (xyb, xyt): i32 = (fast_fixed_mul(dyb, cos_a), fast_fixed_mul(dyt, cos_a))
120 | let (tx00, tx10, tx01, tx11): i32 = (xxl - xyb, xxr - xyb, xxl - xyt, xxr - xyt)
121 | let m: i32 = 131072
122 | if ((tx00 + tz00 < -m && tx10 + tz10 < -m && tx01 + tz01 < -m && tx11 + tz11 < -m) ||
123 | (tx00 - tz00 > m && tx10 - tz10 > m && tx01 - tz01 > m && tx11 - tz11 > m)) {
124 | vis = 0
125 | } else if (solid_count > 0 && tz00 >= z_near && tz10 >= z_near && tz01 >= z_near && tz11 >= z_near) {
126 | let rx: i32 = (vx < bleft) ? 0 : ((vx > bright) ? 2 : 1)
127 | let ry: i32 = (vy > btop) ? 0 : ((vy < bbot) ? 2 : 1)
128 | @lut_tuple(rx * 3 + ry, [bbox_txa->txa:i32, bbox_tza->tza:i32, bbox_txb->txb:i32, bbox_tzb->tzb:i32])
129 | let sx0: i32 = 160 + i32((i64(txa) * 160) / i64(tza))
130 | let sx1: i32 = 160 + i32((i64(txb) * 160) / i64(tzb))
131 | let (mn, mx): i32 = (max(min(sx0, sx1) - 2, 0), min(max(sx0, sx1) + 2, 319))
132 | if (mn > mx || bm_is_full(solid_mask, mn, mx) != 0) { vis = 0 }
133 | }
134 | }
135 | }
136 | vis
137 | }
Have a fast or tiny DOOM engine on GitHub? Suggest the repository below — we build from source on the same idle M1 Max & Zen 4 test rigs and publish verified results.
Generate a valid DOOM PWAD with configurable sectors and monster counts to test engine scaling locally.
Every leaderboard result is measured live on the same host against the same DOOM1.WAD input, using interleaved trials and hardware counters so every claim can be audited and reproduced.
1. Identical Workload: Every engine executes Shareware DOOM1.WAD DEMO1 (5,026 gametics on E1M5, skill 2) in headless 320×200 software mode with sound hardware disabled so monitor vsync never caps frame rate.
2. Interleaved Execution: Engines run in alternating A, B, C, A, B, C rounds (5 rounds each) rather than back-to-back blocks, eliminating thermal drift and transient OS load bias.
3. CPU Time, Wall Time & Hardware Counters: Each invocation is wrapped in /usr/bin/time -l to capture single-core CPU time (user + sys), real wall time, Peak RSS (ru_maxrss), instructions retired, and CPU cycles elapsed.
4. Source-Only Code Size (SLOC): Line counts measure strictly engine source files (non-blank, non-comment lines). Build scripts, Makefiles, CMake files, and external test harnesses are excluded.
5. Stripped Binary & Anti-Cheat Gate: Native binaries are stripped with strip -x before measuring disk size. Community submissions compile from source in an isolated temp workspace, reject prebuilt Mach-O/ELF/WASM binaries via magic-byte checks, and require deterministic frame/audio checksums.
6. Transparent Scope Disclosure: kazad/doom.ic executes all 9 Episode 1 maps and all 5,026 tics of DEMO1 (AI, physics, sprites, HUD, 8-ch audio); exact vanilla v1.9 demo-sync camera parity is in progress and disclosed on every view.
| Engine | Language | Build Settings | Measured Command | Scope / Notes |
|---|---|---|---|---|
| kazad/doom.ic | Instacalc (.ic) | instacalc release build (-O3 -mcpu=native) |
./doom /tmp/DOOM1.WAD --bench |
1,222 .ic SLOC (6 files; +1,042 C loader, +2,244 DSL expander); diverges from vanilla v1.9 DEMO1 ~tic 500 (simplified AI, HP clamped at 1) |
| id-software/linuxdoom-1.10 | C89 (.c) | Apple clang 21.0.0 -O3 -mcpu=native (0 algorithmic edits) |
./linuxdoom_headless.stripped -iwad /tmp/DOOM1.WAD -timedemo demo1 -config bench_sb10.cfg |
Original 1993/1997 source (124 files, 36,103 SLOC); screenblocks=10 full 320×200; vanilla v1.9 DEMO1 synced |
| kraflab/dsda-doom | C99 (.c) | Built from source (clang -O3 -march=native) |
SDL_VIDEODRIVER=dummy SDL_AUDIODRIVER=dummy dsda-doom -iwad /tmp/DOOM1.WAD -complevel 3 -timedemo demo1 -nosound -vidmode 8 -geom 320x200 |
8-bit software mode (-vidmode 8, render_wipescreen 0), 180,900 measured SLOC; vanilla v1.9 DEMO1 synced |
Why Geometric Mean: Arithmetic averages of speedups flip rankings depending on which engine is chosen as baseline (Fleming & Wallace, 1986). Combining speed, RAM, binary size, and SLOC via a weighted geometric mean guarantees baseline-invariant rankings.
Two Complementary Tracks: (1) Native Bare-Metal Track measures true hardware throughput, cache behavior, Peak RSS, and stripped binary size; (2) WebAssembly Calibration VM (CPUMark) runs a deterministic wasm32 kernel in any browser so machines of different OSes and CPUs can be calibrated on one portable virtual machine.
Hardware Counter Sanity Check: At confirmed 320×200, linuxdoom-1.10 retires ~5.55B instructions (1.47B cycles), dsda-doom retires ~13.25B instructions (4.02B cycles, 32-bit pipeline + SDL2), and kazad/doom.ic retires ~3.68B instructions/pass (1.24B cycles).
No Hidden Trade-offs: Every individual dimension stays visible on the Benchmark Matrix, 4-Axis Comparison Bars, and Pareto Frontier so no single composite number obscures a trade-off (for example, linuxdoom-1.10 winning Peak RAM at 4.33 MiB).
Hi, I’m Kalid — creator of BetterExplained.com and Instacalc.com.
I’m working on a new type of programming, and I want to see if it actually works — tested honestly against real software in any language you like. If you’re interested in learning more or following along, sign up here: