Available Robots and Drivers

In order to simulate and interact with a robot in Parametric Robot Control, you need to provide the robot type and the robot driver. Both refer to classes in the PRC.Library.dll, i.e. KUKA.KUKA_KR1000 constructs a KR1000 robot via PRC.Library.Robots.KUKA.KUKA_KR1000().
The driver sets the appropriate kinematic solvers to perform the simulation. A driver may generate robot code or provide a real-time interface.

Since PRC 1.727 a running server describes its own library: the DescribeLibrary gRPC call returns every preset robot, every driver with its settings schema and every external-axis preset, so an integration can offer a setup wizard without a copy of PRC.Library.dll (see About gRPC and the LLM Integration Guide).

Drivers#

KUKA.KSS_KRL_Driver
Release Candidate: Driver for simulating robots running KSS (KRC1-5) and iiQKA.OS 2. Outputs code in KRL format. The KSSVersion setting targets the controller generation (KRC1-KRC2 Legacy, KRC2-KRC5 (KSS <= 8.7), iiQKA.OS 2 (KSS >= 9.0)). With the iiQKA.OS 2 target, the program can be uploaded directly to the controller from the Run panel or the Settings page (Controller Upload section), or automatically after every simulation via the AutoUpload setting. Via the UseSplineMotions setting it can optionally emit spline motion commands (SLIN/SPTP/SCIRC with the C_SPL approximation criterion) instead of LIN/PTP/CIRC – this requires KSS 8.3 or higher. Six-axis KUKA robots only – the seven-axis LBR iiwa runs on the Sunrise driver.

KUKA.KSS_IOB_Driver
Experimental: Driver for the IO Builder integration, derived from KSS_KRL. Two interaction modes are chosen via the Interaction setting: Servoing streams the robot's current axis position as JSON over UDP to an external system whenever the simulation updates, and visualizes positions received back live; Path-Table takes each motion's absolute time from the metadata key TimeStamp (seconds) instead of computing timing from speed, and generates a time-stamped axis_recorder take file (JSON) as its code output instead of KRL.

KUKA.KSS_MXA_Driver
Release Candidate: Driver for connecting with KSS robots via mxAutomation. mxAutomation must be installed in a version that fits the mxAutomation.dll.

KUKA.KUKA_Sunrise_Driver
Experimental: Driver for the KUKA LBR iiwa 7 R800 and 14 R820 (seven axes) running Sunrise.OS. Generates the program as Sunrise XML for the PRC Sunrise Java library – download the library from the driver's Settings page (Controller Software group) and add it to your Sunrise Workbench project – or as a Sunrise Workbench frame file. The optional Sunrise Communicator streams executed tasks to the controller over UDP and shows the robot's live position and forces in PRC. Compliant (force-controlled) motions are defined with the Motion: Set Compliance (Sunrise) component. IF/ELSE, WHILE, wait-for-variable and custom code are not supported by this driver.

UR.UR_Driver
Preview: Driver with support for Universal Robots UR5, UR5e/7e, UR10e, and UR20 on both Polyscope 5 and Polyscope X. Outputs URScript code.

UR.UR_RT_Driver
Preview: Realtime driver for Universal Robots: simulates PRC tasks with the UR solver, streams them as URScript programs over the controller's secondary interface (port 30002), and displays the actual robot position live via RTDE (port 30004). Both channels are officially supported on Polyscope 5 and PolyScope X; e-Series robots must be in Remote Control mode.

ABB.ABB_RAPID_Driver
Preview: Driver with support for ABB robots using RAPID. The IRCVersion setting targets the controller generation: IRC5 (save the generated module as .mod) or IRC7/OmniCore (default, save as .modx).

ABB.ABB_RWS_Driver
Preview: Realtime driver for ABB robots via Robot Web Services (RWS): connects to the controller over HTTPS with a controller user account (IP address, RWS port, username, and password are set in the driver settings), generates the RAPID program, and uploads and executes it directly on the controller. A WebSocket subscription streams the execution state and the live robot position (joint and Cartesian values, also exposed as variables) back into PRC for live visualization. The base can reference a persistent base on the controller by name.

FANUC.FANUC_LS_Driver
Experimental: Driver for FANUC robots. Outputs TP programs in the LS (ASCII) format for R-30iB controllers. Joint values and XYZWPR frames follow the FANUC convention, and tool/base frame data (UTOOL/UFRAME) is written into the program by default so that the generated files are self-contained. The world origin follows FANUC's UF0 convention (on the J1 axis at the height of J2), and the FANUC robot models simulate the coupled J2/J3 axis limits.

IGUS.IGUS_Driver
Preview: Driver with support for the igus ReBel robot, generating igus XML code.

NEURA.NEURA_SIM_Driver
Experimental: Driver with support for NEURA robots (MAiRA 7-DOF and LARA 6-DOF). Generates Python code that requires the NeuraPy library to execute.

NEURA.NEURA_RT_Driver
Experimental: Realtime driver that connects to the NeuraPy server on the robot control box (default 192.168.2.13) and executes/streams motions live, with configurable blending, follow-target mode, and feedback interval.

Supervisor.Supervisor_Driver
Experimental: Connection-only driver (formerly Generic.Generic_Driver): it does not control a robot, but registers a client with the server so it can read the variables of all connected machines (robots, IoT devices, dashboards) and write variables of its own. It pairs with the robot-less Supervisor.Supervisor_Device preset – which is also the fallback the server uses when a setup request contains no robot definition at all. The standard polling path returns the variables of all connected machines plus a machine inventory (IDs, name, model, driver, status), and the .NET client additionally provides QueryVariables() and GetMachineData(id, excludeGeometry) for lightweight machine monitoring – with geometry excluded, replies shrink to under 1 KB and can be polled at 30–60 Hz. Adding tasks is not supported, and no license is required.

