RoboCasa-VP

Dataset Description

RoboCasa-VP is a modified version of the RoboCasa kitchen manipulation datasets, created as part of the Video-Point Model (VPM) project (paper · project page · code).

It covers the human demonstrations of the 235 composite tasks in the pretraining split of RoboCasa365. Every episode is cut into language-annotated subtask clips, and every clip comes with three calibrated views and persistent, metric 3D point trajectories of the robot arm, the gripper and every manipulated object, read directly from the simulator state.

• 🎥 3 synchronized views per clip: left and right base-mounted cameras and the wrist camera (256×256, 20 fps)
• 📍 768 persistent 3D surface points per frame on the robot (512 arm + 256 gripper) and 256 per manipulated object, metric, in the camera frame
• 📷 intrinsics and per-frame extrinsics of every camera (the cameras ride the mobile base)
• 📝 a subtask instruction per clip

Two RoboCasa episodes, each played through four consecutive subtask clips. 128 arm and gripper points and 40 points per manipulated object (white rim) are projected onto the left, right and wrist cameras; dot size and brightness follow camera depth, and trails show the last 10 frames (not drawn for the moving wrist camera).

Key Modifications

Compared to the original RoboCasa datasets:

1. Subtask segmentation: each composite-task episode is split along time into its subtasks (2–32 per episode), each with its own instruction (e.g. "Grasp the coffee cup"). The clips of an episode tile it exactly: no gaps, no overlap, and concatenating them gives back the original point arrays and extrinsics bit for bit.
2. Ground-truth 3D point trajectories of the arm, the gripper and the manipulated objects (see 3D Point Trajectory Curation).
3. Camera calibration: pinhole intrinsics and world-to-camera extrinsics of every view. The two agent-view cameras are mounted on the robot's mobile base, so when the base drives their extrinsics are stored per frame.
4. Per-clip video: the three views are cut per clip and encoded with H.264 (libx264, CRF 18, visually lossless).

3D Point Trajectory Curation

The goal is metric, temporally consistent 3D trajectories of the action-relevant geometry over the whole episode (Appendix B.2 of the paper).

3D point extraction. We start from the visual meshes of every robot link and of the manipulated objects. Surface points are drawn on each mesh by area-weighted triangle sampling, once, in the mesh-local frame, with a fixed random seed; the same points are reused for the whole episode. A fixed point budget goes to each action-relevant component: 512 points on the Franka Panda arm (robot0_link0..7), 256 points on the Panda gripper, and 256 points on each manipulated object. Within a component made of several meshes the budget is split roughly in proportion to mesh surface area. A point $p^{\ell}_i$ sampled on body $\ell$ is placed in the world at time $t$ by the body pose,

$$p_{i,t}^w=R_{\mathrm{\ell },t}^w{p}_i^{\mathrm{\ell }}+t_{\mathrm{\ell },t}^w\mathrm{.}p^\{w\}\_\{i,t\}\; =\; R^\{w\}\_\{\backslash ell,t\}\backslash ,\; p^\{\backslash ell\}\_i\; +\; t^\{w\}\_\{\backslash ell,t\}.$$

Because $p^{\ell}i$ is fixed, point $i$ is the same physical surface location in every frame, and the trajectories carry no resampling noise. In simulation the poses $(R^{w}{\ell,t}, t^{w}_{\ell,t})$ need no estimation: we replay the recorded simulator states in the episode's own MuJoCo model and query the per-frame pose of every mesh geom, object and camera directly (geom_xpos / geom_xmat).

Manipulated objects. Objects are selected deterministically from the simulator state: an object is included if its body moves more than 5 cm during the episode. Receptacles that things are placed into (pans, plates, containers) and distractors stay still and are excluded. Multi-object tasks get one file per moved object (object.npz, object2.npz, …); fixture-only tasks (opening doors, turning knobs) have none.

Camera-frame trajectories and projection. World trajectories are moved into each camera with its world-to-camera extrinsics, $p^{c}_{i,t} = R^{c\leftarrow w}t, p^{w}{i,t} + t^{c\leftarrow w}_t$. Point identities are unchanged by this transformation, so the data gives explicit correspondences across time and across viewpoints.

Filtering. The calibration filter that the paper applies to real-robot data (projected CAD mask vs. SAM 2 mask) is not needed here: cameras, robot and objects all come from the same simulator state.

