This repository contains annotations only — Parquet tables of hand keypoints, camera parameters and poses, language instructions and arm masks. It contains no Ego4D imagery, and none may be published: the Ego4D Dataset License Agreement permits distributing annotations but forbids any portion of the source data appearing in any dataset or product.

You must obtain the source video yourself under your own Ego4D licence; we cannot sublicense it.

The annotations themselves are CC BY 4.0. The Ego4D Dataset License Agreement leaves the End User's intellectual property in derived annotations with the End User, for "academic, commercial, or noncommercial purposes", so these tables are ours to license and commercial use of them is permitted. Every prohibition in that agreement attaches to the Database — the video — which is why no pixels are here and why you still need your own agreement.

Your username, email address and the fields below are collected solely to administer access to this dataset and to evidence acceptance of these terms. They may be provided in aggregate to the licensors of the material for the purpose of verifying compliance.

HuRo-Ego4D

Robotization annotations for the Ego4D share of the HuRo dataset — 103,077 segments, 15,215,821 frames, 140.9 hours, 29.1 GiB. No video.

Per frame: camera intrinsics and metric-scaled poses, hand detections and 3D reconstructions, human-arm segmentation masks, per-segment language instructions, and the retargeted Allex joint trajectories.

Produced by the HuRo robotization pipeline. Paper: arXiv:2609.10706 · Project page: 3587jjh.github.io/HuRo

What's in this repository

The repository name says which corpus this came from, not what is inside. What is here:


Human annotation tables	✅ `clips_chunked/original/annot/` — one Parquet table per segment, robot-independent
Arm-removed video	❌ — the Ego4D agreement forbids any source pixel appearing in a dataset. Rebuild it with stage 7 from your own copy
Robot trajectory tables	✅ ALLEX — `clips_chunked/allex/annot/`
Unmodified source frames	❌ never — download Ego4D under your own licence yourself, and `tools/prepare_segments.py` cuts it to these segments
Robot-rendered frames	❌ never — the ALLEX meshes are evaluation-only. Stage 9 renders them on your machine
Robot trees are keyed by robot name, so a second robot arrives as a sibling of `allex/` and
nothing above it changes. ALLEX is the only one published so far.

Licences differ by file class — see Licence.

What you can do with this

The human annotations are robot-independent — stages 1 to 7 of the pipeline never see a robot. So one download serves three quite different uses:

You want	You need	Stages you run
Hand and camera annotations for 136 hours of egocentric video	this repo	none
Robotize onto your own robot	this repo + your Ego4D videos	7 → 8 → 9 → 10
Reproduce the paper's Allex episodes	this repo + your Ego4D videos	7 → 9 → 10

The second row is the interesting one. Because the arm_mask column is included, you skip the entire annotation half of the pipeline — camera calibration, hand detection and 3D reconstruction, SLAM, person segmentation, VLM captioning — and go straight to inpainting and rendering your robot. Adding a robot needs one YAML file and a URDF, no code change. See Robotizing onto your own robot.

Read this first

Access is gated. Accept the terms on the dataset page and access is granted automatically. You are asked to confirm that you hold your own Ego4D licence; see Licence for the rest.
No .mp4 files are included. The source video is Ego4D's and cannot be redistributed. The Ego4D Dataset License Agreement permits distributing annotations to its images and videos; it does not permit any portion of the video appearing in another dataset. Apply for Ego4D yourself and bring your own copy.
These are pipeline pseudo-labels, not ground truth. Camera poses, hand poses and instructions are all estimated from the video. Use them for pre-training, not as an evaluation reference.
Non-commercial only. Not because of Ego4D — Ego4D permits commercial use of derived work — but because the pipeline that produced these labels runs on HaWoR (CC BY-NC-ND 4.0), ProPainter (S-Lab 1.0 non-commercial) and MANO (research only). See Licence.

clips_chunked/
├── original/annot/<clip_id>/<start>_<end>.parquet   human annotations, stages 2–7
├── allex/annot/<clip_id>/<start>_<end>.parquet      Allex trajectory, stage 8
├── original/annot/<clip_id>.done                     stage 7 marker
└── allex/annot/<clip_id>.done                        stage 8 marker
segments.csv                                           clip_id, start, end, fps, resolution, language

