Benchmark arena · open source

BDX Bench

An independent local benchmark harness, leaderboard and playable browser-game showcase that tests AI models against identical real-world software briefs — with a blind A/B chat arena ranked by Elo.

  • MIT licensed
  • Zero-dependency harness
  • Mock mode needs no key
  • Node.js 20
Showdown Score v2total / 100
  1. 1Space Bunny Free91.0
  2. 2DeepSeek V4.1 Flash80.0
  3. 3Claude Haiku 5.563.0
  4. 4GPT Luna 5.662.0
  5. 5GPT 6 Sol58.0
  6. 6Muse Spark 1.352.0
  7. 7GPT Luna 651.0
  8. 8Gemini 3.8 Flash43.0
  9. 9Gemini Pro Agent24.0

Scores come from the repo’s README and audit data: nine models, one shared prompt, one static audit round. The bars re-rank as you switch the audited dimension — the motion is the sort, not live data.

9models on the Showdown leaderboard
11audited, playable game builds
5×20rubric points per build
12harness mini tasks in 2 suites
1000Elo start, K = 32

What is inside

Three ways to put a model on the scale

One repo, two halves: a public Next.js site that ranks what models actually built, and a small zero-dependency harness for auto-graded tasks and blind head-to-head matches.

public site · web/

Showdown: the game-build audit

Every model gets the same prompt and ships a playable browser game. Each build is graded by reading its source, with the evidence and the defects published.

harness · tasks/

swe-mini & terminal-mini

Twelve small, deterministic tasks with binary checks: JavaScript code fixes and shell jobs, run in isolated workdirs with one attempt at temperature 0.

harness · arena

Blind chat arena with Elo

Two hidden sides answer one prompt, up to three named judges vote, identities reveal on the verdict and Elo ratings update.

Public leaderboard

Showdown Score v2: an audit that reads the code

The unit of evaluation is the artifact, not a text answer. Every model built a self-contained browser game from the same single prompt, and each build is hosted verbatim and playable.

make me a video game where i am killing zombies with fire and all please? a nice wonderfull game i can play for fun okay?
The rule: a feature earns points only when it is genuinely implemented and reachable. On-screen strings, comments, dead code and unreachable UI score zero.METHODOLOGY.md, Part A — no audio at all means 0/20 for audio.

Builds are never patched to hide a defect — that would measure the fixer, not the model. Defects are recorded and shown as first-class content, and every score is reproducible from the audit record.

Controls & Mobilitymovement, aim, dash i-frames, pause, touch that works
20
Combat Physics & Weaponscone/arc/range, burn DoT, contagion, knockback
20
Content & Enemy Varietyreal behavioural divergence, bosses, pickups, upgrades
20
Audio & Sound Designprocedural WebAudio, distinct events, music vs SFX-only
20
Visual Polish & Game Feelhit-stop, slow-mo, shake, damage numbers, pooled particles
20

The audit matrix

Showdown Score v2 per-dimension points, out of 20 each
Model / best buildControlsCombatContentAudioPolishTotal
Space Bunny FreeEMBER DEAD ↗191817191891
DeepSeek V4.1 FlashPYRE — Burn the Horde ↗161714171680
Claude Haiku 5.5INFERNO — Zombie Burner ↗15167121363
GPT Luna 5.6Firebreak: Night Shift ↗151311121162
GPT 6 SolCinderline ↗15119111258
Muse Spark 1.3PYRO vs ZOMBIES ↗1212981152
GPT Luna 6Emberfall ↗1596101151
Gemini 3.8 FlashPYROCLASM: Zombie Inferno ↗10969943
Gemini Pro AgentZombie Fire Survival ↗11620524

Points per dimension (max 20) for each model’s strongest audited build, from the README table and web/src/lib/audit-data.ts. Two models shipped two builds: DeepSeek V4.1 Flash also built INFERNO DEAD (61.0) and Space Bunny Free an earlier build (49.0, superseded). Build links open the live site at bench.bdx.market.

