Connecting to sources…

How to build PAROL6 3D-printed desktop 6-axis robot arm: the whole process

125 steps to build PAROL6 3D-printed desktop 6-axis robot arm, from buying parts, printing and assembly to software, calibration and training, with the bill of materials…

Official store (2026‑11‑04, the collector's Singapore market, euros without VAT): partial kit €999 (in stock; add gearboxes, steppers, a supply and the printed parts), full kit €1,999 (out of stock; without printed parts and supply), assembled €3,000 (out of stock); printed-parts kit €400, screw kit €49, control board €199 / €396. The German market shows €3,570 with VAT for the assembled arm; shipping is calculated at checkout and buyers outside Europe pay duties and import taxes. The repo BOM gives purchase links only, with no prices or total

Bill of materials · Belts

PartQtyEU
Joint 1 belt · HTD3 396 · 6 mm width1
Joint 3 belt · HTD3 342 · 6 mm width1
Joint 4 belt · HTD3 201 · 6 mm width1
Joint 5 belt · HTD3 246 · 6 mm width1

Bill of materials · Pulleys

PartQtyEU
J4 pulley, J5 pulley · HTD3M 12 tooth · 5mm bore, 10mm width2
J1 pulley · HTD3M 15 tooth · 5mm bore, 10mm width1

Buy parts

  • Buy all robot parts

    Purchase all parts needed to build PAROL6 according to the bill of materials.

  • Buy screws and nuts

    Select the screws and nuts from the table; these items can also be bought locally or from many vendors.

  • Choose cheaper MG gearboxes

    MG series planetary gearboxes can be used as a cheaper option, but they have greater backlash.

  • Buy STLink programming adapter

    Buy 1 STLink or programming adapter with pin order SWCLK, SWDIO, GND, 3V3, and 5V; the Source Robotics official programming adapter is also available.

  • Read the modification instructions

    Read the small-print-bed modification PDF first; it covers the required reamers, steel dowel pins, two-part epoxy, and assembly steps. Check the extra hardware under “Small print bed modification” in the BOM.

Print and make

  • Print the Upper_arm replacement

    Use the `Upper_arm` replacement only when the original part does not fit on your printer. Print its two split halves.

  • Print the turret blocker replacement

    Use the `J1_turret_rework_blocker` replacement only when the original part does not fit. Print its two split halves.

  • Print small-bed modification parts

    Print `J1_turret_rework_blocker` and `Upper_arm` from `STL/SMALL_PRINT_BED`; both parts are split in two.

Assemble

  • Anchor the robot to the table

    Bolt the base to the table through its six holes, or clamp it to the edge. A free-standing PAROL6 tips over when it extends.

  • Connect the emergency stop

    Connect the E-stop to the two E-stop terminals on the base. The robot will not run without it.

  • Connect the USB cable

    Connect the USB cable between the robot and the PC.

  • Connect the 24 V power supply

    Connect the 24 V supply to the power connector and plug its mains plug into the switched socket strip or behind the mains switch within reach. A DIN-rail supply must be wired and checked first.

  • Join the Upper_arm halves

    Join the two printed `Upper_arm` halves with steel dowel pins and two-part epoxy. Follow the assembly instructions in the small-print-bed modification PDF.

  • Join the turret blocker halves

    Join the two printed `J1_turret_rework_blocker` halves with steel dowel pins and two-part epoxy. Follow the assembly instructions in the small-print-bed modification PDF.

  • Anchor the base to the table

    Bolt the base to the table through its six holes, or clamp it to the edge.

  • Join the printed parts

    After printing, join the split `J1_turret_rework_blocker` and `Upper_arm` with dowel pins and epoxy.

Software

  • Install Python 3.11.9 on Windows

    Download Python 3.11.9 from python.org and select the “Windows installer (64-bit)”. Tick Add python.exe to PATH on the first screen, then press Install Now.

  • Install Git on Windows

    Download Git from git-scm.com. Install it with the settings proposed by the installer.

  • Open a Windows terminal

    Press the Windows key, type cmd, and press Enter. Change to Documents with cd %USERPROFILE%\Documents; if that path is unavailable, use cd %USERPROFILE%\OneDrive\Documents.

  • Open an Ubuntu terminal

    Open Terminal with Ctrl+Alt+T, or select Terminal from the applications menu.

  • Install Git on Ubuntu

    Run sudo apt install git in the terminal. Enter your password when prompted.

  • Install Python 3.11 on Ubuntu

    Add the deadsnakes PPA, then install Python 3.11, python3.11-venv, and python3.11-tk alongside Ubuntu’s Python.

  • Install Python 3.11.9 on macOS

    Download Python 3.11.9 from python.org and select the “macOS 64-bit universal2 installer”. Run the installer.

  • Install Git on macOS

    Open Terminal with Cmd+Space and the Terminal name, then press Enter. Run xcode-select --install and confirm the opened window to install Git with the Xcode command line tools.

  • Clone the robot repository

    Download the robot repository into your Documents folder. On Linux and macOS, use the Documents folder as the starting location.

  • Install VS Code and PlatformIO

    Install VS Code, open it, and select the Extensions icon on the left. Search for PlatformIO IDE, install it, and restart VS Code when prompted.

  • Install the ST-Link driver

    On Windows, open PAROL6-Desktop-robot-arm in the Documents folder with File Explorer. Extract en.stsw-link009.zip and run dpinst_amd64.exe from the extracted folder.

  • Connect the programming hardware

    Unplug the 24 V supply from the robot. Plug the programming adapter onto the 2×5 header beside the USB port and connect the ST-Link to the PC; the adapter powers the board's microcontroller, not the motors.

  • Open the control board software

    In VS Code, choose File and Open Folder. Select the PAROL6 control board main software inside the PAROL6-Desktop-robot-arm folder.

  • Wait for PlatformIO tools

    On the first use, PlatformIO downloads its tools. Wait until the bar at the bottom of VS Code becomes quiet.

  • Upload the main firmware

    Click the right-pointing Upload arrow in the bottom bar of VS Code to put the main firmware on the control board.

  • Disconnect the programming adapter

    Wait for the firmware upload to finish. Then unplug the programming adapter from the control board.

  • Choose Commander or Python API

    Install the commander software for its button window, program editor, and 3D simulator, the Python API for Python programs, or both. Each program uses its own folder, virtual environment, and private Python copy because the two require different package versions.

  • Install Commander on Windows

    Download the commander software, create its virtual environment, activate it, and install the requirements. The prompt starts with (.venv) after activation.

  • Install Commander on Linux or macOS

    On Linux and macOS, download the commander software, create its virtual environment with Python 3.11, activate it, and install the requirements. The prompt starts with (.venv) after activation.

  • Prepare Python API on Windows

    Download the Python API, switch to version 0.9.1, create its virtual environment, and activate it. Git reporting a detached HEAD after checkout is expected.

  • Install Python API on Windows

    With the Python API virtual environment activated, install the package. The installation takes a few minutes, and the prompt starts with (.venv) after activation.

  • Prepare Python API on Linux or macOS

    On Linux and macOS, download the Python API, switch to version 0.9.1, create its virtual environment with Python 3.11, and activate it. Git reporting a detached HEAD after checkout is expected.

  • Install Python API on Linux or macOS

    With the Python API virtual environment activated, install the package. The installation takes a few minutes, and the prompt starts with (.venv) after activation.

  • Check the installation

    Confirm that the installation ends without an ERROR line. If an ERROR line appears, use the linked Commander installation or Python API installation instructions.

  • Find the serial port on Windows

    Open Device Manager from the Start button and select Ports (COM & LPT). Find the robot’s “USB Serial Device” and note its port, such as COM5.

  • Find the serial port on Linux

    List the ACM devices in the terminal. The robot’s serial port is usually /dev/ttyACM0.

  • Find the serial port on macOS

    List the USB modem devices in the terminal and note the robot’s /dev/cu.usbmodem device name.

  • Grant Linux serial access

    If the software reports “permission denied,” add the user to the dialout group. Log out and back in after running the command.

  • Set the robot serial port

    Open PAROL-commander-software/GUI/files/Serial_sender_good_latest.py in a text editor and set STARTING_PORT to the serial port found for the robot.

  • Launch the Windows controller GUI

    On Windows, activate the virtual environment, change into GUI/files, and run Serial_sender_good_latest.py.

  • Launch the Unix controller GUI

    Activate the virtual environment, change into GUI/files, and run Serial_sender_good_latest.py.

  • Start the robot server on Windows

    Open the PAROL6-python-API directory, activate its virtual environment, and start parol6-server with the robot’s COM port. Leave the terminal open.

  • Start the robot server on Linux or macOS

    Open the PAROL6-python-API directory, activate the virtual environment, and start parol6-server with /dev/ttyACM0 on Linux or the detected /dev/cu.usbmodem… name on macOS. Leave the terminal open.

  • Download Python 3.11.9

    Download Python 3.11.9 from python.org and choose the "Windows installer (64-bit)". Version 3.11.9 is the last 3.11 release with an installer.

  • Install Python

    Run the installer. On its first screen, tick Add python.exe to PATH, then press Install Now.

  • Download and install Git

    Download Git from git-scm.com and install it with the settings proposed by the installer.

  • Open a Windows terminal

    Press the Windows key, type cmd, and press Enter. A black terminal window opens.

  • Verify Python and Git versions

    Run python --version in the terminal, and then run git --version.

  • Enter the Documents folder

    Run cd %USERPROFILE%\Documents to enter your Documents folder. If Windows cannot find the path, run cd %USERPROFILE%\OneDrive\Documents instead.

  • Open a terminal in any folder

    Open a folder in File Explorer, click the address bar, type cmd, and press Enter to open a terminal in that folder.

Calibrate and test

  • Check the base stability

    Firmly push the top of the base sideways; it must not lift or slide.

  • Confirm the software environment

    Confirm that the terminal shows Python 3.11 and a number, and git version and a number. If a command is not found, install that program again; on Windows, tick Add python.exe to PATH, then open a new terminal.

  • Check the software installation

    Check that the install ends without an ERROR line. If one appears, see Commander installation or Python API installation.

  • Open a second terminal and activate the environment

    In the second terminal, enter the PAROL6-python-API directory, activate .venv, and start Python. Keep this terminal open for the later commands.

  • Connect the robot and test ping

    Import parol6, create a RobotClient, and call rbt.ping(). The commander's response log should show robot data, or ping() should return hardware_connected=True.

  • Identify pre-homing joint directions

    The software checks joint limits with a position count that starts at 0 when the board is switched on. Before homing, joint 2 moves only negatively, joints 3 and 6 only positively, and joints 1, 4, and 5 in both directions.

  • Jog the joints in commander

    In the Joint jog menu, briefly press the left positive arrow for joints 1 and 3–6, and the right negative arrow for joint 2. Confirm that joint 2 moves opposite to the positive-direction figure.

  • Jog joints with the Python API

    Use rbt.jog_j() to move joint 1 positively at speed 0.2 for 0.5 seconds and joint 2 negatively at speed -0.2 for 0.5 seconds. A refused jog does not move the joint.

  • Set joint directions

    Before pressing Home, turn joints 1 and 3 to 6 as shown in the figure, and turn joint 2 in the opposite direction on its negative jog. Fix any incorrect direction before homing.

  • Position joint 6 sensor

    Position joint 6 so its sensor is found within one turn in the negative direction, with the tool's cables and tubes not wound up.

  • Match tool and joint 5 offset

    Mount the tool and ensure the firmware's joint 5 homing offset matches it. In main.cpp, j5_homing_offset is 8900 for the pneumatic gripper holder as shipped and 8035 for the SSG-48; if you change it, upload the firmware again as in step 4.

  • Press Home

    Stay at the E-stop, press Home, and run rbt.home(wait=True).

  • Check that the base is secure

    Push the top of the base sideways firmly. The base must not lift or slide.

  • Check Python and Git on Windows

    Run python --version and then git --version. Confirm that the terminal returns version numbers.

  • Check Python and Git on Ubuntu

    Run python3.11 --version and then git --version. Programs below use separate virtual environments made with Python 3.11, where python is Python 3.11.

  • Check Python and Git on macOS

    Run python3.11 --version and then git --version. Programs below use separate virtual environments made with Python 3.11, where python is Python 3.11.

  • Troubleshoot missing commands

    Confirm that the terminal shows Python 3.11 and a version number, and git version and a version number. If a command is not found, install that program again, tick Add python.exe to PATH on Windows, and open a new terminal.

  • Confirm a successful upload

    Check that the terminal at the bottom of VS Code ends with SUCCESS. If it does not, consult the Firmware and Control board troubleshooting pages.

  • Power on the robot

    Hold the arm by the forearm and press the power button on the base. The motors energise, six clicks are heard, and the arm holds its position before you let go.

  • Verify the first power-on

    Confirm that six drivers initialise and the arm supports itself before letting go. If it does not, follow the “First power-on: if nothing happens” troubleshooting instructions.

  • Verify Robot Communication

    Open a second terminal, activate the existing virtual environment, start Python, create a RobotClient, and call ping(). Keep the terminal open for the next steps.

  • Jog and Verify Each Joint

    Before homing, jog each joint briefly and verify its direction. Joint 2 should move negatively; joints 3 and 6 positively; and joints 1, 4, and 5 in both directions.

  • Plan and test TCP movements

    Plan TCP movements, check collisions, and execute them with mock controllers. This is an offline planning/control demo; RCB hardware control and contact/physics simulation are separate integrations.

  • Test gripper presets

    Select the gripper group and test the jaws with its open and closed presets.

  • Check the MSG camera configuration

    For MSG configurations, see the built-in camera view.

  • Review dimensions and frames

    Review the dimensioned PAROL6 sheets, DH convention, PAR6/PAROL6 comparison, mass/COM/inertia status, actuator settings, and pneumatic jaw motion and controls. Jaw-specific grasp centers have not been calibrated.

  • Check flange offset differences

    Confirm that flange is the physical tool-mounting face and tcp is the configured control frame. PAR6 and PAROL6 share the public joint conventions and a 177 mm forearm, but their different wrist-housing lengths require different flange offsets.

Use it

  • Review the safety precautions

    PAROL6 has no brakes, so the arm falls when power is lost. Keep hands out of its path, keep the E-stop within reach, anchor the robot, and read the Safety chapter, which takes five minutes.

  • Run the initial arm bend

    Paste the shown program into the program window and press Start; Stop halts it. The first movement bends the arm to the specified joint angles.

  • Turn the base and return

    Continue the program to turn the base and then return to the after-homing pose. The program ends after the final movement.

  • Move with the Python API

    Type the five lines at the >>> prompt one at a time; each command waits until its movement is complete. The arm bends, moves 30 mm straight down, moves 30 mm back up, turns the base, and returns to the after-homing pose.

  • Run the park program

    Press Park to write the park program into the program window, then press Start to run it. This moves the arm into the commander’s park pose.

  • Hold the arm and power off

    Hold the forearm and press the power button. The arm becomes limp as soon as the motors lose power.

  • Read safety guidance and secure the robot

    Anchor the robot to the table, keep the E-stop within reach, and keep hands out of the arm's path. Read the Safety chapter, which takes five minutes.

  • Run the arm movement program

    Paste the program into the program window and press Start; press Stop to halt it.

  • Control movement with the Python API

    Type these lines one at a time at the >>> prompt; each command waits until its move is done.

  • Run the parked-pose program

    First bring the arm to the parked pose, folded in over the base, then press Park; it writes a three-line program into the program window, which runs with Start.

  • Switch off the arm

    Hold the forearm and press the power button; the arm goes limp as soon as the motors lose power.

Common problems

  • Control PCB availability, purchase sources, and schematics are unclear. #8 #10
  • Published STL files may violate GPL v3 licensing. #12
  • Printing material guidance and complete slicer settings are missing. #6 #11
  • Some STLs have mismatched holes and incorrect mesh geometry. #15 #20
  • BOM and build documentation contain errors, broken, missing, or outdated links. #1 #2 #3 #17 #18
  • Builders get stuck during calibration despite following the setup video. #13

Parts

  • 6 NEMA 17 steppers: one 16 N·cm (42×42×20 mm), three 45 N·cm (42×42×40 mm) and two 65 N·cm (42×42×60 mm)
  • EG-series precision planetary gearboxes: two 20:1 and one 10:1 (the BOM mentions the cheaper MG series with more backlash)
  • The PAROL6 control board (official store) with six TMC5160 drivers; a 24V 5A supply (the BOM names a Mean Well EDR-120-24), an E-stop and a GX16 power connector
  • Bearings: five NSK HR32906J and four HR32907J tapered roller bearings, one AXK3552 needle thrust bearing and 20 each of 3×8×4 and 3×10×4 tension bearings; four HTD3 belts, pulleys and couplers
  • 3 limit switches and 3 inductive sensors; an MHZ2-16D pneumatic gripper with a 24V 5/2 solenoid valve (or a suction cup and vacuum generator)
  • PETG printed parts (STLs grouped by link, with split versions for small print beds), four M3 brass inserts and M2–M4 screws

Tools

  • A 3D printer for PETG (220–250 °C hot end, 60–90 °C bed); PLA does not survive the 60–70 °C near the motors in long use
  • A soldering iron (for the brass inserts), 2/2.5/3 mm hex keys, a small screwdriver and blue threadlocker
  • An ST-Link or the official programming adapter (to upload the main firmware), and a mains switch for the supply within reach

Skills

  • Assembling from the instructions PDF and video playlist: seating bearings square, tensioning belts as in the video, threadlocker on metal screws, positioning the limit switches and sensors
  • Uploading the main firmware with PlatformIO or an ST-Link (store boards ship with test firmware that turns all motors at once), then jogging slowly at first power-on to check joint directions
  • Python 3.11+ and the terminal: the Commander software, the Python API (parol6) or ROS 2 MoveIt

Software

  • PAROL Commander software (GPL‑3.0, Python 3.10/3.11, Windows, Linux, macOS): jogging, a 3D simulator, an RBTscript program editor, I/O and gripper tabs
  • The parol6 Python API (GPL‑3.0; the manual describes v0.9.1): a controller process and a client library with planned and streamed motion, tools and collision checking
  • A ROS 2 MoveIt configuration and ros2_control hardware interface (MIT); URDF and MuJoCo models (robot_descriptions, CC BY 4.0)

Documents