Most industrial robots are programmed in a vendor-specific text language — URScript, RAPID, KRL, FANUC TP, INFORM — paired with a graphical teach pendant. The languages differ, but the concepts (frames, TCP, joint vs linear moves, waypoints, I/O) are universal. This guide explains each language accurately, then helps you pick which to learn first.
The big picture
There is no single "robot language". Every major manufacturer ships its own controller with its own programming language, and a program written for one brand will not run on another. But underneath the differing syntax, every six-axis industrial arm and collaborative robot shares the same handful of ideas. Learn these once and changing vendors becomes a matter of new syntax, not new concepts.
Every program works in coordinate frames — a base frame, a tool frame, and often work-object frames. The TCP is the point on the tool the robot actually controls and moves. Define the TCP correctly and your moves land where you mean them to; get it wrong and every position is off.
A joint move interpolates each axis from its current angle to the target — fast and efficient, but the tool follows a curved path. A linear move drives the TCP in a straight Cartesian line. Every vendor has both: movej/movel, MoveJ/MoveL, PTP/LIN, J/L, MOVJ/MOVL.
Positions are usually taught: you jog the arm to a pose with the pendant and save it as a waypoint rather than typing coordinates. A program is then a sequence of moves between waypoints, often with a blend so the arm rounds corners smoothly instead of stopping at each point.
Robots talk to the rest of the cell through digital inputs and outputs — firing a gripper, signalling a conveyor, reading a part-present sensor. Every language has commands to set an output and read an input, and most real programs are mostly motion plus I/O sequencing.
Language by language
Here is each major language, what it looks like, and where it is used — with links to a full guide for each vendor.
URScript is the text language built into every UR controller, with a Python-like syntax. Motion is movej (joint), movel (linear) and movep (constant-speed process paths); set_digital_out drives I/O like a gripper; set_tcp and set_payload configure the tool. It is widely considered the friendliest robot language, and every graphical PolyScope program compiles down to it. This is the language our simulator teaches because the concepts transfer to every other vendor.
movej(p_home, a=1.4, v=1.0) # joint move
movel(p_pick, a=0.5, v=0.1) # linear move down
set_digital_out(0, True) # close gripperFull guides: Universal Robots programming · Learn URScript
RAPID is ABB's structured text language, edited on the FlexPendant or in RobotStudio. Programs are organised into modules and procedures (PROC … ENDPROC). Motion instructions are MoveJ (joint), MoveL (linear) and MoveC (circular), each taking a target, a speed (v1000) and a zone/blend (z50, or fine to stop exactly). RAPID is common in welding, assembly and material handling.
MoveJ pHome, v1000, z50, tool0;
MoveL pPick, v200, fine, tool0;
SetDO doGripper, 1;Full guide: ABB robot programming
KRL is KUKA's text language, edited on the smartPAD pendant or in KUKA.OfficeLite / WorkVisual. Its motion commands are PTP (point-to-point joint move), LIN (linear) and CIRC (circular). KRL uses $-prefixed system variables for things like I/O ($OUT[1]) and speed, and structures programs with DEF … END. It is heavily used in automotive, heavy handling and machining.
PTP HOME
LIN P_pick
$OUT[1] = TRUE ; close gripperFull guide: KUKA robot programming
FANUC robots are programmed two ways. TP (Teach Pendant) is the everyday language: you build a numbered list of instructions on the pendant, where J means a joint move and L a linear move, each with a speed and a termination type (FINE or CNT for blending). KAREL is FANUC's Pascal-like text language for more complex logic, data handling and background tasks. Most line work is TP; KAREL is used where TP runs out of expressiveness. FANUC is dominant in high-volume automotive and general industry.
J P[1] 100% FINE
L P[2] 200mm/sec CNT50
DO[1] = ON ! close gripper (TP)Full guide: FANUC robot programming
INFORM is the language for Yaskawa Motoman robots, written as an instruction list on the pendant. Motion instructions are MOVJ (joint move) and MOVL (linear move), each with a speed (velocity for joint, mm/s for linear), plus MOVC for circular paths. I/O is handled with instructions like DOUT. Yaskawa is especially strong in arc welding, handling and packaging.
MOVJ VJ=50.00
MOVL V=138
DOUT OT#(1) ON ; close gripperFull guide: Yaskawa robot programming
VAL began as the language of the early Unimation/PUMA robots and is one of the original robot languages. Its modern descendant, VAL3, is the structured text language used on Stäubli robots, with a syntax closer to a general-purpose programming language (typed variables, functions, libraries). Stäubli arms are known for precision and clean-room duty, so VAL3 shows up in high-accuracy assembly, life-sciences and cleanroom applications.
Many collaborative robots are programmed without typing code at all. UR's PolyScope builds a program tree of nodes; Doosan's DART-Studio uses block-based programming; Omron's TMflow uses a flowchart where each node is a move, an I/O action or a logic branch. These visual environments lower the barrier so non-programmers can deploy a cobot, while still exposing the same underlying concepts — waypoints, joint vs linear moves, TCP and I/O.
Full guides: Doosan cobot programming · Omron robot programming
ROS (the Robot Operating System) and its successor ROS2 are not a vendor language but the dominant framework for robotics research and complex integration. You write nodes in Python or C++ that pass messages over topics and services, and use packages like MoveIt for motion planning across many robot brands. ROS is the standard in research labs and multi-robot or vision-heavy systems; on a single arm running a production line, the vendor language is usually what actually executes on the controller.
Which should I learn first?
With several incompatible languages it is tempting to ask which one to memorise. The better question is which one teaches the concepts fastest — because frames, TCP, joint vs linear moves, waypoints and I/O are the same everywhere, and that is what actually transfers between vendors.
URScript is the best place to start. The syntax is approachable, the motion model is the same model every other vendor uses, and you can write and run it in a browser with no hardware. Once those fundamentals are solid, picking up RAPID, KRL, FANUC TP or INFORM is mostly a matter of new keywords. If your path is research or multi-robot integration rather than a single production arm, learn Python alongside it for ROS.
That is exactly how our course is built: you write real URScript on a simulated arm, learn the universal concepts by doing, and finish with a graded capstone — so the skill transfers to whatever brand you meet on the job.
At a glance
| Language | Vendor | Style | Where used |
|---|---|---|---|
| URScript | Universal Robots | Text (Python-like) + PolyScope flow | Cobot cells, pick-and-place, machine tending |
| RAPID | ABB | Text + FlexPendant | Welding, assembly, material handling |
| KRL | KUKA | Text + smartPAD | Automotive, heavy handling, machining |
| TP / KAREL | FANUC | Teach-pendant instructions + Pascal-like text | High-volume automotive and general industry |
| INFORM | Yaskawa Motoman | Teach-pendant instruction list | Arc welding, handling, packaging |
| VAL3 | Stäubli | Text (structured) | Precision assembly, cleanroom, life sciences |
| DART / TMflow | Doosan / Omron | Graphical block / flowchart | Cobot deployment by non-programmers |
| Python / C++ (ROS) | Open-source / multi-vendor | General-purpose code + framework | Research, integration, multi-robot systems |
Keep learning