honest history

v1 was withdrawn

The first method inspected on-screen text and feature claims and over-scored by up to 40 points — one build scored 93 although its “flamethrower” appeared once in the file, in the page title. The v1 numbers are kept only as superseded references.

fairness rules

Verbatim prompt, uniform rubric

Identical prompt for every model, builds hosted unpatched, one judge and one rubric applied uniformly, and re-audits when the rubric changes. Methods are versioned, never silently restated.

The harness suites

swe-mini and terminal-mini

Small, deterministic, auto-gradable tasks run through one OpenAI-compatible gateway, with a reproducible mock mode and an auditable live mode. The suites are retained in the repo; the public site currently ranks Showdown Score v2 instead.

swe-mini · 6 tasks

Code fixes in JavaScript

Read a file, patch it, satisfy the checks.

  • swe-01 Fix off-by-one in sum()
  • swe-02 Add null guard to getDisplayName()
  • swe-03 Implement debounce()
  • swe-04 Fix race in AsyncCounter
  • swe-05 Fix log-line regex parser
  • swe-06 Fix LRU cache eviction order
terminal-mini · 6 tasks

Shell and scripting jobs

Run commands, produce files and output.

  • term-01 Create file tree easy
  • term-02 Grep-count lines easy
  • term-03 CSV column sum medium
  • term-04 JSON transform with python medium
  • term-05 Find palindromes harder
  • term-06 Topological sort harder

How a run is scored

Checks are binary — file-contains, file-exists or a shell exit code — and all of a task’s checks must pass. Each task is worth 10 points.

avgScore = Σ(points · pass) / Σpoints  (primary)
passRate = Σpass / N  (tiebreak)

Fairness rules

  • Same prompt for every model, per task
  • Temperature 0 where the gateway supports it
  • One attempt — no retries or self-repair loops
  • 60 s timeout; a timeout is a fail
  • Isolated workdir; no secrets in logs

How it works

From one brief to a ranking

The same prompt goes to every model, answers are checked or judged under fixed rules, and the leaderboard is derived from the recorded results.

Prompts & tasksone shared brief12 mini tasks ModelsOpenAI-compatiblegateway, models.json Runner & arenaone attempt, temp 0blind A/B matches Checks & judgesbinary task checkscode audit, 3 votes LeaderboardsavgScore, ShowdownElo ranking Prompts & tasksone shared brief · 12 mini tasks ModelsOpenAI-compatible gateway Runner & arenaone attempt, temp 0 · blind A/B Checks & judgesbinary checks · code audit · 3 votes LeaderboardsavgScore · Showdown · Elo

Blind chat arena

Hidden sides, named judges, Elo

The arena runs on the same local server as the harness. It is chat-driven: you paste a prompt, run both models wherever you chat with them, and paste each answer into its side.

Animated blind arena match Two hidden sides A and B answer one prompt. Three judges vote A, A and B. The 2 to 1 majority picks side A, the identities are revealed, and Elo goes from 1000 and 1000 to 1016 and 984. One prompt, two hidden sides SIDE A ?modelAidentity revealed SIDE B ?modelBidentity revealed UP TO 3 NAMED JUDGES A A B 2–1 majority: Side A wins majority wins · tied scorecards = draw ELO · START 1000 · K = 32 A B 10001016 1000984

The rules

  • Blind A/B — identities stay hidden until the verdict
  • Seeded pairing — the same seed reproduces the same schedule, so anyone can audit it
  • Up to 3 votes from named judges (people or models): A, B or draw
  • Majority wins; 1–1 or 1–1–1 style splits are a draw
  • Journal first — every verdict is saved to data/matches.json before the leaderboard is rebuilt
E_A = 1 / (1 + 10^((R_B − R_A)/400))
R′_A = R_A + K × (S_A − E_A)
S = 1 win · 0.5 draw · 0 loss
both at 1000, A wins 2–1 → 1016 / 984

