How to build AlohaMini (AlohaMini2 / AlohaMini 1): the whole process
143 steps to build AlohaMini (AlohaMini2 / AlohaMini 1), from buying parts, printing and assembly to software, calibration and training, with the bill of materials, shop…
The creators' estimates: the README lists the main parts at about $950 (leader arms excluded, frame self-printed from about 6 kg of filament); BOM.md totals the full set (base, two follower arms, two leader arms, fasteners) at CN¥7,548 / about $1,097 self-printed, excluding about 5 kg of filament and common tools such as a table clamp, soldering iron and screwdrivers. The first generation was about $600 self-printed
Bill of materials · Bill of Materials (BOM)
| Part | Qty | US |
|---|---|---|
| Servo — standard | 11 | USD 16 |
| Servo — high-torque | 7 | USD 50 |
| Bus servo controllers | 2 | USD 5 |
| Compute | 1 | USD 93 |
| Cameras | 5 | USD 17 |
| Omni wheels | 3 | USD 40 |
| Battery 12V | 2 | USD 16 |
| Frame | — |
Bill of materials · Mobile base
| Part | Qty | US | CN |
|---|---|---|---|
| Servo motor | 4 | USD 13.89 | CNY 110 |
| Omni wheel | 3 | USD 47 | CNY 135 |
| USB camera | 3 | CNY 125 | |
| (optional) Bearing | 3 | CNY 6 | |
| Bearing | 8 | CNY 3 | |
| M2×12 Phillips screw | 12 | ||
| M3×12 hex socket screw | 36 | ||
| M3×18 hex socket screw | 12 | ||
| M3×30 hex socket screw | 8 | ||
| M3 hex nut | 8 | ||
| M3x5x4 heat-set insert | 36 | CNY 5 | |
| M4×12 hex socket screw | 20 | ||
| M4x6x5 heat-set insert | 12 | CNY 4 | |
| Adhesive | 1 | CNY 12 | |
| Servo extension cable | 2 | CNY 3 | |
| Battery | 2 | USD 43 | CNY 130 |
| USB Type-C cable | 1 | USD 10 | CNY 20 |
| Waveshare Bus Servo Controller | 1 | USD 13 | CNY 27 |
| 3D-printed parts | ~4 kg filament |
Buy parts
- Prepare the mobile base and follower arms
Prepare a mobile base and two follower arms; the follower arms reuse the SO-ARM100 design.
- Prepare the host teleoperation equipment
The host side uses a PC workstation and leader arms; VR controllers or other devices can replace the leader arms. Beginners are recommended to start with leader-arm teleoperation.
- Add standalone-mode components
To operate the base untethered over Wi‑Fi, add the standalone-mode components listed in the table.
- Purchase components and print parts
Purchase the components and 3D-print the parts using the BOM and 3D-print documentation.
- Review BOM and Source Parts
Review the component list and source the listed parts.
Print and make
- Print the bearing covers
Print three OB_Chassis_Bearing_Cover parts.
- Print the servo mounts
Print three OB_Chassis_Servo_Mount parts.
- Print the chassis side panels
Print three OB_Chassis_Side_Panel parts.
- Print the wheel axle connectors
Print three OB_Chassis_Wheel_Axle_Connector parts.
- Print the wheel guards
Print three OB_Chassis_Wheel_Guard parts.
- Print the top camera back covers
Print two OB_Top_Camera_Back_Cover parts.
- Print the shaft sleeves
Print three OB_Chassis_Shaft_Sleeve_12_24 parts.
- Print the chassis dowel pins
Print three O_Chassis_Dowel_Pin_12_37 parts.
- Print all other files
Print each of the other listed files once, including the lift mechanism.
- Print the remaining parts on a standard printer
All parts except the chassis, including the lift mechanism, can be printed on a standard 3D printer.
- Select a large-enough chassis printer
The chassis requires a build volume of at least 385 × 345 × 64 mm; choose a machine around 400 × 360 × 100 mm or larger.
- Outsource the chassis printing if needed
Because of its size, the chassis may need to be printed by an external service.
- Print follower D files
Print all “D_*.stl” files, x2 each.
- Print follower F files
Print all “F_*.stl” files, x2 each.
- Follow the printing instructions
Refer to the linked SO-ARM100 project README for detailed printing instructions.
- Print leader D files
Print all “D_*.stl” files, x2 each.
- Print leader L files
Print all “L_*.stl” files, x2 each.
- Follow the printing instructions
Refer to the linked SO-ARM100 project README for detailed printing instructions.
- Print the hardware STL files
The `/hardware/` directory contains printable STL files.
- Print the Lift Tower Parts
Prepare the lift tower parts in this order: O_POST4_Connector_Base.stl, O_Main_Assembly_Post4.stl, OB_Main_Assembly_Post3.stl, OB_Main_Assembly_Post2.stl, OB_Main_Assembly_Post1.stl.
- Print All Structural Parts
Print all structural parts with Bambu P2S, using approximately 6 kg of filament.
Assemble
- Connect Servo Cables
Connect servos 8, 9, and 10 with the included 20cm servo cables, and connect servos 10 and 11 with a 90cm servo cable.
- Install Servo Bracket Inserts
Install M3 heat-set inserts into the servo brackets using a soldering iron.
- Secure the Servos
Secure the servos using the small screws included with the servos.
- Install Wheel Axle Connectors
Install the wheel axle connectors. If the connector does not fit, sand it down for a better fit. After installation, tighten it with screws or use epoxy resin if it is loose; no additional treatment is needed if it is tight enough.
- Mount Servos to Chassis
Mount the servos to the chassis plate, following the servo order shown in the image.
- Secure Servos with M3x14 Screws
Secure the servos to the chassis plate using M3x14 screws.
- Attach Omni Wheels
Attach the omni wheels to the servo connector using M3x18 screws.
- Install Chassis Bearings
Optionally install the chassis bearings. Insert the 12x18x4 bearings into the dowel pin and shaft sleeves, install M4 heat-set inserts into the Chassis_Bearing_Cover, and fasten it with M4x12 screws.
- Install Side Plate Inserts
Install M3 heat-set inserts into the side plates.
- Assemble Main Posts
Assemble the main posts like building blocks; there are four in total. Use epoxy resin or double-sided tape to bond the parts together.
- Install the Lift Axis
Install the lift axis and prepare the materials according to the BOM list.
- Secure the Gear
Secure the gear using the screws included with the servo.
- Insert Gear into Servo Mount
Insert the gear into the Axis_Servo_Mount.
- Secure Axis Bracket
Secure the Axis_Bracket to the servo using the included M3x6 screws from the servo.
- Install the T-Bracket
Install the T-bracket.
- Secure with Epoxy Resin
Secure it with epoxy resin.
- Slide Lift Axis into Bracket
Slide the lift axis into the T-bracket.
- Install Top and Back Cameras
Install the Top and Back cameras, removing the two screws from the camera back cover.
- Reinstall Camera Back Cover
Reinstall the back cover using M2x12 screws, sandwiching the printed part between the cover and camera.
- Route Camera Cable
Route the camera cable through the internal channel of the printed part.
- Secure Display
Secure the display to the printed part using the included M3 servo screws.
- Insert Display into Main Post
Slide the display into the rear slot of the main post.
- Install Front Camera
Install the Front camera using the same method as the Top camera and slide it into the slot. File down any burrs on the printed part for a smooth fit.
- Route Cables Through Main Post
Route the USB Type-C data cable and DC power cable through the hole on the rear side of the main post.
- Complete Mobile Base Assembly
The Mobile Base assembly is complete.
- Assemble Leader and Follower Arms
Refer to the SO-101 Assembly Guide to assemble the Leader arms and Follower arms.
- Secure Robotic Arm
Secure the robotic arm to both sides of the T-bracket using four M3x30 hex screws and four M3 nuts.
- Connect Left Arm Servo Cable
Connect the 90cm servo cable from servo #11 to the other port on the Waveshare controller board of the left arm.
- Attach Step-Down Converter
Attach the 12V to 5V step-down converter to the base and connect it to the Raspberry Pi.
- Connect Lithium Battery Power
Connect the 12V lithium battery to the step-down converter to provide power.
- Connect DC Splitter Cable
Connect the male plug of the 1-to-2 DC splitter cable to the female connectors of the two DC extension cables.
- Connect Second Lithium Battery
Connect the second 12V lithium battery to the female connector of the 1-to-2 DC splitter cable.
- Complete Final Assembly
The Follower arms and Mobile Base assembly is fully complete.
- Prepare the follower and leader arms
Prepare the follower and leader arms using the AM-ARM200 Assembly Guide before assembling the mobile base.
- Remove chassis print supports
Remove all print supports from the chassis parts, especially the wheel pockets, cable channels, and dowel-pin slots.
- Apply epoxy to mating surfaces
Apply epoxy to the mating surfaces of the chassis parts.
- Install the chassis locking wedge
Insert `OB_Chassis_Locking_Wedge.stl` into the locking-pin slot. Install the three tapered chassis locking pins in the correct direction so they wedge the tower base tightly after assembly.
- Join the chassis frame
Apply epoxy to the `OB_Chassis_Frame_Joiner.stl` joiner, then press the chassis parts together until they are fully seated.
- Install the three wheel servos
Install the three wheel servos in the chassis and place them in the shown orientation after assigning their IDs.
- Connect and secure wheel servos
Connect servo 8 to 9, servo 9 to 10, and servo 10 to 11. Because servos 10 and 11 are far apart, use at least a 90 cm 3-pin servo cable, with 140 cm recommended, and fasten the servos with their supplied screws.
Software
- Add AlohaMini to Existing LeRobot
Copy the files from `alohamini/software` into the existing LeRobot workspace, then follow the configuration and command-line examples in the `lerobot_alohamini` repository.
- Clone the Integrated LeRobot and AlohaMini Repository
Beginners can clone the integrated `lerobot_alohamini` repository directly. It bundles LeRobot and AlohaMini together, so no manual copying or path configuration is required.
- Assign Servo IDs
- Set up software and teleoperation
Install the software, connect the robot, and control it using the software guide.
- Get lerobot_alohamini
Clone the lerobot_alohamini repository, install its dependencies, and run commands from the repository root.
- Install Software and Connect Control
Install the software, connect the robot, and control it through teleoperation according to the software guide.
- Clone and install lerobot_alohamini
Clone and install the `lerobot_alohamini` repository.
- Configure the separate checkout
Set PYTHONPATH on both the PC and Pi, then confirm that the tested checkout is imported instead of another editable installation.
- Apply Pi0.5 data transforms
Apply horizontal and vertical image flips, then align robot actions to the Pi0.5 action space using the configured robot_dof. Create model transforms from the model config and default prompt.
- Validate the 18-value delta mask
delta_action_mask must contain exactly 18 values. When delta actions are enabled, use the mask to transform inputs with DeltaActions and outputs with AbsoluteActions.
Calibrate and test
- Find device ports one at a time
Plug in one device at a time, then identify its port.
- Configure follower arm ports
On the Raspberry Pi, edit src/lerobot/robots/alohamini/config_alohamini.py and set left_port to the left-bus port and right_port to the right-bus port.
- Set stable leader arm aliases
The PC scripts use /dev/am_arm_leader_left and /dev/am_arm_leader_right as the leader-arm aliases; set up the corresponding udev aliases as described in the persistent-arm-ports section of commands.md.
- Keep script device paths consistent
If different device paths are used, keep them consistent in calibrate_bi.py, teleoperate_bi.py, and record_bi.py.
- Check preconfigured complete-kit ports
If you purchased a complete AlohaMini, the follower-arm ports on the Raspberry Pi are already fixed by udev rules and require no action.
- Test evaluation termination
Verify that a Host restart or another command owner ends evaluation. Heartbeat commands do not bypass the Host watchdog.
- Start Host teleoperation and evaluation
Start the Host, teleoperation, and evaluation with the existing environment, robot model, and calibration.
- Run robot recovery tests in order
Use supported arms and a clear workspace; check ordinary teleoperation first, then test slow inference, normal stop, and reconnect. Validate hardware timing and recovery behavior on the robot because mocked tests do not establish them.
- Test missing-image warnings
Camera warnings follow the Host's enabled-camera list and appear once per missing-image episode.
- Check camera warning conditions
State-only responses do not trigger missing-image warnings. Older Hosts without camera metadata use the client configuration, and cached or placeholder images do not gain fresh capture timestamps.
- Assign servo IDs before installation
Assign the servo IDs before installation and configure one servo at a time to avoid ID conflicts.
- Configure a servo ID
Run the example from the repository root to change ID 1 to ID 8 through `/dev/ttyACM0`.
- Use the FD Debug Tool
Use the Feetech FD Debug Tool through the Waveshare bus servo controller with baud rate `1000000`. Scan the servo, write the target ID, then disconnect it before configuring the next servo.
- Run the Chassis Test
With the chassis assembled, run the debug command from the `lerobot_alohamini` repository to drive the base directly for a first test.
- Test Wheel Driving
Run the W/S/A/D drive test on /dev/ttyACM0.
- Test the Lift Axis
Run the U/J lift test on /dev/ttyACM0.
- Configure the robot and ports
Configure the robot and ports as described in `lerobot_alohamini`.
Data and training
- Test blocking inference state refresh
Blocking inference refreshes Host state before execution. A watchdog release alone does not reset inference, and new commands use the current control epoch.
- Test joint holds and resumption
Active joint holds pause evaluation; after release, queued predictions are cleared and evaluation resumes without an Enter prompt.
- Test joint-protection prediction cleanup
Resolved joint-protection events also clear old predictions.
- Check pauses and evaluation frames
Pauses count toward the episode's wall-clock duration. Cached observations are not saved as new evaluation frames.
- Confirm Recording Prerequisites
Before recording, confirm that the Pi host is running as described in §5. Replace `<Pi_IP>` with the Raspberry Pi's IP address and ensure `--robot.robot_model` matches the model running on the Pi host.
- Set Arm and Dataset Options
Set `--teleop.arm_profile` to the leader arm hardware configuration, not the follower robot. Recording prints the local dataset path and uploads to Hugging Face Hub by default; add `--dataset.push_to_hub=false` to keep the dataset local only or `--dataset.root /path/to/dataset` to store or resume it from a specific local directory.
- Create a New AlohaMini 1 Dataset
Run `record_bi.py` to create the `$HF_USER/so100_bi_test` dataset with one 45-second `pickup1` episode at 30 fps and an 8-second reset time.
- Resume an Existing AlohaMini 1 Dataset
Run `record_bi.py` with the same dataset configuration as the new-dataset command and add `--resume` to resume an existing dataset.
- Create a new dataset
Run record_bi.py to create the $HF_USER/am2_bi_test dataset, recording one 30 FPS, 45-second task episode named pickup1 with the AM-ARM leader 6-DoF configuration.
- Resume an existing dataset
Run record_bi.py with the same recording parameters and add --resume to continue adding data to the existing dataset.
- Replay the dataset
Run replay_bi.py to replay episode 0 of the $HF_USER/am2_bi_test dataset and connect to the alohamini2 robot on the Pi. If the dataset is not under $HF_LEROBOT_HOME/$HF_USER/am2_bi_test, add --dataset.root /path/to/am2_bi_test.
- Visualize the dataset
Run lerobot-dataset-viz to display episode 0 of the $HF_USER/am2_bi_test dataset with compressed images enabled.
- Train the ACT policy locally
Run lerobot-train to train an act policy on the $HF_USER/am2_bi_test dataset with the CUDA device, output to outputs/train/act_your_dataset1, wandb disabled, and the pyav video backend.
- Use a cloud GPU
Use any cloud GPU provider such as AutoDL, Lambda Labs, or Vast.ai. Set up the environment the same way as local, run the same training command, then copy the checkpoint back for evaluation.
- Start Pi and select model
Make sure the Pi host is running, then run inference from the PC. `--robot.robot_model` must match the Pi model: `alohamini1` is SO-ARM 5-DoF with 16-dim state, while `alohamini2` or `alohamini2pro` is AM-ARM 6-DoF with 18-dim state.
- Run ACT synchronous evaluation
Use `evaluate_bi.py` to evaluate ACT for 3 episodes of 45 seconds at 20 fps. An interpolation multiplier of 3 runs the control loop at 60 Hz after the first action and linearly interpolates between policy actions.
- Run SmolVLA RTC evaluation
Use RTC to run policy inference asynchronously and refresh part of the action chunk while the robot executes queued actions. Set the execution horizon to 10, maximum guidance weight to 10.0, queue threshold to 30, and interpolation multiplier to 1.
- Check evaluation output settings
Both examples load a local checkpoint and save the evaluation dataset locally without uploading it. Before running, set `HF_USER` or replace it with your username, ensure `--policy.path` exists with the complete pretrained model, and use a new `--dataset.repo_id` whose local output directory does not already exist.
- Run teleoperation, data collection, and evaluation
Run teleoperation, data collection, and evaluation from the `lerobot_alohamini` repository.
- Configure AlohaMini2Pro training data
Create TrainConfig named alohamini2pro with Pi0Config(pi05=True, action_horizon=10). Configure LeRobotAlohaMiniDataConfig to load /path/to/your/dataset_root, use task prompts and default_prompt, and set robot_dof and dataset_action_dim to 18.
- Map AlohaMini observations and actions
Map cam_high, cam_left_wrist, and cam_right_wrist to the chest, wrist_left, and wrist_right images; map state to observation.state and actions to action. Add the prompt parameter, otherwise model training will not include the task description.
- Set native 18D delta actions
Enable use_delta_actions and configure six delta-action joints for each arm, while keeping the grippers, base, and lift axes absolute.
- Set dataset assets and checkpoint weights
Set the dataset path with assets_dir and asset_id; together they form a path equivalent to repo_id. Load weights from gs://openpi-assets/checkpoints/pi05_base/params with CheckpointWeightLoader.
- Configure pi0.5 fine-tuning
Set 50,000 training steps, batch size 4, two workers, and disable wandb.
- Select fine-tuning weights
Use the pi0.5_base weights for fine-tuning and modify the weight path as needed.
- Compute normalization statistics
Before fine-tuning, run scripts/compute_norm_stats.py to compute data normalization statistics according to openpi requirements.
- Start remote policy server
Start the HTTP policy server on port 8000 with the pi05_test2 configuration, specified weight path, and a default prompt.
- Start the AlohaMini host
Start the AlohaMini lekiwi_host with the so-arm-5dof arm profile.
- Evaluate a 16-DoF robot
Run the local evaluate_bi.py receiver in remote_http mode, connect to the local policy server, and set the robot to 16 DoF.
- Evaluate an 18-DoF robot
For an 18-DoF robot, run evaluate_bi.py in remote_http mode, connect to the local policy server, and set the robot to 18 DoF.
Use it
- Control the base from your PC
Run wheels.py and axis.py with the /dev/ttyACM0 port. Use W/S/A/D to drive the base and U/J to raise or lower the lift, without installing a single-board computer on the robot.
Common problems
Parts
- 11 Feetech STS3215 12V (1/345): the three wheels plus the wrist joints and grippers of both follower arms
- 7 Feetech STS3095 12V (95 kg·cm): one for the lift, three for the shoulder and elbow joints of each follower arm
- Leader arms: 14 STS3215 7.4V (1/147), two Waveshare driver boards, a 5V supply
- Raspberry Pi 5 (2 GB), 32 GB microSD, a 12V→5V 5A buck converter; two 12V 11,200 mAh Li-ion packs (one for the arms, one through the buck converter for the Pi)
- Five H65V1 720p USB cameras (2.4 mm): front, back, chest and both wrists
- Three 127 mm omni wheels, Waveshare servo boards, eight 4×13×5 mm lift-track bearings and eight 12×18×4 mm bearings, a 20×40 extrusion and Φ12 steel pins (printed substitutes work but are much weaker)
- 3D prints in PLA, PETG or ABS, sized for a Bambu P2S; six wall loops recommended for load-bearing parts
Tools
- 3D printer (Bambu P2S class; the first generation needs a bed of 380 mm or more)
- Epoxy (Loctite E‑120HP) to bond the base and lift tower
- Table clamp, soldering iron and screwdriver set (the BOM leaves common tools out)
- A PC as the client for the leader arms; training needs a CUDA GPU, or a cloud GPU
Skills
- Servo ID setup (the lerobot_alohamini script or Feetech's FD debug tool at 1,000,000 baud)
- Linux, SSH, udev port aliases and LAN setup
- LeRobot calibration, teleoperation, recording and training (ACT, SmolVLA); advanced: π0.5 fine-tuning with OpenPI
Software
- lerobot_alohamini v0.6.0 (2026‑07‑12, merged with LeRobot 0.6): Pi host plus PC client for calibration, teleoperation, recording, training and evaluation
- 50 Hz host control with a watchdog and current-based stall protection
- AlohaMini2 / 2 Pro URDFs; a first-generation ROS package (RViz and Gazebo)
- examples/pi0.5_openpi: π0.5 fine-tuning and deployment with OpenPI