Connecting to sources…

How to build LeKiwi: the whole process

230 steps to build LeKiwi, from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop links and the official source…

About $482 for the 12V version with the SO‑101 teleoperation set; base only about $251.5; wired base about $184 (repo BOM, US prices)

Bill of materials · Mobile Base Structure

PartQtyUSEUCN
4" Omni wheels3USD 9.99EUR 24.5CNY 135
M2 M3 M4 Assorted Screw Set1USD 14.99EUR 23.5CNY 25

Bill of materials · Sensors and Compute

PartQtyUSEUCN
Raspberry Pi 5 (4GB)1USD 60EUR 57CNY 410
USB camera2USD 12.98EUR 12CNY 48
microSD card1USD 11.23EUR 10CNY 58

Buy parts

  • Choose motor and electronics version

    LeKiwi offers 5V, 12V and wired versions for the motors and electronics.

  • Beginners should pick the 5V version

    If this is your first robot build choose the 5V version because it is a little easier to assemble; choose 12V if you are experienced and want to lift heavier objects.

  • Cheapest option is the wired LeKiwi

    For the cheapest options go for the wired LeKiwi robot, listed at the end of the Bill of Materials.

  • Buy mobile base structure parts

    The three rows of the Mobile Base Structure table are the same for both the 5V and 12V versions.

  • Buy sensors and compute parts

    Buy the four items listed in the Sensors and Compute table.

  • Buy the other parts

    Buy the four remaining items listed under Other.

  • Go to the 12V version list

    The 12V version covers mobile base electronics and the SO-101 2 robot arm teleoperation set.

  • Buy 12V mobile base electronics

    Buy the six items of the Mobile Base Electronics (12V) table for the 12V version.

  • Buy the 12V SO-101 teleoperation set

    Buy the four items in the SO-101 2 Robot Arm Teleoperation Set (12V) table.

  • Go to the 5V version list

    The 5V mobile base electronics list includes a 20000mAh 85W power bank.

  • Choose the 5V SO-101 Teleoperation Set

    Buy the SO-101 2 Robot Arm Teleoperation Set (5V) listed in the BOM.

  • Select Parts for the Wired Version

    Prepare the components in the 11-row BOM table for the wired version.

  • Find Optional LeKiwi Kit Parts

    Optional LeKiwi kits, including the LeKiwi Full Kit 12V Verision, are available from Seeed Studio internationally.

  • Obtain Arducam 5MP wide-angle cameras

    Prepare Arducam 5MP wide-angle cameras for the base and wrist camera mounts.

  • Obtain a webcam

    Prepare a webcam for the wrist and base camera mounts.

  • Obtain the printable STL files

    Obtain all the STL files for the 3D-printed parts provided in the document.

  • Obtain access to a 3D printer

    If you do not have a 3D printer, consider Bambu Lab, Prusa, or another brand from the document's list.

  • Buy the XL330 frame and idler set

    Buy 1 XL330 Frame and Idler Wheel 4pcs set according to the BOM. The table lists suppliers including Robotis, MyBotShop, GenRobots, RoboSavvy, TaoBao, and the Robotis Japan store, with prices for different regions.

  • Buy the XL430 idler wheel set

    Buy 1 XL430 Idler Wheel set according to the BOM. The table lists suppliers including Robotis, MyBotShop, GenRobots, Robosavvy, TaoBao, and the Robotis Japan store, with prices for different regions.

  • Source the LeKiwi parts

    Open the linked README and use its bill of materials and sourcing links.

  • Obtain access to a 3D printer

    If you do not already have access to a 3D printer, obtain one; the document recommends Bambu Lab or Prusa.

  • Buy parts according to the BOM

    Open the BOM and buy all the parts listed there.

