Datasets:
image imagewidth (px) 1.92k 1.92k |
|---|
ARC-Embodied
ARC-Embodied (arc_embodied) is a synthetic embodied-reasoning dataset in
which a robot solves Abstraction and Reasoning Corpus (ARC) tasks by moving
colored cubes. It provides canonical ARC grids alongside Isaac Lab trajectories,
camera observations, simulator state, and semantic grasp/place actions.
ARC-Embodied is the dataset. ERA Bench is the benchmark and evaluation framework built on it.
The ERA Bench simulator provides the Isaac Lab simulation and dataset-generation pipeline. The ERA Bench Evaluation repository provides the dataset loader and benchmark evaluation framework.
Each row shows the final table-camera frame of every demonstration for one task. The input grid is on the left, the completed output grid is on the right, and the reserve cubes are in the foreground.
Dataset summary
These statistics count each raw episode once, excluding its task-view hard links.
| Property | Value |
|---|---|
| File format | HDF5 |
| File size | 73.69 GB (68.63 GiB) |
| Raw recorder episodes | 329 (all marked successful) |
| ARC tasks | 62 (50 training, 12 evaluation) |
| ERA Bench items | 77 (task_id, test_key) pairs |
| Demonstration episodes | 252 |
| Demonstrations per task | 2-10 |
| Test pairs per task | 1-3 |
| Recorded control timesteps | 356,083 |
| Nominal control/camera cadence | 20 Hz |
| Recorded trajectory time | approximately 4.95 hours |
| ARC grid values | integers 0-9 |
| Episode-dataset compression | gzip, level 4 |
Dataset organization
The dataset is stored in arc_embodied.hdf5. The HDF5 file contains:
- raw, episode-centric Isaac Lab recordings under
/data/demo_<n>; - task-centric ARC views under
/data/<task_id>; - natural-language rule annotations under
/rules/<task_id>.
One benchmark item consists of all demonstrations for an ARC task and one test pair. Tasks with multiple test pairs therefore produce multiple items with the same demonstration context.
The dataset contains exactly one raw episode per (task_id, task_pair),
with no duplicate pairs or unreferenced raw episodes. The task views link all
252 demonstration episodes and 77 test episodes.
HDF5 structure
T denotes the number of control timesteps in an episode. Camera streams
contain an initial observation followed by one frame per control timestep.
/
βββ data/
β βββ demo_<global_episode_id>/
β β βββ actions float32 [T, 12]
β β βββ processed_actions float32 [T, 13]
β β βββ high_level_actions/
β β β βββ action_timeline int64 [1, T, 5]
β β βββ obs/
β β β βββ actions float32 [T, 12]
β β β βββ eef_pos float32 [T, 3]
β β β βββ eef_quat float32 [T, 4]
β β β βββ gripper_pos float32 [T, 2]
β β β βββ joint_pos float32 [T, 9]
β β β βββ joint_vel float32 [T, 9]
β β β βββ table_cam uint8 [T+1, 252, 336, 3]
β β β βββ table_cam_depth float32 [T+1, 252, 336, 1]
β β β βββ table_cam_semantic_segmentation uint8 [T+1, 252, 336, 4]
β β β βββ origin_top_cam uint8 [T+1, 256, 352, 3]
β β β βββ wrist_cam uint8 [T+1, 112, 112, 3]
β β β βββ wrist_cam_depth float32 [T+1, 112, 112, 1]
β β β βββ wrist_cam_semantic_segmentation uint8 [T+1, 112, 112, 4]
β β βββ initial_state/
β β β βββ articulation/robot/
β β β β βββ joint_position float32 [1, 9]
β β β β βββ joint_velocity float32 [1, 9]
β β β β βββ root_pose float32 [1, 7]
β β β β βββ root_velocity float32 [1, 6]
β β β βββ rigid_object/<object>/
β β β βββ root_pose float32 [1, 7]
β β β βββ root_velocity float32 [1, 6]
β β βββ states/
β β β βββ articulation/robot/
β β β β βββ joint_position float32 [T, 9]
β β β β βββ joint_velocity float32 [T, 9]
β β β β βββ root_pose float32 [T, 7]
β β β β βββ root_velocity float32 [T, 6]
β β β βββ rigid_object/<object>/
β β β βββ root_pose float32 [T, 7]
β β β βββ root_velocity float32 [T, 6]
β β βββ task_info/
β β βββ task_id uint8 [1, 8]
β β βββ task_pair int64 [1, 1]
β β βββ is_test bool [1]
β βββ <task_id>/
β βββ demo_<n> ββ hard link βββββββββββ> raw episode
β βββ test_<n> ββ hard link βββββββββββ> raw episode
β βββ rule ββ hard link βββββββββββ> /rules/<task_id>
β βββ arc_grids/
β βββ <demo_n or test_n>/
β βββ input_grid int64 [rows, columns]
β βββ output_grid int64 [rows, columns]
βββ rules/
βββ <task_id>/
βββ data scalar UTF-8 JSON
Root groups and attributes
| Location | Meaning |
|---|---|
/data |
Contains both raw episodes and task-centric views. |
/data.attrs["total"] |
Number of raw recorded episodes: 329. |
/data.attrs["env_args"] |
JSON-encoded simulation settings such as timestep, action decimation, render interval, and number of environments. |
/rules |
Contains one rule annotation group per ARC task. |
env_args.sim_args specifies dt=0.01 seconds,
decimation=5, render_interval=5, and num_envs=2. These settings imply
100 Hz physics and 20 Hz control/rendering. The trajectory duration above is
the sum of episode control timesteps divided by 20 Hz, not wall-clock
simulation time. The control-timestep total is the sum of episode
num_samples attributes, not /data.attrs["total"].
Raw episodes
Each /data/demo_<global_episode_id> group is one physical robot trajectory.
Its numeric suffix is a global recording index, not its position within an ARC
task. Episode attributes are:
| Attribute | Meaning |
|---|---|
num_samples |
Number of control samples T. |
success |
Recorder success flag for the episode. |
Actions
| Dataset | Meaning |
|---|---|
actions |
Raw policy/controller action at each timestep. This is a recorder-specific 12-dimensional vector. |
processed_actions |
Action after environment processing, including the actuator-level gripper representation. |
obs/actions |
Action value included in the observation stream. |
high_level_actions/action_timeline |
Stable semantic grasp/place representation used by the embodied benchmark. |
The exact column-level contract for actions and processed_actions is not
stored as HDF5 metadata. Consumers interested in low-level control should use
the original environment action configuration. The semantic action timeline has
the following documented format:
action_timeline[0, t] = [phase, color_id, location_type, row, column]
| Field | Meaning |
|---|---|
phase |
0 no action, 1 grasp, 2 place. |
color_id |
ARC color ID of the manipulated cube; -1 for no action. |
location_type |
0 reserve, 1 output grid, -1 for no action. |
row, column |
Zero-based output-grid position, or -1, -1 for a reserve grasp or no action. (0, 0) is the top-left cell. |
The recorded timeline repeats actions at control rate. Benchmark preprocessing run-length encodes consecutive identical actions and removes phase-0 runs.
ARC color IDs follow the standard mapping:
| ID | Color | ID | Color |
|---|---|---|---|
| 0 | black/background | 5 | gray |
| 1 | blue | 6 | magenta |
| 2 | red | 7 | orange |
| 3 | green | 8 | teal |
| 4 | yellow | 9 | brown |
Observations
Example observations from task 3b4c2228, demonstration 0, using the final
frame in arc_embodied.hdf5. The overhead camera records RGB only. Depth images
are visualized with a turbo color map, normalized separately for each camera;
segmentation images show the assigned class colors.
| Dataset | Meaning |
|---|---|
obs/eef_pos |
End-effector Cartesian position. |
obs/eef_quat |
End-effector orientation quaternion. |
obs/gripper_pos |
Two gripper-finger joint positions. |
obs/joint_pos |
Nine robot joint positions. |
obs/joint_vel |
Velocities for the same robot joints. |
obs/table_cam |
RGB frames from the fixed table/scene camera. |
obs/origin_top_cam |
RGB frames from the fixed overhead camera. |
obs/wrist_cam |
RGB frames from the wrist-mounted camera. |
obs/table_cam_depth |
Table-camera depth frames. |
obs/wrist_cam_depth |
Wrist-camera depth frames. |
obs/table_cam_semantic_segmentation |
Colorized table-camera semantic-segmentation frames. |
obs/wrist_cam_semantic_segmentation |
Colorized wrist-camera semantic-segmentation frames. |
RGB images are channel-last uint8. Depth images are single-channel float32.
Semantic-segmentation images are four-channel uint8 images rather than scalar
class-ID maps.
All 329 episodes have the camera shapes shown above, with T+1 frames per
stream. Resolutions in width Γ height order are 336 Γ 252 for table_cam,
352 Γ 256 for origin_top_cam, and 112 Γ 112 for wrist_cam.
Simulator state
initial_state stores the simulator state immediately after reset. states
stores the same quantities over the trajectory.
| Dataset | Meaning |
|---|---|
articulation/robot/joint_position |
Robot joint positions. |
articulation/robot/joint_velocity |
Robot joint velocities. |
articulation/robot/root_pose |
Robot-root position and quaternion pose. |
articulation/robot/root_velocity |
Robot-root linear and angular velocity. |
rigid_object/<object>/root_pose |
Position and quaternion pose of one scene object. |
rigid_object/<object>/root_velocity |
Linear and angular velocity of one scene object. |
Rigid-object names depend on the scene. They include input-grid cubes and reserve cubes. Black/background ARC cells are represented by the absence of a cube.
Task information
| Dataset | Meaning |
|---|---|
task_info/task_id |
Eight-character ARC task ID stored as ASCII bytes in a uint8 array. |
task_info/task_pair |
Pair index in the ARC task's combined demonstration/test pair sequence. |
task_info/is_test |
Recorder-time indicator that the pair belongs to the task's test examples. |
Task-centric views
Each /data/<task_id> group presents the data in the form expected by ARC and
ERA Bench:
demo_<n>links to a solved demonstration episode;test_<n>links to a test episode;arc_grids/<episode_key>/input_gridstores the canonical ARC input;arc_grids/<episode_key>/output_gridstores the canonical ARC output;rulelinks to the task's rule annotation.
Episode and rule entries are HDF5 hard links. They reference existing objects in
the file instead of copying the large trajectory payloads. The arc_grids
datasets are copied canonical arrays so that evaluation is self-contained and
does not require the original ARC task files.
Rule annotations
/rules/<task_id>/data is a UTF-8 JSON string with this structure:
{
"task_id": "0520fde7",
"inferred_rule": "Natural-language transformation description.",
"task_type": "training",
"reference_claims": [
{
"claim_id": "R1",
"claim": "One supporting claim."
}
]
}
task_type records the task's original ARC training or evaluation
partition. The rule and reference claims are descriptive annotations.
Loading
The file is hierarchical and contains variable-length episodes, so use h5py
rather than treating it as a flat table:
from huggingface_hub import hf_hub_download
import h5py
path = hf_hub_download(
repo_id="nardo7/arc-embodied",
filename="arc_embodied.hdf5",
repo_type="dataset",
)
with h5py.File(path, "r") as dataset:
task_ids = sorted(dataset["rules"].keys())
task = dataset[f"data/{task_ids[0]}"]
demo_keys = sorted(key for key in task if key.startswith("demo_"))
test_keys = sorted(key for key in task if key.startswith("test_"))
demonstration = task[demo_keys[0]]
first_frame = demonstration["obs/table_cam"][0]
action_timeline = demonstration["high_level_actions/action_timeline"][0]
test_input = task[f"arc_grids/{test_keys[0]}/input_grid"][()]
Read camera datasets through slices or selected frame indices to avoid loading a complete episode video into memory.
ERA Bench PyTorch dataset
The ERA Bench Evaluation repository
provides ArcTaskDataset, a PyTorch Dataset that
discovers task-centric views and returns one (task_id, test_key) item at a
time. Run this from the ERA Bench repository after installing its requirements:
from pathlib import Path
from src.datasets import ArcTaskDataset, uniform_frame_indices
from src.vlm_preprocessing import prepare_vlm_task
dataset = ArcTaskDataset(
Path("data/arc_embodied.hdf5"),
expose_test_targets=False,
frame_index_selector=uniform_frame_indices(20),
cameras=("table_cam",),
)
sample = dataset[0]
print(sample.task_id, sample.test_key)
# This is the target-safe input for a VLM: demonstrations plus the first test
# frame and test input grid, without test targets or the test action timeline.
vlm_task = prepare_vlm_task(sample)
expose_test_targets=False hides the canonical test output grid from the
returned test case. Always pass the sample through prepare_vlm_task() before
serializing it into a model prompt; that is the boundary that also removes the
test action timeline and later test frames.
Test-target isolation
The HDF5 file contains complete test trajectories and canonical test outputs so that an evaluator can score predictions. They must not be exposed to a model during evaluation.
For each (task_id, test_key) item, the ERA Bench input contract is:
- all selected demonstration frames, grids, and compressed semantic actions;
- only the selected initial test frame and test input grid;
- no test output grid, later test frames, or test action timeline.
Intended uses
ARC-Embodied supports research on:
- embodied abstract reasoning;
- vision-language understanding of robot demonstrations;
- semantic robot-action prediction;
- ARC grid prediction from multimodal context;
- robot-state, depth, and segmentation analysis;
- offline replay and dataset diagnostics when the original simulator setup is available.
Limitations
- It covers a selected subset of ARC tasks.
Citation
@dataset{arc-embodied,
author = {Alejandro Nardo GonzΓ‘lez},
title = {ARC-Embodied},
year = {2026},
publisher = {Hugging Face},
url = {https://huggingface.co/datasets/nardo7/arc-embodied}
}
License
ARC-Embodied is licensed under Apache-2.0; see LICENSE. It includes canonical
ARC-AGI-1 grids, which are also distributed under Apache-2.0. The dataset was
generated using default NVIDIA Isaac Lab and Isaac Sim components; the dataset
contains generated simulation outputs only, not simulator software, Omniverse
Kit, USD assets, textures, or asset packs. See THIRD_PARTY_NOTICES.md and
PROVENANCE.md for the attribution and provenance records.
- Downloads last month
- 51

