README.md

metadata

license: cc-by-4.0
language:
  - en
pretty_name: 'OCTAVE: A Capability-Resolved Benchmark for End-to-End HTML5 Game Generation'
tags:
  - benchmark
  - code-generation
  - game-generation
  - coding-agents
  - html5
  - llm-evaluation
task_categories:
  - text-generation
size_categories:
  - n<1K
configs:
  - config_name: default
    data_files:
      - split: test
        path: octave_benchmark_180_en.json

OCTAVE: A Capability-Resolved Benchmark for End-to-End HTML5 Game Generation

OCTAVE evaluates whether coding agents can build a complete HTML5 game from a natural-language Game Specification. It goes beyond a single leaderboard number: every task is broken down into requirement-level evidence and mapped onto eight game-development Capability Dimensions (C1–C8). This shows which capabilities an agent actually implements and which kinds of requirements it still misses.

The name comes from the musical octave. Eight capability dimensions span the space of game development, the way eight notes span an octave. Each task is scored on two layers, analogous to a tone's fundamental and its overtones:

• Completeness: the publicly specified core functionality (the fundamental).
• Richness: hidden, deeper system relationships that are implied but never stated (the overtones).

At a glance

Tasks	180
Evaluation Requirements	1,800 = 1,080 Completeness (public) + 720 Richness (hidden)
Per task	6 Completeness + 4 Richness requirements
Sources	150 real player requests · 20 commercial-mechanics reconstructions · 10 expert-designed tasks
Platforms	PC Web 95 · Mobile Web 85 (separate tracks from construction onward)
Visual forms	2D 91 · 3D 89
Genres	6 (Simulation & Sandbox 45, Strategy 34, Adventure & Puzzle 31, Action 30, RPG 24, Social & Tabletop 16)
Capability Dimensions	C1–C8
Language	English

Task sources

track	Source	Tasks	PC Web	Mobile Web
main	Real player requests. Game-generation requests from players, cleaned, de-identified and rewritten into judgeable specifications. 150 tasks were selected from a 250-task candidate pool by capability coverage.	150	75	75
repro	Commercial-mechanics reconstruction. Core mechanics of publicly documented games (Steam and mobile stores), rebuilt into self-contained requirements. They do not reproduce the original games in full.	20	10	10
expert	Human expert design. Tasks that add complex system relationships and engineering constraints that are under-represented in player requests.	10	10	0

Capability Dimensions (C1–C8)

The dimensions come from the game-design framework of Zubek's Elements of Game Design (Mechanics, Systems, Gameplay, Macrostructure, Player Experience). They are turned into capabilities that can be checked through requirements and observable behavior.

Paper code	Capability Dimension	Design concept	Scope	Code used in this file
C1	Core Rules	Mechanics	Game rules, state transitions, core mechanics, win/loss conditions	C1
C2	AI/NPC	Systems	NPC behavior, decision logic, autonomous system behavior	C5
C3	Numerical Design	Systems	Attributes, resources, economies, progression, numerical relationships	C6
C4	Interaction and Input	Gameplay	Player input, interaction mapping, game controls	C2
C5	Levels and Scenes	Macrostructure	Spatial organization, levels, scenes, game progression	C4
C6	Animation and Rendering	Player Experience	Rendering, animation, dynamic visual states	C3
C7	Feedback and Game Feel	Player Experience	Visual, auditory and state feedback for actions and events	C7
C8	Guidance and Meta-UI	Player Experience	Tutorials, prompts, HUDs, menus, pausing, end states	C8

Note on codes. The capability fields in this release (agent_ability, checklist_capabilities, hidden_checklist_capabilities, gen:C* in label_original) use the codes in the last column. Map them to the paper's numbering with:

TO_PAPER = {"C1": "C1", "C2": "C4", "C3": "C6", "C4": "C5", "C5": "C2", "C6": "C3", "C7": "C7", "C8": "C8"}

Only the codes differ. Every requirement keeps exactly the same capability annotation.

A task carries several capability labels. A single requirement may also map to several capabilities; in the paper's main analysis, its first label is its primary capability. label_original also contains cog:C1–C12 tags, which belong to an unrelated 12-item cognitive axis. Do not use them for capability statistics.

Requirement layers