Output representation. Each sample holds synchronized multi-view RGB, the persistent 3D surface-point trajectories of the arm, gripper and manipulated objects, and all camera metadata needed to reproduce the image-space projections, including per-frame extrinsics. Each point index refers to the same physical surface location across time and across camera views.

Dataset Structure

RoboCasa-VP/
├── README.md
├── assets/                       # demo.mp4 and its poster example.png
├── manifest.json                 # every episode -> shard, task, its clips, frame ranges, instructions
├── data/
│   ├── robocasa_vp-000.tar       # 21 shards
│   ├── ...
│   └── robocasa_vp-020.tar
└── tools/
    ├── visualize_sample.py       # re-projects all 3D points onto the videos (calibration check)
    └── render_demo.py            # renders demo videos like the one above

Each shard holds whole episodes. An episode directory (<Task>Pretrain_ep<NNNNNN>) has one sub-directory per subtask clip:

DeliverBrewedCoffeePretrain_ep000096/
├── subtask_00/
│   ├── view1.mp4        # robot0_agentview_left, 256x256, 20 fps
│   ├── view2.mp4        # robot0_agentview_right, 256x256, 20 fps
│   ├── ego.mp4          # robot0_eye_in_hand (wrist), 256x256, 20 fps
│   ├── robot.npz        # points: (T, 512, 3) float32
│   ├── gripper.npz      # points: (T, 256, 3) float32
│   ├── object.npz       # points: (T, 256, 3) float32, one file per manipulated object
│   └── meta.json
├── subtask_01/
└── ...

Every subtask_XX/ is a self-contained sample. T is the clip length (meta.json → n_frames), and frame t of the videos, the point arrays and the per-frame extrinsics is the same instant.

Data Format

Point tracks

file	key	shape	dtype	content
robot.npz	points	(T, 512, 3)	float32	Franka Panda arm surface points (robot0_link0..7, no gripper)
gripper.npz	points	(T, 256, 3)	float32	Panda gripper surface points, fingers included
object.npz, object2.npz, …	points	(T, 256, 3)	float32	surface points of each manipulated object (0–7 files per clip)

All points are in meters, in the view1 camera frame of the same frame (OpenCV convention: +x right, +y down, +z forward). The point order is fixed, so points[:, i] is one trajectory.

meta.json

