Parameters

Robots Grasshopper parameters are wrappers around typed Robots objects. This page is the reference for those objects: what each one means, what properties it carries, which units it uses, how Grasshopper can create or cast it, and which parts of the program pipeline consume it.

For a workflow-oriented component list, see Components. For the high-level programming model, see Core concepts.

Shared conventions

Robots uses the fixed unit system documented in Core concepts. Object properties below repeat units only where a field needs them.

Many objects have a Name. Names are used by postprocessors to emit tool, frame, speed, zone, and command declarations. Names must start with a letter and contain only letters, digits, and underscores. They can be at most 32 characters. Some manufacturers have shorter practical limits and may warn.

When a target attribute is unnamed, Create Program assigns a generated name such as Speed000 or Frame000. If several distinct attributes share the same name, Create Program renames them and reports a warning. Reuse the same object when targets should refer to the same controller declaration.

Some parameters are persistent and can store values inside the Grasshopper document. Runtime parameters can pass values through wires, but they are normally produced by components or scripts each solution.

Parameter	Stores	Persistent	Main producers
Target	A Cartesian or joint target	No	Create Target, points, planes, joint strings, scripts
Tool	A tool/end effector	No	Create Tool, Load Tool, scripts
Frame	A work frame	Yes	Create Frame, Load Frame, points, planes, scripts
Speed	Robot speed settings	Yes	Create Speed, numeric/string casts, scripts
Zone	Stop/fly-by settings	Yes	Numeric/string casts, scripts
Command	A robot command	No	Command components, scripts
Joints	Joint values in radians	Yes	Kinematics, Degrees To Radians, strings, scripts
Toolpath	An ordered target collection	No	Target lists, scripts, custom components
Robot System	A robot cell definition	No	Load Robot System, scripts
Program	A checked or custom-code program	No	Create Program, Program Simulation, Custom Code
Post Processor	A custom postprocessor	No	Scripts, custom plugins

Casting from standard Grasshopper data

Grasshopper can convert some standard data directly into Robots parameters. These casts are convenient, but they create simple objects with built-in fallback values. Use the dedicated creation components or scripting when optional properties matter.

Parameter	Accepted simple casts	Result
Target	Point	Cartesian target at the point, with World XY orientation.
Target	Plane	Cartesian target using that plane.
Target	String with six or seven comma-separated numbers	Joint target with those joint values in radians.
Frame	Point	Static frame at the point, with World XY orientation.
Frame	Plane	Static frame using that plane.
Speed	Number	Speed with translation speed set to that number; rotation remains PI rad/s (180 deg/s) and the remaining fallback values are listed in Speed Parameter.
Speed	String with one number	Same as a number cast.
Speed	String with two comma-separated numbers	Translation speed and rotation speed. External-axis speeds, acceleration, and time use the fallback values listed in Speed Parameter.
Zone	Number or integer	Zone with distance set to that number. Rotation values are approximated from distance.
Zone	String with one number	Same as a number cast.
Zone	String with two comma-separated numbers	Zone distance and TCP rotation. External-axis rotation follows the supplied rotation.
Joints	Number or integer	A one-value joint array.
Joints	Comma-separated string	Joint array in radians. An empty string becomes an empty array.
Toolpath	Target	A one-target toolpath value.

Target casts use the fallback target attributes described in Target Parameter.

Parameter casts happen at the Grasshopper boundary. In scripts and .NET code, prefer constructing the object directly so units and optional fields are explicit.

Parameter reference

Target Parameter

A Target describes one robot pose and the attributes attached to that pose. A toolpath is an ordered collection of targets.

Typical sources are Create Target, points, planes, comma-separated joint strings, scripts, and custom toolpath logic. Typical destinations are Create Program, Kinematics, Create Target as a reference target, and Deconstruct Target.

Target types

Type	Main property	Meaning	Typical use
Joint target	Joints	Robot joint rotations directly, in radians.	Start, home, recovery, or any pose where exact joint posture matters.
Cartesian target	Plane	Desired TCP plane, interpreted relative to the target frame.	Process paths and geometry-driven programming.

