DROID-VP

Dataset Description

DROID-VP is the DROID data that VPM-DROID, the DROID model of the Video-Point Model (VPM), is trained on: three camera views, the raw joint actions and states, the language instruction and the non-idle segments of every episode, the camera calibration and poses of every view and the 3D point tracks of the robot. It is uploaded exactly as the training run reads it. Nothing is re-encoded, re-sampled or filtered beyond what training does.

• 🎥 3 synchronized views per episode: exterior camera 1 (left), exterior camera 2 (right) and the wrist camera, all at 180×320 and 15 fps, stored as JPEG frames
• 🦾 raw 8D actions and states per frame: 7 Franka joint positions (rad) + gripper (0 = open … 1 = closed), not normalized, and the end-effector pose per frame
• 📷 intrinsics and camera-to-robot-base pose of every view on every frame: the exterior cameras are static, the wrist camera moves with the end effector
• 📍 768 metric 3D points on the robot per frame (256 on the Robotiq 2F-85 gripper, 512 on the Franka arm), placed on the robot's CAD model by forward kinematics; point i is the same physical point on every frame and in every view
• 📝 one language instruction per episode
• ✂️ non-idle frame ranges per episode; training windows are sampled only inside them
• 🔢 50,430 training episodes (13.4 M frames per view, 248 h); 17,982 episodes carry point tracks, 13,909 of them (3.1 M training windows) are the point-track training set

Three episodes of the point-track training set, played back to back: exterior 1 (left), exterior 2 (middle) and wrist (right). 128 of the 768 robot points, evenly spread over the arm and gripper, are projected into every view with that frame's camera pose. A point keeps its colour in all three views. Dot size and brightness follow camera depth, and the static cameras show the last 10 frames as trails.

Relation to the original DROID release

Everything comes from the LeRobot conversion of DROID 1.0.1 (lerobot/droid_1.0.1):

Dataset Structure

The layout mirrors the one our training loader reads: a LeRobot-style lerobot/droid_1.0.1/ tree with the frame caches and the point caches, next to tables/ with the episode index, the action, state and pose tables and the camera calibration.

DROID-VP/
├── README.md
├── assets/                      # demo.mp4 and its poster example.png
├── tables/
│   ├── droid/
│   │   ├── meta.json              # fps, camera keys / sizes, joint-table layout and q01/q99 ranges
│   │   ├── tasks.json             # language instruction of every episode (list, episode row order)
│   │   ├── episodes.npz           # episode index, see below
│   │   ├── joint_actions.npy      # (27,630,375, 8) float32
│   │   ├── joint_states.npy       # (27,630,375, 8) float32
│   │   ├── cartesian_states.npy   # (27,630,375, 6) float32 end-effector pose
│   │   └── cameras.npz            # per-episode calibration of the three cameras
│   └── droid_points/
│       ├── meta.json              # point conventions, sources, matching statistics
│       ├── episodes.npz           # per episode: has_points, recommended, wrist id / serial / intrinsics
│       └── ego_id_to_episode_index.csv   # source episode id <-> LeRobot episode_index
├── lerobot/droid_1.0.1/
│   ├── videos/
│   │   ├── observation.images.exterior_1_left/chunk-000/file-NNN.framecache/   # 231 files
│   │   ├── observation.images.exterior_2_left/chunk-000/file-NNN.framecache/   # 230 files
│   │   └── observation.images.wrist_left/chunk-000/file-NNN.framecache/        # 143 files
│   │       ├── frames.bin         # concatenated JPEG bytes, one image per frame
│   │       ├── index.npy          # (N, 2) int64: byte offset, byte length of frame i
│   │       └── meta.json
│   └── points/observation.points.wrist_left/chunk-000/file-NNN.pointcache/    # 143 files
│       ├── index.npy              # (N,) int64: frame i of the chunk video -> row below, -1 = no points
│       ├── gripper.npy            # (n, 256, 3) float32, wrist camera frame
│       ├── robot.npy              # (n, 512, 3) float32, wrist camera frame
│       ├── T_cam_world.npy        # (n, 4, 4) float32, wrist camera_from_world
│       └── meta.json
└── tools/
    ├── frame_cache.py             # frame-cache reader (numpy + Pillow)
    ├── point_cache.py             # point-cache reader (numpy)
    └── read_episode.py            # episode loader: frames, joints, poses, intrinsics, 3D points, projection

