Nodes, pins, and wires
Place a node, wire its pins, and read execution and typed data in a Round Trip visual script without guessing from color alone.
On this page
A node is one thing that happens. Its pins are where things go in and come out. Its wires show what feeds what.
What it does
Section titled “What it does”Every visual script is drawn with two kinds of wire. White exec wires set the order: they run from one node to the next, and the game does each node in turn along the white path. Colored data wires carry a value, such as a number, a yes-or-no, or an object, from the pin that produces it to the pin that uses it. The wire takes the color of the value’s type, so a red wire always carries a bool and a purple one carries an object.
A node that sits on the white path does something: it calls a method, changes a value, or chooses a path. A node with no white pins only works out a value, such as a comparison, and hands it to whichever node its colored wire reaches.
Two kinds of wire
Section titled “Two kinds of wire”If you have used Unreal Engine Blueprint, this is the same convention. If you have not, think of a flowchart and a spreadsheet. A white wire is a flowchart arrow: it says then. A colored wire is a spreadsheet reference: it says use this value. Each method’s diagram is those two drawings laid over each other.
White wires say when. The method starts at the entry node’s Exec pin and follows white wires from node to node, left to right, doing each node once as it reaches it. In the script a white wire is the gap between one statement and the next. Where the white path stops, the method ends: a BRANCH whose false pin has no wire simply does nothing on false, and a magenta EXIT node is an early return.
Colored wires say what. A colored wire carries one value from the pin that produces it, on the right of a node or pill, to the pin that uses it, on the left of another. In the script it is an argument, an operand, or the value being assigned. A pill or a value node, colored like the value it produces, has no white pins because it never runs on its own: it works out its value when the node on the white path that uses it runs.
The two kinds follow different rules, and the canvas enforces them as you drag:
| White exec wire | Colored data wire | |
|---|---|---|
| Says | when: do this next | what: use this value |
| In the script | the next statement | an argument, an operand, or an assigned value |
| Direction | an output on the right into an input on the left | the same |
| Out of one pin | one wire; dropping a second wire on the same output replaces the first | as many wires as you like, one per place the value is used |
| Into one pin | any number; several paths can meet at one node | one wire; dropping a second wire on the same input replaces the first, and replaces a typed value |
| Connects to | only other white pins | only a pin that accepts the type; the pins that cannot take the wire dim while you drag |
A replaced wire is one undo away: press Cmd/Ctrl+Z and the earlier wire comes back. To run two nodes after one node, chain them, wiring the first node’s exec output into the second and the second’s into the third.
Drag a wire into empty canvas
Section titled “Drag a wire into empty canvas”Most nodes you add belong on the white path, right after a node that is already there. So the quickest way to add one is to start from the pin it follows. Press on a white Exec output, drag onto empty canvas, and let go. A menu opens where you let go. It lists only the nodes that run: statements such as Log under LOGGING and branch, the loops and the switches under FLOW CONTROL, and method calls, found the same way as in the right-click menu. Type part of a name, such as IsTrue, to search the class and every other method in the project. Variable reads, static reads and calls that only return a value, such as Mathf.Clamp, are left out, because a value never runs on its own. Pick a node and it lands at the drop point, already wired to the pin you dragged from.
The new node and its wire are one edit: a single Cmd/Ctrl+Z removes both, so a wrong pick costs one undo. A statement placed from the right-click menu lands unwired instead. It reaches the script only once a white wire joins it to the path, so dragging from the pin it should follow saves that step.
To add a node after the new one, drag again from its exec output; each drop extends the white path by one node. You can also drag backwards, from a node’s white exec input: the node you pick lands wired into that input, so it runs just before.
Dragging from a colored output pin instead opens a menu of that value’s members, with get and set buttons on variables, while clicking a method’s row calls it; see Method calls.
When to use it
Section titled “When to use it”This is the vocabulary every other page uses. Read it before you build your first behavior, such as an enemy that only attacks while it can see the player, or a door that opens once the player holds a key. Come back to it when a diagram gets dense and you want to separate what runs from what feeds it.
What it looks like
Section titled “What it looks like”How to use it
Section titled “How to use it”Build a branch that logs on each path
Add a method
In the left rail, click + on the Methods header and press Enter.
Drop a branch from the exec pin
Press on the entry node’s white Exec pin, drag onto empty canvas to its right, and let go. In the menu that opens at the drop point, under FLOW CONTROL, click branch.
6 stepsFull size ↗Feed the condition
Right-click empty canvas below and to the left of the branch. In the VARIABLES section of the menu, click get on a bool row, such as enabled. Drag from the dot on the right end of the red enabled pill to the Condition pin.
8 stepsFull size ↗Drop a Log on true
Press on the branch’s white true pin, drag onto empty canvas to its right, and let go. In the menu, under LOGGING, click Log.
6 stepsFull size ↗Type the message
Click the box beside message and type
"Ready", with the double quotes, then press Enter.Give false its own Log
Do the same from the branch’s white false pin: drag onto empty canvas, pick Log, and type
"Not ready"beside its message pin. Now both paths do something.Place a value node, then undo it
Right-click empty canvas and, under OPERATORS, click Equals. Look at the node, then press Cmd/Ctrl+Z to remove it again.
Compile
Press Compile in the toolbar.
Color meanings
Section titled “Color meanings”| Value or family | Color | Meaning |
|---|---|---|
| exec | rgba(255,255,255,0.70) |
execution pins and wires |
| int | #4EA054 |
whole numbers |
| float | #6CB47A |
decimal numbers (float, double, decimal) |
| bool | #B34D4D |
yes-or-no values |
| string | #E34A99 |
text |
| char | #6B8B9A |
single characters |
| object | #8E5CFF |
references to objects |
| struct | #B07AB0 |
value types and Unity structs such as Vector3 |
| void | #808011 |
no value flows |
| wildcard | #9A9A9A |
type not decided yet |
| Entry / Exit | #800080 |
where the method starts and stops |
| Flow / Conditions | #FFB400 |
branches, loops, switches |
| Pure | #095F19 |
a value node with more than one result, or none of a known type; every other node without exec pins takes its result’s color from the rows above |
| Impure | #0C0C42 |
statements and SET nodes |
| Call this class | #15B5A6 |
call to a method on this class or a base class |
| Call other class | #0B6E72 |
call into another class in your project, or a Unity or .NET method |
| Call external | #566573 |
a call that resolves to no method in the project or anything it references |
| Assignment | #FF9F43 |
declaring or changing a value |
| Await | #00A8FF |
waiting |
| Try/catch | #CD6133 |
catching errors |
| Using | #2E86C1 |
resource scope |
| Placeholder | #787878 |
something the canvas cannot show |
Color is never the only signal. Titles, badges, pin labels, filled versus hollow dots, and node shape carry the same distinctions.
What it writes
Section titled “What it writes”If you also work in C#, this is how a BRANCH node with a bool on Condition and a call on each of true and false appears in the script. This one is drafted on EnemyStateMachine in the Platformer sample:
A statement placed by dragging from an exec pin writes the same line a hand-drawn wire would. This is ExecDropDemo after Compile, reloaded from the script: one Log dropped from the entry node with "dropped" typed on its message pin.
When it goes wrong
Section titled “When it goes wrong”When it goes wrong
| Symptom | Check | Fix |
|---|---|---|
| A value node appears to run out of order. | Look for white pins on the node. Value nodes and pills have none. | Follow its colored output wire to the node on the white path that uses the value. |
| A wire will not connect. | Check that you dragged from a right-side output to a left-side input, and that the colors match, or that both pins are white. | Drag from the other end, or feed the pin from a source of the matching color. |
| A wire I drew earlier vanished when I drew another. | Both wires left the same white output, or both arrived at the same colored input. Each of those holds one wire, so the new one replaced the old. | Press Cmd/Ctrl+Z to bring the first wire back. To run two nodes in turn, chain them along the white path; to feed one input from two values, combine them in a value node first. |
| A node I added is missing from the script after Compile. | Look for a white wire into its exec pin. A node placed from the right-click menu lands unwired, and a node off the white path is never written. | Drag a white wire to it from the node it should follow. Next time, drag from that exec pin onto empty canvas and pick the node there: it lands already wired. |
| A red message under a node reads Node not completely wired: 'condition' has no value source. | Read the pin it names in quotes. That pin has no wire, no typed value and no default, so the call cannot be written. | Drag a wire into that pin or type a value beside it, and the message goes away. Until then it stays, even when the canvas redraws: after you split or recombine a pill, undo or redo, or leave the method and come back. |
| A wire color seems wrong for a custom type. | Decide whether the type is a reference to an object or a value type. | Read object purple for references and the lighter struct purple for known value types. |
| A gray placeholder node interrupts the white path. | Hover it: its tooltip names the part the canvas cannot show. | Read the limitation and edit that part in the script. The method refuses Compile while the placeholder remains. |
- Pills and literals: feed pins from pills and typed values, and split a shared pill’s wire into its own pill.
- Branch: choose between two paths with true and false.
- Node colors: every type and family color on one page.







