PLC Simulator
Online robot arm simulator

Online 6-Axis Robot Arm Simulator — Free in Your Browser

Program a UR-style industrial robot arm with real URScript, run pick-and-place under live physics, and learn jogging, waypoints, payload, and cobot safety — all in a browser tab. No install. No robot. No vendor license. Start free, then go Pro for the full graded course and certificate.

Free basic play, no card needed. Pro unlocks the full graded curriculum and certificate.

A UR-style six-axis robot arm standing in a 3D factory cell in the browser-based robot arm simulator, with a parts table, safety railing and pallet.
The real 3D simulator: a six-axis robot arm in a factory cell. You write the URScript; the simulator solves the kinematics and runs it under physics.

What it is

A virtual robot arm simulator you run online, free

This is an online robot arm simulator: a 3D, UR-style six-axis articulated arm that you program with real URScript and watch run — without owning the robot, installing heavyweight offline software, or risking a real machine while you learn. You write the motion, the simulator solves the inverse kinematics and physics, and the arm does exactly what your program tells it to.

The arm has a gripper, the table has parts, and everything runs together in a single browser tab — the URScript interpreter, the six-axis kinematics, the rigid-body physics, and the work cell. You can jog the arm, build a full pick-and-place cycle, and have your program graded against a real goal. It is the same approach that made our PLC simulator work: practise the real skill, online, free to start.

A six-axis articulated robot arm in the online robot arm simulator, with rotary joints J1 through J6, a two-finger gripper, and the tool centre point markedA six-axis articulated robot arm with a base and a two-finger gripper, its six rotary joints labelled J1 through J6.J1J2J3J4J5J6TCP
The six-axis arm you program: joints J1–J6 give it full reach and orientation, with the gripper’s tool centre point (TCP) at the working end.

Important

An industrial robot arm simulator, not a game

Search for “robot simulator” and most results are games — sandbox builders, Roblox experiences, fantasy robots. This is not that. This is an industrial and educational robot arm simulator for people learning to program real automation.

You program a realistic Universal Robots style six-axis arm in real URScript, and your programs are graded against engineering goals: place the part within tolerance, finish under the cycle-time budget, move without a collision, and stay within the collaborative-robot force limit. There is no make-believe and no toy physics — the skills you build here are the skills used to program robots on a real production line.

How it works

Jog, write URScript, run, grade

1

Jog the arm

Move the six-axis arm in joint space (rotate each axis) and in Cartesian / TCP space (drive the tool point in X, Y, Z). Jogging teaches you base vs tool frames and exactly where the tool centre point sits before you write a line of code.

2

Write real URScript

Type actual UR commands in the editor — movej for fast joint moves, movel for straight Cartesian lines, set_digital_out and gripper control, plus waypoints, variables, and loops. The interpreter understands the real language, not a simplified stand-in.

3

Run it under physics

The simulator solves the inverse kinematics for each target pose, plans the joint trajectory, and runs it under rigid-body physics. Grasp a part and it follows the gripper; collide with the table or exceed a safe contact force and that is detected and surfaced.

4

Get a graded result

Each task defines success — part placed at B within tolerance, no collision, under the cycle-time budget, within the cobot force limit. Your program runs, is checked against those goals, and you get specific feedback on what to fix. That goal-based grading is what turns watching into learning.

What you can simulate

From a first move to a full pick-and-place cell

The 6-axis robot arm simulator models the things that actually matter when you program a real cobot cell — not just pretty motion.

Pick-and-place

The core skill: approach, grasp, lift, traverse, place, release — the backbone of real cobot work, built from movej and movel moves.

Waypoints & paths

Chain waypoints into a path and tune speed and acceleration so the arm flows smoothly through a sequence instead of stopping at every point.

Payload

Set the payload the gripper is carrying and see how mass changes the safe speed and the way the arm tracks its trajectory.

Collisions

The physics detects when the arm or the part hits the table, a fixture, or itself — so you learn to plan approach and retract heights that clear the cell.

Protective stop (cobot safety)

Exceed a safe contact force and the simulated arm triggers a protective stop, just like a real collaborative robot — teaching the safety habits cobot work demands.

Gripper & digital I/O

Open and close the gripper with set_digital_out, read and set signals, and actually pick something up rather than just waving the tool around.

