rhoyn-robotics/data-sample

Rhoyn Robotics G1 Teleoperation Sample

A sample of whole-body teleoperation data from rhoyn, collected on a Unitree G1 Edu+ humanoid (29 DoF, Dex1-1 grippers) teleoperated with a PICO 4 Ultra VR headset, recorded at 30 Hz. Each folder is a self-contained LeRobot v3.0 dataset holding one episode, plus extra sensor streams (depth, lidar, IMU, raw teleop packets) stored alongside it.

Folder	Task	Duration	Frames	Preview
wipes/	Pull a wet wipe from the pack and wipe the table	97 s	2,921	previews/wipes.mp4
socks/	Pick up the two socks and pair them together	92 s	2,747	previews/socks.mp4
eggs/	Crack eggs into the pan and scramble them	232 s	6,965	previews/eggs.mp4

The preview videos tile every camera stream (color and stereo IR) and the lidar point cloud into a single view.

Per episode: 9 synchronized camera streams (head + two wrist RealSense cameras, color and stereo IR), lossless 16-bit depth from all three cameras, a Livox MID-360 lidar point cloud, three IMUs, the full joint state and torque pipeline, and the raw VR teleoperation packets.

Data collected to your spec

This repository is a free sample of the format. rhoyn collects teleoperation data for your robot and your tasks, objects and scenes, on our own teleop stack, and delivers it in this format (LeRobotDataset v3.0 plus the extra sensor streams).

• Robots: Unitree G1 now; YAM, OpenArm and reBot from early November.
• Free pilot: 50 episodes of your task. Train on them and keep them.
• Licensing: exclusive or non-exclusive, or full ownership transfer, matched to the project.

Contact hello@rhoyn.com or book a 30-minute call. Hardware and format details are in the data card.

Loading

Each task folder is its own LeRobot dataset, so download the repo and point LeRobot at one folder:

from huggingface_hub import snapshot_download
from lerobot.datasets.lerobot_dataset import LeRobotDataset

path = snapshot_download("rhoyn-robotics/data-sample", repo_type="dataset")
ds = LeRobotDataset("rhoyn-robotics/data-sample", root=f"{path}/wipes")

Loading by repo id alone (LeRobotDataset("rhoyn-robotics/data-sample")) is not supported, because the repo root is not itself a LeRobot dataset. Use the root= form above.

Videos are AV1-encoded. Decoding needs an AV1-capable decoder (dav1d or libaom) in your ffmpeg / PyAV / torchcodec build. Recent pip wheels of PyAV and torchcodec include one.