Data Format

Conventions: metres, OpenCV camera axes (+x right, +y down, +z forward), world = the DROID robot base frame. A 6D pose is (x, y, z, roll, pitch, yaw) with extrinsic-xyz Euler angles (scipy from_euler("xyz")), as in DROID. Camera j = 0, 1, 2 is exterior 1 (left), exterior 2 (right), wrist (meta.json → camera_keys).

episodes.npz (tables/droid/)

One entry per episode (95,658 rows, row i = LeRobot episode_index i):

key	shape	content
episode_index	(E,) int64	LeRobot episode index
row_start, length	(E,) int64	the episode's rows in joint_actions.npy / joint_states.npy / cartesian_states.npy are row_start … row_start + length − 1; row row_start + k is frame k
dataset_from_index	(E,) int64	global LeRobot frame index of the episode's first frame
keep	(E,) bool	successful, not blacklisted, has a non-idle range
cam_ok	(E, 3) bool	frames of camera j are cached for this episode
cam_chunk, cam_file	(E, 3) int32	frame cache holding the episode: videos/<camera j>/chunk-{cam_chunk:03d}/file-{cam_file:03d}.framecache
cam_base	(E, 3) int64	frame index of the episode's first frame inside that frame cache
range_ep, range_start, range_end	(R,) int64	non-idle ranges: episode row and [start, end) episode-relative frames

Actions, states and end-effector pose

file	shape	content
joint_actions.npy	(N, 8) float32	LeRobot action: commanded absolute joint positions joint_0 … joint_6 (rad) + gripper (0 = open … 1 = closed)
joint_states.npy	(N, 8) float32	LeRobot observation.state: measured joint positions + gripper position, same layout
cartesian_states.npy	(N, 6) float32	LeRobot observation.state.cartesian_position: end-effector pose in the robot base frame (6D pose)

cameras.npz (tables/droid/)

One entry per episode row, cameras in the order above:

key	shape	content
extrinsics6	(E, 3, 6) float64	camera-to-world pose of the left ZED lens (6D pose). Wrist: its pose at frame 0
extrinsics_src	(E, 3) int8	exterior calibration source: 0 = DROID-VP, 1 = KarlP/droid, 2 = original DROID (always 2 for the wrist)
extrinsics6_raw	(E, 3, 6) float64	the original DROID calibration, for reference
intrinsics_hd	(E, 3, 4) float64	fx, fy, cx, cy in pixels at intrinsics_wh = 1280×720; scale by 320/1280 and 180/720 for the stored frames
intrinsics_src	(E, 3) int8	0 = the camera's own serial, 1 = the collector's most frequent serial for that slot, 2 = median over serials of that camera kind
serial	(E, 3) int64	camera serial whose intrinsics are used (0 for source 2)
slots, intrinsics_wh		camera keys; [1280, 720]

The wrist camera on frame t is c2w(t) = eef(t) · eef(0)⁻¹ · c2w(0), with eef the 4×4 end-effector pose from cartesian_states.npy.

Point tracks

tables/droid_points/episodes.npz, one entry per episode row:

key	shape	content
has_points	(E,) bool	the episode has point tracks in the point source (23,126 episodes); the 17,982 of them whose wrist frames are included (cam_ok[:, 2]) have their point caches here
recommended	(E,) bool	passes the point source's quality filter (use by default)
ego_id	(E,) str	source episode id, LAB+uuid+YYYY-MM-DD-HHh-MMm-SSs
ego_serial	(E,) str	wrist camera serial
ego_K	(E, 3, 3) float32	wrist intrinsics of DROID's rectified calibration at 180×320 (NaN when DROID has none)

