Universal Robots Pick and Place Program in PolyScope (Video)

Universal Robots programming is done in PolyScope, the graphical software on the teach pendant, by building a tree of program nodes and teaching waypoints by moving the arm. A first pick-and-place program needs only a handful of nodes: a MoveJ to a safe position, MoveL moves for the approach, pick and retract, a gripper command, and the same pattern again at the place position, all inside a loop.

This walkthrough builds that program step by step, explains when to use each move type, shows how subprograms keep it tidy, and then hands over to Ray Fulks's video, which builds a pick-and-place with subprograms on a real UR arm. You can follow along in the free URSim simulator if you do not have a robot.

What do you need before you start programming a UR robot?

Three things decide whether your first program behaves: the tool settings, the payload and the safety configuration.

• TCP (tool centre point). Tell the robot where the working point of the gripper is, for example 150 mm out from the tool flange along Z. Waypoints and straight-line moves are calculated at the TCP, so a wrong TCP makes MoveL paths look odd.
• Payload. Enter the mass and centre of gravity of the gripper (and later the part). A wrong payload can cause protective stops, poor force behaviour and drifting freedrive.
• Safety settings. Joint limits, speed limits and safety planes are set in the installation, protected by a password. Our guide to cobot training and collaborative robot safety explains why a cobot still needs a risk assessment.

How to build a pick-and-place program in PolyScope

The steps below follow PolyScope 5 on an e-Series or UR Series robot. The ideas carry over to PolyScope X, though the screens look different.

Step 1: a safe home position

Add a MoveJ node and teach a waypoint called Home with the arm clear of everything. MoveJ moves all joints together, so the tool follows a curved path. It is the quickest way to move through open space.

Step 2: approach, pick, retract

At the pick position you need three waypoints:

1. Approach, about 100 mm above the part, reached with MoveJ from Home.
2. Pick, down at the part, reached with a MoveL so the gripper goes straight down.
3. Retract, back up to the approach height, also with MoveL.

Teach them by putting the arm in freedrive and moving it by hand, or with the jog arrows for fine positioning. A neat trick is to make Pick a waypoint and then make Approach and Retract relative to it, so if the part position changes you reteach one point, not three.

Step 3: grip and confirm

Between Pick and Retract, close the gripper. With a URCap gripper plug-in this is a Grip node; with a simple pneumatic gripper it is a Set node that switches a tool digital output. Then add a Wait node for the gripper's "closed on part" signal. Without that wait, the robot will happily carry nothing to the place position.

Step 4: place

Repeat the pattern at the drop-off: MoveJ to a place-approach waypoint, MoveL down, open the gripper (Set or Release node, then a short Wait), MoveL back up.

Step 5: loop

Tick the option for the program to loop forever, or put the sequence inside a Loop node, and run it first at reduced speed with the speed slider.

When should you use MoveJ, MoveL or MoveP?

Use MoveJ for travel through free space, because it is fast and kind to the joints. Use MoveL whenever the tool must move in a straight line, which is every approach, pick, place and retract. Use MoveP for process work where the tool speed must stay constant, such as gluing or sealing; Universal Robots' own support article on MoveP and MoveC describes MoveP as moving the tool in linear motion at constant speed with circular blends.

Blend radius rounds the corners between waypoints so the robot does not stop at each one. It makes cycles faster, but Universal Robots warns that if the radii are too large for the distance between waypoints, a waypoint can be skipped. Keep blends at zero on the pick and place waypoints themselves, where the tool must actually arrive.

Why use subprograms in a UR program?

Once the program works, move the pick sequence into a subprogram called Pick and the place sequence into one called Place, and call them from the main program with Call nodes. The main program then reads like a description of the job: Home, Pick, Place, repeat.

Subprograms pay off as soon as the cell grows. A second pick location becomes a second call, a reject station reuses Place with different waypoints, and maintenance staff can find their way around the program. This is exactly what the video below demonstrates.

Watch: pick and place using subprograms

In this lesson from Ray Fulks, about 12 and a half minutes long and recorded in 2019, he builds a pick-and-place program on a Universal Robots arm and organises it with subprograms, as the title says. The robot and PolyScope version in the video are older than today's, but the program structure is the same in current PolyScope 5.

For further watching, Ray Fulks also has short lessons on blend radiuses for movement optimisation and on installing the Universal Robots offline simulator.

Common mistakes in a first UR program

• Teaching Pick with a MoveJ. The tool swings in an arc on the way down and can clip the part or the fixture. Use MoveL for the last 100 mm.
• Forgetting the payload change. When the gripper holds a heavy part, update the payload with a Set node after the grip and back again after the release, or the robot may protective-stop or drift.
• No check on the gripper. A Wait on the gripper feedback, with a timeout that raises a popup, turns a silent failure into a clear message for the operator.
• Absolute waypoints everywhere. If the fixture moves 5 mm, every waypoint must be retaught. Relative waypoints, or a feature (a taught plane or point) that the waypoints are referenced to, make re-teaching a one-point job.
• Ignoring the start position. If the program is stopped halfway and restarted, the first move must still be safe. Put a move to Home in a BeforeStart sequence or at the top of the program.

What is URScript, and do you need it?

URScript is the scripting language the UR controller runs. Every PolyScope program is converted to URScript, and you can view it, add Script nodes, or send script to the robot over the network from a PC or PLC. A pick move in URScript is a short line such as a movel command with a target pose, acceleration and speed; a gripper command is a call that sets a tool digital output.

You do not need URScript for a first program. It becomes useful when you want to calculate positions, talk to a vision system, or drive the robot from external software. If you also program industrial arms, compare this with FANUC's teach pendant and ABB's RAPID in RobotStudio: the waypoint ideas are the same, the language is not.

How can you practise UR programming without a robot?

Download URSim, Universal Robots' offline simulator. It runs the real controller software and PolyScope on your PC. According to Universal Robots' URSim download page, URSim is made for Linux, so on Windows or macOS you run it in a virtual machine such as VirtualBox or VMware Player; the current non-Linux package includes the UR3e, UR5e, UR10e and UR20, and you need a free account to download it.

In URSim you can build the whole pick-and-place above, run it, and watch the 3D view. What you cannot practise is the physical side: freedrive, real gripper feedback and payload behaviour. Our comparison of free robot programming simulators puts URSim next to RobotStudio, RoboDK and ROS 2.

PolyScope 5 or PolyScope X?

Universal Robots now ships two software platforms. PolyScope 5 is the established node-based software. PolyScope X is the newer platform; Universal Robots' PolyScope X product page lists features such as reusable motion profiles, world-centric frames, colour-coded nodes and a browser-based interface that can be used for offline programming. Check which one your robot runs before you follow any tutorial, because menus and node names differ. The program logic in this post (safe home, approach, pick, retract, place, loop) is the same on both.

Learn it properly, free

The free Universal Robots Cobot Programming with PolyScope course collects Ray Fulks's lessons on setup, TCP and payload, safety planes, pick-and-place, palletising and troubleshooting into one route. For offline programming across brands, add RoboDK Offline Programming and Simulation, or browse all Universal Robots courses. Universal Robots Academy also offers its own free e-learning modules. If you are just starting in robotics, our industrial robotics training guide maps out the wider field. For where open-source robot software is heading, read about Intrinsic Core and Qualcomm's PickNik acquisition.

Checked 5 October 2026 against Universal Robots' product, support and download pages listed below.

Take the free course

Robotics · Beginner · Free

Universal Robots Cobot Programming with PolyScope

Robotics · Beginner · Free

RoboDK Offline Programming and Simulation

Robotics · Intermediate · Free

ROS 2 Robot Programming with Python