A joint target is the most unambiguous way to define a robot pose. For a typical six-axis robot, it stores six joint rotations in radians. The JointTarget constructor accepts six or seven finite joint values; the selected robot system then checks whether that count matches the robot.

A Cartesian target stores a TCP plane. The robot system must solve inverse kinematics to convert the plane into joint values. Cartesian targets can fail when the plane is unreachable, outside joint limits, too close to a singularity, or incompatible with a forced configuration. A common singularity is a wrist singularity, where the requested pose requires the fourth and sixth joints to become parallel.

The first target of a real program should normally be a joint target, or a Cartesian target that the program check can safely convert to joint motion. This gives the robot an unambiguous starting posture.

Common target properties

Property	Applies to	Unit	Description
Tool	Both	Object	End effector used at the target. See Tool Parameter for fallback values.
Frame	Both	Object	Work coordinate system used by the target. See Frame Parameter for fallback values.
Speed	Both	Object	Speed and timing settings. See Speed Parameter for fallback values.
Zone	Both	Object	Stop point or fly-by settings. See Zone Parameter for fallback values.
Command	Both	Object	Optional command or grouped commands. If omitted, no command is emitted.
External	Both	Radians or millimeters by mechanism	Numeric external-axis values used by kinematics, simulation, and checks.
ExternalCustom	Both	Text	Optional controller-specific external-axis output strings supplied by scripts.
Joints	Joint target	Radians	Robot joint rotations.
Plane	Cartesian target	Millimeters and radians through plane orientation	Desired TCP plane relative to the target frame.
Configuration	Cartesian target	Enum flags	Optional IK configuration: Shoulder, Elbow, Wrist, or Undefined.
Motion	Cartesian target	Enum	Joint, Linear, or Process. If omitted, the target uses Joint motion.

When a target property has no explicit input and no reference target value to inherit, it uses the fallback values documented in the Tool, Frame, Speed, and Zone sections below. Command emits nothing, and External is an empty array.

ExternalCustom does not replace External. Numeric external values are still needed for simulation, speed checks, collision checking, and kinematics. Use scripting helpers such as ExternalAxes.Custom(...) only when generated code needs custom external-axis text.

Cartesian configuration

Many industrial robots can reach the same TCP plane in several joint configurations. When configuration is not forced, Robots selects a valid solution by closest joint-space distance from the previous target. Joints are weighted equally.

Forcing a configuration narrows the solver choice, but it does not always make the pose fully unambiguous. The previous target still matters because joints may reach the same configuration through different absolute rotations.

Forced configuration is meaningful for Cartesian joint motion. For non-joint motions, Create Program warns that the forced configuration is ignored.

Motion types

Motion	Behavior	Notes
Joint	Solves the target plane once and moves in joint space. The TCP path can curve through world space.	Used when Motion is omitted. Useful for approach, retreat, pick-and-place, and avoiding singularities along a strict linear path.
Linear	Moves the TCP in a straight line in world space.	Useful for milling, extrusion, welding, inspection, and other process paths. Intermediate samples are checked.
Process	UR-only continuous-process motion posted as movep.	Rejected for other manufacturers. UR Process also rejects time-based speed.

A linear path can fail even when the end plane is reachable, because the intermediate samples may cross a singularity, joint limit, or unreachable pose.

Frames and target coordinates

A target plane is written as if the target frame were the origin. For example, a Cartesian target at (0, 0, 100) with a frame located at (100, 100, 100) is placed at world coordinate (100, 100, 200) when the frame has world orientation. See Frame Parameter.

Grasshopper creation notes

Create Target can create Cartesian or joint targets. Right-click the component to switch target type and to add optional inputs for Configuration, Motion, Tool, Speed, Zone, Command, Frame, and External.

A connected reference target can provide fallback values. If an optional input is absent, the new target keeps the corresponding value from the reference target. This is useful for modifying only the plane, joints, speed, zone, or another single property while preserving the rest.

Create Target cannot have both Plane and Joints inputs at the same time. A string cast is only a quick way to create a joint target with the built-in fallback tool, frame, speed, zone, command, and external axes; use Create Target when the target needs explicit tool, speed, zone, frame, command, external axes, motion type, or configuration data.

