DROID-VP

Dataset Description

DROID-VP is a modified version of the DROID dataset, created as part of the Video-Point Model (VPM) project (paper · project page · code). It is the real-robot manipulation data VPM is trained on.

Every DROID episode is cut into language-annotated subtask clips, and every clip comes with calibrated two-view RGB video and persistent, metric 3D point trajectories of the Franka Panda arm and the Robotiq 2F-85 gripper. The trajectories are not pseudo-labels from a visual point tracker: they are computed from the robot's CAD geometry and its recorded joint states, so each point keeps the same physical identity over time and across the two cameras.

• 🎥 2 synchronized exterior views per clip (1280×720, 15 fps)
• 📍 768 persistent 3D surface points per frame (512 arm + 256 gripper), metric, in the camera frame
• 📷 intrinsics, distortion and extrinsics of both cameras
• 📝 a subtask instruction, a primitive-skill label and the whole-episode instruction per clip

Three DROID episodes, each played through all of its subtask clips. 128 of the 768 arm and gripper points (evenly spread over the robot) are projected onto both views with the stored calibration; dot size and brightness follow camera depth, and trails show the last 10 frames.

Key Modifications

Compared to the original DROID release:

1. Subtask segmentation: each episode is split along time into its subtasks using the RoboInter-Data annotations. A clip carries its own instruction (e.g. "place the blue object in the drawer") and one of 15 primitive-skill labels. The clips of an episode tile it exactly: no gaps, no overlap, and concatenating them gives back the original point arrays bit for bit.
2. Kinematics-grounded 3D point trajectories of the arm and gripper for every frame (see 3D Point Trajectory Curation).
3. Calibration filtering: an episode is kept only if its projected robot CAD model agrees with the robot seen in the image (CAD-mask recall ≥ 0.9 against a SAM2 mask).
4. Success-only, language-annotated episodes: only episodes that DROID labels as successful and that have a language instruction are included.
5. Per-clip video: the two exterior views (left image of each ZED 2 camera) are cut per clip and re-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 CAD (visual) meshes of every robot link, with calibrated cameras and a known transformation between the robot base and each camera. 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 component: 512 points on the Franka Panda arm (links 0–7) and 256 points on the Robotiq 2F-85 gripper (including the fingers). 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 link $\ell$ is placed in the world at time $t$ by the link pose,

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

where the link pose $(R^{w}{\ell,t}, t^{w}{\ell,t})$ comes from forward kinematics of the recorded joint configuration. Because $p^{\ell}_i$ is fixed, point $i$ is the same physical surface location in every frame, and the trajectories carry no resampling noise. The world frame is the DROID robot base.

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. DROID cameras form a static rig, so one extrinsic matrix per camera holds for every frame.

Calibration filtering. Even small errors in the camera extrinsics or in the robot base pose cause a visible offset between the projected CAD model and the robot in the image, so we validate every real episode before keeping it. Using the recorded joint configuration and the calibration, we render the robot CAD model into every frame, which gives a binary mask $M^{\mathrm{CAD}}_t$. We pick the frame where the projected robot is largest,

$$t^{\star }=\arg \underset{t}{\max }\mid M_t^{\mathrm{C}\mathrm{A}\mathrm{D}}\mid ,t^\{\backslash star\}\; =\; \backslash arg\backslash max\_t\; \backslash left|\; M^\{\backslash mathrm\{CAD\}\}\_t\; \backslash right|,$$

because a large robot region is the least sensitive to small masks, truncation and weak overlap. On that frame we obtain an image-based robot mask $M^{\mathrm{SAM}}_{t^\star}$ with SAM 2 and compute the CAD-mask recall

$${\mathrm{R}\mathrm{e}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{l}}_{\mathrm{C}\mathrm{A}\mathrm{D}}=\frac{\mid M_{t^{\star }}^{\mathrm{C}\mathrm{A}\mathrm{D}}\cap M_{t^{\star }}^{\mathrm{S}\mathrm{A}\mathrm{M}}\mid }{\mid M_{t^{\star }}^{\mathrm{C}\mathrm{A}\mathrm{D}}\mid },\backslash mathrm\{Recall\}\_\{\backslash mathrm\{CAD\}\}\; =\; \backslash frac\{\backslash left|\; M^\{\backslash mathrm\{CAD\}\}\_\{t^\backslash star\}\; \backslash cap\; M^\{\backslash mathrm\{SAM\}\}\_\{t^\backslash star\}\; \backslash right|\}\{\backslash left|\; M^\{\backslash mathrm\{CAD\}\}\_\{t^\backslash star\}\; \backslash right|\},$$

the fraction of the geometry predicted by the calibrated robot model that the image supports. Episodes with a recall below 0.9 are discarded. Recall is used instead of a symmetric overlap score because the SAM 2 mask can include non-robot regions or merge the robot with nearby objects; what matters is that the geometry used for the 3D supervision lands on the robot seen in the image.

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

Dataset Structure