<clip_id> is the Ego4D clip UUID. <start> and <end> are inclusive frame indices into the 30 fps, 256-pixel-shorter-side re-encode of that clip, produced with the ffmpeg command in the repo README. Re-encode identically or the indices will not line up.

clips_chunked/original/video/ is absent: it holds Ego4D pixels, which this repository may not redistribute. There is no allex/overlay/ tree either — no HuRo repository ships one. The stage-9 overlay table was a copy of the stage-8 table differing in a single column, so that column, overlay_valid, is carried in allex/annot/ instead.

Two .done markers per clip: stage 8 is satisfied by original/annot/<clip>.done, and stage 9 requires its robot's stage-8 marker, allex/annot/<clip>.done. Stage 6's original/video/<clip>.done is deliberately absent — no frames ship here, so a marker saying they were cut and rectified would make your own stage 7 skip over nothing. Write it yourself once you have cut your own segments. There is no stage-9 marker either, for the same reason: stage 9 skips every clip whose marker already exists (stage9_robot_overlay.py:368-372).

Resolution (H×W)	Segments	Frames	Hours @30fps
256×342	90,113	13,543,006	125.4
256×456	12,898	1,665,456	15.4
256×258	41	5,256	0.05
512×256	25	2,103	0.02
Total	103,077	15,215,821	140.9

These are the resolutions of the re-encode the annotations index into — the 256-pixel-shorter-side one above — and every row carries its own height / width. They are not the LeRobot resolutions: stage 10 downscales to a 192-pixel shorter side, so 256×342 becomes 192×256 there.

Columns

One row per video frame. Two tables per segment — the human annotations from stages 2–7, and the Allex trajectory from stage 8. Only the first is needed to retarget to your own robot.

`original/annot/<clip_id>/<start>_<end>.parquet` — robot-independent

Column	Type	Meaning
`clip_id`, `frame_id`	string, int32	Ego4D clip UUID; frame index, restarting at 0 per segment
`height`, `width`	int32	the undistorted frame size the annotations were made at
`intr_model`	string	the camera model the raw intrinsics belong to
`fx`, `fy`, `cx`, `cy`, `xi`	float64	the camera model as recorded. `xi` is positive on 74.7 % of these segments — those frames are rectified before the annotations are made
`pinhole_fx`, `pinhole_fy`, `pinhole_cx`, `pinhole_cy`	float64	the rectified pinhole every geometry column here is expressed against. Project keypoints with these, not with `fx`/`fy`
`cam_pose`	float32[4,4]	cam-to-world, OpenCV, metric-scaled and gravity-aligned
`arm_mask`	binary, bit-packed (H,W) bool	the human-arm mask stage 7 inpaints. 44 % of the table's bytes, and the reason you can skip stages 1–6
`hands[]`	list of struct	one entry per detected hand — see below
`n_person_det`	int32	number of person detections in the frame
`narr`	struct	`think`, `left`, `right`, `bimanual` — the VLM's per-segment narration
`language`	string	the merged instruction, one per segment

hands[] fields: box float32[4] [x1,y1,x2,y2], conf, side int8 (0 left, 1 right), side_conf, kpts3d float32[21,3] in MediaPipe order and camera frame, wrist_rot float32[3] axis-angle — null where stage 5 could not resolve the wrist orientation — finger_rot float32[15,3] axis-angle, and hand_mask, which is null on every row in every HuRo subset: the per-hand masks were transient inputs to inpainting and were never persisted.

Both tables carry all 37 columns of the shared HuRo schema; they differ in which are filled. The stage-8 columns listed in the next section are present but null in this one. contact_*, objects[] and offset exist in the pipeline's internal tables but are not published.

`allex/annot/<clip_id>/<start>_<end>.parquet` — Allex only

Skip this table entirely if you are targeting your own robot; stage 8 regenerates its equivalent.