Tool Parameter

A Tool describes the end effector attached to the robot flange.

Typical sources are Create Tool, Load Tool, and scripts. Typical destinations are Create Target and custom target-generation workflows.

Tool properties

Property	Unit	Description
Tcp	Plane	Tool center point relative to the robot flange.
Weight	kg	Tool or payload weight used for payload warnings.
Centroid	Point	Tool center of mass. Defaults to the TCP origin when omitted.
Mesh	Mesh	Display mesh used for preview.
CollisionMesh	Mesh	Mesh used internally by collision checking. When not supplied, it uses the same mesh reference as Mesh; if Mesh is omitted, both are the empty mesh.
UseController	Boolean	Use tool data already defined on the controller instead of declaring it where supported.
Number	Controller index	Manufacturer-specific controller tool number. Also implies UseController.
Name	Text	Declaration or library name.

Create Tool exposes name, TCP, optional four-plane calibration, weight, centroid, and preview mesh. Collision meshes and controller-managed tool numbers are usually supplied by tool library XML/3DM or scripting.

When a target or parameter needs a fallback tool, Robots uses a TCP at the flange origin with World XY orientation, weight 0 kg, centroid at the TCP origin, an empty display mesh, the same empty mesh for collision checking, controller-managed tool disabled (UseController = false), no controller tool number, and the name DefaultTool.

TCP and calibration

The TCP plane is defined relative to the robot flange. Create Tool can also calculate the TCP origin from four calibration planes. Those planes should represent four different flange orientations around the same physical point. The calculated TCP keeps the orientation of the input TCP plane and replaces the origin.

A tool can cast to its TCP plane for preview or standard Grasshopper geometry operations.

Meshes

Mesh is display geometry. CollisionMesh is used by collision checking. When a library does not define collision meshes, Robots uses the display mesh reference instead of duplicating mesh data.

Controller-managed tools

Controller-managed tool support is manufacturer-specific. See Manufacturer support for the current tool and frame support matrix.

Frame Parameter

A Frame is the work coordinate system used by targets. It can be static, controller-managed, or coupled to a moving mechanism or coordinated robot.

Typical sources are Create Frame, Load Frame, standard points or planes, and scripts. Typical destinations are Create Target and custom workflows that need reusable work coordinates.

Frame properties

Property	Unit	Description
Plane	mm and orientation	The work coordinate system. Target planes are interpreted relative to this plane.
CoupledMechanicalGroup	Index	Mechanical group that moves the frame, or -1 for no coupling.
CoupledMechanism	Index	External mechanism in the coupled group, or -1 when coupling to a robot flange.
IsCoupled	Boolean	True when CoupledMechanicalGroup is not -1.
UseController	Boolean	Use frame data already defined on the controller instead of declaring it where supported.
Number	Controller index	Manufacturer-specific controller frame number. Also implies UseController.
Name	Text	Declaration or library name.

Create Frame exposes Plane, Coupled Mechanical Group, Coupled Mechanism, and optional Name. UseController and Number are mainly set through robot-library XML or scripting.

When a target or parameter needs a fallback frame, Robots uses a World XY plane at the world origin, no coupling (CoupledMechanicalGroup = -1, CoupledMechanism = -1), controller-managed frame disabled (UseController = false), no controller frame number, and the name DefaultFrame.

Coordinate semantics

Target coordinates are written as if the frame were the origin. A Cartesian target at (0, 0, 100) with a frame located at (100, 100, 100) is placed at world coordinate (100, 100, 200) when the frame has world orientation.

A frame can cast back to a plane for preview or regular Grasshopper geometry operations.

Coupled frames

Use coupled frames when a work plane moves with an external mechanism, positioner, track, or another robot.

Common examples:

• Robot with a positioner in the same mechanical group: Coupled Mechanical Group = 0, Coupled Mechanism = 0.
• Two coordinated robots where the second robot moves the work frame: Coupled Mechanical Group = 1, Coupled Mechanism = -1.

Create Program validates coupling. A coupled frame is rejected if the robot system does not support frame coupling, the group does not exist, the mechanism does not exist, or the frame is coupled to the same robot that is using it.

