Dataset Viewer
Auto-converted to Parquet Duplicate
Search is not available for this dataset
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.

Final table-camera frames for all demonstrations of three ARC-Embodied tasks

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

RGB, depth, and semantic segmentation observations from the overhead, table, and wrist cameras

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_grid stores the canonical ARC input;
  • arc_grids/<episode_key>/output_grid stores the canonical ARC output;
  • rule links 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