• Completeness Requirements (checklist, 6 per task) correspond to mandatory content in the Game Specification. Each one states an observable outcome under specific conditions. It never merely asks that a system "should exist", so a requirement passes only when the functionality forms a complete behavioral loop.
• Richness Requirements (hidden_checklist, 4 per task) test cross-system coupling, edge cases, complex states, and behavior under changes in scale. They follow two principles: zero prompting (they are never shown to the model) and resistance to incidental satisfaction (a crude or superficial implementation is unlikely to trigger them).

Example (hard_action_rpg_3d_017, a mechanic where destroying a wall changes routes):

• Completeness: After a wall between rooms is destroyed, blockage, collision and navigation update together. The player can now pass through the opening, and enemies that previously detoured recalculate their paths.
• Richness: When walls are destroyed in succession, or while an enemy is moving along an old route, affected paths must update. Intact walls keep blocking, openings leave no residual collision, and pathfinding resumes once a route becomes available again.

Difficulty

level is a task-level design difficulty (easy 42 · medium 45 · hard 50 · extreme 43). It is assigned at construction time, independently of model results, from six ordinal dimensions scored 0–3:

Dimension	What it measures
D1 Breadth of system coupling	How many hard systems interact, and how densely
D2 Algorithmic and simulation core	From state machines to multi-core or simulation-level cores
D3 Verification rigor	From functional presence to replay/hashing with multiple constraint types
D4 Dynamic governance and adaptation	Feedback loops, closed-loop adaptation
D5 Multi-agent and social cognition	From scripted NPCs to multi-party games and shared beliefs
D6 Scale and performance	From no scale requirement to thousands of entities with smoothness constraints

The paper also reports a requirement-level difficulty, a_DS = D1 + D2 + 0.8·D3 + 0.8·D4 + 0.7·D5 + 0.5·D6. It splits the 1,800 requirements into four equal-count strata of 450 each. This is a coarse stratification axis: it is only weakly correlated with actual pass rates (Spearman ρ = −0.135), so it should not be read as a predictor of individual outcomes. Per-requirement scores are not included in this file.

Fields

Field	Type	Description
task_id	string	Unique identifier
track	string	main (player request) / repro (commercial-mechanics reconstruction) / expert (expert design)
platform	string	web (PC Web) / mobile (Mobile Web)
render	string	2d / 3d
category	string	One of 6 genres
genre, subtype	string	Normalized genre / subtype slugs
incentive	string	single-agent / cooperative / competitive / mixed-motive
level	string	Task-level design difficulty: easy / medium / hard / extreme
desc	string	One-line concept
prompt	string	The Game Specification given to the agent. Four sections: [Game] / [Core Mechanics] / [Must Implement] / [Creative Freedom]. Mobile tasks add touch-interaction requirements.
checklist	list[string]	6 Completeness Requirements
hidden_checklist	list[string]	4 Richness Requirements. Never show them to the agent.
agent_ability	list[string]	Task-level capability labels (see the note on codes)
checklist_capabilities	list[list[string]]	Capabilities of each Completeness Requirement
hidden_checklist_capabilities	list[list[string]]	Capabilities of each Richness Requirement
verify	string	Evaluator entry point (2D / 3D template)
attachment, result_verify	list / string	Reserved, empty in this release
notes	string	Provenance and design metadata
source_file, category_original, label_original	—	Raw annotation fields, kept for auditability
repro_meta	object	repro tasks only: reconstructed game, evidence with graded labels (STORE, DEV, WIKI, GUIDE, REVIEW, INFER), and the minimal state surface

Usage

from datasets import load_dataset

ds = load_dataset("rezonalab/game-benchmark", split="test")

task = ds[0]
print(task["prompt"])            # give ONLY this to the agent
print(task["checklist"])         # 6 Completeness Requirements (judge after generation)
print(task["hidden_checklist"])  # 4 Richness Requirements (never shown to the agent)

pc_web  = ds.filter(lambda x: x["platform"] == "web")
players = ds.filter(lambda x: x["track"] == "main")

Evaluation protocol (as in the paper)