Column	Type	Meaning
`state_qpos`	float32	Allex joint angles, ordered by the `state_qpos_joint_names` metadata
`state_eef_left`, `state_eef_right`	float32	wrist position (3) + rotation 6D (6) + hand joint angles
`state_mask_left`, `state_mask_right`	bool	false where that side's hand is missing
`cam_pose_base`	float32[4,4]	cam-to-robot-base, OpenCV (`cam_pose_convention` metadata). `cam_pose` stays cam-to-world
`retarget_cost`, `err_ddq`, `err_tip_mm_`, `err_palm_mm_`, `err_local_dir_*`, `err_cam_pos_mm`, `err_cam_rot_deg`	float32	IK diagnostics; stage 10 filters episodes on the `err_*` columns
`overlay_valid`	bool	carried from stage 9, which is not shipped

Schema metadata, readable without the robot config via pq.read_table(...).schema.metadata: state_qpos_joint_names, state_eef_layout (per_side:wrist_pos3_rot6d6_hand_joints), state_eef_left_hand_joint_names, state_eef_right_hand_joint_names, state_eef_frame (robot_base_frame), cam_pose_convention (opencv_cam_to_base), and robot_name. The metadata is attached to the allex/ tables only; original/annot carries none.

Positions in metres, angles in radians. Robot base frame is x forward, y left, z up; camera axes are OpenCV. Decode a row with decode_row from common/io.py — arm_mask is bit-packed and absent per-hand arrays are stored as NaN lists.

python examples/read_parquet.py clips_chunked

Getting the video

Download only the clips you need. The annotations here cover 9,107 Ego4D clips, and Allex trajectories exist for 8,972 of those — not the full 15,132-clip Ego4D release. The distinct clip_id values in segments.csv are the download list; the other 6,025 clips are video you cannot use with anything in this repository.

101,308 of the 103,077 segments have an Allex trajectory (98.3%). The remaining 1,769 ship their human annotations alone.

# your own Ego4D videos, re-encoded to 30 fps / 256 px shorter side
ffmpeg -i <ego4d>.mp4 -vf "fps=30,scale='if(gt(iw,ih),-2,256)':'if(gt(iw,ih),256,-2)'" \
    -c:v libx264 -crf 18 -an clips/<clip_id>.mp4

Re-encode exactly as above or the frame indices in segments.csv will not line up.

Then rectify and cut each clip into clips_chunked/original/video/<clip_id>/<start>_<end>.mp4. tools/prepare_segments.py is not published yet, so this step is yours for now, and two things are easy to get wrong:

The released segments are rectified, not raw. Stage 6 undistorts every frame before it writes a segment (pipeline/stage6_annot_narr.py:714). 76,995 of the 103,077 segments here (74.7%) carry a positive xi, up to 3.24 — where fx 365 becomes pinhole_fx 142. Build the maps from the columns in our tables and apply them per frame:
```
from common.camera import need_undistort, build_undistort_maps, undistort_apply
row   = ...                                 # row 0 of our <start>_<end>.parquet
shape = (row["height"], row["width"])
intr  = [row["fx"], row["fy"], row["cx"], row["cy"], row["xi"]]
if need_undistort(intr, shape):
    map1, map2, _, _ = build_undistort_maps(shape, intr, auto=True)
    frame = undistort_apply(frame, map1, map2)
```
Rectification preserves the frame size, so a segment cut from raw frames passes every check stage 7 makes and is then inpainted in the wrong geometry, silently. pinhole_fx differing from fx in a table is the signal that its segment was rectified.
start and end are inclusive, so a segment holds end - start + 1 frames, and that count must equal its table's row count — stage 7 asserts it.

Encode each segment as H.264 / yuv420p at 30 fps, which is what common/video.py:18 writes.

Both paths below start from here.

Rebuilding things yourself

Cutting your own segments from the source corpus, retargeting onto a different robot, rendering it into the frames, and packing the result as a LeRobot dataset are all documented in REBUILDING.md in this repository. None of it is needed to use the dataset as published.

Other HuRo subsets