field	content
id	<episode>/subtask_XX
sample_id, task, task_category, episode	episode name, RoboCasa task, task, demo index
lang, language_instructions	subtask instruction
robot_type	PandaOmron (Franka Panda on an Omron mobile base)
fps, n_frames, n_video_frames	20, clip length T, frames per video
extrinsics_convention	"cam_from_world"
views.<view>.camera	robosuite camera name
views.<view>.intrinsics	fx, fy, cx, cy, width, height (pinhole from the camera field of view, no distortion)
views.<view>.T_cam_world	world-to-camera matrix, p_cam = T_cam_world @ [p_world; 1]: 4×4 for view1/view2 (the clip's first frame), (T, 4, 4) for the wrist camera ego
views.<view>.T_cam_world_perframe	(T, 4, 4) per-frame extrinsics of view1/view2, present when the base moves during the episode
views.<view>.max_base_drift_m, static	largest camera displacement within the clip, and whether it is below 1 cm
camera_moves, max_base_displacement_m	whether the base-mounted cameras move more than 1 cm within the clip
object	n_manipulated, manipulated (cfg, category, file, max_disp_m of each object file), the selection rule and the displacement of every object
points	description and shape of each point file
subtask	index, n_subtasks, instruction, frame_range ([start, end) in the original episode), orig_id, orig_n_frames, annotation_source
provenance	method used to build the trajectories

Projecting the points into a view

import json, numpy as np

d = "DeliverBrewedCoffeePretrain_ep000096/subtask_01"
meta = json.load(open(f"{d}/meta.json"))
pts = np.concatenate([np.load(f"{d}/{f}.npz")["points"] for f in ("robot", "gripper", "object")], axis=1)

def view_T(v, t):
    m = meta["views"][v]
    T = np.asarray(m.get("T_cam_world_perframe", m["T_cam_world"]))
    return T if T.ndim == 2 else T[t]                          # (T, 4, 4) when the camera moves

t, v = 0, "ego"
T = view_T(v, t) @ np.linalg.inv(view_T("view1", t))           # view1 camera (frame t) -> camera v (frame t)
intr = meta["views"][v]["intrinsics"]
p = pts[t] @ T[:3, :3].T + T[:3, 3]
uv = np.stack([intr["fx"] * p[:, 0] / p[:, 2] + intr["cx"],
               intr["fy"] * p[:, 1] / p[:, 2] + intr["cy"]], 1)  # pixels, valid where p[:, 2] > 0

tools/visualize_sample.py <clip_dir> --out vis.mp4 renders all views with the projected points.

Statistics

Episodes	24,504
Tasks	235 composite tasks (mostly 100–110 demonstrations each)
Subtask clips	217,594
Clips per episode	2–32 (median 8, mean 8.9)
Frames	27,410,478 per view (380.7 h at 20 fps)
Clip length	20–2,260 frames (median 100 = 5 s, mean 126, 10th–90th percentile 40–240)
Views	3 (left and right agent views, wrist), 256×256, 20 fps
3D points per frame	768 on the robot (512 arm + 256 gripper) + 256 per manipulated object
Manipulated objects per clip	0: 3,222 · 1: 40,896 · 2: 92,694 · 3: 53,292 · 4: 22,162 · 5: 1,398 · 6: 3,798 · 7: 132
Clips with a moving base (> 1 cm)	68,659 (31.6%, from 14,913 episodes)
Unique subtask instructions	2,004
Robot	Franka Panda on an Omron mobile base (simulated, robosuite / MuJoCo)
Size	487 GB (videos 104 GB, point tracks 363 GB) in 21 tar shards

Usage

# everything
hf download rooty2020/RoboCasa-VP --repo-type dataset --local-dir RoboCasa-VP
# or one shard
hf download rooty2020/RoboCasa-VP --repo-type dataset --local-dir RoboCasa-VP --include "data/robocasa_vp-000.tar" "manifest.json"

cd RoboCasa-VP && mkdir -p extracted && for t in data/*.tar; do tar -xf "$t" -C extracted; done
python tools/visualize_sample.py extracted/DeliverBrewedCoffeePretrain_ep000096/subtask_01 --out vis.mp4
python tools/render_demo.py extracted/<episode>/subtask_0[0-3] --out demo.mp4   # consecutive clips play back to back; needs av, matplotlib

manifest.json lists every episode with its shard, task, clips, frame ranges and instructions, plus the size and SHA-256 of every shard. Rebuild the arrays of a whole episode by concatenating its clips in order:

import glob, numpy as np
clips = sorted(glob.glob("extracted/<episode>/subtask_*"))
robot = np.concatenate([np.load(f"{c}/robot.npz")["points"] for c in clips])   # == full-episode trajectory

Original RoboCasa Dataset

RoboCasa-VP is derived from the RoboCasa simulation framework and its RoboCasa365 human demonstrations:

• Paper: RoboCasa365: A Large-Scale Simulation Framework for Training and Benchmarking Generalist Robots
• Repository: https://github.com/robocasa/robocasa
• License: assets and datasets CC BY 4.0, code MIT

Subtask boundaries and instructions come from happyhappy-jun/episode_subtask_annotations_x2_parallel.

Citation

If you use this dataset, please cite both the RoboCasa365 paper and the VPM paper.

@article{vpm2026,
  title   = {Learning the 4D World through Point Trajectory Forecasting},
  author  = {Jeon, Byungwoo and Hong, Sunghwan and Kim, Dohyeon and Lee, Jonghoon and Park, Jungwoo and Lee, Inhee and
             Baek, Doosan and Kim, Jinil and Lim, Taehyun and Joo, Hanbyul and Pollefeys, Marc and Xie, Saining and
             Shin, Jinwoo},
  journal = {arXiv preprint arXiv:2610.06940},
  year    = {2026}
}

@inproceedings{robocasa365,
  title     = {RoboCasa365: A Large-Scale Simulation Framework for Training and Benchmarking Generalist Robots},
  author    = {Soroush Nasiriany and Sepehr Nasiriany and Abhiram Maddukuri and Yuke Zhu},
  booktitle = {International Conference on Learning Representations (ICLR)},
  year      = {2026}
}

License

RoboCasa-VP is released under the Creative Commons Attribution 4.0 International (CC BY 4.0) license, the license of the original RoboCasa datasets.