Connecting to sources…

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

  • Low control frequency reduces force-estimation accuracy. #34
  • Exposed and poorly planned wire harnesses cause routing and assembly problems. #49

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

Documents