The pick-and-place cycle in the 6-axis robot arm simulator: approach above the part, grasp, lift, traverse to the place point, lower, and releaseA repeating pick-and-place cycle around a loop: approach, close gripper, lift, traverse, place, open gripper.1Approach2Close3Lift4Traverse5Place6OpenLOOP
Pick-and-place — approach, grasp, lift, traverse, place, release — built from movej and movel moves.
Gripper control via digital I/O in the robot arm simulator: a digital output closes the two-finger gripper to grasp a part and opens it to releaseA two-finger robot gripper shown open (DO=0) and closed on a part (DO=1), controlled by a digital output signal.OPENDO = 0set DOCLOSEDpartDO = 1DO active
Drive the gripper with set_digital_out — a digital output closes the fingers to grasp and opens them to release.
Payload at the robot arm tool centre point: the mass the gripper carries affects safe speed, reach, and how accurately the six-axis arm tracks its pathA robot arm holding a payload box at its tool centre point, with a mass and centre-of-gravity indicator and a small downward droop hint.3.0 kgCoGdroop
Payload — the mass at the TCP changes safe speed, reach, and how the arm tracks its trajectory.
Collaborative robot safety in the arm simulator: a speed-reduced safety zone and a protective stop triggered when the arm makes an over-force contactA collaborative robot surrounded by concentric speed-and-separation monitoring zones, with a protective-stop indicator when a person enters the inner zone.warningreduced speedstopPROTECTIVESTOP
Cobot safety — reduced-speed zones and force-limited protective stops, just like a real collaborative arm.

Real code

You write the same URScript a real arm 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 — the distinction every robot arm programmer has to learn, shown live.

movej versus movel on a 6-axis robot arm: a fast curved joint-space path compared with a straight-line Cartesian tool path between the same two posesTwo tool paths between the same two points: a curved joint move (movej) in cyan and a straight linear move (movel) in amber.ABmovej — joint arcmovel — straight line
movej curves fast through joint space; movel holds a straight Cartesian line.
How URScript becomes arm motion in the simulator: parse the commands, solve inverse kinematics per pose, plan a timed joint trajectory, and run it under physicsThree lines of URScript — movej, movel and set_digital_out — each mapped by an arrow to the corresponding motion on the robot arm.program.urpmovej(p1)movel(p2)set_digital_out(0,True)
Parse → inverse kinematics → trajectory → physics — the pipeline behind every Run.

Why it works

Why an online arm simulator is the best way to learn

vs a real robot arm

A six-axis arm costs tens of thousands and one wrong move can damage it or the cell. The simulator lets you fail safely and repeat a task a hundred times — the only way to actually build skill — at zero risk and zero cost.

vs heavyweight desktop sims

Official offline simulators are capable but often ship as a Linux virtual machine or a paid desktop install that beginners struggle to set up. Ours opens in a browser tab on any computer, with lessons that teach from zero.

vs robot games

The robot games filling app stores teach nothing about automation. This is a real industrial arm in real URScript with engineering-grade grading — so your practice turns into job-ready robot programming skill.

A complete robot arm work cell in the simulator: a six-axis arm, a parts table with pick and place locations, a pallet, and a safety fence around the cellA top-down robot work cell: a central robot, an infeed conveyor, a pick fixture, a place pad, all enclosed by a safety fence.safety fenceconveyorpickRrobotplace
The arm never works alone — the simulator gives you a full cell with a parts table, pick and place stations, a pallet, and a safety fence to plan around.

Pricing

Free to play, Pro for the full course

The basic arm simulator is free — open it in your browser and program a 6-axis arm with no card needed. A Pro subscription unlocks the full graded robot programming course and a certificate when you complete it. Start free, upgrade only if you want the structured curriculum and the credential.

Keep exploring

More robot programming resources

Questions

Robot arm simulator FAQ

Yes. You can run a 6-axis robot arm in your browser for free — no install, no account hoops, and no hardware. The free tier lets you jog the arm, write basic URScript moves, and run a simple pick-and-place. Going Pro unlocks the full graded course and a certificate, but the core arm simulator is genuinely free to play with first.

Program a 6-axis robot arm in your browser.

No install. No robot. No vendor license. Real URScript, graded from zero — free to start.