494 episodes of humans assembling IKEA furniture, captured with RoboCap (a head-worn stereo rig) and a pair of RoboWrist wrist cameras. Every episode carries 8 synchronized 1080p30 video streams — three stereo pairs from the head plus one downward view per wrist — alongside 200 Hz IMU and 100 Hz magnetometer from all three devices, and a machine-readable time-sync validation report.

Furniture assembly is a long-horizon, contact-rich manipulation problem: it involves tool use, bimanual part alignment, insertion under tight tolerance, and multi-minute plans where an early mistake is only discovered much later. Episodes here average 119 s — roughly twice the length of our origami set — and the head-plus-wrist viewpoint keeps both the hands and the workpiece in frame throughout.

This is the human demonstration counterpart to BitRobot/2026-humanoid-ikea-assembly-challenge, which covers the same task performed by a teleoperated Unitree G1. Released unannotated.

At a glance


Episodes	494
Video streams per episode	8 (6 head + 2 wrist)
Total video	129.3 stream-hours (16.3 h wall-clock)
Episode length	119 s mean (89–174 s)
Video	H.265 / HEVC, 1920×1080, 30 fps
IMU	200 Hz accelerometer + gyroscope (×3 devices)
Magnetometer	100 Hz (×3 devices)
Tactile gloves	120 Hz, 2 episodes only (see below)
Capture rigs	4 RoboCap units
Dates	2026-07-20 → 2026-07-24
Size	219.3 GB
Time-sync validated	412 / 494 episodes (82 unvalidated)

The capture hardware

RoboCap is a head-worn rig carrying six cameras arranged as three stereo pairs, plus a 6-axis IMU and a magnetometer. RoboWrist units strap to each wrist, each contributing one downward-facing camera, an IMU and a magnetometer. The wrist units pair to the RoboCap over its subdevices link, and all three clocks are cross-validated after capture.

Component	Part	Rate
Cameras (all 8)	`sc233hgs`	1920×1080 @ 30 fps, H.265
IMU (accel + gyro)	`icm42688p`	200 Hz
Magnetometer	`mmc5983ma`	100 Hz
Tactile glove (2 episodes)	`opencyberglove`, protocol `OCG2-132B`	120 Hz

The 8 camera streams

File	Mount	View
`robocap_video_left.mp4` / `robocap_video_right.mp4`	head	main stereo pair
`robocap_video_left_eye.mp4` / `robocap_video_right_eye.mp4`	head	eye-line stereo pair
`robocap_video_left_front.mp4` / `robocap_video_right_front.mp4`	head	forward stereo pair
`robowrist_left/video_down.mp4`	left wrist	downward onto the hands
`robowrist_right/video_down.mp4`	right wrist	downward onto the hands

Layout

episode_<YYYY-MM-DD>_<HH-MM-SS>_<rig>/
  info.json                      # per-episode metadata (English)
  timesync_report.txt            # original TimeSync Validator output (when present)
  robocap_video_left.mp4         robocap_video_right.mp4
  robocap_video_left_eye.mp4     robocap_video_right_eye.mp4
  robocap_video_left_front.mp4   robocap_video_right_front.mp4
  robocap_imu_left.db            robocap_imu_right.db
  robocap_mag_middle.db
  robowrist_left/   video_down.mp4  imu.db  mag.db
  robowrist_right/  video_down.mp4  imu.db  mag.db
  cyberglove_left/  glove.db          # 2 episodes only
  cyberglove_right/ glove.db          # 2 episodes only
metadata.parquet   metadata.csv   # one row per episode
streams.parquet                   # one row per media/sensor file

The episode folder name is <session timestamp>_<first 8 hex of the RoboCap device id>. A couple of episodes also carry timesync_report_prior.txt, where the validator was run twice; timesync_report.txt is always the later run.

Sensor data format

The .db files are SQLite. Read them directly — no custom parser needed.

import sqlite3, pandas as pd

con = sqlite3.connect("episode_.../robocap_imu_left.db")
acc  = pd.read_sql("select x, y, z, timestamp from acc_data  order by timestamp", con)
gyro = pd.read_sql("select x, y, z, timestamp from gyro_data order by timestamp", con)
meta = dict(con.execute("select key, value from metadata"))   # sensor models, firmware, device ids

File	Tables	Columns
`_imu_.db`	`acc_data`, `gyro_data`	`x, y, z, timestamp, imuid_`
`_mag_.db`	`mag_data`	`mag_x, mag_y, mag_z, timestamp, imuid_`
`cyberglove_*/glove.db`	`glove_data`	`t0`–`t18`, `acc_`, `gyro_`, `mag_*`, `temperature`, `timestamp_us`
all	`metadata`	`key, value` — sensor models, firmware version, device ids