The per-frame data can also be read directly with pandas or pyarrow from <task>/data/chunk-000/*.parquet.

Contents of each episode folder

<task>/
├── meta/            info.json, stats.json, tasks.parquet, episodes/, plus sidecar metadata
│                    (calibration.json, depth.json, lidar.json, d435_imu.json, pico.json)
├── data/            per-frame parquet (state, actions, IMU, torques, teleop, sync info)
├── videos/          9 AV1 video streams, one per camera / IR imager
├── depth/           lossless 16-bit depth (FFV1 .mov) for 3 cameras, at 15 fps
├── lidar/           Livox MID-360 points, raw packets, and lidar IMU
├── d435_imu/        head camera IMU
└── pico/            raw Pico VR teleop controller packets

The sidecar folders (depth/, lidar/, d435_imu/, pico/) are not part of the LeRobot format. LeRobot tools such as aggregate_datasets ignore them, so read them directly using the paths and metadata in meta/.

Cameras (videos/)

Key	Resolution	Description
observation.images.d435	848×480	Head RealSense D435, color
observation.images.d435_ir1, _ir2	848×480	Head D435, stereo IR
observation.images.d405_left, d405_right	424×240	Wrist RealSense D405, color
observation.images.d405_{left,right}_ir1, _ir2	424×240	Wrist D405, stereo IR

IR streams are monochrome but stored as 3-channel video (the gray value is replicated), so they load as (3, H, W) like the color streams.

The right wrist camera is mounted upside down and its frames are rotated upright at recording time (frames_rotated_upright: true in meta/calibration.json). The left wrist camera's frames are stored as captured.

Per-frame data (data/)

Key	Dim	Description
observation.state	60	29 joint positions, 29 joint velocities, 2 gripper apertures
observation.effort	31	Measured joint torques
observation.motor_temp	29	Motor temperatures
observation.imu.pelvis, observation.imu.chest	10 each	Quaternion, gyro, accelerometer
action	31	29 joint position targets, 2 gripper aperture targets
action.kp, action.kd, action.tau_ff	29 each	Low-level PD gains, feedforward torque
action.dq_target †	29	Velocity targets
action.tau_requested, action.torque_cap, action.tau_commanded †	31 each	Torque pipeline: requested, capped, commanded
observation.torque_budget, action.torque_allowed, action.torque_limited †	16 each	Arm torque-safety limiter state
action.teleop	26	Operator VR wrist poses, locomotion commands (vx, vy, yaw rate, height), triggers, grips, sticks
action.teleop.buttons	8	VR controller buttons
observation.teleop_active	1	Whether teleop was engaged (always 1 in this sample)
observation.frame_counter, sensor_ts_us, frame_offset_us	12 each	Per-stream camera sync info
observation.row_time_us, observation.control_offset_us	1 each	Row and control-loop timing

Full joint names and per-element units for every vector are in meta/info.json.

† Not present in eggs/. The eggs episode was recorded on 2026-10-05, before the arm torque-safety limiter was added to the recording stack, so it has 31 features instead of 38. wipes/ and socks/ share an identical schema and can be merged with LeRobot's aggregate_datasets; eggs/ cannot be merged with them without dropping those 7 keys.

Note on NaNs: observation.frame_counter, observation.sensor_ts_us and observation.frame_offset_us contain NaN in their three depth columns (d435_depth, d405_left_depth, d405_right_depth). This is expected: depth is recorded at 15 fps in depth/, and meta/depth.json maps each depth frame to its data row.

Control and actions

The operator wears a Pico VR headset and controllers. The robot is driven by two controllers at once:

• Arms and grippers (operator). The 14 arm joints and 2 grippers follow the operator's tracked wrist poses (retargeted to joint targets) and the grip triggers. Only these joints receive feedforward torque (action.tau_ff).
• Legs and waist (learned controller). The 15 leg and waist joint targets come from a GR00T whole-body-control locomotion policy, which switches between balance and walking modes. The operator steers it with the controller sticks; those commands are recorded in action.teleop as vx, vy, yaw_rate and height_command. For these joints action.tau_ff and action.dq_target are always 0.

For policy learning, the operator-driven action is the arm and gripper part of action (or the raw wrist poses in action.teleop), plus the locomotion commands in action.teleop. The leg and waist entries of action are included for completeness and for whole-body training.

Synchronization

All streams are timestamped against one host clock. The data rows are a fixed 30 Hz grid (observation.row_time_us), and each camera contributes the frame nearest to each row. The cameras run freely and are not hardware-triggered, so each camera frame is within about ±16.7 ms (half a frame) of its row time, and head and wrist frames in the same row can be up to about 30 ms apart. The exact capture time and offset of every stream's frame are recorded per row in observation.sensor_ts_us and observation.frame_offset_us.

Lidar points, IMU samples and Pico packets keep their native rates and carry their own timestamps. meta/lidar.json, meta/d435_imu.json and meta/pico.json describe the clocks.

Depth

Depth is lossless 16-bit (FFV1, gray16le), 424×240 at 15 fps, for all three cameras. Depth frame i belongs to data row 2i. Convert to meters with meters = raw * depth_scale (0.001 for the D435, 0.0001 for the D405s, given per stream in meta/depth.json).

Two raw values mean "no valid depth" and should be masked:

• 0: no depth (no stereo match).
• 65535: saturated or out of range. This mostly happens on the wrist D405s when the scene is beyond their short working range.

The stats in meta/depth.json exclude both values.

Calibration

Camera intrinsics (all color, IR and depth streams) are RealSense factory calibration, read from each device at recording time.

Camera-to-robot and lidar-to-robot extrinsics come from the robot model, not from a hand-eye calibration. The head camera and lidar poses come from the Unitree G1 URDF; the wrist cameras' poses come from the CAD model of their 3D-printed mounts. Every transform carries a source field saying this. These poses are suitable for coarse fusion. If you need precise depth-to-robot or lidar-to-camera alignment, plan to refine them.

License and attribution

This sample is released under CC BY 4.0. You can use it for anything, commercial work included, with credit to rhoyn.

Privacy

Episodes were recorded in indoor home and office settings. No people appear in the camera streams; the color streams were screened for faces. The Pico packets contain controller poses relative to the operator's head heading, with no identifying information.