SplatBench

SplatBench is a benchmark and RL environment for raw spatial reasoning. A language model gets eight photos of an object and rebuilds the object in 3D by placing every Gaussian itself through tool calls, with no code and no optimizer. We grade the build from eight camera angles the model never saw, so only a correct 3D structure scores well.

This repository holds the environment, the 30 tasks and all 1,230 episodes from the SplatBench report: every tool call, every image the model received, the full scene after every edit and the hidden held-out score at each step. The SplatBench explorer replays any episode in the browser.

Tasks

Build. The scene starts empty. The model writes every Gaussian (center, three scales, rotation, color and opacity) through tool calls, checks its work with renders from the reference cameras and submits.

Reassembly. The scene starts from a 300-Gaussian gradient-descent fit of the object, clustered into six parts with k-means. Each part is moved to a random place and rotated about the vertical axis by 45° to 180°, and the part labels are shuffled. The model finds where each part belongs and moves it back with transform_group.

The objects are six procedural shapes with exact ground truth (snowman, mushroom, table, rocket, tree, robot), six NeRF-Synthetic models (LEGO bulldozer, chair, hot dog, ficus, microphone, drum kit) and three photographed objects (the Ignatius statue and the Caterpillar excavator from Tanks and Temples, a jade carving from BlendedMVS). Every object appears as a build task and as a reassembly task, which makes 30 tasks. Each scene is normalized to +Z up inside [−0.9, 0.9]³, with 8 reference views that the model sees and 8 held-out views that it never sees, at 256 × 256 pixels on white.

An episode allows 300 Gaussians, 40 tool calls and 16 renders. The model acts only through these tools:

Tool	What it does
add_gaussians, edit_gaussians, delete_gaussians	Change the scene. An invalid call changes nothing and still uses a call.
transform_group	Move, rotate or scale a labeled group (or a list of ids) as one rigid piece.
list_gaussians, describe_groups, view_references	Inspect the scene and look at the photos again.
render_views	Render the scene from reference cameras next to the photos, with a difference image and PSNR, SSIM and silhouette IoU. Uses a render.
render_angle	Render the scene from any orbit angle, with no photo to compare. Uses a render.
submit	End the episode. The environment also submits when the call budget runs out.

SplatScore. At submission the scene is rendered from the held-out cameras and compared with the real photos using PSNR, SSIM and LPIPS. Each metric is placed between two fixed points, an empty scene (0) and a gradient-descent fit with the same 300-Gaussian cap and the same reference photos (100), and the three are averaged:

$$\text{SplatScore}=\frac{100}{3}\sum _{m\in \{\text{PSNR},\text{ SSIM},\text{ LPIPS}\}}\frac{m_{\text{model}}-m_{\mathrm{\varnothing }}}{m_{\text{GD}}-m_{\mathrm{\varnothing }}}\backslash text\{SplatScore\}\; =\; \backslash frac\{100\}\{3\}\; \backslash sum\_\{m\; \backslash in\; \backslash \{\backslash text\{PSNR\},\backslash \; \backslash text\{SSIM\},\backslash \; \backslash text\{LPIPS\}\backslash \}\}\; \backslash frac\{m\_\{\backslash text\{model\}\}\; -\; m\_\{\backslash varnothing\}\}\{m\_\{\backslash text\{GD\}\}\; -\; m\_\{\backslash varnothing\}\}$$

Scores below zero are common, because misplaced Gaussians cover background that an empty scene gets right. Averaged over the tasks, a single Gaussian in the object's average color scores 4.2, gradient descent with 64 Gaussians scores 67.7 and the scrambled reassembly start scores −51.7.

Results

Each model ran every task twice at medium reasoning effort, for 480 episodes. Intervals are 95% bootstrap intervals over tasks.