Two different clock columns and units. RoboCap and RoboWrist logs use timestamp in nanoseconds; the CyberGlove logs use timestamp_us in microseconds. Both are per-device monotonic clocks, not Unix epoch — comparable within one device, never across devices by raw value. RoboCap/RoboWrist x/y/z are raw signed sensor counts; the glove's acc_*/gyro_*/mag_* are already in physical units.

Tactile gloves (2 episodes)

Two episodes additionally carry opencyberglove tactile gloves at 120 Hz: glove_data holds tactile channels t0–t18 (up to 11 are live — the count actually varying per file is recorded as tactile_channels in streams.parquet; the rest sit pinned at their no-contact value), plus the glove's own 9-DOF IMU and a temperature reading. Find them with metadata.parquet → has_cyberglove == True. This is a small pilot subset, not a headline modality of this release.

Aligning streams across devices

Each episode's info.json gives, per file, start_delta_s and end_delta_s — the offset of that stream's start and end against the episode reference clock, as measured by the TimeSync Validator. Use these to align head video against wrist video and IMU. Within an episode the six head cameras agree to well under a millisecond; the wrist devices are independently clocked and typically sit a few hundred milliseconds to a few seconds off, so do not assume frame 0 of a wrist video is frame 0 of a head video. The 82 unvalidated episodes have no such offsets — align them yourself, or skip them.

Quality control

Every validated session was checked by an internal TimeSync Validator against these thresholds: max 6 s stream-to-stream offset, max 1.5% sample drop, and per-sample interval gaps within 6× the nominal period. timesync_report.txt is the original tool output, preserved as-is; its human-readable section is in Chinese, and its machine-readable JSON block — reproduced in English in info.json — carries the same information.

All 412 validated episodes passed — no episode here is marked as failing.

Separately, 82 episodes (17%) were never run through the validator (rigs 5046d0e5, 5b36bf78, 6cc09719, 72d4ea32). Their media is complete and probes clean, but their cross-device alignment is unverified: tsync_passed is null and info.json has "timesync": null. Filter on tsync_passed == True if you need only episodes with a passing time-sync check.

Known characteristics

Unannotated. No task labels, assembly-step segmentation, part identities, hand poses or object states. Frame-accurate timing and cross-device alignment metadata are provided; semantics are not.
No camera calibration. Intrinsics and extrinsics are not included in this release, so the stereo pairs are not rectified and metric depth is not recoverable off-the-shelf.
Timezone of session_timestamp is not asserted — it is the literal device-recorded value. Use it for ordering, not for wall-clock reasoning.
Which furniture item is being assembled is not recorded per episode. Rig and date are, so episodes can be grouped by capture session.
One rig reports a 15-character device id (2b2a8d804d1d236) rather than the usual 16, a dropped leading zero in firmware. It is preserved verbatim in metadata.parquet rather than silently padded.

Loading

hf download BitRobot/RoboCap-IKEA-500 --repo-type dataset --local-dir ./ikea

# just the metadata (a few hundred KB) before pulling 200+ GB of video
import pandas as pd
eps = pd.read_parquet("hf://datasets/BitRobot/RoboCap-IKEA-500/metadata.parquet")
streams = pd.read_parquet("hf://datasets/BitRobot/RoboCap-IKEA-500/streams.parquet")

validated = eps[eps.tsync_passed == True]      # episodes with a passing time-sync check
with_gloves = eps[eps.has_cyberglove]          # the tactile-glove pilot episodes

# a single episode
hf download BitRobot/RoboCap-IKEA-500 --repo-type dataset \
  --include "episode_2026-07-21_03-29-35_6cc09719/*" --local-dir ./one

Related datasets

BitRobot/RoboCap-Origami-500 — same rig, bimanual origami folding
BitRobot/2026-humanoid-ikea-assembly-challenge — the same task on a teleoperated Unitree G1
BitRobot/HIW-500 — 500+ h of humanoid whole-body teleoperation in real homes

License

Released under CC BY 4.0. If you are interested in additional datasets like this one, for commercial or academic purposes, please get in touch.

Citation

@misc{robocap_ikea_500_2026,
  title  = {RoboCap-IKEA-500: Human Furniture Assembly from Head and Wrist Capture},
  author = {BitRobot and FrodoBots},
  year   = {2026},
  howpublished = {\url{https://huggingface.co/datasets/BitRobot/RoboCap-IKEA-500}}
}

Downloads last month: 2

Total file size:

219 GB