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}°")Most delta firmware (Marlin, Klipper, GRBL-Mega) ships with this already implemented — you rarely need to code IK yourself unless you’re writing firmware from scratch.
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 delta robot. The frame (V-slot extrusion), motors, control board and firmware are all available as complete kits. Convert the print head to a gripper or tool mount and you have a capable delta robot for under $150.
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 | Why |
|---|---|---|
| 3D printer conversion | Marlin / Klipper | Delta kinematics built in, huge community |
| Custom pick-and-place | GRBL-Mega | G-code interface, easy to drive from Python |
| Full ROS control | MoveIt + custom URDF | Motion planning, but complex setup |
For a Python-driven delta, send G-code over serial to
GRBL and let the firmware handle IK — your Python script only needs to send
G1 X20 Y0 Z-200 F3000 target coordinates.
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. Several open-source firmware implementations (Marlin, RepRap) include delta IK, so you don't have to derive it from scratch.