Model	SplatScore [95% CI]	Cost per episode	Time per episode
GPT-6 Astra	49.6 [41.4, 58.0]	$1.69	6.6 min
GPT-6.1 Sol	38.6 [30.6, 46.3]	$0.26	5.1 min
Claude Opus 5.5	25.0 [17.1, 32.6]	$0.71	5.0 min
GPT-6 Luna	8.6 [1.8, 15.2]	$0.02	4.5 min
Claude Sonnet 5.5	5.7 [0.2, 10.6]	$0.04	0.7 min
Claude Haiku 5.5	3.6 [−5.8, 12.4]	$0.01	1.9 min
Grok 4.7	2.1 [−8.8, 11.8]	$1.38	24.0 min
GPT-5.6 Terra	1.2 [−7.4, 9.4]	$0.19	2.1 min

GPT-6 Astra beats GPT-6.1 Sol on 29 of the 30 tasks, and Sol beats Claude Opus 5.5 on 28. The remaining models score near a single Gaussian in the object's average color, and most of the differences among them are within noise. Even Astra stays below gradient descent with 64 Gaussians.

Reasoning effort. All models except Grok 4.7 ran again at high and maximum effort on a 15-task subset, so the medium scores here differ slightly from the leaderboard.

Model	Medium	High	Max	Cost per episode at medium	Cost per episode at max
GPT-6 Astra	51.8	55.8	61.6	$1.90	$5.15
GPT-6.1 Sol	43.9	47.6	56.8	$0.30	$0.90
Claude Opus 5.5	31.5	33.1	45.4	$0.75	$6.53
Claude Sonnet 5.5	7.4	18.7	35.3	$0.02	$5.00
Claude Haiku 5.5	9.2	6.2	20.9	$0.01	$0.21
GPT-6 Luna	17.5	14.8	20.8	$0.02	$0.05
GPT-5.6 Terra	4.3	10.8	18.2	$0.20	$0.96

Higher effort raises almost every model's score, and the cost per episode rises much faster than the score. GPT-6.1 Sol at maximum effort beats GPT-6 Astra at medium effort for less than half the cost.

One-shot reconstruction. On the 15 build tasks, the model gets a single tool call and no renders.

Model	One-shot	Full episode	Gain from feedback [95% CI]
GPT-6 Astra	4.3	44.5	+40.2 [26.8, 57.5]
GPT-6.1 Sol	8.3	37.1	+28.8 [15.7, 45.1]
Claude Opus 5.5	9.5	27.8	+18.4 [13.1, 23.7]
GPT-6 Luna	−3.3	11.3	+14.7 [9.6, 20.2]
Claude Sonnet 5.5	−1.0	3.4	+4.4 [0.9, 9.0]
Claude Haiku 5.5	−12.5	2.5	+15.0 [7.7, 25.6]
GPT-5.6 Terra	−23.2	−1.5	+21.7 [9.6, 34.9]

In one shot, GPT-6 Astra, GPT-6.1 Sol and Claude Opus 5.5 are statistically level, so Astra's lead in the full episode comes from how it uses render feedback.

Early submit refused. Claude Sonnet 5.5, Claude Haiku 5.5, GPT-6 Luna and GPT-5.6 Terra often submit early at medium effort. Refusing their first submit before call 20 once, with a reminder that the score comes from views they have not seen, changes no model's score beyond noise. At maximum effort none of them submits early.

The report covers the per-task results, the per-call score curves and replays of individual episodes.

What this repository contains

Config	Splits	Rows	One row is
leaderboard (default)	results	33	A model in one setting: SplatScore with its 95% interval, cost and time per episode, and the comparison with the reference setting on the same tasks.
episodes	settings	1,230	One episode: scores and metrics, tool use, tokens, cost, the held-out score after every edit, reassembly part errors and the final scene.
steps	settings	34,222	One step: the tool call, the text and image the model received, the full scene after the call and its hidden held-out score.
transcripts	settings	1,230	One conversation: the system and user messages, the model's messages with reasoning summaries and tool calls, and each tool result linked to its step.
tasks	test	30	One task: reference and held-out photos with their cameras, the exact prompts, the gradient-descent fits, the scrambled start with the true part poses, and the baseline scores.