Controller-managed frames

Controller-managed frame support is manufacturer-specific. See Manufacturer support for the current tool and frame support matrix.

Speed Parameter

A Speed describes motion speed, acceleration, external-axis speed, and optional time-based target duration.

Typical sources are Create Speed, persistent parameters, numeric casts, comma-separated strings, and scripts. Typical destinations are Create Target and custom target-generation workflows.

Speed properties

Property	Unit	Default	Used by
TranslationSpeed	mm/s	100	TCP translation speed for linear/cartesian timing, checks, and code.
RotationSpeed	rad/s	PI (180 deg/s)	TCP rotation and swivel speed.
TranslationExternal	mm/s	5000	Linear external-axis speed.
RotationExternal	rad/s	6 * PI (1080 deg/s)	Rotational external-axis speed and joint-space external limits.
TranslationAccel	mm/s^2	2500	Posted by UR and Doosan where applicable; used for acceleration warnings.
AxisAccel	rad/s^2	4 * PI (720 deg/s^2)	Posted by UR, Doosan, and Franka Emika where applicable; used for acceleration warnings.
Time	s	0	Optional target duration used by UR and Doosan where supported.
Name	Text	none	Declaration name in generated code.

These defaults are the starting values for Create Speed, speed casts, and target fallback speed. A number cast replaces only TranslationSpeed; a two-number string replaces TranslationSpeed and RotationSpeed.

Robots moves at whichever limit is most restrictive for the current segment. Translation, rotation, joint, and external-axis limits can all become the limiting factor.

Acceleration and time

Acceleration is not dynamically integrated by simulation. The simulation remains kinematic and velocity-based. Acceleration values are used by postprocessors that support them and to warn when a velocity-only duration estimate is likely optimistic.

Speed.Time is a scripting/API property. When greater than zero, supported postprocessors can ask the controller to reach the target in that time, and Robots uses that time for the segment duration. UR and Doosan use time-based speed where supported. UR Process motion rejects Speed.Time.

Reuse and generated code

Use one shared speed object when many targets should refer to the same controller speed. If you wire the same raw number or string directly into many target speed inputs, Grasshopper can create multiple distinct speed objects with the same value, which can produce unnecessary duplicate declarations.

Casts and limitations

A number or a string containing one number supplies only TranslationSpeed; omitted fields keep the defaults listed in the table above. A string with two comma-separated numbers also supplies RotationSpeed; external-axis speed, acceleration, and time still use the defaults. Use Create Speed or scripting when those fields, names, or time-based speed matter.

Zone Parameter

A Zone describes whether the robot must stop exactly at a target or may blend through it as a fly-by point.

Typical sources are persistent parameters, number casts, comma-separated strings, scripts, and custom components. Typical destinations are Create Target and custom target-generation workflows.

Zone properties

Property	Unit	Default	Description
Distance	mm	Required constructor value; the built-in fallback zone uses 0.	TCP zone radius. Values greater than tolerance make the target a fly-by point.
Rotation	rad	If omitted, (Distance / 10) degrees converted to radians.	TCP orientation approximation zone.
RotationExternal	rad	If omitted, follows Rotation; if Rotation is omitted, follows the distance-derived value.	Rotational external-axis approximation zone.
IsFlyBy	Boolean	Distance > 0.001	True when Robots treats the target as a fly-by point.
Name	Text	none	Declaration name in generated code.

When a target or parameter needs a fallback zone, Robots uses Distance = 0 mm, Rotation = 0 rad, RotationExternal = 0 rad, and therefore IsFlyBy = false.

Stop points and fly-by points

A zero zone is a stop point. The robot stops at the target before continuing, and commands run at the target.

A nonzero zone allows fly-by motion. The robot can begin moving toward the next target before exactly reaching the current target. This creates more continuous motion but gives up exact target precision.

See Simulation for how fly-by zones are sampled and what controller behavior is outside the simulation model.

Commands force stop points

If a target has commands and a fly-by zone, Create Program changes that target to a stop point and emits a warning. This avoids hiding command timing inside a blended move.

Reuse and casts

Use one shared zone object when many targets should refer to the same controller zone. Repeated raw number or string casts can create duplicate zone declarations.

