Episodes Preview bimanual_parallel_gripper Visualizer
57 episodes · 30 fps · 3 cameras · 1920×1080 h264

bimanual-tabletop-tasks-sample

Left wrist, scene and right wrist video with the 3-D gripper poses from the dataset (2x speed).

This is a free sample: 57 episodes across 53 tasks, every one reviewed by us. The full collection is larger (around 300 episodes so far, with repeated demonstrations of each task), and new tasks can be recorded on request. Contact: book a call · hello@kirorobotics.com · kirorobotics.com

Format: LeRobot dataset v3.0 (Hugging Face).

Bimanual manipulation demonstrations: two hand-held parallel grippers (left and right hand), each with a wrist camera, and a static scene camera. Every episode is one demonstration of one task.

At a glance

  • 57 episodes, 71092 frames, 39.5 min at 30 frames per second
  • wrist videos 1920 x 1920 px (full fisheye view), scene video 1920 x 1080 px, H264, frame k of a video = frame k of its episode
  • tasks: close_zipper_pouch (1), declutter_table (1), fold_kitchen_towel (1), fold_socks_into_basket (2), insert_blue_jumper_wire_into_breadboard (1), insert_green_jumper_wire_into_breadboard (1), insert_red_jumper_wire_into_breadboard (1), insert_usb_cable (1), insert_yellow_jumper_wire_into_breadboard (1), make_smiley_face (1), open_jar_and_remove_scissors (1), open_jar_and_remove_white_thread (1), place_all_items_into_jar (1), place_items_into_jar (1), pour_water_into_glass (1), put_all_items_into_zipper_pouch (1), put_black_thread_into_jar (1), put_clips_in_box (1), put_earphones_in_case (1), put_electric_toothbrush_into_zipper_pouch (1), put_on_pen_cap (1), put_pens_in_pen_holder (2), put_scissors_and_black_thread_into_jar (1), put_scissors_into_jar_and_close_lid (1), put_sunscreen_and_manual_toothbrush_into_zipper_pouch (1), put_tablet_into_zipper_pouch (1), put_toys_in_bowl (1), put_white_thread_and_scissors_into_jar (1), put_white_thread_into_jar (1), put_white_thread_into_jar_and_close_lid (1), put_white_thread_into_small_jar (1), remove_all_items_from_zipper_pouch (1), remove_black_thread_from_jar (1), remove_blue_jumper_wire_from_breadboard (1), remove_clips_from_box (1), remove_earphones_from_case (1), remove_green_jumper_wire_from_breadboard (1), remove_pen_cap (1), remove_red_jumper_wire_from_breadboard (1), remove_seasoning_packet_from_zipper_pouch (1), remove_tablet_from_zipper_pouch (1), remove_white_thread_and_scissors_from_jar (1), remove_white_thread_from_jar (1), remove_white_thread_from_small_jar (1), remove_yellow_jumper_wire_from_breadboard (1), screw_nut_and_bolt (1), sort_objects_by_color (2), sort_objects_by_shape (2), stack_cups_into_pyramid (1), unscrew_nut_and_bolt (1), untangle_red_wire (1), untangle_usb_cable (1), wipe_table (1)
  • audio: none

Layout of this folder

  • meta/info.json, meta/stats.json, meta/tasks.parquet, meta/episodes/chunk-000/file-000.parquet
  • data/chunk-000/file-000.parquet: one row per frame
  • videos/observation.images.<camera>/chunk-000/file-<episode>.mp4: one file per episode and camera
  • extra (ignored by LeRobot): imu/episode_<i>_<hand>.parquet, annotations.json, calibration/

Features: observation.state (14), action (14), observation.tcp_quat_xyzw (8), observation.gripper_angle_deg (2), observation.gripper_opening (2), observation.camera_pose (14), observation.pose_valid (2), observation.phase (2, when included), observation.images.wrist_left, observation.images.wrist_right, observation.images.scene.

Loading

from lerobot.datasets.lerobot_dataset import LeRobotDataset
ds = LeRobotDataset("KiroRobotics/bimanual-tabletop-tasks-sample")
frame = ds[0]          # tensors: observation.state, action, observation.images.wrist_left (3, H, W) in [0, 1], ...