The splits of episodes, steps and transcripts are the five settings:

Setting	Episodes	Models	Tasks	Protocol
medium_effort	480	8	all 30	The leaderboard, at medium reasoning effort.
high_effort	210	7	15-task subset	High reasoning effort.
max_effort	210	7	15-task subset	The highest reasoning effort each model supports.
early_submit_refused	120	4	15-task subset	Medium effort. The first submit before call 20 is refused once.
one_shot	210	7	15 build tasks	Medium effort. One tool call and no renders.

Every task ran twice (run 1 and 2). The 15-task subset is marked by effort_subset. episode_id joins the tables and matches the episode ids of the report's player; task_id ends in __sculpt for a build task and __assemble for a reassembly task.

A Gaussian is {id, pos, scale, quat, color, opacity, group}: the center, the standard deviations along the Gaussian's own axes, the rotation as a quaternion (w, x, y, z), RGB in [0, 1], the opacity and the model's group label. The world is right-handed with +Z up. Cameras are OpenCV-style world-to-camera R and t with pinhole fx, fy, cx, cy.

• steps.hidden_score is the held-out SplatScore after every call that changed the scene. The model never sees it. It drives the per-call curves of the report and can serve as a process reward.
• In transcripts, step links each tool result to its row in steps, which holds the image of that result. 68 of the 32,737 tool calls have no step: they were cut off mid-generation, used argument names the tools do not accept or came after the episode had ended, so the environment never ran them.
• context_compacted marks 90 long episodes (88 of the 90 Claude episodes at maximum effort and two Claude Haiku 5.5 episodes at high effort) in which earlier turns were summarized to fit the model's context window. Their transcripts list every message, but by the end the model no longer saw all of them in full.
• Costs are the token cost of each episode in US dollars.

from datasets import load_dataset

board = load_dataset("perpetual-research/splatbench", "leaderboard", split="results").to_pandas()
episodes = load_dataset("perpetual-research/splatbench", "episodes", split="medium_effort").to_pandas()
print(episodes.groupby("model_name")["score"].mean().sort_values(ascending=False))

# every step of GPT-6 Astra building the table, with the image it received and its hidden score
steps = load_dataset("perpetual-research/splatbench", "steps", split="medium_effort", streaming=True)
for s in steps.filter(lambda s: s["episode_id"] == "gpt-6-astra__table__sculpt__eval_r2"):
    print(s["step"], s["tool"], s["hidden_score"], s["response"][:80])
    if s["image"] is not None:
        s["image"].save(f"table_{s['step']:02d}.png")

# the conversation of the same episode
transcripts = load_dataset("perpetual-research/splatbench", "transcripts", split="medium_effort")
messages = transcripts.filter(lambda r: r["episode_id"] == "gpt-6-astra__table__sculpt__eval_r2")[0]["messages"]

Use the environment

hf download perpetual-research/splatbench --repo-type dataset --local-dir splatbench
cd splatbench
uv sync                # add --extra trl for the TRL adapter

Each tool call is one step that returns text and sometimes an image, and the reward arrives once, at the end of the episode.

from splatbench import SplatEnv, load_task

env = SplatEnv(device="cuda")                       # "cpu" works too
obs = env.reset(load_task("data/bench/tasks/table__sculpt.json"))   # obs.text, obs.image: the reference sheet
out = env.add_gaussians([{"pos": [0, 0, 0.1], "scale": [0.45, 0.35, 0.03], "color": "#805e31"}])
out = env.render_views(views=[0, 1, 6, 7])          # ToolOut(text, image, done)
out = env.submit()
reward = env.get_reward()                           # clip(SplatScore / 100, 0, 1)

env.trajectory holds the same per-step log as the steps table, including the hidden held-out metrics. splatbench.prompts has the exact system prompt and tool schemas used for every episode, and task_variant(task, "early_submit_refused" | "one_shot") builds the two other protocols.