A number or one-number string sets Distance. A two-number string sets Distance and Rotation; RotationExternal follows the supplied rotation.

Command Parameter

A Command is code that runs at a target or during program initialization.

Typical sources are Message, Wait, Set DO, Set AO, Pulse DO, Wait DI, Stop Program, Group Command, Custom Command, and scripts. Typical destinations are Create Target and Create Program initialization commands.

Common command behavior

Property or concept	Description
Name	Used for declarations where a postprocessor needs a named value. Unnamed commands are named by Create Program.
RunBefore	Scripting/API option that asks supported postprocessors to place a target command before the target motion. Current Grasshopper command components do not expose this input.
Declaration	Optional code emitted once per program for commands that need variables, helper functions, or setup.
Target code	Code emitted at each target where the command is attached.
Init command	Command passed to Create Program initialization commands instead of a target.
Group command	A command container that flattens several commands into one input.

Command support is manufacturer-specific. If a command or its declarations cannot be represented for the selected manufacturer, Create Program reports an error instead of silently dropping it.

Commands attached to a fly-by target force that target to become a stop point during program preflight. Create Program reports a warning when it does this.

Built-in commands

Command	Main inputs	Notes
Custom Command	Name, manufacturer, target code, declaration/setup code	Use for manufacturer-specific code. Manufacturer can be a specific brand or All. Requires code, declaration, or both.
Group Command	Command list	Combines several commands into one command value.
Message	Text	Emits a pendant/controller message where supported.
Pulse DO	Digital output, pulse time in seconds	Defaults to 0.2 seconds. Validates IO bounds.
Set AO	Analog output, value	Validates IO bounds. Robots only checks that value is finite; controller range is manufacturer-specific.
Set DO	Digital output, boolean value	Validates IO bounds.
Stop Program	none	Pauses or aborts according to manufacturer behavior. Not implemented for every manufacturer.
Wait	Time in seconds	Adds wait time to duration estimates.
Wait DI	Digital input, desired boolean value	Validates IO bounds.

Named IO comes from the robot library. Libraries can use Robots zero-based indexing or supported controller numbering. Controller numbering is currently supported only where Robots knows the manufacturer convention.

Joints Parameter

A Joints parameter stores an array of finite numbers, normally joint rotations in radians.

Typical sources are Kinematics, Degrees To Radians, Program Simulation, Deconstruct Program Targets, comma-separated strings, and scripts. Typical destinations are Create Target, Kinematics, and external-axis inputs.

Uses

Use	Expected values
Joint target input	Six or seven robot joint values in radians, then checked against the selected robot system.
Previous joints for Kinematics	One set of previous joint values used to choose among ambiguous IK solutions.
External axes input	One value per external axis. Units depend on the mechanism: radians for rotational axes and millimeters for linear axes.
Redundant joint value	Some redundant robot workflows can accept one external value for the redundant joint.

Robots uses radians internally even when controller languages display or accept degrees. Use Degrees To Radians when bringing manufacturer-style joint values into Robots, because axis signs and external-axis conventions can be robot-specific.

A comma-separated string such as 0,1.57,0,0,0,0 creates a six-value joint array. An empty string creates an empty array.

Toolpath Parameter

A Toolpath is an ordered collection of targets passed as one object.

Typical sources are target lists, scripts, custom components, or Robots internals. Typical destinations are Create Program and Deconstruct Toolpath.

A single target also implements the toolpath interface, so it can be accepted where a one-target toolpath is useful. Grasshopper can cast a Target into a Toolpath parameter.

Create Program accepts either target lists or toolpath lists. For multi-robot systems it creates one target/toolpath input per mechanical group. Every group must have the same number of targets.

Robot System Parameter

A Robot System represents the robot cell used for kinematics, checking, simulation, collision detection, code generation, and remote upload.

Typical sources are Load Robot System and scripts. Typical destinations are Create Program, Kinematics, Get Plane, From Plane, Degrees To Radians, and advanced custom workflows.

Robot system data

