GameForge Harness
v0.1.0 public alpha · Unity + Godot

Give game agents room to build. Verify what they ship.

GameForge is an open game-development harness. The solver gets a complete disposable project and freedom to use code, shell, image, and official engine tools. A separate evaluator builds, launches, replays, records, and verifies the result.

Apache-2.0 Python 3.11+ Codex subscription or API
independent-replay.godot verified
Arena Survivor gameplay with player movement, projectiles, enemies, and score
Arena SurvivorEngine-input replay · Godot
Runtime gatePassed without script errors
Evidence Input → state change
63.15%GameCraft full140
64.16%GameDevBench full332
40 / 40Open-ended hard gates
13Playable evidence cases
The core separation
“Do not prescribe how the model builds the game. Do not let the model decide whether the game works.

The solver owns exploration and implementation. The harness owns the reproducible project boundary, engine lifecycle, execution profile, receipts, and independent evidence.

How it works

One open loop. One independent verdict.

The model can inspect, improvise, call the engine, capture feedback, and change strategy. Final acceptance remains outside that loop.

  1. 01

    Brief + project

    A game brief or change request enters a disposable full workspace.

  2. 02

    Open solver

    The model chooses its own files, tools, engine commands, and validation strategy.

  3. 03

    Game artifact

    The output is a complete Unity or Godot project, not a chat answer.

  4. 04

    Independent replay

    A solver-invisible evaluator builds, launches, injects input, and captures evidence.

  5. 05

    Verified result

    Receipts separate solver, engine, host, runtime, evaluator, and gameplay outcomes.

Benchmark results

Fixed tasks, measured competitively.

Frozen suites and paired baselines show how the same open harness performs on repeatable game-development tasks.

GameDevBench · full332 Godot
64.16% 213 of 332 tasks passed
+8.73 pp
GameForge
64.16
Local Official
55.42
+29tasks passed
4.87e−6paired McNemar p
Open the comparison
Open-ended results

Broad briefs, without a prescribed path.

Empty or minimal projects. Natural-language game briefs. No required node names, source layout, API, tool order, intermediate gate, or solver workflow.

20 / 20 Godot Open20

Import + runtime hard gates

Twenty genres from empty projects, with blinded quality parity against local Official.

View evidence
20 / 20 Unity Open20

Build + Player hard gates

Twenty genres from minimal projects, with 40 of 40 valid evaluator screenshots.

View evidence
A general harness

Freedom where it helps. Boundaries where they matter.

Solvers, engines, and authority profiles are independent choices behind one game workspace and evidence contract.

01

Replaceable solvers

Use a saved Codex subscription login or a standard OpenAI Responses API tool loop.

CodexResponses API
02

Thin engine adapters

Unity and Godot share workspace, budget, receipt, backend, and result contracts.

UnityGodotMore planned
03

Explicit authority

Choose maximum native freedom, supervised engine transport, or external isolation.

native-opensupervisedisolated
Quick start

From clone to an open game task.

Bring Python 3.11 or 3.12, uv, Git, and the engine you want to use. Authentication can come from a local Codex login or an API key kept in the host environment.

Terminal
$ git clone https://github.com/AlbusChen/GameForge-Harness.git
$ cd GameForge-Harness
$ uv sync --locked --all-groups
$ cp config/model.subscription.example.yaml \
    config/model.local.yaml
$ uv run gameforge run-game-workspace \
    --project /path/to/game \
    --engine auto \
    --request "Add a playable dash mechanic." \
    --model-profile config/model.local.yaml
Current scope

Evidence with named boundaries.

Build openly. Verify independently.

Bring a solver, an engine, and a game worth testing.