1. Generation. Each task starts in an empty, independent workspace. The agent receives only the Game Specification (prompt) and one initialization instruction, then develops autonomously with no further human input. In the paper the budget is 120 minutes per task and no library or framework is restricted. The final workspace is the artifact.
2. Stage 1: Static Runnability Gate. The evaluator inspects the submission directory, required files, entry artifacts and execution paths to decide whether the project can run.
3. Stage 2: Requirement-level judgment. Each requirement gets a 0/1 judgment backed by evidence: files, functions, states and data flows on actual execution paths. Names, comments, READMEs and dead code do not count. A compound requirement passes only if all of its sub-conditions hold, and there is no partial credit.
4. Aggregation. Report Completeness (public pass rate) and Richness (hidden pass rate) separately, along with the gate-failure-or-missing-artifact rate. Gate-failed artifacts keep their requirement scores, and missing artifacts score 0. Stratify by source, platform, capability and difficulty rather than pooling.

The evaluator templates (PC/Mobile × 2D/3D) and the generation and evaluation code are in the OCTAVE repository.

Baseline results

12 model–harness combinations (Claude Code 2.1.263 / Codex CLI 0.147.0), all 180 tasks, evaluator gpt-6-astra (static source-code review). Requirement pass rates are computed over all records.

Model	Harness	Gate failure or missing artifact	Completeness	Richness
DeepSeek-V4.1-Flash	CC	20.6%	25.9%	28.9%
DeepSeek-V4-Flash-0731	CC	26.7%	23.5%	28.5%
Fable 5	CC	21.1%	39.0%	39.3%
Fable 5.1	CC	17.8%	44.7%	40.7%
GLM-5.2	CC	26.7%	24.3%	28.1%
GLM-5.3	CC	21.7%	31.1%	34.0%
Opus 5	CC	16.1%	37.2%	40.4%
Seed evolving	CC	33.3%	21.0%	24.9%
DeepSeek-V4-Pro	CX	22.8%	22.2%	27.5%
GPT-5.5	CX	15.6%	26.9%	28.3%
GPT-5.6-sol	CX	16.7%	33.4%	32.6%
GPT-6-astra†	CX	13.3%	57.1%	49.3%
Overall	—	21.0%	32.2%	33.5%

† Same model as the evaluator (self-evaluation); interpret with care. Without self-evaluation, no combination reaches 50% on either layer. The best, Fable 5.1, reaches 44.7% Completeness and 40.7% Richness.

Key findings:

• Systems do relatively well on C3 Numerical Design and C1 Core Rules. C7 Feedback and Game Feel and C4 Interaction and Input expose the largest gaps.
• Richness is not uniformly harder than Completeness. The ordering flips with task source (player requests 27.4 / 28.8, reconstruction 52.0 / 49.2, expert 65.1 / 72.7), so the two layers should be reported separately.
• Mobile Web scores higher than PC Web for every combination (Completeness 37.6% vs 27.4%, Richness 44.0% vs 24.2%). The direction holds after restricting to shared source types. PC and Mobile are separately designed task sets, not paired implementations.
• On a limited human cross-check (8 Mobile player tasks, 266 judgeable requirements, one annotator per artifact), humans judged 76.3% satisfied versus the evaluator's 46.2%. The main disagreement is requirements that humans find satisfied but static review fails.

Limitations

• Static evaluation. Judgments come from source-code review without screenshots, browser logs or interaction traces. They complement runtime verification rather than replace it, and the evaluator shares a model family with one evaluated combination.
• Different sources, different conventions. Player, reconstruction and expert tasks differ in content and authoring style, and all expert tasks are PC Web. Stratify by track and platform.
• Reconstruction evidence is desk research. repro mechanics come from store pages, developer descriptions, wikis, guides and reviews, not from playing the games. Claims labeled INFER are not presented as facts about the original games. repro_dungeonwarfare3_mobile_2d_013 has a well-documented PC predecessor and carries higher contamination risk.
• Hidden requirements are released. Richness Requirements are included here for reproducibility. Results are only comparable if they are never exposed to the agent during generation.
• Human validation is limited. Construction review was done by a 12-person project expert group (developers, designers, testers) that partly overlapped with the construction team. The human cross-check uses one annotator per artifact, so no inter-annotator agreement is reported.

License

The data is released under CC BY 4.0. The code in the accompanying repository is MIT-licensed.

Citation

@misc{octave2026,
  title  = {OCTAVE: A Capability-Resolved Benchmark for End-to-End HTML5 Game Generation},
  author = {{Rezona Lab}},
  year   = {2026},
  note   = {Dataset: https://huggingface.co/datasets/rezonalab/game-benchmark}
}