Doosan Robotics collaborative robots are programmed with DART Studio, the teach pendant, Drag&Teach hand-guiding, and — for advanced work — DRL, the Python-style Doosan Robot Language. Before you wrestle with vendor-specific tools, master the universal fundamentals — waypoints, the tool centre point, joint vs linear motion, gripper I/O, payload, and collaborative safety — hands-on in a free browser simulator. Because DRL’s movej / movel verbs read almost exactly like the URScript you write here, these concepts carry straight onto a Doosan teach pendant.
Honest note: this is not a Doosan emulator and it does not run DART-Suite. It teaches the transferable cobot-programming fundamentals using real URScript on a UR-style arm.
The Doosan stack
Doosan Robotics makes collaborative robots across several ranges — the M-series, A-series, H-series, E-series and P-series — and its programming workflow is built around a few core tools. Knowing what each one does — and what it expects you to already understand — tells you exactly where to start.
Most Doosan programming happens on the teach pendant. You build a program as a visual flow of commands — motion moves, waits, I/O, and logic — rather than typing raw code. You jog the arm to positions and record them as waypoints, then chain those waypoints into a task. This graphical, block-style approach is the bread-and-butter of day-to-day Doosan work.
DART Studio is Doosan’s programming workspace (part of the wider DART-Suite). It is where you assemble the command flow, configure motion and I/O, set the tool and payload, and define safety. For advanced control you write DRL — the Doosan Robot Language — a Python-based scripting language with verbs like movej(), movel() and set_digital_output(). It is Doosan-specific software, the standard tool for building and validating Doosan programs.
Because Doosan cobots are collaborative, you can teach positions by hand: grab the arm and physically move it to where you want it, and the robot records that waypoint (Doosan calls this Drag&Teach). It is a fast, intuitive way to set points — but you still need to understand waypoints, motion types, and safety to turn a set of taught points into a reliable program.
Doosan extends its cobots through DART-Platform, an app ecosystem layered on top of the robot. It is how Doosan and partners add capabilities — but the same fundamentals of waypoints, motion, payload, and force-limited collaborative safety still apply underneath every app.
What transfers
Doosan’s DART-Suite and graphical flow are vendor-specific, but the concepts beneath them are not. Every six-axis collaborative arm — Doosan, Universal Robots, FANUC CRX, KUKA — is driven by the same handful of ideas. Our browser simulator teaches each one hands-on using real URScript, so you build the mental model first and learn Doosan’s specific interface second.
Approach, act, retract: chaining points into a smooth, safe path is the same skill on any controller. Doosan’s graphical flow is just a different way of expressing that sequence.
Define the working point of your gripper or tool so the robot moves the right spot to the right place. Get the TCP wrong and every position is off, on Doosan or anywhere else.
Joint moves are fast through joint space; linear moves keep the tool on a straight Cartesian line. Knowing when to use each is core to every brand, including Doosan.
Doosan’s Drag&Teach lets you move the arm by hand to record waypoints. Understanding what a waypoint is — and how it feeds into motion — is what makes hand-guiding productive rather than guesswork.
Reading inputs and setting outputs to drive a gripper or signal a PLC is universal — only the way you wire it into the program changes.
Configure payload, respect reach limits, and avoid collisions and over-force contact. On collaborative robots like Doosan’s, this becomes force- and speed-limited collaborative safety.
Concept mapping
You program in real URScript in the simulator. Here is how each concept maps to the Doosan world so you can see the bridge clearly. The bridge is unusually short: DRL — the Doosan Robot Language — is a Python-style language whose motion verbs (movej, movel, set_digital_output, set_tcp) read almost exactly like the URScript you write here, so the mapping below is close to one-to-one in both thinking and naming.
| Learned here (URScript / UR-style) | On a Doosan cobot (DART Studio / DRL) |
|---|---|
| movej — joint move | movej() in DRL, or the joint-move block in the DART Studio flow |
| movel — linear move | movel() in DRL, or the linear-move block in the DART Studio flow |
| Hand-jog to a pose | Drag&Teach hand-guiding to record a waypoint |
| Tool centre point (set_tcp) | set_tcp() / tool setup in DRL or on the pendant |
| Digital I/O (set_digital_out) | set_digital_output() in DRL, or the I/O block in the flow |
| Payload configuration | set_tool / payload (tool weight) setting on the controller |
| Protective stop / force limits | Joint-torque-sensed collaborative force and speed limits |
Note: this mapping shows conceptual (and, for DRL, near-syntactic) equivalence to help you transfer skills. The simulator does not generate or run Doosan DRL programs — for that, you would use Doosan’s DART Studio or a real teach pendant.
Where to start
You can jump straight into Doosan’s ecosystem — but if you have never programmed a robot, the tools assume knowledge you do not have yet, and getting hardware in front of you gets in the way of practising. The faster path is to build the fundamentals where they are free and frictionless, then layer Doosan’s interface on top.
DART-Suite runs on a Doosan teach pendant, which means real (or rented) hardware. It is powerful, but it assumes you already understand waypoints, the TCP, and motion types — so beginners spend their energy fighting the interface instead of learning to think like a robot programmer.
Open a tab, write real URScript on a UR-style arm, and practise the exact concepts Doosan relies on — for free, with graded tasks. When you reach a Doosan pendant, you are learning a new interface, not a new way of thinking.
Cobots & safety
Doosan Robotics builds collaborative robots designed to operate near people without the traditional safety cage. Every joint carries a torque sensor, so the arm can feel unexpected contact and stop — that joint-torque sensing is what underpins Doosan’s collision detection and its Drag&Teach hand-guiding. That lower barrier is part of what makes cobots a common entry point into robot programming.
But collaborative does not mean consequence-free. Whatever the brand, cobot safety comes down to force and speed limits, protective stops on unexpected contact, payload that is configured correctly, and a program that avoids collisions in the first place. Our simulator teaches exactly that: tasks are graded not just on placing the part, but on staying within a force limit and avoiding over-force contact — the same discipline a Doosan cobot (or any collaborative arm) demands.
In the simulator
You do not just watch — you write real URScript, run it on a simulated six-axis arm under physics, and get graded against a real goal. Every skill here is a fundamental Doosan programmers rely on too.
Move the arm in joint and Cartesian space; understand base vs tool frames and how the TCP is defined.
movej vs movel — when each is right, and how speed and acceleration change the motion (the same distinction Doosan’s flow exposes).
Read and set digital signals; open and close a gripper to actually pick something up.
Approach, grasp, lift, traverse, place, release — the backbone of real robot and cobot work.
Configure payload and tool centre point and see how they change reach, accuracy, and safe speed.
Trigger and avoid protective stops and over-force contact — the heart of collaborative safety.
Keep exploring
Write real robot code in your browser — waypoints, TCP, motion, gripper I/O, pick-and-place, and collaborative safety. No install, no robot, free to start. Then take those skills to a Doosan teach pendant.