RSIGame/EvoGame-BaseGames

EvoGame Base Games

Complete, runnable 2D games written by LLM agents, together with the full generation run that produced each one: the agent's own log and trajectory, the harness configuration, the build and replay logs, recorded demo playthroughs (video + frames) and the automatic verifier score for every game.

Two engines are covered:

• Godot 4 projects (project.godot + GDScript), and
• Phaser web projects (package.json + src/).

Every game was produced by a coding agent from a written task brief, then built, replayed and scored by a rubric-based verifier (a multimodal judge watching the recorded demos). The reward in verifier/breakdown.json and result.json is the score used by the EvoGame pipeline; it is a product of a build gate and weighted rubric variables, and the per-requirement sub-scores are included.

All of this data has been anonymised (see Cleaning below). Nothing here was human-authored: the games, their assets and their code are model output and have not been reviewed, so quality varies.

Contents

folder	contents	size	what it is
basegame-corpus/	3 archives + 8 metadata files	3.44 GB	De-duplicated corpus: 1,998 game projects (1,446 Godot / 552 Phaser), 1,070 matching generation trajectories, manifest, splits and failure statistics
basegen_batch1/	335 archives	5.52 GB	Generation batch 1 — one archive per trial (complete run tree)
basegen_batch2/	326 archives + 3 metadata files	3.78 GB	Generation batch 2 — the tasks batch 1 had not completed
basegen_batch3/	249 archives + 2 metadata files	6.60 GB	Generation batch 3 — a larger task set, higher reasoning effort

basegen_batch1/2/3 are three sequential generation batches run by the same harness with the same agent stack; they differ in the task set, the reasoning effort and the sampling date. The original batch directories carried internal run codenames, which have been replaced by these neutral batch names.

basegame-corpus/

MANIFEST.json                  per game: id / engine / genre / files / bytes / has_trajectory / reward
games_godot.tar.gz             games/godot/<id>/       Godot 4 projects
games_phaser.tar.gz            games/phaser/<id>/      Phaser (web) projects
trajectories.tar.gz            trajectories/<id>/      result.json, config.json, trajectory.json, verifier/
splits/                        all / with_trajectory / godot / phaser
stats/failures.csv             aggregated failed trials (game, trial, outcome, reward, cost, model)
stats/dropped_incomplete.json  generations dropped as empty shells

Only 1,070 of the 1,998 games have a paired trajectory — the rest come from earlier batches whose job trees were not kept. Use splits/with_trajectory.txt for the paired subset. The 140 benchmark tasks were excluded from this corpus at build time to avoid evaluation contamination.

basegen_batch*/

One tar.gz per trial, named <task-id>__<trial-id>.tar.gz, containing the whole run tree:

<task-id>__<trial-id>/
  config.json  lock.json  result.json      harness config, resolved lock, trial result (incl. reward)
  run_configuration.json                   run provenance (batch 3 only)
  agent/codex.txt                          the agent's console log
  agent/trajectory.json                    structured agent trajectory (ATIF)
  agent/sessions/.../rollout-*.jsonl       raw model/session rollout
  sandbox/workspace/game/                  the generated game project
  sandbox/workspace/game/demo_outputs/     the agent's recorded input traces
  trial.log                                harness log for the trial
  verifier/breakdown.json                  reward, formula, per-requirement and per-demo scores
  verifier/build.log  verifier/ctrf.json   build and test results
  verifier/demos/<demo>/<demo>.mp4         replay video
  verifier/demos/<demo>/frames/*.png       frames handed to the judge

Batch-level metadata (run_manifest.json, selected_trials.json, run_completion.json, assignment.json) sits next to the archives.

Cleaning and anonymisation

The release was produced by re-packing every source archive member by member. Game content, scores, rubrics, model identifiers and timings are untouched; only environment-identifying material was rewritten. Applied to every text member and to every member name:

1. Paths. The agent work directory became /workspace/game; harness and bench directories became /workspace/harness/...; every other absolute path (/home/<user>, /opt/..., /tmp/..., /mnt/..., hdfs://...) became <path> keeping a safe basename. Godot scene-tree node paths (/root/Main/...) were left alone — they are game content, not filesystem paths. 403,280 rewrites.
2. Identity tokens (account and user names, colleague handles, internal tool and project names) → <redacted>. The framework names OpenGame / @opengame/core and OpenGameArt were kept, as were game content words. 13,610 rewrites.
3. Internal infrastructure. The model-gateway host and its route became <api_base>; internal mirrors, tracing services, cluster and organisation names became <redacted>.
4. Config and manifest fields. credential_file, hf_repo, archive_root, trials_dir, jobs_root, state_root, runtime_root, task_root, trial_uri, repo_id, OPENAI_BASE_URL and OPENAI_API_KEY were neutralised in place (the keys stay, the values become placeholders), so the schema is unchanged. Scientific fields — reward, rubric text, per-demo scores, model name, reasoning effort, timings, checksums — were kept. 26,577 fields.
5. Host process listings removed. Some agent logs contain ps -ef / ps aux dumps of the whole build machine. These were deleted, not merely scrubbed: each listing is replaced by the marker [host process listing removed]. 26 listings, 379 lines.
6. Owner columns. Owner and group columns in captured ls -l output were rewritten to user. 168,636 lines. Emails became <email> (all of them, including those in third-party licence text), and non-loopback IPv4 literals became <ip>.
7. Credential-shaped strings and any literal value of the pipeline's own secrets were replaced by <redacted>. The prior audit of the source data found zero credentials; this is a safety net. 1 replacement(s).
8. Tar metadata. Every member is owned by user:user with uid/gid 0. Modes and modification times are preserved.
9. Names. Internal run codenames were replaced by the neutral batch names in folder names, archive names and member names, and the per-trial run directory level was collapsed, so each archive starts directly at <task-id>__<trial-id>/. The generation model identifier is a scientific field and is left verbatim.

Binary and media members (images, video, audio, fonts, compiled Godot caches) were copied unchanged; their names were cleaned and they were scanned for identity tokens.

Two things were dropped rather than cleaned: a pointer file that only contained a link to another repository, and one model-written script found inside a game directory that searched /proc for the generation harness and killed it — it is not game content and exists only to describe the build machine. Both are listed in clean_stats.json.

Verification

Every output archive was re-scanned, member by member, with an independent scanner carrying 926 files through 47 identity/credential patterns plus 9 extra release-specific patterns, including a planted-leak self-test that plants one leak per pattern and requires the cleaner to remove all of them. Result: 0 leak hits in 0 files. scan_report.json records the full result, ledger.csv has one row per input archive (members, bytes before/after, status) and clean_stats.json has the per-rule counts.

Known limitations

• Games are model-generated and unreviewed; quality varies widely. reward is a reasonable coarse filter (the paired corpus has a median around 0.64).
• Trajectory coverage in basegame-corpus is 53%.
• Some Phaser games were generated from parameterised difficulty templates and are highly similar within a family; take care in de-duplication experiments.
• Godot projects need a re-import on first open — the .godot/ import cache was dropped from basegame-corpus (the per-trial archives keep whatever the run produced).
• The snapshot is pinned to one revision of the source data; trials produced after it are not included.

Dataset statistics

All figures were recomputed on 2026-09-18. The per-trial figures are a full census, not a sample: every one of the 910 trial archives in the release was opened and read (0 read errors). The corpus-folder figures come from the published per-file state and split files; where a number could not be verified member-by-member that is said explicitly.

Release contents

folder	files	archives	members	bytes	share
basegame-corpus/	11	3 + 8 metadata files	113,824	3,438,374,895	17.8%
basegen_batch1/	335	335 trials	73,555	5,516,958,025	28.5%
basegen_batch2/	329	326 trials + 3 metadata	69,752	3,780,283,512	19.6%
basegen_batch3/	251	249 trials + 2 metadata	72,943	6,601,146,961	34.1%
total	926	910 trials + 3 corpus archives	330,074	19,336,763,393

Input snapshot: 928 files / 19,343,421,539 bytes at one pinned source revision; 2 files were dropped rather than cleaned (see Cleaning).

Games, engines and tasks

	basegame-corpus	basegen_batch1	basegen_batch2	basegen_batch3	total
games / trials	1,998 games	335 trials	326 trials	249 trials	1,998 + 910
Godot	1,446	335 (100%)	326 (100%)	249 (100%)	1,446 + 910
Phaser / web	552	0	0	0	552
distinct task ids	1,998	334	326	249	909 across the three batches
with a paired agent trajectory	1,070 (53.6%)	335 (100%)	326 (100%)	249 (100%)

• Every per-trial run archive in all three batches is a Godot project (sandbox/workspace/game/project.godot present in 910/910, package.json in 0/910, and replay_engine == godot in every verifier breakdown). The Phaser games in this release exist only as finished projects inside basegame-corpus/, without run trees.
• The three batches use pairwise disjoint task sets: 334 + 326 + 249 = 909 distinct ids over 910 trials, so exactly one task (in batch 1) was run twice and no task is shared between batches.
• Corpus verification: splits/with_trajectory.txt is 26,555 bytes, which is exactly the byte length of the 1,070 trajectory ids observed in the corpus trajectory archive, so 1,070 paired trajectories is exact. splits/phaser.txt (13,547 B) accounts for the 551 observable Phaser game ids (13,521 B) plus one further id, so 552 Phaser games is exact. splits/all.txt (50,242 B) is byte-exactly godot.txt + phaser.txt. The 1,446 Godot figure is the one number here that could not be confirmed id-by-id — the Godot corpus archive exposes no readable id list outside MANIFEST.json; it is consistent with the 36,695-byte Godot split.

Verifier reward

The reward is a build gate multiplied by weighted rubric variables, scored by a rubric-based multimodal judge over the recorded demo videos.

Where the reward came from. Three copies exist and they agree:

source	present	precision
verifier/breakdown.json → reward	907 / 910	full (e.g. 0.51859375)
verifier/reward.txt	910 / 910	6 decimal places
result.json → verifier_result.rewards.reward	910 / 910	6 decimal places

The figures below use verifier/breakdown.json where it exists (907) and verifier/reward.txt for the remaining 3. Maximum disagreement between breakdown.json and reward.txt over the 907 archives that have both: 5.0 × 10⁻⁷. No trial is unscored, but 3 trials have no verifier/breakdown.json and no verifier/ctrf.json — their verification did not complete — and all three carry reward = 0.0.

set	n	mean	median	p10	p25	p75	p90	min	max	reward > 0	reward ≥ 0.5
all trials	910	0.4819	0.4918	0.2878	0.3964	0.5879	0.6734	0.0000	0.9400	899 (98.8%)	439 (48.2%)
basegen_batch1	335	0.5191	0.5202	0.3736	0.4401	0.5986	0.6773	0.0000	0.8200	333 (99.4%)	189 (56.4%)
basegen_batch2	326	0.3788	0.3954	0.1312	0.2883	0.4899	0.5761	0.0000	0.6994	317 (97.2%)	79 (24.2%)
basegen_batch3	249	0.5666	0.5681	0.4125	0.4712	0.6507	0.7290	0.1312	0.9400	249 (100%)	171 (68.7%)

11 trials score exactly 0. No per-trial reward is available for the Phaser games, which have no run tree here. Per-game rewards for the 1,998 basegame-corpus games were not recomputed: they live in basegame-corpus/MANIFEST.json, which is a single 331 KB member of the release and was not opened for this pass; the build notes give a median around 0.64 for the paired subset, and that figure is not verified here.

Build success

build_ok is the verifier's build gate; a failed build forces reward 0.

set	breakdowns read	build_ok == true	rate
basegen_batch1	334	333	99.70%
basegen_batch2	324	324	100%
basegen_batch3	249	249	100%
all	907	906	99.89%

Counting the 3 trials whose verification never produced a breakdown as failures gives 906 / 910 = 99.56%. Build success is therefore not the discriminating signal in this data — the rubric score is.

Other per-trial facts: median 5 recorded demo playthroughs per trial (mean 5.53; one trial recorded none); no trial recorded a harness exception; total agent inference cost across the 910 trials was $144.39 (median $0.112 per trial).

Cleaning: what changed

	count
members processed	330,074
text members	116,206
media members	159,971
binary members	715
members rewritten	24,986 (21.5% of text members)
files dropped entirely	2
members dropped entirely	1

Rewrites by rule:

rule	rewrites
harness / job-tree paths → /workspace/harness/...	281,044
captured ls -l owner and group columns → user	168,636
scratch paths → <path>/<basename>	55,360
superuser dot-directories → <path>/<basename>	41,766
config / manifest fields neutralised in place	26,577
container service directories → /workspace/harness/<name>	16,182
run codename inside a config value → neutral batch name	10,959
model-gateway route name → <redacted>	6,599
internal hostname → <redacted>	6,419
harness root → /workspace/harness	4,182
run codename (names) → neutral batch name	4,120
task tree → /workspace/harness/tasks	1,745
sandbox root → /workspace	1,511
home directories → <path>/<basename>	1,479
run-directory references collapsed to the trial name	652
IPv4 literals inspected (non-loopback → <ip>)	519
account name → <redacted>	501
host process-listing lines deleted	379 (26 listings)
e-mail address → <email>	274
model-gateway URL → <api_base>	46
internal service names → <redacted>	43
tool install / mount / distributed-storage paths	10
member names rewritten	1
credential-shaped string → <redacted>	1

Path-class rewrites total 403,280 (plus 652 run-directory references). Scientific fields — reward, rubric text, per-demo scores, reasoning effort, timings and checksums — were left verbatim, so the schema is unchanged.

Verification

check	result
output archives re-scanned	926 / 926
leak hits	0
files with a leak	0
planted-leak self-test	51 patterns planted, 51 detected, 0 residual — PASS
tar member ownership	uniform user:user (0:0) across all 330,060 members
members too large to scan	0
validity spot-check	24 / 24 trial games valid; 19 / 19 Godot and 19 / 19 Phaser corpus games valid
upload size check	931 files, 0 size mismatches

How this was built

Every game here was produced by a coding agent working from a written task brief, then built, replayed and scored by an automatic rubric-based verifier — a multimodal judge that watches the recorded demo videos. The release is the union of a de-duplicated corpus of finished game projects plus three sequential generation batches, each batch one archive per trial holding the complete run tree: agent log, structured trajectory, harness config, build and replay logs, demo videos and frames, and the verifier's score breakdown. The source data was pinned at one revision and never modified; the release was produced by re-packing every archive member by member. Cleaning rewrote environment paths to /workspace/game and /workspace/harness/..., neutralised user, account, host, gateway and internal-service identifiers, blanked credential-shaped strings, normalised captured ls -l owner columns and tar member ownership, replaced internal run codenames with neutral batch names, and deleted — not merely scrubbed — 26 dumps of the build host's process table. Evaluation tasks were held out at corpus-build time so that nothing in this release overlaps the benchmark set used to evaluate agents trained on it. Every output archive was then re-scanned member by member with an independently written scanner plus a planted-leak self-test; the result is zero hits in 926 files. Published 2026-09-18.

Citing this dataset

@misc{evogame_basegames_2026,
  title        = {EvoGame-BaseGames: Agent-Generated 2D Games with Full Generation Runs and Verifier Scores},
  author       = {Anonymous},
  year         = {2026},
  note         = {Under double-blind review; dataset released with the submission},
  howpublished = {Dataset}
}

Known limitations

• Engine imbalance, and it is structural. All 910 per-trial run archives are Godot. Phaser games appear only as finished projects in basegame-corpus (552 of 1,998), with no run tree, no demo videos and no per-trial reward here. Anything that needs a trajectory or a score at the trial level is Godot-only.
• Recording gaps. Only 1,070 of the 1,998 corpus games (53.6%) have a paired generation trajectory; the rest come from earlier batches whose job trees were not kept. Three trials finished generation but their verification never produced a breakdown, so they have a score of 0 with no rubric detail, and one trial recorded no demo at all.
• Judge variance. Rewards come from a rubric-based multimodal judge, not from human review or from a deterministic test suite. Batch means differ by almost 0.19 (0.379 to 0.567) while build success is ~100% everywhere, so most of the spread is the judge and the task set, not compile-level quality. Treat the reward as a coarse ordering, and do not compare scores across batches as if they were calibrated.
• The build gate is nearly uninformative — 99.9% of trials build — so filtering on build_ok removes almost nothing.
• Unreviewed model output. Games, assets and code are model-generated and have not been reviewed for correctness, licence or content.
• Template families. Some Phaser games were generated from parameterised difficulty templates and are highly similar within a family; de-duplication experiments should account for this.
• Godot re-import needed. The .godot/ import cache was dropped from the corpus projects, so they need a re-import on first open. The per-trial archives keep whatever the run produced.
• Pinned snapshot. The release is one revision of the source data; trials produced after it are not included, and one task appears twice (two trials).