movej vs movel vs movep: URScript Move Commands Explained

Ask any Universal Robots integrator what trips up beginners first, and a lot of them will say the same thing: using the wrong move command. movej, movel, and movep all get the tool from one place to another, but they do it through completely different motion, and picking the wrong one causes everything from ugly cycles to crashes. Here is how to choose correctly, every time.

The one-line summary

• movej — moves the joints to the target the fastest way. The tool tip follows a curved, unpredictable path. Fast and safe in open space.
• movel — moves the tool tip in a straight line in Cartesian space. Predictable path, slower, can hit limits. Use near things.
• movep — moves the tool at constant speed along a process path, blending through waypoints. Use for dispensing, gluing, welding-style moves.

Now the detail that makes the difference.

movej — joint move

movej(target_q, a=1.4, v=1.05)

movej commands each of the robot's six joints to rotate to a set of target angles. The controller coordinates them so they all arrive together, taking the quickest route through joint space. The tradeoff: the tool tip traces a curved arc you did not explicitly design. Between start and end, the elbow might swing wide.

Use movej when:

• You are moving across open space (home → above the part).
• The exact path does not matter, only the start and end poses.
• You want the fastest, smoothest repositioning.

Avoid movej when there is anything to hit between the two points, or when the tool must stay on a defined line (near a fixture, into a bin, along a surface).

A subtle but important detail: movej can take either joint angles or a Cartesian pose. If you give it a pose, it solves the inverse kinematics to joint angles first, then does a joint move — so the tip still follows a curved path, not a straight one. Beginners often assume "I gave it a pose, so it moves in a straight line." It does not. That is what movel is for.

movel — linear move

movel(target_pose, a=1.2, v=0.25)

movel keeps the Tool Centre Point travelling in a straight Cartesian line from start to end, holding a controlled orientation along the way. This is the move you want whenever the path matters.

Use movel when:

• Approaching or retreating from a part along a defined direction.
• Inserting into a fixture, a chuck, or a hole.
• Moving along or just above a surface.

The costs of movel:

• It is slower. Forcing a straight line means the joints sometimes move awkwardly to keep the tip on track.
• It can hit joint limits or singularities. A straight Cartesian path can demand a joint configuration the arm cannot reach, or pass through a singularity (typically when the wrist joints line up and a wrist joint would need near-infinite speed). The robot will slow dramatically or fault. The fix is usually to break the move into segments or shift the approach so you avoid the singular region.

movep — process move with blends

movep(target_pose, a=1.2, v=0.25, r=0.05)

movep moves the tool at constant tool speed along a path and blends through waypoints with a blend radius r (in metres), so the robot does not stop and start at each point. Use it for process motions where consistent speed matters: applying adhesive, dispensing a bead, a smooth inspection sweep.

The blend radius is the key idea: instead of decelerating to zero at a waypoint and accelerating away again, the robot cuts the corner within radius r, keeping motion fluid. Bigger r means smoother and faster but a path that strays further from the exact waypoint.

Blend radius isn't just for movep

You can add a blend radius to movej and movel too (via the r parameter or blend settings in PolyScope). For a multi-waypoint pick-and-place, blending the intermediate waypoints turns a jerky stop-start cycle into a smooth, fast one. The rule of thumb: blend the via points you are passing through; do not blend the points where you actually do something (the exact pick and place poses), because the robot would cut the corner and miss.

# Smooth approach: blend the via point, stop sharp at the pick
movej(home,          a=1.4, v=1.0)
movel(pick_approach, a=1.2, v=0.5, r=0.05)   # blend through the via point
movel(pick,          a=0.5, v=0.1)           # no blend — land exactly on the part

Speed and acceleration: a and v

Every move takes acceleration a and velocity v:

• For movej, the units are rad/s² and rad/s (joint space).
• For movel/movep, the units are m/s² and m/s (tool space).

Beginners often crank these up to save cycle time and then wonder why the arm overshoots or trips a protective stop. Start conservative, especially for movel near parts. With a payload in the gripper, momentum matters — a fast move with a heavy part can overshoot or trigger the cobot's force limits. Tuning these safely is exactly the kind of thing a simulator lets you do without risking a real arm or a real part.

A worked decision

Picture moving a part out of a bin, across the table, and placing it precisely in a fixture:

1. Lift out of the bin: movel straight up — you must clear the bin walls on a known path.
2. Traverse to the fixture: movej (or a blended move) across open space — fast, path does not matter.
3. Descend into the fixture: movel straight down — the insertion path must be exact.

Mixing the three correctly — fast joint moves where it is safe, straight linear moves where it counts — is what separates a clumsy 12-second cycle from a clean 6-second one.

Practise this without a robot

Reading about move types only gets you so far; the intuition comes from seeing the curved movej arc versus the straight movel line, and from watching a badly chosen move clip a fixture. That is hard to do safely on a real arm and awkward to set up in a Linux-VM simulator.

We are building a browser-based UR simulator where you write real URScript and watch exactly these differences play out — the movej arc, the movel line, a singularity slowdown, an over-force protective stop — with goal-based grading on real pick-and-place tasks. No install, free to start. It is launching soon; join the early-access list on that page.

Key takeaways

• movej = fastest, curved joint-space path. Use in open space.
• movel = straight Cartesian line. Use near parts and fixtures; watch for singularities and slower speed.
• movep = constant-speed process path with blends. Use for dispensing-style moves.
• Blend the via points, never the action points.
• Tune a and v conservatively near parts and with payloads.

Next steps

• New to the language? Start with What is URScript?.
• Ready for a full first program? Read How to program a Universal Robot.
• Join the early-access list for the robot simulator and watch these moves run.