DROID-VP/
├── README.md
├── assets/                       # demo.mp4 and its poster example.png
├── manifest.json                 # every episode -> shard, its clips, frame ranges, instructions, skills
├── data/
│   ├── droid_vp-000.tar          # 12 shards, ~29.5 GB each (the last one ~2.4 GB)
│   ├── ...
│   └── droid_vp-011.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, named by its DROID id (<lab>+<hash>+<timestamp>), has one sub-directory per subtask clip:

AUTOLab+0d4edc83+2023-10-21-19h-02m-35s/
├── subtask_00/
│   ├── view1.mp4        # exterior camera 1, 1280x720, 15 fps, H.264
│   ├── view2.mp4        # exterior camera 2, 1280x720, 15 fps, H.264
│   ├── robot.npz        # points: (T, 512, 3) float32
│   ├── gripper.npz      # points: (T, 256, 3) float32
│   └── meta.json
├── subtask_01/
└── subtask_02/

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

Data Format

Point tracks (robot.npz, gripper.npz)

file	key	shape	dtype	content
robot.npz	points	(T, 512, 3)	float32	Franka Panda arm surface points (links 0–7, no gripper)
gripper.npz	points	(T, 256, 3)	float32	Robotiq 2F-85 surface points, fingers included

All points are in meters, in the view1 camera 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 id>/subtask_XX
uuid	DROID episode id
scene_path	location of the episode in the raw DROID 1.0.1 release
lang, language_instructions	subtask instruction
instruction_add	instruction of the whole episode
primitive_skill	one of 15 skills (pick, transfer, place, push, press, pull, slide, fold, manipulate, pour, throw, twist, insert, shake, strike)
task_category	DROID task description of the episode
success, success_source	always true (success episodes only)
fps, n_frames	15, clip length T
extrinsics_convention	"cam_from_world"
views.<view>.intrinsics	fx, fy, cx, cy, distortion k1, k2, p1, p2, k3, width, height (ZED factory calibration of the left image)
views.<view>.T_cam_world	4×4 world-to-camera matrix, p_cam = T_cam_world @ [p_world; 1]; world = DROID robot base
views.<view>.serial	ZED camera serial
points	description and shape of each point file
subtask	subtask_idx, n_subtasks, frame_range ([start, end) in the original episode), orig_id, orig_n_frames, RoboInter provenance (roboint_index, roboint_key, annotation_source)

The videos are the raw (distorted) camera images, so apply the distortion coefficients when projecting.

Projecting the points into a view

import json, numpy as np, cv2

d = "AUTOLab+0d4edc83+2023-10-21-19h-02m-35s/subtask_00"
meta = json.load(open(f"{d}/meta.json"))
pts = np.concatenate([np.load(f"{d}/gripper.npz")["points"],
                      np.load(f"{d}/robot.npz")["points"]], axis=1)          # (T, 768, 3), view1 camera frame

def view_T(v):
    return np.asarray(meta["views"][v]["T_cam_world"])                       # 4x4, cam_from_world

world_from_v1 = np.linalg.inv(view_T("view1"))
for v in ("view1", "view2"):
    T = view_T(v) @ world_from_v1                                             # view1 camera -> camera v
    intr = meta["views"][v]["intrinsics"]
    K = np.array([[intr["fx"], 0, intr["cx"]], [0, intr["fy"], intr["cy"]], [0, 0, 1]])
    dist = np.array([intr[k] for k in ("k1", "k2", "p1", "p2", "k3")])
    p_cam = pts[0] @ T[:3, :3].T + T[:3, 3]                                   # frame 0
    uv, _ = cv2.projectPoints(p_cam, np.zeros(3), np.zeros(3), K, dist)      # (768, 1, 2) pixels

tools/visualize_sample.py <sample_dir> --out vis.mp4 renders all views with the projected points (it skips points far outside the image before applying the distortion model).

Statistics

Episodes	28,308
Subtask clips	89,312
Clips per episode	1–39 (median 3, mean 3.16)
Frames	7,655,477 per view (141.8 h at 15 fps)
Clip length	2–2,463 frames (median 64 ≈ 4.3 s, mean 85.7, 10th–90th percentile 20–172)
Views	2 exterior cameras, 1280×720, 15 fps
3D points per frame	768 (512 arm + 256 gripper)
Unique subtask instructions	50,944
Robot	Franka Panda + Robotiq 2F-85
Labs	13 (TRI 9,105 · AUTOLab 3,555 · IPRL 2,473 · RAIL 2,286 · IRIS 2,083 · CLVR 1,892 · REAL 1,626 · PennPAL 1,223 · RPL 1,093 · ILIAD 1,038 · GuptaLab 933 · WEIRD 699 · RAD 302 episodes)
Size	327 GB in 12 tar shards (videos 270 GB, point tracks 57 GB)

Primitive skills (clips): pick 26,195 · transfer 25,000 · place 24,379 · push 3,116 · press 2,356 · pull 2,045 · slide 1,253 · fold 1,183 · manipulate 1,160 · pour 1,023 · throw 698 · twist 672 · insert 153 · shake 57 · strike 22.

