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
| Part | Qty | US | EU | CN |
|---|---|---|---|---|
| 4" Omni wheels | 3 | USD 9.99 | EUR 24.5 | CNY 135 |
| M2 M3 M4 Assorted Screw Set | 1 | USD 14.99 | EUR 23.5 | CNY 25 |
Bill of materials · Sensors and Compute
| Part | Qty | US | EU | CN |
|---|---|---|---|---|
| Raspberry Pi 5 (4GB) | 1 | USD 60 | EUR 57 | CNY 410 |
| USB camera | 2 | USD 12.98 | EUR 12 | CNY 48 |
| microSD card | 1 | USD 11.23 | EUR 10 | CNY 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