Print and make

  • Enable specified part supports

    Enable supports for the 3D-printed components where supports are specified.

  • Calibrate printer and level bed

    Calibrate the printer and level the bed according to the printer-specific instructions.

  • Clean the print bed

    Clean the print bed.

  • Load the filament

    Load the filament into the printer.

  • Upload STL and arrange automatically

    Upload the STL file to printing or slicing software, then auto-rotate and auto-arrange it.

  • Enable supports and slice

    Enable supports where specified, then slice the model.

  • Set 15% infill density

    Set the infill density to 15%.

  • Set 0.2 mm layer height

    Set the layer height to 0.2 mm.

  • Set 150 mm/s print speed

    Set the printing speed to 150 mm/s.

  • Upload G-code and print

    If needed, upload the G-code slice file to the printer and print; the document gives an estimated total time of about 34 hours.

  • Remove printed parts

    Remove the printed parts from the printer.

  • Clean bed when needed

    Clean the print bed if needed.

  • Remove supports from parts

    Remove any supports from the printed parts.

  • Calibrate and level the printer

    Calibrate the printer and level the bed according to the printer-specific instructions.

  • Clean the print bed

    Clean the print bed before printing.

  • Load the filament

    Load the filament into the 3D printer.

  • Upload STL and arrange automatically

    Upload the STL file to printing or slicing software, then use auto-rotate and auto-arrange.

  • Enable supports and slice

    Enable supports where specified for the part, then slice the model.

  • Apply the tested print settings

    The tested settings are 15% infill density, 0.2 mm layer height, and 150 mm/s printing speed.

  • Upload G-code and print

    If needed, upload the sliced G-code file to the printer and print.

  • Remove the printed parts

    Remove the printed parts from the 3D printer.

  • Clean the bed if needed

    Clean the print bed if needed.

  • Remove supports from the parts

    Remove any support structures from the printed parts.

  • Print wired-version parts

    Print `3DPrintMeshes/wired_specific/cable_holder v0.stl` and `3DPrintMeshes/wired_specific/usb_connector_case v1.stl`, and assemble them as shown.

  • Print the base camera mount

    Print `3DPrintMeshes/base_camera_mount.stl`.

  • Print the wrist camera mount

    Print `3DPrintMeshes/wrist_camera_mount.stl`.

  • Print the base webcam mount

    Print `3DPrintMeshes/webcam_mount/webcam_mount.stl`.

  • Print the gripper camera insert

    Print `3DPrintMeshes/webcam_mount/so100_gripper_cam_mount_insert.stl` for the M3 nut in the gripper.

  • Print the wrist webcam mount

    Print `3DPrintMeshes/webcam_mount/webcam_mount_wrist.stl`.

  • Print the LeKiwi parts

    Follow the README's 3D-printing instructions. Use its advice if this is your first print or you do not own a 3D printer.

  • Print Modified Koch Components

    Print the modified Koch arm base and the modified static gripper.

  • Continue to 3D printing

    After purchasing the parts in the BOM, continue to the 3D Printing guide.

  • Print all listed parts

    Open the 3DPrinting document and print all the parts listed there.

Assemble

  • Attach the drive motor to the motor mount

    Secure the drive motor to the motor mount with 4 m2x5 tap screws.

  • Mount the drive motor assembly on the base

    Use 4 m3x12 machine screws to screw the drive motor mount onto the bottom base plate.

  • Attach the hub to the omniwheel

    Attach the wheel hub to the omniwheel with 2 m4x12 machine screws.

  • Attach the servo horn to the hub

    Secure the servo horn to the wheel hub using 2 m3x16 machine screws.

  • Attach the servo horn to the drive motor

    Secure the servo horn to the drive motor with 1 m3x6 machine screw.

  • Attach all three wheel modules

    Attach all 3 wheel modules to the bottom base plate.

  • Mount the servo controller and battery mounts

    Insert m3 nuts into the servo controller and battery mounts. Screw both onto the bottom base plate with 4 m3x12 machine screws.

  • Add the servo driver and drive-servo wiring

    Add the servo driver and connect the wires to the 3 drive servos.

  • Wire the 12V power version

    Use wago lever connectors to connect the battery ground and power leads to the 12v->5v converter and dc barrel plug adapter. Mount the converter with 2 m3x16 machine screws and 2 m3 nuts.

  • Mount the 5V power bank holder

    Use the power bank holder from `3DPrintMeshes/5v_specific/5v_power_bank_holder.stl` to keep the power bank in place. Mount it at the back of the lower plate.

  • Connect the 5V cables by diagram

    Connect the cables according to the wiring diagram.

  • Install the Raspberry Pi 5

    Place the Raspberry Pi 5 into the bottom of the Pi case, then snap on the top of the case.

  • Mount the top plate and arm

    Attach the Pi to the top base plate with 2 m3x12 machine screws, then mount the SO-101 arm with 4 m3x20 machine screws. Either the modified or original SO-101 base will work.

  • Install the wired cable holders

    When connecting the USB-C extension cable, keep the UGreen logo on the same side as the `20GBS, 240W` label and place that label side upward. If the cameras or motor controller board cannot be detected, flip the cable 180 degrees.

  • Connect cameras and controller cables

    Attach the cables for the two cameras, motor control board, and USB-C extender as shown.

  • Route cables through the top plate

    Feed the servo controller USB-C-to-USB-A cable, 5V USB-C power cable, and SO-101 servo wires through the hole in the top base plate.

  • Mount the assembled top plate

    Mount the top base plate onto the motor mounts using 4 m3x12 machine screws.

  • Mount the base Arducam camera

    Screw the base camera mount onto the bottom base plate and attach the Arducam 5MP wide-angle camera with 2 M2.5x12 machine screws. The camera mount cable can also be fed through the cutout.

  • Mount the wrist Arducam camera

    Screw the wrist camera mount to the static gripper using 4 M2x5 tapping screws and attach the Arducam 5MP wide-angle camera with 2 M2.5x12 machine screws.

  • Assemble the gripper with M3 nut

    Print the new gripper with the insert for the M3 nut, insert the nut, then insert the motor and attach the gripper.

  • Secure the wrist webcam

    Add an M3x12mm bolt to the wrist camera mount and screw it firmly until it locks with the M3 nut in the gripper. Insert the camera, add 2x M3x35mm bolts in the back holes, and insert 2 nuts into the slots to lock the bolts.

  • Mount the base webcam

    Install the base camera in the same way using `3DPrintMeshes/webcam_mount/webcam_mount.stl`, and attach it to the front of LeKiwi.

  • Connect Controller and Raspberry Pi Power

    Plug the DC barrel plug adapter into the servo motor controller and the 5V USB-C connector into the Raspberry Pi 5.

  • Connect Servo Controller and Cameras

    Plug the USB cables from the servo controller and cameras directly into the Raspberry Pi.

  • Attach the drive motor

    Secure the drive motor to the motor mount with four m2x5 tap screws.

  • Attach the wheel hub

    Secure the wheel hub to the omniwheel using two m4x12 machine screws.

  • Attach the wheel hub

    Secure the wheel hub to the servo horn with four m3x16 machine screws.

  • Assemble both bottom plates

    Align the outer holes of the 3D-printed triangular insert with the TB3 plate and secure it using six M3x8 machine screws and matching nuts.

  • Mount the drive motor mounts

    Mount each drive motor mount on the bottom plate with two m3x12 machine screws at the front and two m2.5x12 machine screws at the back.

  • Connect motor wires and mounts

    Connect the motor wires in series and insert two m3 nuts into the slots of both the battery mount and base camera mount.

  • Secure battery and camera mounts

    Secure the battery mount to the bottom plate using two m3x12mm machine screws.

  • Secure the camera mount

    Secure the camera mount to the plate using two m3x16mm machine screws.

  • Connect power converter and plug

    Use Wago lever connectors to connect the ground and power battery wire leads to the 12V-to-5V converter and DC barrel plug adapter leads.

  • Mount the power converter

    Mount the 12V-to-5V converter to the bottom plate using two m4x16mm machine screws and two m4 nuts.

  • Connect and secure the U2D2

    Connect the unconnected motor wire, USB cable, and power wires to the U2D2 power hub board.

  • Secure the U2D2 board

    Attach standoffs to the U2D2 board and secure it to the base plate using three m3x16mm machine screws.

  • Install Raspberry Pi 5 in Case

    Place the Raspberry Pi 5 into the bottom half of the Pi case and snap on the top cover.

  • Attach the Webcam

    Attach the webcam as shown.

  • Mount Top Plate Components

    Mount the Raspberry Pi to the top plate with two M2x12 machine screws and nuts, then secure the Koch arm with four M3x12 machine screws and nuts.

  • Connect Motor Power Wires

    Connect the 5V motor wire to the U2D2 power hub board with jumper cables. Route the power and ground wires through the voltage reducer, then connect them to the appropriate 5V and GND ports.

Software

  • Install Miniforge for Conda

    Download and run the Miniforge installer for your operating system and processor architecture.

  • Create Conda Environment

    Create a Conda virtual environment named lerobot with Python 3.12.

  • Create uv Virtual Environment

    As an alternative to Conda, install Python 3.12 with uv and create a virtual environment using it.

  • Activate Conda Environment

    Activate the lerobot Conda environment each time you open a shell to use LeRobot.

  • Install evdev With Conda

    When installing LeRobot inside WSL, also install evdev from the conda-forge channel.

  • Activate uv Environment

    On Linux or macOS, activate the virtual environment with the source command. In Windows PowerShell, use the Windows activation command.

  • Install evdev With uv

    When installing LeRobot inside WSL with uv, install the libevdev development package and install evdev in the virtual environment.

  • Check Apple Silicon Requirements

    On Apple Silicon, use macOS 14 or newer for PyTorch and macOS 15 or newer for MPS acceleration. On macOS 14, LeRobot uses the CPU instead.

  • Check Linux NVIDIA Requirement

    On Linux, the default PyTorch wheels require NVIDIA driver version 580.65 or newer. For older drivers, use the referenced PyTorch CUDA variant.

  • Install FFmpeg on Ubuntu or Debian

    Install FFmpeg system-wide on Ubuntu/Debian. The document notes that this is supported with PyTorch >= 2.10 and TorchCodec ≥ 0.10; older PyTorch versions require the conda-forge FFmpeg package.

  • Install FFmpeg on Apple Silicon Mac

    Install FFmpeg with Homebrew on macOS for Apple Silicon.

  • Clone the LeRobot repository

    Clone the LeRobot GitHub repository and change into its directory.

  • Install LeRobot from source

    Install LeRobot in editable mode with pip or uv. Choose core_scripts for robot workflows such as recording, replaying, and calibration; training adds policy training dependencies; all includes every policy, environment, hardware, and development tool.

  • Install the core LeRobot package

    Install the base LeRobot package from PyPI using pip or uv. This provides only the core ML dependencies, so extras are needed for most workflows.

  • Install composite LeRobot extras

    Install composite extras for core robot scripts, policy training, combined recording and training, or the complete package.

  • Install specific policy and hardware extras

    Add the Pi, SmolVLA, or diffusion policy extras, the ALOHA and PushT simulation environment extras, or the Feetech motor support extra. Multiple extras can be combined.

  • Choose the platform CUDA build

    On Linux, the PyPI default wheels for torch and torchvision are CUDA 13 builds requiring driver 580.65 or newer. macOS and Windows use the PyPI default wheels and can skip this section.

  • Install matching CUDA PyTorch components

    For an older driver or GPU, install PyTorch from the matching index first. The cu126 index is for drivers supporting only CUDA 12 and installs torch 2.14 because torch 2.15 has no CUDA 12 build; then install torchcodec from the CPU index, choosing a matching release when torch is below 2.11.

  • Install LeRobot from source or PyPI

    After installing the matching PyTorch build, install LeRobot either as an editable source package or from PyPI.

  • Install with uv and a CUDA backend

    With uv pip, use the --torch-backend option to select the CUDA index and install LeRobot in one step.

  • Configure CUDA for a uv lockfile

    A uv sync uses the committed lockfile. To change its CUDA build, add the index under [tool.uv.index] and [tool.uv.sources] in pyproject.toml, then regenerate the lock with uv lock.

  • Install Linux build dependencies

    If build errors occur, install the additional system dependencies for Linux with apt-get.

  • Consult the PyAV compilation guide

    For systems other than Linux, use the linked Compiling PyAV instructions for bringing your own FFmpeg.

  • Combine and install optional extras

    Combine multiple extras, such as .[aloha,feetech], and refer to pyproject.toml for all available extras. If using uv, replace pip install with uv pip install.

  • Install a simulation environment

    Install aloha, pusht, libero on Linux only, or metaworld; these automatically include the dataset extra. If using uv, replace pip install with uv pip install.

  • Install the motor control extra

    Install dynamixel for Koch v1.1 or feetech for SO100/SO101/Moss. Both motor options communicate through rustypot.

  • Open the local Trackio dashboard

    Trackio is included in the training extra, and local runs require no account or login. Runs are stored in a local SQLite database under ~/.cache/huggingface/trackio and can be opened with trackio show --project lerobot.

  • Log in to the Hugging Face CLI

    Log in through the Hugging Face CLI with a write-access token generated from Hugging Face settings, and add it to git credentials.

  • Set the Hugging Face user variable

    Run the provided commands to set HF_USER from the CLI username and display the value.

  • Initialize the robot interfaces

    Instantiate the SO101 follower and SO101 leader using their respective configurations.

  • Build the dataset feature set

    Convert the robot action and observation features into dataset features, then combine them into one feature dictionary.

  • Start keyboard and visualization tools

    Initialize the keyboard listener for recording controls and start Rerun visualization with the session name "recording".

  • Create the default processors

    Create the default processors for teleoperator actions, robot actions, and robot observations.

  • Pin a pushed checkpoint revision

    Add --policy.pretrained_revision with a commit hash, branch, or tag to pin a specific pushed version. A pushed checkpoint can be selected by its step, such as 010000.

  • Use the wired setup

    For the wired LeKiwi, skip Raspberry Pi installation and SSH setup. Run the LeKiwi and leader-arm teleoperation scripts directly on your PC.

  • Prepare the remote computer

    Set up the remote computer that will run the LeKiwi robot. Use a Raspberry Pi, or a PC that runs on 5V and has at least two USB ports for the cameras and motor control board.

  • Install LeRobot and LeKiwi Support on Pi

    Follow the linked Installation Guide on the Raspberry Pi, then install the LeKiwi extra with Feetech motor support and ZeroMQ.

  • Install LeRobot and LeKiwi Support Locally

    If LeRobot is not already installed on the laptop or PC, follow the linked Installation Guide and install the LeKiwi extra with Feetech motor support and ZeroMQ.

  • Find Each Motor Board USB Port

    Run the port-finding script for each bus servo adapter. When prompted, disconnect the corresponding leader or follower arm, press Enter, and reconnect the USB cable after the port is identified.

  • Grant Access to Linux USB Ports

    On Linux, grant access to the identified USB ports by running the two chmod commands.

Calibrate and test

  • Check Raspberry Pi IP address

    Run the command on the Raspberry Pi command line to check the Pi’s IP address.

  • Check Pi network reachability

    Ping the Raspberry Pi from your laptop or PC. If the ping fails, ensure the Pi is powered on and connected to the same network, and check that SSH is enabled.

  • Test SSH connection

    Use SSH with your Pi username and IP address. If you get a connection error, ensure SSH is enabled by running sudo raspi-config, then navigate to Interfacing Options -> SSH and enable it.

  • Calibrate Both Arms

    Calibrate the leader arm and the follower arm. The wheel motors do not need calibration.

  • Calibrate the Mobile-Base Follower Arm

    Connect the arm to the Raspberry Pi, connect to the Raspberry Pi via SSH, and run the calibration command with a unique robot name. Move the robot so every joint is at the middle of its range and press Enter, then move all joints through their full range of motion.

  • Run Commands on the Laptop

    For the wired LeKiwi version, run all commands on the laptop.

  • Calibrate the Leader Arm

    Run the calibration command or API example on the laptop where the leader arm is attached. Use the leader arm’s port and assign a unique name with --teleop.id.

  • Set up and calibrate the robot

    Follow the setup and calibration tutorial for the robot and teleoperation device, such as LeKiwi, SO-101, OpenArm, or Koch.

  • Add Cameras to the Setup

    Follow the linked Cameras guide to add cameras to the setup.

  • Configure the follower robot

    Create an SO101 follower configuration using the specified serial port and ID. Configure a wrist camera at 640×480 and 30 FPS on index 0, and a top camera at 640×480 and 30 FPS on index 1.

  • Configure the teleoperator

    Create an SO101 leader configuration using the specified serial port and the ID "my_leader_arm".

  • Reuse recorded calibration and task

    Use the same --robot.id so the calibration is found, and use the same --robot.cameras and task description as in the recorded dataset.

  • Configure Space privacy

    New Spaces are public unless the organization’s default is private. Pass --trackio.private=true to create a private Space.

  • Configure console output capture

    Each run records its launch command and console output, including prints, logs, and tracebacks, on the run’s dashboard page. Pass --trackio.capture_console=false to keep console output out of the run.

  • Connect Power and Start

    Plug the DC barrel plug adapter into the servo motor controller and the 5V USB-C connector into the Raspberry Pi 5. The U2D2 power hub board and camera USB cables can plug directly into the Raspberry Pi.

  • Configure ports and IP addresses

    Change the ports, IP addresses, and other configuration values for the specific setup.

Data and training

  • Start teleoperation from the command line

    Run the teleoperate command with the follower and leader types, ports, and IDs. The command identifies missing calibrations, starts calibration if needed, connects both devices, and begins teleoperation.

  • Start teleoperation with the Python API

    Create follower and leader configurations, connect both devices, read actions from the leader, and send them to the follower. Use the same robot ID for teleoperating, recording, and evaluating the same setup.

  • Teleoperate With Camera Feeds

    Run lerobot-teleoperate with the SO-101 follower and leader IDs and ports. Configure wrist and top OpenCV cameras at 640×480 and 30 fps, and enable display_data=true.

  • Build the Rerun Teleoperation Loop

    Configure the SO-101 follower with wrist camera 0 and top camera 1 at 640×480 and 30 fps, and configure the leader. Initialize rerun visualization, connect both devices, and run the 30 Hz loop that obtains observations and actions, sends actions, and logs visualization data.

  • Record and upload five episodes

    Adapt the robot-specific ports, IDs, cameras, and teleoperation settings, then execute the command to record 5 episodes and upload the dataset to the Hub.

  • Set the recording parameters

    Set the script to record 5 episodes at 30 FPS, with 60-second episodes, a 10-second reset time, and the task description "My task description".

  • Create the recording dataset

    Create a LeRobotDataset with the specified repository ID, 30 FPS, combined features, follower robot type, videos enabled, and four image-writing threads.

  • Run the episode recording loop

    Continue recording while the episode index is below 5 and the stop-recording event is not set. Log each episode before running the recording loop.

  • Record teleoperated robot data

    Run the recording loop with the robot, teleoperator, dataset, processors, and events at 30 FPS. Set the control time to 60 seconds, the task description to "My task description", and display the recorded data.

  • Reset Between Recordings

    Reset the environment when recording is not being stopped and another episode remains or the episode is being re-recorded.

  • Re-record the Current Episode

    For a re-recorded episode, clear the recording event flags and episode buffer, then continue the recording loop.

  • Save Each Recorded Episode

    Save the completed episode and advance the episode index after recording.

  • Finalize and Upload the Dataset

    Finalize the dataset, disconnect the robot and teleoperation device, and push the dataset to the Hugging Face Hub.

  • Keep Consistent Camera Names

    Choose wrist and top as the camera names, resulting in observation.images.wrist and observation.images.top keys, and reuse the same --robot.cameras value throughout the tutorial.

  • Identify the Timestamped Dataset

    lerobot-record appends the session date and time to --dataset.repo_id, producing a unique name such as record-test_20260929_143012.

  • Find the Local Dataset Name

    Find the full generated dataset name on the Hugging Face profile or in ~/.cache/huggingface/lerobot/${HF_USER}.

  • Disable Dataset Name Timestamping

    Add --dataset.no_stamp=true to keep the exact repository ID passed to the recording command.

  • Locate the Recorded Dataset

    The recorded dataset is stored locally in ~/.cache/huggingface/lerobot/{repo-id}.

  • Open the Dataset Hub Page

    After recording, the dataset is uploaded to the dataset page at https://huggingface.co/datasets/${HF_USER}/record-test_YYYYMMDD_HHMMSS.

  • Tag the Dataset for Discovery

    The dataset is automatically tagged with LeRobot, and custom tags such as --dataset.tags='["tutorial"]' can also be added.

  • Push the Dataset Manually

    Push the local dataset to the Hugging Face Hub manually.

  • Upload the recorded dataset

    Upload the timestamped record-test dataset from the local Hugging Face cache to a dataset repository.

  • Store recordings in LeRobot format

    lerobot-record stores captured data on disk using the LeRobotDataset format during recording.

  • Disable automatic dataset uploading

    Set `--dataset.push_to_hub=False` to disable uploading.

  • Allow automatic recording checkpoints

    Checkpoints are created automatically while recording.

  • Resume an existing recording dataset

    Re-run the same command with `--resume=true` and the full timestamped `--dataset.repo_id`. Set `--dataset.num_episodes` to the number of additional episodes and provide the required local `--dataset.root="local_path"`.

  • Start a new recording dataset

    Without `--resume=true`, re-running the command starts a new dataset with a new timestamp. If `--dataset.no_stamp=true` is used, delete the existing dataset directory first.

  • Set the episode recording duration

    Set `--dataset.episode_time_s=60` to make each recording episode last 60 seconds.

  • Set the environment reset duration

    Set `--dataset.reset_time_s=60` to allow 60 seconds for resetting the environment after each episode.

  • Set the number of episodes

    Set `--dataset.num_episodes=50` to record 50 episodes in total.

  • Move to the next episode

    Press the Right Arrow or `n` to stop the current episode or reset time early and move to the next episode.

  • Re-record the current episode

    Press the Left Arrow or `r` to cancel the current episode and record it again.

  • Stop recording and upload data

    Press Escape or `q` to immediately stop the session, encode the videos, and upload the dataset.

  • Use recording shortcuts in any session

    The recording shortcuts work on X11, Wayland, and headless or SSH sessions. If a global keyboard backend is unavailable, launch lerobot-record from an interactive terminal and keep it focused; no `$DISPLAY` setup is required.

  • Check keyboard teleoperation support

    Keyboard teleoperation requires a global key backend and works only on X11, a Windows desktop, or macOS with Accessibility or Input Monitoring permission. It does not work on Wayland or headless sessions.

  • Create a larger grasping dataset

    Create a larger dataset for training by grasping an object at different locations and placing it in a bin.

  • Record at least fifty episodes

    Record at least 50 episodes, with 10 episodes for each object location.

  • Keep the recording setup consistent

    Keep the cameras fixed and maintain consistent grasping behavior throughout the recordings.

  • Keep the object visible

    Make sure the manipulated object is visible on the cameras. You should be able to perform the task yourself using only the camera images.

  • Add variations gradually

    After reliable grasping performance is achieved, gradually add grasp locations, grasping techniques, or camera-position changes. Avoid adding too much variation too quickly because it may hinder results.

Use it

  • Run a base autonomous rollout

    The base strategy performs an autonomous rollout without recording data, which is useful for quick evaluation. The example loads the policy from ${HF_USER}/my_policy and runs for a duration of 60.

  • Run LeRobot from Its Installation Folder

    Whenever using LeRobot, open the ~/lerobot installation folder and run one of the commands.

Common problems

  • Teleoperation fails or errors after about 30 seconds #23 #24
  • Regional BOM power components have inconsistent specifications and ratings #6 #12
  • Provided STL and 3MF files fail to open #16 #21
  • Arm remains jittery at rest despite stable power #10
  • Print and assembly files still reference obsolete motor mounts #11
  • URDF remains outdated after motor mount changes #14
  • Discord invitation does not let builders join the server #5

Datasets

Parts

  • 3 ST3215 servos (about $13.89 each)
  • 3 four-inch omni wheels (VEX, about $9.99 each)
  • Raspberry Pi 5 4GB (about $60)
  • 2 USB cameras, workspace and wrist (about $12.98 each)
  • 12V 5A Li-ion battery (about $32.99) or an 85W power bank for the 5V version
  • SO‑101 two-arm teleoperation set (about $199.78)
  • 3D prints (repo 3DPrintMeshes folder)

Tools

  • 3D printer
  • Tool list in the repo's Assembly.md

Skills

  • Raspberry Pi and Linux basics
  • LeRobot configuration

Software

  • LeRobot
  • Keyboard or controller teleoperation and data collection

Documents