The point caches use the frame numbering of the wrist frame cache of the same file: episode row r, frame k is frame cam_base[r, 2] + k of points/observation.points.wrist_left/chunk-{cam_chunk[r,2]:03d}/file-{cam_file[r,2]:03d}.pointcache, and index.npy at that frame gives the row in gripper.npy, robot.npy and T_cam_world.npy (−1 = no points on that frame). A point in the robot base frame is inv(T_cam_world) · p_cam. Gripper indices 0–139 lie on the rigid gripper base, the rest on the moving fingers.

Frame caches

Frame i of a .framecache is the i-th frame of the original concatenated LeRobot chunk video. Episode frame k of camera j is frame cam_base[ep, j] + k of the episode's frame cache. All frames are 180×320 RGB JPEGs (quality 90).

Usage

hf download rooty2020/DROID-VP --repo-type dataset --local-dir DROID-VP      # ~1.03 TB
cd DROID-VP
python tools/read_episode.py --root . --list 5 --with-points               # episodes with point tracks
python tools/read_episode.py --root . --row 53978 --points --out ep.mp4    # 3 views + projected robot points (needs imageio[ffmpeg])

import sys; sys.path.insert(0, "DROID-VP/tools")
from read_episode import DroidVP

ds = DroidVP("DROID-VP")
rows = ds.point_training_rows()              # the 13,909 point-track training episodes
r = rows[0]
actions, states = ds.joints(r)               # (L, 8) each, frame-aligned
instruction = ds.tasks[r]
frames = [ds.frame(r, j, k=0) for j in range(3)]   # exterior 1, exterior 2, wrist; (180, 320, 3) uint8 each
eef = ds.eef_pose(r)                         # (L, 4, 4) end-effector pose, robot base frame
c2w = ds.camera_c2w(r, 2)                    # (L, 4, 4) wrist camera-to-base pose per frame
K = ds.intrinsics(r, 0)                      # (3, 3) pixel intrinsics of exterior 1 at 180x320
X, has = ds.points(r)                        # (L, 768, 3) robot points in the base frame; has: frames with points
uv, depth, in_view = ds.project(r, 0)        # pixels in exterior 1, depth (m), visibility test as in training

The caches can also be read without the helpers: index.npy[i] of a frame cache gives the byte offset and length of frame i in frames.bin, and those bytes decode as a JPEG; the point caches are plain .npy arrays.

Statistics

Episodes (training set)	50,430 (of 95,658 in DROID 1.0.1); 13,401,413 frames per view (248.2 h at 15 fps)
Episodes with point tracks	17,982 with frames in this release (23,126 in the point source); 15,641 in the training set
Point-track training set	13,909 episodes, 3,764,106 frames (69.7 h), 3,122,260 windows
Point frames	4,828,903 (768 points each: 256 gripper + 512 arm)
Exterior calibration, training set	DROID-VP 18,616 · KarlP/droid 7,125 / 7,655 · original 24,689 / 24,159 episodes (exterior 1 / exterior 2)
Exterior calibration, point-track training set	DROID-VP 13,759 · KarlP/droid 150
Views	exterior 1, exterior 2, wrist; 180×320 JPEG (q90), 15 fps
Action / state	8D raw joint positions + gripper, 27,630,375 rows (all episodes)
Robot	Franka Panda + Robotiq 2F-85
Size	1.03 TB (frame caches 982 GB, point caches 45 GB, episode / action / camera cache 2.5 GB)

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, through its LeRobot conversion lerobot/droid_1.0.1. The post-release exterior calibration comes from KarlP/droid by the DROID authors.

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

Citation

If you use this dataset, please cite the original DROID paper and the VPM paper.

@article{jeon2026vpm,
  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.28594},
  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}
}

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.