Robots#

The following robots are currently integrated. They expand the robot library currently available in KUKA|prc.

KUKA.KUKA_KR1000
KUKA.KUKA_KR100120P2
KUKA.KUKA_KR10R11003
KUKA.KUKA_KR10R1420
KUKA.KUKA_KR10R14402
KUKA.KUKA_KR120KR150R31002
KUKA.KUKA_KR120KR210R27002
KUKA.KUKA_KR120R1800
KUKA.KUKA_KR120R3900K
KUKA.KUKA_KR120R3900K2
KUKA.KUKA_KR125200
KUKA.KUKA_KR12KR20R1810
KUKA.KUKA_KR13R9003
KUKA.KUKA_KR150240L110180
KUKA.KUKA_KR180KR240R29002
KUKA.KUKA_KR180R3500K2
KUKA.KUKA_KR200comp
KUKA.KUKA_KR20R3100
KUKA.KUKA_KR210KR240R2700
KUKA.KUKA_KR210R31002
KUKA.KUKA_KR210R3300K
KUKA.KUKA_KR22R1610
KUKA.KUKA_KR250KR300R27002
KUKA.KUKA_KR3060
KUKA.KUKA_KR3070R2100
KUKA.KUKA_KR30L16
KUKA.KUKA_KR3605002
KUKA.KUKA_KR3R540
KUKA.KUKA_KR480R3330
KUKA.KUKA_KR4R600
KUKA.KUKA_KR50R2500
KUKA.KUKA_KR50R25002
KUKA.KUKA_KR50R2500CRW
KUKA.KUKA_KR5arcHW
KUKA.KUKA_KR600R2830
KUKA.KUKA_KR610R1100
KUKA.KUKA_KR610R11002
KUKA.KUKA_KR610R900
KUKA.KUKA_KR610R9002
KUKA.KUKA_KR61620
KUKA.KUKA_KR616Arc
KUKA.KUKA_KR6R1820
KUKA.KUKA_KR6R18402
KUKA.KUKA_KR6R700
KUKA.KUKA_KR6R7002
KUKA.KUKA_KR70R21002
KUKA.KUKA_KR816R20102
KUKA.KUKA_KR8R14402ArcHW
KUKA.KUKA_KR8R1620
KUKA.KUKA_KR90KR120R2900
KUKA.KUKA_KR90KR150R3700K
KUKA.KUKA_KR90KR270R2500
KUKA.KUKA_KR90KR270R2700
KUKA.KUKA_KR90KR270R3100
KUKA.KUKA_LBR12R1260
KUKA.KUKA_LBR14R820
KUKA.KUKA_LBR3R760
KUKA.KUKA_LBR7R800
KUKA.KUKA_OALego

KUKA.KUKA_LBR7R800 and KUKA.KUKA_LBR14R820 are the seven-axis LBR iiwa (Sunrise driver only); KUKA.KUKA_LBR12R1260 is the LBR iico with an offset wrist.

IGUS.IGUS_ReBel

Supervisor.Supervisor_Device (robot-less preset for machine monitoring – no kinematics, no geometry, no axes)

NEURA.NEURA_LARA_3
NEURA.NEURA_MAIRA_M

UR.UR_5
UR.UR_57e
UR.UR_10e
UR.UR_20

ABB.ABB_IRB6620
ABB.ABB_IRB6700_150_320

FANUC.FANUC_LRMate200iD
FANUC.FANUC_M2000iA_2300
FANUC.FANUC_R2000iC_165F

Robots that are not in the library can be defined as a Custom Robot – in Grasshopper 1 and 2 from link meshes, axis planes, limits and speeds, or over gRPC as a CustomRobot naming its kinematics solver (kinematics_solver_class, e.g. KUKA.KUKA_6DOF). The axes must follow the layout conventions of the chosen six-axis family (KUKA, KUKA offset-wrist, ABB, FANUC, UR, NEURA, igus); seven-axis custom robots are not supported.

External Axes#

External axes are simulated alongside the robot; the simulation result contains their positions and out-of-range flags per interpolated step. Users of the .NET Client Library can instantiate ready-made presets from PRC.Library.ExternalAxes:

KUKA: KUKA_KL4000 (linear axis), KUKA_KP1V (KP1V500 single rotary axis), KUKA_DKP400 (2-axis positioner), KUKA_DKP500 (DKP500-2 HW 2-axis positioner), KUKA_KP2HV500 (KP2 HV500 2-axis positioner)

NEURA: MAV500 (MAV-500 AGV)

Over gRPC, an external axis is either referenced by its preset class (ExternalAxis.preset_external_axis_class, e.g. KUKA.KUKA_KL4000 – the server adds geometry, ranges and orientation) or shipped as a full definition. In Grasshopper 1 and 2, custom units are built with the Custom Linear Axis, Custom Rotary Positioner and Custom 2-Axis Positioner components, and every rotary positioner (KUKA units included) takes an optional Workpiece Mesh / Workpiece Collision input that is moved and collision-checked with the table. External axes require a full license.

Driver-Specific Settings#

The settings dictionary returned by SetupRobot is driver-specific – always inspect the returned keys rather than hard-coding them. Notable keys that affect the generated output:

Generated Code & File Extensions#

Since 1.716 the simulation result also lists every generated file with its name (files in SimulationResult) – prefer it over choosing the extension yourself. When saving the code output of a simulation to disk, choose the file extension based on the driver: