The delta robot looks like three arms hanging from a ceiling, meeting at a small platform. It’s not a conventional serial arm — it’s a parallel manipulator, and that distinction makes it the fastest robot configuration available at the hobby scale. Here’s the geometry, the maths, and the best ways to build one.
Why parallel beats serial for speed
In a serial arm, motor 1 carries motors 2, 3, 4 and all their links on top of it. Every joint motor must accelerate the mass of every downstream joint. That adds up fast — which is why big 6-DOF arms move slowly compared to their power.
A delta robot inverts this: all three motors stay fixed on the base. The moving platform weighs almost nothing (just the end effector and three forearm links). When all three motors share the platform load equally, the inertia the control system must overcome is minimal. Industrial delta robots routinely do 300+ picks per minute.
The workspace is the trade-off: a delta can reach a cylindrical volume beneath its base — good radius, limited height, no ability to tilt the tool beyond a few degrees without a separate wrist axis.
The geometry
A symmetric delta has three identical upper arms of length L1, each driven by a
motor at 120° spacing on the base. Three parallel forearm links of length L2 connect
each upper arm to the platform. The platform can only translate (X, Y, Z) — it cannot
rotate.
[Motor A] [Motor B] [Motor C]
| | |
[Arm A] [Arm B] [Arm C] ← upper arms (L1)
\ | /
[Rod] [Rod][Rod] [Rod][Rod] [Rod] ← forearms (L2, parallel pairs)
[PLATFORM]The three constraint equations force the platform to stay level — no motor combination can tilt it, only translate it.
Inverse kinematics (closed form)
For a target platform position (px, py, pz), the required angle θ for each motor
can be found by projecting the 3D problem onto the plane containing that arm:
import math
# Delta geometry constants (mm)
R_BASE = 150 # base triangle circumradius
R_EE = 50 # end-effector triangle circumradius
L1 = 120 # upper arm length
L2 = 250 # forearm length
def ik_one_arm(px, py, pz, angle_offset):
"""Solve one arm. angle_offset = 0, 120, 240 degrees."""
a = math.radians(angle_offset)
# Transform target into arm's plane
x = px * math.cos(a) + py * math.sin(a)
y = -px * math.sin(a) + py * math.cos(a)
# Offset for base and end-effector triangle size
y -= (R_BASE - R_EE)
# Distance in arm plane
d2 = x*x + y*y + pz*pz
c = (d2 - L1*L1 - L2*L2) / (2 * L1 * L2)
if abs(c) > 1:
raise ValueError("Target out of reach")
theta2 = math.acos(c)
theta1 = math.atan2(pz, y) - math.atan2(
L2 * math.sin(theta2), L1 + L2 * math.cos(theta2)
)
return math.degrees(theta1)
# Target: 20 mm right, 0 mm front, -200 mm down
for i, offset in enumerate([0, 120, 240]):
angle = ik_one_arm(20, 0, -200, offset)
print(f"Motor {i}: {angle:.1f}°")Be aware of what firmware does and doesn’t cover. Marlin’s and Klipper’s standard delta
kinematics are for linear deltas — the 3D printers whose carriages slide up towers.
The rotary delta in this guide swings its arms instead; Klipper’s rotary_delta mode
supports that geometry but is marked experimental, and GRBL-Mega is Cartesian only. For
most rotary builds, running the function above yourself is the dependable route.
Motors: steppers are standard
All three motors see identical loads, so you use three identical NEMA 17 stepper motors. Stepper advantages for a delta:
- No encoder needed for position — open-loop works because the geometry is rigid and load is symmetric.
- High holding torque at rest keeps the platform from drifting.
- Identical units simplify the BOM and firmware configuration.
Drive them with A4988 or TMC2208/2209 drivers on an Arduino Mega or a dedicated delta controller board (RAMPS 1.4 is the classic choice).
DIY delta build paths
Path A — 3D printer conversion. A Kossel or Rostock-style 3D printer is a linear delta robot. The frame, motors, control board and firmware come as complete kits, and the delta kinematics are already in the firmware. Swap the print head for a gripper or tool mount and you have a working delta, just with sliding carriages rather than swinging arms.
Path B — Print the links, buy the motion parts. Several delta robot designs on Printables/Thingiverse provide STL files for the upper arm mounts, ball-joint holders and platform. Buy the carbon-fibre rods (or print them), NEMA 17 steppers and a RAMPS board. The STL files guide covers how to evaluate print quality for structural parts.
Path C — Acrylic/aluminium kit. A handful of pre-designed delta kits exist for the educational market — usually laser-cut acrylic with budget steppers. Lower ceiling but faster to running.
Firmware recommendations
| Use case | Firmware / approach | Why |
|---|---|---|
| Linear delta (printer conversion) | Marlin or Klipper | Linear delta kinematics built in, huge community |
| Rotary delta arm | Your own IK + stepper control | Dependable; Klipper rotary_delta exists but is experimental |
| Full ROS control | MoveIt + custom URDF | Motion planning, but complex setup |
For a Python-driven rotary delta, run the IK function above on your computer, convert each motor angle to steps, and send the three step targets over serial to the controller driving the steppers.
Delta vs SCARA vs 6-DOF
| Delta | SCARA | 6-DOF | |
|---|---|---|---|
| Speed | Fastest | Fast | Slower |
| Workspace | Cylinder (below base) | Ring (horizontal) | Hemisphere |
| Tool orientation | Fixed (level) | Fixed (vertical) | Full 6-axis |
| Kinematics complexity | Medium | Low | High |
| Best for | Pick-and-place, sorting | Assembly, PCB work | General manipulation |
Frequently asked questions
What is a delta robot arm?
A delta robot is a parallel manipulator: three identical arms connect a fixed base to a moving platform, and all three motors mount on the stationary base. Moving all three motors together moves the platform in X, Y and Z. Because the motors don't move, the moving mass is tiny — delta robots are the fastest configuration for pick-and-place tasks.
How is a delta robot different from a regular serial arm?
A serial arm (like a 6-DOF servo arm) chains links end-to-end so each motor carries all the links beyond it. A delta arm is parallel — three independent linkages share the load. The payoff is speed: less moving mass means less inertia to accelerate. The trade-off is a smaller, roughly cylindrical workspace and more complex kinematics.
What are delta robots used for?
Delta robots dominate high-speed pick-and-place in food, pharmaceutical and electronics manufacturing — picking objects from a conveyor at several hundred picks per minute. In the DIY world they appear as 3D printer mechanisms (Kossel, Rostock), pen plotters, and small CNC sorting machines.
Is delta robot kinematics hard to implement?
Harder than a SCARA, simpler than a 6-DOF serial arm. Forward kinematics (joint angles → platform position) requires solving a system of sphere intersection equations. Inverse kinematics (target position → joint angles) is more useful and has a closed-form solution for a symmetric delta. Delta 3D-printer firmware handles linear (tower) deltas, but for a rotary delta arm you will usually run the closed-form IK in your own code — it is only a few lines.