How to build OpenArm 2.0 (open-source humanoid arms): the whole process
113 steps to build OpenArm 2.0 (open-source humanoid arms), from buying parts, printing and assembly to software, calibration and training, with the bill of materials, s…
Enactic puts a complete bimanual system at $6,500 (README and LeRobot docs; openarm.dev labels the figure bill-of-materials cost). The certified manufacturer WowRobo sells it assembled for $6,500 without the top stereo camera or $7,300 with it (2026‑11‑01, shipping and import duties extra); no DIY kit price is listed
Buy parts
- Buy an Assembled or DIY OpenArm
Browse verified and certified manufacturers worldwide at openarm.dev to obtain an assembled or DIY OpenArm.
- Review the Bill of Materials
Follow the official OpenArm hardware documentation for the bill of materials and sourcing.
- Purchase OpenArm
Get an assembled or DIY OpenArm through the purchase page.
Print and make
- Follow the Printing Instructions
Follow the official OpenArm hardware documentation for the 3D printing instructions.
Assemble
- Secure the Arm Installation
Fasten the arm to a flat, stable surface using screws or clamps.
- Complete the Mechanical Assembly
Follow the official OpenArm hardware documentation for mechanical assembly.
- Connect the Electrical Wiring
Follow the official OpenArm hardware documentation for electrical wiring.
- Verify CAN Bus Wiring
Check the CAN-H, CAN-L, and GND wiring.
Software
- Install Miniforge
Install Miniforge with the provided download and installation commands. This step is for conda users.
- Create a Python 3.12 Environment
Create a virtual environment with Python 3.12 using conda, or use uv to install Python 3.12 and create the environment.
- Activate the Virtual Environment
Activate the lerobot conda environment each time you open a shell, or activate the uv environment with the appropriate command for Linux/macOS or Windows PowerShell.
- Install evdev for WSL
When installing LeRobot inside WSL, install evdev using the provided conda or Ubuntu commands.
- Check Apple Silicon Requirements
Use macOS 14 or newer for PyTorch on Apple Silicon. MPS acceleration requires macOS 15 or newer; on macOS 14, LeRobot falls back to CPU.
- Check Linux NVIDIA Requirements
On Linux, the default PyTorch wheels require an NVIDIA driver of version 580.65 or newer. For older drivers, see the PyTorch CUDA variant.
- Check ffmpeg requirements
LeRobot uses TorchCodec for video decoding by default, which requires ffmpeg. Skip this installation on macOS Intel (x86_64) and Linux armv7l because LeRobot automatically falls back to pyav.
- Use CPU video decoding on Jetson
On Jetson with aarch64 and CUDA, video decoding runs on CPU by default. The provided Jetson Dockerfile builds torch and torchcodec from source with CUDA support for JetPack 6.2.
- Install ffmpeg in conda
Install ffmpeg in your conda environment. This method works with all PyTorch versions and is required for PyTorch versions earlier than 2.10.
- Use system-wide ffmpeg
With PyTorch 2.10 or newer and TorchCodec 0.10 or newer, TorchCodec can dynamically link to a system-wide ffmpeg installation. This is useful when using uv or other non-conda environment managers.
- Install FFmpeg on Ubuntu or Debian
Install ffmpeg system-wide. System-wide ffmpeg requires PyTorch >= 2.10 (TorchCodec ≥ 0.10); with older PyTorch versions, use conda install ffmpeg -c conda-forge instead.
- Install FFmpeg on Apple Silicon macOS
Install ffmpeg system-wide with Homebrew. System-wide ffmpeg requires PyTorch >= 2.10 (TorchCodec ≥ 0.10).
- Clone the LeRobot repository
Clone the lerobot repository and navigate into its directory.
- Install editable robot workflow dependencies
Install the library in editable mode with the core_scripts extra for recording, replaying, and calibration workflows.
- Install editable policy training dependencies
Install the library in editable mode with the training extra for training policies.
- Install all editable dependencies
Install the library in editable mode with all policies, environments, hardware, and development tools.
- Install editable robot workflows with uv
Use uv to install the library in editable mode with core_scripts for recording, replaying, and calibration workflows.
- Install editable training dependencies with uv
Use uv to install the library in editable mode with the training extra for training policies.
- Install all editable dependencies with uv
Use uv to install the library in editable mode with all policies, environments, hardware, and development tools.
- Install the base LeRobot package
Install the base lerobot package from PyPI. This provides only the core ML dependencies.
- Install LeRobot with uv
Install the base lerobot package from PyPI using uv. This provides only the core ML dependencies.
- Install robot workflow extras
Install the composite core_scripts extra to support recording, replaying, and calibration.
- Install policy training extras
Install the training extra to support training policies.
- Install recording and training extras
Install the combined core_scripts and training extras to support recording and training.
- Install all LeRobot extras
Install every LeRobot feature extra.
- Install Pi policy dependencies
Install the policy dependencies for Pi0, Pi0.5, and Pi0-FAST.
- Install SmolVLA policy dependencies
Install the dependencies required by the SmolVLA policy.
- Install diffusion policy dependencies
Install the diffusion policy dependencies, including diffusers.
- Install simulation environment dependencies
Install the dependencies for the ALOHA and PushT simulation environments.
- Install Feetech motor support
Install the extra that provides Feetech motor support.
- Choose the correct PyTorch installation
On macOS and Windows, use the default PyPI wheels and skip the CUDA-specific section. On Linux with an older driver or GPU, install PyTorch from the matching index before installing LeRobot.
- Install CUDA 12 PyTorch
Install the CUDA 12.6 PyTorch and torchvision wheels for drivers that only support CUDA 12. The CUDA 12 index installs torch 2.14 because torch 2.15 has no CUDA 12 build.
- Install CPU TorchCodec
Install TorchCodec from the CPU index because the default Linux PyPI TorchCodec package is a CUDA 13 build. With torch below 2.11, select the matching release from the TorchCodec compatibility table.
- Install LeRobot
Install LeRobot from the source checkout with all optional dependencies, or install the published package from PyPI. Use the source or PyPI command that matches your installation source.
- Install LeRobot with uv
Use the uv pip torch backend selector to install LeRobot with the CUDA 12.6 build in one step.
- Change the uv CUDA build
The uv sync command uses the committed lock file. To change its CUDA build, add the index to [tool.uv.index] and [tool.uv.sources] in pyproject.toml, then regenerate the lock file.
- Install build dependencies
If build errors occur, install cmake, build-essential, Python development headers, pkg-config, and the listed FFmpeg development libraries on Linux. For other systems, follow the PyAV FFmpeg installation instructions.
- Combine optional dependency extras
Install only the extras needed for the desired functionality. Multiple extras can be combined.
- Install a simulation environment
Install aloha or pusht; libero is Linux only, and metaworld is also available. These extras automatically include the dataset extra, and uv can replace pip install with uv pip install.
- Install motor control support
Install feetech for SO100, SO101, or Moss, or dynamixel for Koch v1.1. Both motor-control extras communicate through rustypot.
Calibrate and test
- Locate the Emergency Stop
Know the location of the emergency stop device and how to operate it.
- Inspect the Arm Before Operation
Check for loose screws, damaged mechanical limits, unusual noises, and wiring damage.
- Configure the Follower Arm
Apply the follower configuration options listed in the document’s table.
- Configure the Leader Arm
Apply the leader configuration options listed in the document’s table.
- Apply Default Motor Configuration
Configure the Damiao motors using the default values in the motor configuration table.
- Check the Power Supply
Verify that the power supply connections are secure.
- Run CAN Diagnostics
Run the CAN diagnostic test on interface can0.
- Check the CAN Interface
Verify that the can0 CAN interface is configured.
- Verify the ROS 2 Installation
Run `ros2 -h` and `ros2 topic list` to verify the ROS 2 installation.
- Resolve ffmpeg version issues
This normally installs ffmpeg 8.X with the libsvtav1 encoder. If libsvtav1 is missing or there is a torchcodec version mismatch, explicitly install ffmpeg 7.1.1.
Data and training
- Write version 0.4.0 datasets
Use dora-openarm-dataset-recorder or Dataset.write() to write datasets; the current format version is 0.4.0.
- Create the dataset directory tree
Each episode directory contains the action, cameras, and obs subdirectories, while the dataset root contains metadata.yaml. Arm states are stored as state.parquet, lifter states as elevation.parquet, and camera images as JPEG files.
- Record each session separately
Record each session into a new dataset directory; episode IDs are assigned sequentially during recording, and cancelled episodes are deleted, so IDs may have gaps.
- Merge only compatible session datasets
Combine session datasets with openarm-dataset-merge; the version, equipment, and frequencies in metadata.yaml must be exactly the same for datasets being merged.
- Match settings for sessions to merge
Sessions to be merged must be recorded with the same robot, leader, and dataflow.
- Store one arm-state row per sample
Store one row per sample in obs/arms/<side>/state.parquet and action/arms/<side>/state.parquet, where side is right or left. The timestamp column uses Unix time in nanoseconds, and every other column is a list of float32 values for one attribute.
- Map recorded arm-state attributes
obs usually has qpos, qvel, and qtorque; action has qpos from dora-openarm-data-collection dataflows, or pose when a dataflow records end-effector targets directly. Gripper is the gripper motor position, and pose uses the openarm_control convention.
- Inspect Right-Arm State Data
Read episodes/0/obs/arms/right/state.parquet and inspect the timestamp, qpos, qvel, and qtorque columns. The first qpos sample contains 8 float32 values.
- Read Lifter Elevation Data
Inspect the timestamp and value columns in obs/lifter/elevation.parquet and action/lifter/elevation.parquet. The value is a list containing one value: the OpenArm Cell lifter elevation in millimeters from the bottom.
- Organize Five Camera Streams
Store each camera as either a cameras/<name>/<timestamp>.jpeg directory or an uncompressed cameras/<name>.tar archive containing the same JPEG files. File names use the Unix timestamp in nanoseconds of the camera message, and the tar format is recommended for uploading to the Hugging Face Hub.
- Complete Dataset Metadata
Record the dataset version, location, operator, operation type, tasks, episodes, equipment, perceptions, and frequencies in metadata.yaml. The OpenArm Cell metadata also describes the lead_screw mechanism, 5.0 lead length, 300 stroke, bottom home position, and mm unit.
- Keep Task Prompts Consistent
Use the same prompt for the same task because openarm-dataset-merge treats tasks with the same prompt as the same task. The prompt is the short task instruction shown in the data collection web UI and used for LeRobot, GR00T, and robot_eval_logger conversions.
- Configure collection metadata
In the dora-openarm-data-collection dataflow metadata file metadata_$ROBOT.yaml, such as metadata_cell.yaml, set location, operator, and tasks. The recorder also adds version, operation_type, episodes, frequencies, equipment.leader (KER), and model (rollout).
- Read old formats and write new ones
openarm_dataset can read older formats from 0.1.0–0.3.0 and unversioned datasets. Dataset.write() or openarm-dataset-convert --format openarm always writes the latest format.
- Open and inspect a dataset
Point Dataset at the root directory of a recording, then inspect the episode count, version, and tasks. The example dataset contains 2 episodes at version 0.4.0.
- Select an Episode object
dataset.meta.episodes is a list of Episode objects. Pass an Episode object, not an integer index, to the loading methods; the example episode has id 0, success False, and task_index 0.
- Load observations and actions
Use dataset.load_obs(episode) and dataset.load_action(episode) to read an episode; they return a dict of pandas DataFrames keyed by signal name with arms/right and arms/left qpos, qvel, qtorque plus lifter/elevation.
- Use a float timestamp index
Pass use_unixtime=True to the loading functions to get a float index instead of a datetime index.
- Convert to qpos, pose or rot6d
Select a representation with state="qpos", state="pose" or state="rot6d"; recorded data is converted on the fly, qpos to pose via forward kinematics and pose to qpos via inverse kinematics, computed with openarm_control.
- Run inverse kinematics from recorded qpos
The inverse kinematics starts from the episode's recorded qpos, a warning is shown for samples it could not solve, the gripper value is passed through without conversion, and the dataset files are not modified.
- Load and Inspect Camera Frames
Load the episode’s camera frames and inspect the `ceiling`, `head_left`, `head_right`, `wrist_left`, and `wrist_right` cameras. Get frame 0 from the ceiling camera, which returns a NumPy array with shape `(600, 960, 3)`, and iterate through all frames from that camera.
- Sample Synchronized Timesteps
Sample at 30 Hz to align observations, actions, and camera frames so they can be consumed as one timestep. Samples contain a timestamp, left and right arm qpos, qvel, and qtorque, plus `lifter/elevation`; images from each camera have shape `(600, 960, 3)`.
- Validate the Dataset
- Convert to a LeRobot Dataset
Convert OpenArmDataset to a LeRobot Dataset using either the lerobot_v2.1 or lerobot_v3.0 format.
- Configure conversion options
Use --state {qpos,pose,rot6d} to select the arm state representation; the default is qpos. Use --arm-dynamics to also export recorded joint velocity and torque as observation.velocity and observation.torque.
- Filter dataset episodes
Use --success-only to include only successful episodes, or --valid-only to include only valid episodes.
- Use other dataset formats
The --format option also supports gr00t (GR00T LeRobot), robot_eval_logger, and openarm (the latest OpenArm Dataset format).
- Package camera data
With --format openarm --camera-format tar, each camera is stored as a single tar archive; this is recommended for uploading to the Hugging Face Hub.
- Sync runs to a Space
Authenticate with Hugging Face, then specify the target Space with --trackio.space_id=<user>/<space>. The Space is created if it does not exist.
- Configure tracking for remote jobs
Tracking for remote jobs launched with --job.target requires a space_id. The space_id is necessary because the pod’s local database is lost when the job ends.
- Set the Space privacy option
New Spaces are public by default unless the organization’s default is private. Pass --trackio.private=true when creating a private Space.
- Control console output capture
Each run records its launch command and console output, including prints, logs, and tracebacks, which appear on the run’s dashboard page. On a Space, this output is as visible as the Space itself; use --trackio.capture_console=false to omit it.
Use it
- Read the Official Safety Guide
Read the official safety guide before operating OpenArm.
- Maintain a Safe Operating Distance
Keep body parts and objects outside the arm's range of motion during operation.
- Wear Required Protective Equipment
Always wear safety goggles and use additional personal protective equipment as needed.
- Respect the Payload Limits
Do not exceed 6.0 kg peak or 4.1 kg nominal payload per arm.
- Set Up Unilateral Teleoperation
Let the follower arm directly mimic the leader’s movements through position commands, with no force feedback returned. This mode is simple and robust for initial tests and free-space motion.
- Set Up Bilateral Force Feedback
Enable two-way force feedback between the leader and follower arms so the operator can feel what the follower arm touches. Follow the Bilateral Control guide for detailed setup and configuration.
Common problems
Parts
- Joint motors (DAMIAO, 24V, CAN, two 14-bit magnetic encoders): DM‑J8009P‑2EC at the shoulder (20 N·m rated / 40 N·m peak), DM4340 series in the upper arm and elbow (9 / 27 N·m, 40:1), DM‑J4310‑2EC at the wrist (3 / 7 N·m)
- Two-finger parallel gripper (30 N grip per WowRobo's page) with a built-in Arducam B0495 camera and replaceable fingers
- MiSUMi aluminium-extrusion pillars; a 190×250×8 mm base plate with 48 M6 holes (WowRobo); mechanical limits on every joint
- Standard-BOM vision: a ZED Mini stereo head camera and two wrist cameras sharing one USB hub and a 5 Gbps repeater cable
- USB-to-CAN‑FD adapter (the FAQ recommends the devices in the 1.0 BOM), two 24V 15A supplies and an emergency stop (WowRobo accessory list)
- Teleop leader OpenArm KER: a motorless passive arm with 16 Infineon TLE5012B 15-bit absolute magnetic encoders and links scaled to 70% (purchase page)
Tools
- A self-build needs machined CNC parts and printed casings (the LeRobot docs say every part can be bought and built by individuals or labs); most buyers get factory-assembled units
- A Linux computer with a CAN‑FD interface; screws or clamps to fix the base to a table, safety goggles and an emergency stop (safety guide)
Skills
- Linux and CAN interface setup (lerobot-setup-can or the openarm_can CLI), zero-position calibration
- ROS 2 / MoveIt 2 or dora-rs dataflows; tuning MIT-mode PD gains and gravity and friction compensation (FAQ)
- Imitation learning and policy inference: LeRobot, plus Isaac Lab, MuJoCo or mjlab simulation
Software
- openarm_can (Apache‑2.0): CAN motor control library and CLI
- openarm_ros2 (ros2_control and MoveIt 2), openarm_description (URDF/xacro)
- dora-openarm-*: KER, Meta Quest 3 VR and WebXR teleoperation, data-collection, inference and evaluation dataflows
- LeRobot (Apache‑2.0): pip install -e ".[damiao]", types openarm_follower, openarm_leader and the bimanual bi_openarm_*
- Simulation and data: openarm_mujoco, openarm_isaac_lab, openarm_mjlab; the openarm_dataset format converts to LeRobot