Universal Robots simulator — learn URScript in your browser, 5 lessons free
Write real URScript on a simulated UR-style e-Series cobot arm, run pick-and-place with live physics, and learn frames, TCP, I/O, the gripper, and cobot safety — with auto-graded lessons, from zero. No install, no robot, no vendor license. A free account is required: 5 of 21 lessons are free; go Pro for the other 16 and a certificate.
The real 3D simulator: a six-axis UR-style e-Series arm in a factory cell. You write the URScript; the simulator solves the kinematics and runs it under physics.
The robots
What are Universal Robots?
Universal Robots (UR) makes collaborative robots — cobots — six-axis articulated arms designed to work safely alongside people without the cages a traditional industrial robot needs. The current e-Series family spans the UR3e, UR5e, UR10e, and UR16e, which differ mainly in reach and payload but share the same kinematics and the same programming model. Their friendly programming and large community make UR the most popular on-ramp into robot programming.
You program a UR in two complementary ways. PolyScope is the graphical interface on the teach pendant, where you jog the arm and build a program tree of waypoints and nodes. URScript is UR’s underlying text language — movej, movel, movep, set_digital_out, and more — which runs on the controller and is what every PolyScope program ultimately executes. Learning URScript is the fastest way to truly understand how a UR moves.
Two numbers frame why this skill is worth having: Universal Robots’ e-Series line now spans payloads up to 16 kg (universal-robots.com), and the International Federation of Robotics counted 4.66 million industrial robots in operation worldwide in 2024 (IFR, World Robotics 2025).
The UR-style six-axis arm the simulator models, with joints J1–J6 and the tool centre point.
Our simulator
A browser-based UR simulator that teaches real URScript
Our Universal Robots simulator puts a 3D UR-style arm in your browser tab. You write real URScript — the same commands a UR controller runs — and the simulator parses it, solves the inverse kinematics for each pose, plans the joint trajectory, and runs the motion under physics. Grab a part with the gripper and it follows the tool; drive into something and a collision is detected. Nothing to install, no virtual machine, no robot, no license.
Crucially, the lessons are auto-graded. Each task defines success — place the part at B within tolerance, no collision, under a cycle-time budget, within the cobot force limit — your program runs, and you get specific feedback on what to fix. That goal-based grading is what turns watching into learning. Under the hood is a real URScript lexer, parser and interpreter — not a look-up table of accepted answers — feeding 20 auto-graded robot lessons on a platform of 135 graded automation scenarios.
Can I learn URScript without a UR robot?
Yes. The simulator runs real URScript in your browser, so movej, movel, set_digital_out and gripper commands behave the way a UR controller executes them. You can practise the whole pick-and-place workflow — frames, TCP, payload, I/O — without owning hardware, then carry the identical syntax straight to PolyScope.
movej vs movel, run in the simulatorThe graded pick-and-place cycle, A → B
Real code
You write the same URScript a real UR runs
No drag-blocks-only toy and no invented pseudo-language. A first pick-and-place program in the simulator looks like this — and the exact same commands run on a physical Universal Robots controller:
# Pick a part at A, place it at B
set_tcp(p[0,0,0.15,0,0,0]) # tool centre point: 150 mm gripper
set_payload(0.8) # 0.8 kg part in the gripper
movej(home_q, a=1.4, v=1.0) # joint move to a safe home pose
movel(pick_approach, a=1.2, v=0.3) # linear move above the pick
movel(pick, a=0.5, v=0.1) # straight down onto the part
set_digital_out(0, True) # close gripper
sleep(0.4)
movel(pick_approach, a=1.2, v=0.3) # lift straight up
movel(place, a=1.2, v=0.25) # linear move to place B
set_digital_out(0, False) # open gripper
movej(home_q, a=1.4, v=1.0) # return home
The simulator parses this, solves the inverse kinematics for each target pose, plans the joint trajectory, and runs it under physics. movej moves fast through joint space; movel keeps the tool on a straight Cartesian line; movep holds a constant tool speed through blends — the distinctions every UR programmer has to learn, shown live.
“If the language you practise isn’t the language the controller runs, you’re learning a diagram, not a robot.”
The simulator parses your URScript, solves the inverse kinematics, plans the trajectory, and runs it.
Honest comparison
URSim vs a browser learning simulator
These tools solve different problems, and the best workflow often uses both. URSim is the official tool for building real programs; ours is the fastest way to learn URScript before you get there.
URSim (official)
Universal Robots’ own offline simulator. It runs the full PolyScope and UR controller in a Linux virtual machine, so you can build and validate complete production programs on your computer and deploy them to a real robot. It is the right tool for serious offline programming — it is just heavier to install and configure, and assumes you already know the robot.
Our browser simulator (learning)
A zero-install simulator that opens in a browser tab on any computer. It teaches URScript from zero with guided, auto-graded lessons and a 3D UR-style arm. It is not a replacement for URSim’s full program development — it is the learning on-ramp. Many people start here, then move to URSim once the fundamentals click.
In short: URSim = full official offline sim for real programs; this = the free, browser-based way to learn URScript with graded lessons. Complementary, not competing.
Safety first
Learn cobot safety — protective stops and payload
A collaborative robot is only collaborative when it is configured safely. The simulator teaches the safety behaviour that defines a cobot, so you build the right instincts before you ever stand next to a real arm.
Protective stop
When the arm meets an unexpected over-force contact, it stops — a protective stop. Learn what triggers it, how to recover, and how to plan motion that avoids nuisance stops.
Payload & TCP
Set the payload mass and tool center point correctly. Get them wrong and the arm misjudges its own dynamics; the simulator shows how payload and TCP affect reach, accuracy, and safe speed.
Speed & force limits
Cobots run within force and speed limits when sharing space with people. Practice keeping moves inside those limits while still hitting your cycle time.
Safe approach motion
Use approach waypoints and linear moves so the tool comes onto a part predictably — the habit that keeps real cells collision-free.
Force limiting and the protective stopPayload and TCP set correctly
What you’ll learn
From first jog to a graded pick-and-place cell
The course takes you from never having touched a robot to programming a working, collision-free pick-and-place cell — every lesson graded against a real goal.
Jogging & frames
Move the arm in joint space and in Cartesian space; understand base vs tool frames and how the TCP is defined.
Your first moves
movej vs movel vs movep — when each is right, and how speed and acceleration change the motion.
Digital I/O & gripper
Read and set digital signals; open and close a gripper to actually pick something up.
Pick-and-place A→B
The core skill: approach, grasp, lift, traverse, place, release — the backbone of real cobot work.
Waypoints & blends
Chain waypoints with blend radii for smooth, fast cycles instead of stop-start motion.
Payload & TCP
Configure payload and tool center point and see how they change reach, accuracy, and safe speed.
Collision & safety
Cobot protective stops: trigger and avoid over-force contacts; respect safety planes and speed limits.
Graded capstone
Palletise four parts into a pattern — no collision, under cycle time, within force limits — and earn the pass.
Pricing
Free to play, Pro to master
Create a free account (no card needed) and 5 of the 21 lessons are free — write URScript and run the simulated UR arm with unlimited runs. Go Pro to unlock the other 16 lessons and earn a certificate of completion. Same login as our PLC simulator.
Yes. Our Universal Robots simulator runs entirely in your browser — no download, no virtual machine, no vendor license. You write real URScript, run it against a simulated UR-style arm with physics, and learn pick-and-place, frames, TCP, and cobot safety through guided, auto-graded lessons. It opens in a tab on Mac, Windows, Linux, or a Chromebook. It is built to teach URScript from zero, so it is the fastest way to get hands-on without installing anything.
Yes — that is exactly what this simulator is for. You write the same movej, movel, movep, set_digital_out, and gripper commands you would type into a Universal Robots controller, and the simulator solves the kinematics and runs the motion under physics. Because you practice the real language rather than a simplified stand-in, the skills carry straight onto a physical UR arm and PolyScope. You need only a modern browser.
URSim is Universal Robots’ own official offline simulator. It runs the real PolyScope software and UR controller in a Linux virtual machine, so you can build and test full production programs on your computer before deploying them to a physical robot. It is powerful and is the right tool for serious offline programming, but it is heavier to install and configure and assumes you already know your way around the robot. Our browser simulator is complementary: it is the zero-install way to learn URScript fundamentals with graded lessons, and many people use it first and then move to URSim for full program development.
Our simulator models a UR-style six-axis e-Series cobot arm, so the motion model, URScript commands, TCP and payload setup, and the pick-and-place workflow match what you would do on a UR5e. Universal Robots’ e-Series arms — UR3e, UR5e, UR10e, and UR16e — share the same articulated kinematics and the same URScript language, differing mainly in reach and payload, so the programming skills you build here apply directly to the UR5e and across the rest of the e-Series family.
You can start for free. Create a free account (no card needed) and 5 of the 21 lessons are free, with unlimited runs — write URScript and run the simulated arm. A Pro subscription unlocks the other 16 lessons and a certificate, for when you want the complete curriculum and proof of completion.
URSim is UR’s official Linux-VM offline simulator that runs the real PolyScope controller for building and testing production programs. UR Studio is UR’s newer free browser-based tool for designing and validating a cobot cell — reach, cycle time, cell layout — alongside PolyScope X. RoboDK is paid professional offline-programming software aimed at integrators. All three are excellent for production planning and deployment. Ours is different on purpose: it is a learning simulator that teaches URScript from zero with auto-graded lessons, runs in a browser tab with nothing to install, and is free to start. We are the learning on-ramp — a complement to those tools, not a competitor to them.
Program a Universal Robot in your browser.
No install. No robot. No license. Real URScript on a simulated UR-style e-Series arm — free account required, 5 lessons free, graded from zero.
