SimVer-ano/simverse2026

SimVerse

⚠️ Anonymized for double-blind review. This dataset is currently undergoing peer review. It is hosted under an anonymous account dedicated to the review process; the author and citation fields are deliberately unfilled. Permanent ownership and citation information will be added after the review concludes. Please do not attempt to deanonymize the maintainers of this dataset during review.

A multi-task benchmark for evaluating multimodal LLMs on interactive simulation puzzles. Five independent tasks that share a uniform prompt skeleton and a uniform output contract, so cross-task comparisons are meaningfully apples-to-apples.

What's in this dataset

Config	Records	Modality	Output
voi	600	images (target + base shapes)	shape placements
cube1	502	images (blank net + path)	face → patternId map
cube2	502	images (initial net + target)	roll direction sequence
lamp	610	image (arm + obstacles)	per-joint angle list
cutrope	272	gameplay video	text command script

Total: 2,486 levels across 5 tasks.

Quickstart

from datasets import load_dataset

# Load one task config
ds = load_dataset("SimVer-ano/simverse2026", "lamp")
example = ds["test"][0]

# Each example is fully self-contained:
print(example["prompt"]["system"])     # 5-section system prompt text
print(example["prompt"]["user"])       # 9-section user prompt text
print(example["answer"])               # gold answer in the locked schema
print(example["images_relative_to_config"])  # paths to media (relative to this config dir)

The prompt field contains the exact text the original benchmark presented to models — see docs/PROMPT_SKELETON.md for the canonical 5-section system + 9-section user structure shared by all five tasks.

Output contract (all five tasks)

Every task asks the model to end its reply with a single line:

FINAL_JSON: <one-line JSON object>

The JSON's schema is fixed per task (see the per-config README for shape). The dataset's answer field uses the same schema, so one JSON loader handles both model output and ground truth.

Task	answer schema
voi	{"placements": [{"shape", "angle", "vertex", "grid"}, ...]}
cube1	{"faces": {TOP: {patternId, rotation}, ...}}
cube2	{"directions": ["N","S","E","W", ...]} (open-ended; engine validates)
lamp	{"actions": [{"joint", "angle"}, ...]}
cutrope	{"commands": "...", "reason": "...", "confidence": 0..1} (open-ended; simulator validates)

Files in each config

<config>/
├── test.jsonl                # one JSON object per line — HF-auto-loadable
├── data/                      # same records, split into per-level files (frontend-compatible)
└── images/   or  videos/      # binary media referenced by the JSON

cube1 and cube2 additionally ship a catalog.json (the frontend's index/manifest), and cutrope additionally ships a source/ mirror of the original frontend level files.

The per-record fields visible in test.jsonl are a superset of what's in data/. Two extra helper fields appear only in JSONL records:

Field	Purpose
__sample_id__	The canonical level id (e.g. "lamp-000", "C123") — handy as a primary key.
images_relative_to_config (or video_relative_to_config)	Media paths rewritten to be relative to the config root, so they resolve from the Image() / Video() feature loader without further normalization.

The original media paths inside the JSON record (e.g. imageAssets.target for VOI, image_paths.blank_net_image for cube1, video.path for cutrope) are preserved as the canonical task-native fields — use either depending on your loader.

Reproducing the benchmark

Each record carries the complete prompt the benchmark submits to the model. To reproduce a run from scratch:

1. Read prompt.system and prompt.user from the record.
2. Attach the referenced media (image/video) using either images_relative_to_config or the task-native field.
3. Submit to your model with whatever multimodal protocol it accepts.
4. Extract the line starting with FINAL_JSON: from the reply, parse it as JSON.
5. Compare against answer (or invoke the per-task validator from the SimVerse repo).

The accompanying code at https://github.com/SimVer-ano/simverse2026 includes the parser, validator, and runner for every config.

Per-config details

• voi/README.md
• cube1/README.md
• cube2/README.md
• lamp/README.md
• cutrope/README.md

Responsible-AI metadata

The full datasheet (Gebru et al. 2018, 7-section format) is in datasheet.md. The machine-readable RAI metadata is in croissant.json (Croissant 1.0, including the RAI extension). A human summary:

• Data collection. All five tasks are programmatically generated. VOI uses a polygon-rasterization XOR generator; cube1/cube2 use a Python cube-state simulator; lamp uses a forward-kinematics generator with axis-aligned obstacle placement; cutrope is built on top of the open-source yell0wsuit/cuttherope-h5dx HTML5 port (MIT-licensed) by recording deterministic gameplay clips and authoring matching command scripts. No human subjects or real-world data were involved.
• Annotation protocol. Reference solutions are produced by the same generators that create each puzzle. For closed-form tasks (VOI, cube1, lamp), the answer is uniquely determined and machine-verifiable. For open-ended tasks (cube2, cutrope), the dataset's answer field carries one known-valid reference solution; validators run the underlying engine against the model's actual output rather than performing string equality, so multiple correct answers earn full credit.
• Limitations. Synthetic puzzles in fixed visual styles per task — models may learn render-style shortcuts. All prompts are English-only. cube1 includes ? sentinel patterns when faces are under-determined; downstream uses outside the SimVerse evaluation flow may need to filter these. Reference solutions for open-ended tasks are non-unique, so simple string-match scoring is inappropriate; use the bundled engine-based validator.
• Biases. Each task's visual style is uniform across its records, which can bias evaluations toward render-style recognition rather than the reasoning skill the task is intended to probe. Reference solutions for open-ended tasks favor specific solution paths even when other paths are equally valid. Object-count distributions in cutrope reflect the upstream yell0wsuit corpus.
• Personal / sensitive information. None. Fully synthetic; the dataset contains no personally identifiable information, no human-subject data, and no sensitive content.
• Intended use cases. Held-out benchmarking of multimodal LLMs on (a) spatial-pattern reconstruction, (b) multi-step planning under physical constraints, and (c) short-horizon video-to-program inference. Not a held-out training set, not a real-world capability predictor, not a substitute for application-specific evaluation.
• Social impact. Low. Synthetic abstract puzzles unlikely to encode harmful content. Primary risk: benchmark gaming via render-style overfitting if widely adopted.
• Maintenance. All levels are deterministically regenerable from the generators in the accompanying code repository (linked from this card under the post-acceptance camera-ready URL). Schema changes are released as new versioned snapshots.

NeurIPS 2026 compliance

This dataset is prepared for the NeurIPS 2026 Datasets & Benchmarks track:

• ✅ Hosted on Hugging Face (one of the supported platforms with auto-Croissant generation)
• ✅ Croissant 1.0 metadata file at croissant.json, with both Core and minimum-RAI fields
• ✅ Open license (MIT) declared in both the dataset card YAML and Croissant
• ✅ RAI items addressed in this README and machine-readable in croissant.json
• ✅ Anonymized for double-blind review (see notice above)

Reviewers can validate the Croissant file via https://croissant.dev/validate.

Citation

@dataset{simverse_2026,
  title  = {SimVerse: A Multi-Task Benchmark for Multimodal Reasoning on Interactive Simulation Puzzles},
  author = {<authors>},
  year   = {2026},
  url    = {https://huggingface.co/datasets/SimVer-ano/simverse2026}
}

License

MIT — see LICENSE.