Subset	Repo	Contents
EPIC-KITCHENS-100	`Joocjun/HuRo-EPIC-KITCHENS`	robotized episodes and annotations — modified frames ship, no source download needed
Egocentric-10K	`Joocjun/HuRo-Egocentric10K`	robotized episodes and annotations — modified frames ship, no source download needed
Ego4D	this repo	annotations only; bring your own video
EgoVerse	`Joocjun/HuRo-EgoVerse`	robotized episodes and annotations — modified frames ship, no source download needed
EgoDex	not released — CC BY-NC-ND 4.0 forbids sharing adapted material. regenerating it from your own copy is possible with this pipeline, but the recipe document is not published yet	—

Licence

This repository is not a single licence, and it is not CC BY-NC either — the Ego4D agreement, not a Creative Commons licence, governs the underlying material. Three layers stack, and the narrowest one wins for any given file:

Layer	Sets
The source corpus	the Ego4D Dataset License Agreement, which expressly makes derived annotations the End User's own intellectual property, usable for any purpose, and forbids distributing any portion of the video
The pipeline	HaWoR (CC BY-NC-ND 4.0) and MANO (research only) produced the hand reconstructions. A tool's licence is not generally held to reach what the tool produces, so these terms are not carried into the tables
The robot model	the ALLEX kinematic model, for the `allex/annot` trajectories only — see ALLEX below

What that means file by file:

File	Licence
Pipeline code (the HuRo repo)	Apache-2.0
Human annotation tables (`original/annot/`, `segments.csv`, `*.done`)	CC BY 4.0
Allex trajectory tables (`allex/annot/`)	the same, plus the ALLEX notice below
Ego4D imagery	not in this repository. Nothing here grants you any right to it

The reasoning behind these terms — in particular why the licences of the models inside the pipeline are not held to reach the numbers they produced — is set out in DATA_LICENSE.md.

ALLEX

No ALLEX-rendered frames are in this repository — it contains no pixels at all. The allex/annot tables are joint angles and end-effector poses retargeted onto the ALLEX kinematic model, taken from the ALLEX model repository's URDF, which is BSD 3-Clause. That licence requires its notice be retained:

ALLEX robot model and rendered appearance © 2026 WIRobotics Inc. Used with permission. ALLEX model information: https://github.com/wirobotics-rih/allex_model

The ALLEX meshes carry a separate, narrower licence, and nothing derived from them is published here: no mesh, point cloud, depth map, surface normal or rendered image. What ships is kinematic — the robot's configuration, not the shape of its parts.

Pipeline components

The components that produced these labels retain their own licences — HaWoR (CC BY-NC-ND 4.0), ProPainter (S-Lab 1.0, non-commercial), MANO (research only), and the others listed in THIRD_PARTY_NOTICES.md. Review it before redistributing anything derived from this release.

Attribution for Ego4D, as its agreement requires:

Egocentric Live 4D Perception (Ego4D) Database: A large-scale first-person video database, supporting research in multi-modal machine perception for daily life activity. Ego4D Consortium 2020. https://sites.google.com/view/ego4d/home

Citation

@misc{jeong2026huro,
      title={HuRo: Robotizing Human Videos for Scalable VLA Pretraining},
      author={Jinho Jeong and Se June Joo and Jaehyun Kang and Dongyun Kim and Yena Kim and Hanjung Kim and Seon Joo Kim},
      year={2026},
      eprint={2609.10706},
      archivePrefix={arXiv},
      primaryClass={cs.RO},
      url={https://arxiv.org/abs/2609.10706},
}

Downloads last month: 5

Total file size:

31.3 GB

Collection including Joocjun/HuRo-Ego4D

HuRo

Collection

Robotized egocentric human video. One repo per source dataset, since their licences differ. • 4 items • Updated about 8 hours ago

Paper for Joocjun/HuRo-Ego4D

HuRo: Robotizing Human Videos for Scalable VLA Pretraining

Paper • 2609.10706 • Published Sep 18 • 24

Accept the terms to access HuRo-Ego4D