512 episodes of human bimanual origami folding, 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.

Origami is a deliberately hard target for manipulation research: the object is deformable, near-planar, visually low-texture, and its state is defined by crease history rather than by pose. Success needs precise bimanual coordination and sustained visual attention on the hands — which is exactly what a head-plus-wrist capture rig sees.

This is the raw dataset for the Robotic Origami Challenge. It is released unannotated.

At a glance


Episodes	512
Video streams per episode	8 (6 head + 2 wrist)
Total video	51.1 stream-hours (6.5 h wall-clock)
Episode length	46 s mean (29–114 s)
Video	H.265 / HEVC, 1920×1080, 30 fps
IMU	200 Hz accelerometer + gyroscope (×3 devices)
Magnetometer	100 Hz (×3 devices)
Capture rigs	3 RoboCap units, 3 RoboWrist pairs
Dates	2026-07-20 → 2026-07-23
Size	84.5 GB
Time-sync validated	510 / 512 episodes (2 without a report)

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
RoboCap firmware	1.2.13
RoboWrist firmware	4.0.2

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
  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
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 handful 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_`
all	`metadata`	`key, value` — sensor models, firmware version, device ids

Timestamps are nanoseconds on a per-device monotonic clock, not Unix epoch. They are comparable within one device, never across devices by raw value. x/y/z are raw signed sensor counts, not scaled to g or deg/s.

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.

`info.json`

One per episode, generated from the validator's machine-readable block plus a direct probe of every file:

{
  "episode_id": "episode_2026-07-21_03-29-38_5b36bf78",
  "device_id": "5b36bf78449afe26",
  "session_timestamp": "2026-07-21T03:29:38",
  "session_timestamp_note": "as recorded by the device; timezone not asserted",
  "robowrist_left_id": "7c09116c9ab54795",
  "robowrist_right_id": "4193a1bc74bb26b9",
  "imu_model": "icm42688p", "mag_model": "mmc5983ma", "camera_sensor": "sc233hgs",
  "duration_s": 58.97,
  "timesync": { "overall_passed": true, "tool_version": "1.0.8", "...": "..." },
  "streams": [
    { "file": "robocap_video_left.mp4", "type": "video", "codec": "hevc",
      "width": 1920, "height": 1080, "fps": 30.02, "duration_s": 58.97,
      "quality_status": "PASS", "drop_rate_pct": 0.0,
      "start_delta_s": 0.000036, "end_delta_s": 0.000036 }
  ]
}

Quality control

Every session was checked by an internal TimeSync Validator before release, 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 510 validated episodes passed. No episode in this release is marked as failing.

Known characteristics

Unannotated. No task labels, fold-step segmentation, 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.
IMU/mag values are raw counts. Scale factors depend on the icm42688p / mmc5983ma range configuration and are not recorded per episode.
2 episodes have no time-sync report ("timesync": null in info.json). Their media is complete and probes clean; they simply were not run through the validator. They are not marked as passing.

Loading

hf download BitRobot/RoboCap-Origami-500 --repo-type dataset --local-dir ./origami

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

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

Related datasets

BitRobot/HIW-500 — 500+ h of humanoid whole-body teleoperation in real homes
BitRobot/2026-humanoid-ikea-assembly-challenge — raw challenge data for furniture assembly
BitRobot/FrodoBots-Mini-4K — ~4,000 h of sidewalk-robot teleoperation

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_origami_500_2026,
  title  = {RoboCap-Origami-500: Bimanual Origami Folding from Head and Wrist Capture},
  author = {BitRobot and FrodoBots},
  year   = {2026},
  howpublished = {\url{https://huggingface.co/datasets/BitRobot/RoboCap-Origami-500}}
}

Downloads last month: 6

Total file size:

84.5 GB