Property or concept	Description
Name	Library or system name.
Controller	Optional controller family or variant from the library.
Manufacturer	ABB, KUKA, UR, Staubli, Franka Emika, Doosan, Fanuc, Igus, or Jaka.
BasePlane	Placement of the robot system in the Rhino model.
IO	Digital and analog input/output names and numbering convention.
DisplayMesh	Combined display geometry for the system.
DefaultPose	Default joint planes, display meshes, and collision meshes.
Remote	Optional remote upload/play/pause implementation for supported manufacturers.
Default postprocessor	Code generator used unless a Post Processor override is supplied.

Robot systems can be simple one-robot systems or industrial systems with multiple mechanical groups. Industrial systems may include external axes such as positioners or tracks.

The robot library describes controller and mechanism facts. The Base input on Load Robot System places that robot system in the current Rhino model. Do not bake project-specific shop placement into a reusable library file.

Kinematics and orientation conversion

Kinematics solves one target per robot group. For Cartesian targets, previous joint values help choose among multiple valid inverse-kinematic solutions.

Get Plane and From Plane use the robot system to choose the manufacturer-specific orientation representation: ABB quaternions, KUKA/Fanuc/Igus style Euler conventions, UR axis angles, Franka quaternions, and other system-specific conversions. Without a robot system, the generic conversion assumes quaternions.

Preview

The Robot System parameter previews robot system geometry. Disable preview or use it sparingly in large definitions if repeated mesh display becomes heavy.

Program Parameter

A Program is the checked result of combining a robot system with one or more toolpaths.

Typical sources are Create Program, Program Simulation, and Custom Code. Typical destinations are Program Simulation, Check Collisions, Save Program, Remote Connection, Deconstruct Program Targets, and visualization components.

Program inputs

Input	Meaning
Name	Program name. Names must be valid Robots identifiers and may be further constrained by manufacturers.
Robot System	The cell, kinematics, postprocessor, and manufacturer context.
Targets	One target/toolpath list per mechanical group. Multi-group systems require matching target counts.
Init Commands	Optional commands emitted before motion starts.
Multi-File Indices	Optional target indices where generated code should split into additional files. Index 0 is always inserted.
Step Size	Linear sampling distance in millimeters for checks and simulation. Smaller values are more accurate and slower.

Program outputs and properties

Output or property	Description
Program	The program object passed to downstream components.
Code	Generated controller code tree, present only if there are no errors.
Duration	Approximate duration in seconds.
Warnings	Non-blocking issues that should be reviewed.
Errors	Blocking issues; code is not generated.
Targets	Fixed and checked system targets used internally for simulation and diagnostics.
Attributes	Named tools, frames, speeds, zones, and commands collected for code generation.
HasSimulation	True for checked programs with simulation data; false for custom-code programs.

What Create Program checks

Create Program validates toolpath count, target count, external-axis counts, frame coupling, tools, payload, kinematics, motion support, command support, postprocessor support, program names, and multi-file split indices. It also names unnamed attributes, warns about duplicate names, warns when targets still use the fallback tool (flange-origin TCP, 0 kg) or fallback speed (100 mm/s translation), and changes command-bearing fly-by targets into stop points.

Errors stop code generation. Warnings do not stop code generation, but should be reviewed before running code on a controller.

Simulation and custom code

A normal program contains simulation data. Program Simulation, Check Collisions, Deconstruct Program Targets, and visualization components depend on that data.

Custom Code replaces generated code while preserving a program object for saving and transfer. A custom-code program cannot be simulated or collision-checked because Robots no longer has target-level motion data.

Post Processor Parameter

A Post Processor is an optional code generator override for a robot system.

Typical sources are scripts and custom plugins. Typical destination is Load Robot System.

Use this when you want Robots to keep using the library, kinematics, checking, simulation, and object model, but emit controller code through a custom implementation. Custom postprocessors should fail clearly when a controller feature is not supported.

The postprocessor interface returns generated code as a three-level text list. It is advanced API surface; most users should rely on the default postprocessor for the selected robot system.

Generated library value lists

Load Robot System, Load Tool, and Load Frame can create a hidden Robots library value list next to the component. This is not a normal typed parameter. It is a convenience list of installed library names, and it refreshes from the online/local library state.