Fairness: identical prompt, temp 0, one attempt per side, and A/B order alternated across matches to avoid position bias.

Quick start

Run it locally

Commands are copied from the repo’s README and docs. The harness needs only Node.js; the examples use PowerShell.

Start the zero-dependency harness

No npm install required for the harness. It serves the dashboard, arena and prompt bank.

Zero-dependency harness

npm start
# Open http://127.0.0.1:8765

Run the public site (optional)

The Next.js 16 app behind bench.bdx.market.

Public site (Next.js)

cd web
npm install
npm run dev
# Open http://localhost:3000

Run a suite

Mock mode returns canned fixtures, needs no key and costs nothing.

Run a suite from the CLI

node runner/run.js --model <id> --suite <swe-mini|terminal-mini> --mode <mock|live> --out <path>

# no key needed (mock):
npm run mock

Go live with a key

Optional gateway override: BDX_BASE_URL (default https://gpt.bdx.market/v1).

Live runs need a key (set it, never print it)

$env:BDX_AI_API_KEY = "your-key-here"
# Do NOT run: echo $env:BDX_AI_API_KEY

Run a blind arena match

Paste each model’s answer into its side, collect up to 3 votes, then tally the verdict.

Create a blind arena match

Invoke-RestMethod http://127.0.0.1:8765/api/matches -Method Post `
  -ContentType 'application/json' `
  -Body '{"promptId":"p-001","modelA":"bdx-ai/gpt-5.6-luna","modelB":"bdx-ai/go-muse-spark-1.3-contributor","seed":42}'
# inspect one match (sides hidden until verdict)
curl http://127.0.0.1:8765/api/matches/<id>

Score and rank

Score guide: 0.9–1.0 correct and insightful, 0.7–0.8 correct, 0.5–0.6 partial, 0.3–0.4 wrong direction, 0.0–0.2 nonsense.

Score a prompt, then read the leaderboard

Invoke-RestMethod http://127.0.0.1:8765/api/scores -Method Post `
  -ContentType 'application/json' `
  -Body '{"promptId":"p-001","model":"bdx-ai/gpt-5.6-luna","answer":"<paste>","score01":0.8,"notes":"clear example"}'

curl http://127.0.0.1:8765/api/leaderboard

Models configured in models/models.json

  • Claude Haiku 5.5
  • Space Bunny Free
  • DeepSeek V4.1 Flash
  • Gemini Pro Agent
  • GPT 6 Sol
  • GPT Luna 6
  • GPT Luna 5.6
  • Muse Spark 1.3
  • Gemini 3.7 Flash
  • Gemini 3.8 Flash

Harness endpoints include /api/health, /api/models, /api/tasks, /api/runs, /api/leaderboard, /api/prompts, /api/scores, /api/matches and /api/arena-leaderboard. If code and docs disagree, the repo says code wins.

Honest limits

What this benchmark is not

The repo is upfront about scale. Treat results as indicative, and read the evidence rather than only the number.

Tiny scale

12 curated mini tasks, not thousands of real issues or full VMs. One prompt, one domain on the public audit — eleven builds, nine models, so a 1-point gap is not a finding.

Single shot

One attempt at temperature 0 measures deterministic single-shot output, not agent loops with tool use. The audit is a single round with no confidence intervals.

Simple checks

No Docker per task, and binary checks only — no hidden FAIL_TO_PASS / PASS_TO_PASS rigor. Mock is not live: never compare mock and live rows directly. Local-only, no auth.

FAQ

Questions, answered from the repo

What is BDX Bench?

BDX Bench is an independent benchmark harness, leaderboard and playable browser-game showcase for testing AI models against identical real-world software briefs. The repo has two halves: a Next.js site (web/) behind bench.bdx.market that ranks models by the quality of the games they built, and a zero-dependency Node.js harness (server/, runner/, tasks/) with the swe-mini and terminal-mini suites, a prompt bank and a blind chat arena with Elo ratings. It is MIT licensed.

How are models ranked on the public leaderboard?

By Showdown Score v2. Every model received the same unprimed prompt asking for a zombie-burning video game and built a self-contained browser game. Each build is audited by reading its source against five dimensions worth 20 points each: Controls and Mobility, Combat Physics and Weapons, Content and Enemy Variety, Audio and Sound Design, and Visual Polish and Game Feel. The total is out of 100. A feature only earns points when it is genuinely implemented and reachable, so on-screen strings, comments and dead code score zero, and a build with no audio scores 0 on audio.

Why was Showdown Score v1 withdrawn?

v1 scored builds by inspecting on-screen text and feature claims, which credited features that were absent from the code and reported scores up to 40 points too high. One build scored 93 although its flamethrower appeared exactly once in the file, in the page title. v1 is withdrawn, its numbers are kept only as superseded references, and v2 audits the implementation itself.

What are the swe-mini and terminal-mini suites?

They are the two suites of the harness. swe-mini has six small JavaScript code-fix tasks (for example fixing an off-by-one in sum(), implementing debounce(), or fixing a race in an async counter). terminal-mini has six shell and scripting tasks (for example a CSV column sum, finding palindromes, or a topological sort). Each task is checked automatically with binary checks, all of which must pass, and is worth 10 points. The suites are kept in the repo, but the public site currently ranks Showdown Score v2 instead.

How does the blind arena with Elo work?

A match asks one prompt to two hidden sides, A and B, and model identities stay hidden until the verdict. Pairing is seeded, so the same seed reproduces the same schedule. Up to 3 named judges (people or models) each vote A, B or draw; a majority wins and tied scorecards are a draw. Every model starts at Elo 1000 with K = 32, so when two 1000-rated models meet and A wins the ratings become 1016 and 984, while a draw changes nothing. Every verdict is written to data/matches.json before the leaderboard is rebuilt.

Do I need an API key to try it?

Not for mock mode. Mock runs return canned fixture output, need no key and cost nothing, so they are good for plumbing and offline use. Live runs go through an OpenAI-compatible gateway (default https://gpt.bdx.market/v1, overridable with BDX_BASE_URL) and need BDX_AI_API_KEY set in your environment. The docs say never to print or commit the key. Mock and live results are never meant to be compared directly.

How trustworthy and how big is the benchmark?

It is deliberately small and says so. The public audit covers one prompt in one domain, eleven builds from nine models, a single round with no repeat runs, judged by code inspection rather than a large human panel, so a 1-point gap is not a finding. The harness suites are 12 mini tasks, single attempt, with no Docker per task and binary checks only, so results are indicative rather than statistically significant. Scores and the evidence behind them are published so readers can disagree.

Which models does it cover?

The nine models on the Showdown leaderboard are Space Bunny Free, DeepSeek V4.1 Flash, Claude Haiku 5.5, GPT Luna 5.6, GPT 6 Sol, Muse Spark 1.3, GPT Luna 6, Gemini 3.8 Flash and Gemini Pro Agent. models/models.json is the source of truth for the harness and also lists Gemini 3.7 Flash. Only models reachable through the OpenAI-compatible gateway can be run by the harness.

Are the results in the results/ folder real?

No. The three files results/demo-*.json are synthetic demo runs generated by scripts/seed-demo.js; each is marked mode "mock" and demo true, and its log says no real agent was executed. This website therefore does not present them as rankings. The leaderboard shown here is the Showdown Score v2 audit from the README.

Is BDX Bench free and what does it need?

Yes. It is MIT licensed. The harness server is a zero-dependency Node.js program started with npm start (it serves on 127.0.0.1:8765 by default), and the repo pins Node 20 in .nvmrc. The public site in web/ is a Next.js 16 / React 19 app run with npm install and npm run dev.