---
pretty_name: EditHero
license: other
license_name: mixed-cc
license_link: https://huggingface.co/datasets/AlayaLab/EditHero/blob/main/LICENSE-DATA.md
task_categories:
- image-to-3d
- text-to-3d
- image-to-image
- image-text-to-text
language:
- en
tags:
- 3d
- 3d-editing
- 3d-generation
- part-level
- benchmark
- multi-turn
- long-horizon
- llm
- vlm
- agent
- code-generation
- vibe-modeling
- glb
size_categories:
- 1K<n<10K
configs:
- config_name: edits
  data_files:
  - split: test
    path: preview/*.parquet
---

# EditHero data

EditHero is a benchmark for long-horizon, part-level 3D editing. Each chain starts from a textured, part-segmented host
object and applies a sequence of edits (add, remove, replace, retexture), each with a natural-language instruction and
an exact target state. 457 chains, 2,755 edits, 3,212 states, 252 host objects, in six families: A (additions), P (replacements),
R (removals), M (material changes), G (mixed geometry edits) and X (geometry and material edits mixed).

Paper and project page: https://alaya-lab.github.io/EditHero/. Code (data engine, rebuild, rendering, annotation):
https://github.com/AlayaLab/EditHero.

## What is in a chain

For every turn: the instruction (English and Chinese), the 3D state after the turn (GLB), renders of that state from
four fixed views, and masks of the parts the turn edited. For the chain: the recipe that rebuilds every state exactly
from the parts, and the source objects with their licenses.

An editing method gets the instruction and, if it takes an image, the `cond` view (view 0) of the target state. The
three `heldout` views are for checking the result from angles the method never saw.

## Browse

The dataset viewer above shows every edit (2,755 rows): chain, turn, operation, the cond view of the state before and
after the edit, the mask of the edited parts in that view, and the instruction. The same table is in `preview/*.parquet`:

```python
from datasets import load_dataset
edits = load_dataset("AlayaLab/EditHero", "edits", split="test")
```

`sample/` holds one complete chain (A/1a3267df_s0) unpacked, with its instructions (`sample/chain.json`, `sample/README.md`).

## Download

The index files and captions are plain files; everything else comes as uncompressed tars, one per chain family
(A, G, M, P, R, X), one per part source and one for the annotation files. Extract them in the same folder; the tars
recreate the `data/` layout below.

```bash
huggingface-cli download AlayaLab/EditHero --repo-type dataset --local-dir EditHero
cd EditHero && for t in data/*/*.tar; do tar -xf "$t" && rm "$t"; done
# only some of it, e.g. the renders and part masks:
huggingface-cli download AlayaLab/EditHero --repo-type dataset --local-dir EditHero --include "data/renders/*" "data/part_masks/*" "data/*.json"
```

## Layout

| Path | Contents |
|---|---|
| `data/chains.json` | Index of the chains: host object, operations, instructions, licenses of the source objects the chain uses |
| `data/cameras.json` | Fixed four-view camera rig per chain. View 0 is the conditioning view (`cond`), views 1-3 are held out (`heldout`) |
| `data/states/<chain>/turnNN.glb` | The correct state after every turn (turn00 is the initial object) |
| `data/renders/<chain>/turnNN/view{0..3}_{cond,heldout}.png` | Every state rendered with the chain's rig (420 x 420, RGBA) |
| `data/part_masks/<chain>/turnNN/{source,target,edit}_view{0..3}_{cond,heldout}.png` | Pixels of the parts edited in turn NN, in the same four views: `source` = those parts in the previous state, `target` = in the new state, `edit` = union. `masks.json` per chain lists the edited nodes and pixel counts |
| `data/recipes/<chain>/` | The recipe of each chain (`place_report.json`, `turn00_manifest.json`, `checks.json`, `provenance.json`) and the derived files it uses (retexture bakes, edited part copies) |
| `data/parts/` | Every part the recipes use: `partverse_xl/<object>/<part>.glb` from PartVerse-XL, `hy3d/<object>/<part>.glb` from HY3D-Bench (textured by us) |
| `data/captions/captions_qwen3.json` | Captions of the whole PartVerse-XL library (37,348 objects, 324,375 parts): per object `{"object": [brief, detailed], "parts": {"<pid>": [brief, detailed]}}`, written by Qwen3-VL-32B. The engine retrieves parts by these captions |
| `data/captions/hy3d_captions.json` | Captions and bounding boxes of the HY3D-Bench parts in the part library (Qwen3-VL-8B) |
| `data/annotations/assembly/A/<chain>/` | Every intermediate file of the 97 family-A chains that assemble a host from its own parts: planner input (`parts.json`), assembly plan (`plan.json`), annotator brief, Qwen draft, agent revision, left/right check, relational rewrite and Qwen check of the instructions (shipped as `data/annotations/assembly.tar`). The pipeline and its prompts are in the code repository (`part_assembly/annotate/`) |
| `ATTRIBUTION.csv` | Every source object: uid, source, title, author, URL, license, chains that use it |

## Rebuild, render, build new chains

Everything below uses the code repository (https://github.com/AlayaLab/EditHero).

- **Rebuild and verify.** `bash jobs/rebuild_all.sh EditHero/data out/` regenerates every state from its recipe and checks
  it node by node (vertex count, sum of |v|, texture hashes) against `checks.json`.
- **Render.** `scripts/render_state.py` renders any state, or your own edited GLB, with a chain's four-view rig, exactly
  like the renders here. All renders were made with [blender_kit](https://github.com/AuroraRyan0301/Blender-Visualization-Skill)
  (Blender 4.2, Cycles). If it saves you an afternoon of arguing with Blender, a ⭐ on it would make its author's day.
- **Build new chains.** The data engine builds chains on any part-segmented host, with the part library and the captions
  of this dataset: `docs/DATA_ENGINE.md` in the code repository walks through it step by step.
- **Instructions.** The instructions were rewritten from the engine's template sentences (kept in every recipe record as
  `instruction_original`) by the rules in `docs/INSTRUCTIONS.md`.

## Licenses

See `LICENSE-DATA.md`.