SplatTRLEnv (splatbench/trl_env.py) adapts the environment to TRL's environment_factory, so each GRPO rollout gets its own environment. Dataset rows carry a task_path, and complex arguments travel as JSON strings. For training, the reward is shifted so that scenes worse than empty still rank against each other: r = clip((SplatScore + 50) / 150, 0, 1), where an empty scene earns one third and the gradient-descent fit earns 1.

trainer = GRPOTrainer(
    model=model,
    train_dataset=Dataset.from_list([{"prompt": [{"role": "user", "content": "Rebuild the object."}],
                                      "task_path": "data/bench/tasks/snowman__sculpt.json"}]),
    environment_factory=SplatTRLEnv,
    args=GRPOConfig(max_tool_calling_iterations=24),
)

New training tasks need no manual authoring: splatbench.procedural builds the procedural objects and random multi-object scenes from code (random_blob_scene(seed)), and splatbench.prep.prepare_scene turns any scene into a build task and a reassembly task, so the benchmark objects can stay held out.

Evaluate a model

scripts/run_eval.py runs the benchmark protocol against any OpenAI-compatible endpoint with tool calling and image input: OpenAI, OpenRouter, Anthropic's OpenAI-compatible endpoint, vLLM, SGLang and others. It runs every task twice, resumes where it stopped and prints a SplatScore with a 95% interval that compares directly with the leaderboard.

OPENAI_API_KEY=... uv run python scripts/run_eval.py --models gpt-6.1-sol --effort medium

OPENROUTER_API_KEY=... uv run python scripts/run_eval.py --base-url https://openrouter.ai/api/v1 \
    --api-key-env OPENROUTER_API_KEY --models claude-opus-5.5=anthropic/claude-opus-5.5 \
    --extra-body '{"reasoning": {"effort": "medium"}}'

uv run python scripts/run_eval.py --base-url http://localhost:8000/v1 --api-key-env NONE --models your-model

--protocol early_submit_refused and --protocol one_shot run the other settings, and --tasks takes a subset. Each episode writes the same per-step log as the steps table.

Reproduce the results

uv run python scripts/analyze.py        # the tables above and the leaderboard config, from the episode tables
uv run python scripts/shape_checks.py   # mirror test and build size, from the final scenes
uv run python scripts/rescore.py        # re-render every submitted scene and score it again
uv run python scripts/baselines.py      # the fixed points: one Gaussian, gradient descent with 64 Gaussians, scrambled start

analyze.py reproduces every published score, interval and paired comparison exactly. rescore.py re-scores the 480 leaderboard scenes; the new scores differ from the recorded ones by 0.02 points on average and 0.22 at most, because the logged Gaussians are rounded to three decimals. To rebuild the task set from its public sources, run scripts/prepare_procedural.py and scripts/prepare_datasets.py.

Limits

Two runs per task make single-task comparisons noisy, so every comparison here uses the whole task set, and the three photographed objects are too few to read as a separate ranking. The objects are bounded and centered, colors are flat and images are small, so the benchmark says little about lighting, materials or open scenes. There is no human baseline yet.

License

Code: MIT. Episodes, analysis and procedural objects: CC BY 4.0. Scenes derived from NeRF-Synthetic (CC BY 3.0), BlendedMVS (CC BY 4.0) and Tanks and Temples keep their sources' terms; the Tanks and Temples scenes (Ignatius, Caterpillar) and their episode images are for non-commercial research only. Details in LICENSE.md.

Citation

@misc{perpetual2026splatbench,
  title  = {SplatBench: Raw Spatial Reasoning by Placing 3D Gaussians},
  author = {{Perpetual Research}},
  year   = {2026},
  url    = {https://perpetualresearch.si/splatbench}
}

Perpetual is a research lab crafting RL environments for creative intelligence. Contact: founders@vibemotion.ai · @perpetual_si