Some subtasks are very short (10% of clips have ≤ 20 frames). VPM trains on clips of at least 33 frames.

Usage

# everything (~327 GB)
hf download rooty2020/DROID-VP --repo-type dataset --local-dir DROID-VP
# or one shard
hf download rooty2020/DROID-VP --repo-type dataset --local-dir DROID-VP --include "data/droid_vp-000.tar" "manifest.json"

cd DROID-VP && mkdir -p extracted && for t in data/*.tar; do tar -xf "$t" -C extracted; done
python tools/visualize_sample.py "extracted/AUTOLab+0d4edc83+2023-10-21-19h-02m-35s/subtask_00" --out vis.mp4
python tools/render_demo.py extracted/<episode_id>/subtask_* --out demo.mp4 --height 360   # needs av, matplotlib

manifest.json lists every episode with its shard, its clips, their frame ranges, instructions and skills, plus the size and SHA-256 of every shard, so the data can be indexed without extracting it. Rebuild the point arrays of a whole episode by concatenating its clips in order:

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

Original DROID Dataset

DROID-VP is derived from DROID, a large in-the-wild robot manipulation dataset collected with Franka Panda robots across 13 institutions:

• Paper: DROID: A Large-Scale In-The-Wild Robot Manipulation Dataset
• Website: https://droid-dataset.github.io/
• License: CC BY 4.0

The language instructions come from DROID's language annotations. Subtask boundaries, subtask instructions and primitive-skill labels come from RoboInter-Data (Annotation_pure), joined to DROID on the episode id.

Citation

If you use this dataset, please cite both the original DROID paper and the VPM paper. If you use the subtask annotations, please also cite RoboInter.

@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}
}

@article{khazatsky2024droid,
  title   = {DROID: A Large-Scale In-The-Wild Robot Manipulation Dataset},
  author  = {Alexander Khazatsky and Karl Pertsch and Suraj Nair and Ashwin Balakrishna and Sudeep Dasari and Siddharth Karamcheti and Soroush Nasiriany and Mohan Kumar Srirama and Lawrence Yunliang Chen and Kirsty Ellis and Peter David Fagan and Joey Hejna and Masha Itkina and Marion Lepert and Yecheng Jason Ma and Patrick Tree Miller and Jimmy Wu and Suneel Belkhale and Shivin Dass and Huy Ha and Arhan Jain and Abraham Lee and Youngwoon Lee and Marius Memmel and Sungjae Park and Ilija Radosavovic and Kaiyuan Wang and Albert Zhan and Kevin Black and Cheng Chi and Kyle Beltran Hatch and Shan Lin and Jingpei Lu and Jean Mercat and Abdul Rehman and Pannag R Sanketi and Archit Sharma and Cody Simpson and Quan Vuong and Homer Rich Walke and Blake Wulfe and Ted Xiao and Jonathan Heewon Yang and Arefeh Yavary and Tony Z. Zhao and Christopher Agia and Rohan Baijal and Mateo Guaman Castro and Daphne Chen and Qiuyu Chen and Trinity Chung and Jaimyn Drake and Ethan Paul Foster and Jensen Gao and Vitor Guizilini and David Antonio Herrera and Minho Heo and Kyle Hsu and Jiaheng Hu and Muhammad Zubair Irshad and Donovon Jackson and Charlotte Le and Yunshuang Li and Kevin Lin and Roy Lin and Zehan Ma and Abhiram Maddukuri and Suvir Mirchandani and Daniel Morton and Tony Nguyen and Abigail O'Neill and Rosario Scalise and Derick Seale and Victor Son and Stephen Tian and Emi Tran and Andrew E. Wang and Yilin Wu and Annie Xie and Jingyun Yang and Patrick Yin and Yunchu Zhang and Osbert Bastani and Glen Berseth and Jeannette Bohg and Ken Goldberg and Abhinav Gupta and Abhishek Gupta and Dinesh Jayaraman and Joseph J Lim and Jitendra Malik and Roberto Martín-Martín and Subramanian Ramamoorthy and Dorsa Sadigh and Shuran Song and Jiajun Wu and Michael C. Yip and Yuke Zhu and Thomas Kollar and Sergey Levine and Chelsea Finn},
  journal = {arXiv preprint arXiv:2403.12945},
  year    = {2024}
}

@article{li2026robointer,
  title   = {RoboInter: A Holistic Intermediate Representation Suite Towards Robotic Manipulation},
  author  = {Li, Hao and Wang, Ziqin and Ding, Zi-han and Yang, Shuai and Chen, Yilun and Tian, Yang and Hu, Xiaolin and
             Wang, Tai and Lin, Dahua and Zhao, Feng and others},
  journal = {arXiv preprint arXiv:2602.09973},
  year    = {2026}
}

License

DROID-VP is released under the Creative Commons Attribution 4.0 International (CC BY 4.0) license, the license of the original DROID dataset. The subtask annotations are taken from RoboInter-Data; please also follow its terms.