Coordinate frames and units

  • Table frame (all poses): right-handed, metres. Origin on the table top at the centre of the work area (the operator's mat, about 0.65 m wide x 0.42 m deep, so about x in [-0.21, 0.21] m, y in [-0.33, 0.33] m); x points toward the operator, y to the operator's right, z up.
  • TCP (tool centre point) of each gripper: the pinch point between the fingertips. TCP frame: x across the jaws (opening direction), z forward along the jaws toward the fingertips, y = z x x.
  • Wrist camera frame: x right, y down, z along the optical axis (image convention). Its fixed pose in the TCP frame is T_tcp_camera in the calibration file wrist_<hand>.json; its pose in the table frame per frame is camera_pose.
  • Rotations: rotation vectors (axis x angle, rad) and quaternions in (x, y, z, w) order.
  • Time: seconds from the episode start; frame j is at j / fps.

Per-frame fields

field unit meaning
state m, rad, m per hand (left, then right): TCP x, y, z, rotation vector rx, ry, rz, gripper width
action as state the next frame's state (absolute target pose and gripper width); the last frame repeats
tcp_quat_xyzw - TCP orientation as a quaternion
gripper_width m fingertip opening relative to fully closed
gripper_angle_deg deg opening angle between the fingers, 0 = closed
gripper_opening 0..1 normalised opening: 0 = closed, 1 = fully open
camera_pose m, quaternion wrist camera position + orientation in the table frame
pose_valid bool false where the pose is interpolated across a longer gap (> 0.25 s from a measurement)

IMU

Raw inertial samples of each gripper at the native rate (about 1000 Hz), not filtered and not resampled: t (s from the episode start), gyro (rad/s) and accel (m/s^2, specific force including gravity), both expressed in the axes of that hand's TCP frame. The accelerometer is not at the TCP, so its readings include the lever-arm terms of rotation. The gyro is not bias-corrected.

Robot feasibility labels

For each episode and robot arm: could two arms of that model replay both hands' TCP motion (inverse kinematics with joint limits, joint speed and Cartesian speed / acceleration limits)? Cell assumed: two arms, bases 0.60 m apart, tool length 0.20 m, base distance from the work-area centre (the table frame's origin) toward the operator: UR5e 0.90 m, Panda 0.90 m, iiwa7 0.90 m, Gen3 0.75 m, xArm7 0.60 m, fr3 0.75 m, piper 0.58 m, so101 0.42 m, vx300s 0.42 m, wx250s 0.42 m, arx_l5 0.42 m.

  • passes: feasible at the recorded speed
  • reasons per hand: joint_speed, near_singularity, joint_limits, out_of_reach, wrist_too_fast, tcp_accel, tcp_too_fast, tcp_lin_accel
  • events: where in the episode a limit is exceeded (start_s, end_s, peak_s, peak, unit, robots, hand)

Labels are in annotations.json (ik) or the format's own episode metadata.

Step notes

Per episode in annotations.json (notes), written automatically by a vision-language model from the episode's videos and the gripper sensor; notes.source says whether a person checked or corrected them:

  • steps: the task as consecutive sub-steps (start_s, end_s, hand, text), e.g. for language-conditioned or hierarchical policies
  • outcome: success / partial / fail, with outcome_note
  • events: regrasps, drops, recoveries, hesitations, collisions (t_s, kind, hand, text)
  • objects: the objects handled; scene: what varies in the setup

Camera calibration

The episodes come from 10 recording setups (the grippers were re-mounted and re-calibrated between them), so there is one set of files per setup: calibration/setup_<k>/<camera>.json (wrist_left, wrist_right, scene), and calibration/episodes.json gives each episode's setup. Each file holds: the Kannala-Brandt (equidistant fisheye) model for the exported image size:

theta   = atan2(sqrt(X^2 + Y^2), Z)          (valid beyond 90 deg off-axis)
theta_d = theta (1 + k1 theta^2 + k2 theta^4 + k3 theta^6 + k4 theta^8)
u = fx theta_d X / r + cx,   v = fy theta_d Y / r + cy,   r = sqrt(X^2 + Y^2)

Fields: fx, fy, cx, cy, k1..k4, image_width, image_height; pixel centres at integer coordinates. For points in front of the camera this equals OpenCV's cv2.fisheye model with D = [k1, k2, k3, k4]. The wrist files also hold T_tcp_camera. The scene camera is static; its pose in the table frame is T_table_camera in scene.json when known.

Accuracy (approximate)

  • TCP pose and wrist camera pose: typical error under 5 mm.
  • Time alignment between the three cameras: about 8 ms (under a quarter of a frame at 30 fps).

Notes

  • Episodes start and end close to the first and last motion of either hand.
  • Some small image regions are filled with the colour of their surroundings.

Step annotations: language_persistent

Every frame carries language_persistent: the full list of step rows of its episode, repeated on every frame (the same layout as LeRobot's language columns). Each row: role ("assistant"), content (the step, e.g. "Pick up the orange ring near the right edge."), style ("subtask"), timestamp (start time of the step in seconds from the episode start), camera and tool_calls (null). language_events is empty. Steps of the left and right hand can run at the same time; annotations.json has the same steps with their end time and hand, plus the outcome, events, objects and scene of each episode.

rows = sorted(frame["language_persistent"], key=lambda r: r["timestamp"])
current = [r["content"] for r in rows if r["timestamp"] <= float(frame["timestamp"])][-1:]
Downloads last month
49