Skip to content
Bit Quirky Round Trip
Visual Scripting

Search documentation

All topics and APIs

Close returns focus to Search.

What are you looking for?

Try a common topic or a C# feature.

Browse the reference instead

Esc closes · Tab reaches results · Enter opens the focused link

v1.0.0
Menu

Canvas

Learn the visual language Round Trip uses for C# values, execution, reads, edits, and layout.

The canvas is C# arranged as a path you can trace. White wires carry execution from one statement to the next. Colored wires carry typed values. Nodes do work; compact pills read values; inline literals hold values that have no wire yet.

Read CollectCoin from the window to its wires

Select a screenshot to enlarge it.

The full PlayerController.CollectCoin window with the selected method in the left rail and its visual script between the rails.
Figure 1. Locate the active canvas CollectCoin is highlighted in the Explorer. The center is its method body; the inspector on the right describes the selected method.
CollectCoin diagram with a branch leading to EXIT or four calls, fed by colored value wires and compact pills.
Figure 2. Follow order first, values second This closer view shows the same method. Follow the white exec wire from the entry through BRANCH. The false path collects the coin, adds coins, refreshes the HUD and plays audio; colored wires supply the values.
The parts of a Round Trip diagramAn AddCoins call card for another class. Its first body row holds the white exec pins: a triangle marked exec on the left edge for the input and one on the right for the output. Below them, a purple target pin is wired from the _scoreCounter pill, and a green count pin holds the literal 1 in a box just outside the card, to the left of its pin. A white exec wire runs from the output through a wire knot into a second card, SetLabel, whose text pin is hollow with an empty box beside it. Seven callouts appear in order: exec pin, data pin, wire, pill, literal, hollow pin, and wire knot. The final frame shows every label._scoreCounterScoreCounterAddCoinsexecexectargetcount1SetLabelexecexectextexec pindata pinwirepillliteralhollow pinwire knotThe parts of a Round Trip diagramAn AddCoins call card for another class. Its first body row holds the white exec pins: a triangle marked exec on the left edge for the input and one on the right for the output. Below them, a purple target pin is wired from the _scoreCounter pill, and a green count pin holds the literal 1 in a box just outside the card, to the left of its pin. A white exec wire runs from the output through a wire knot into a second card, SetLabel, whose text pin is hollow with an empty box beside it. Seven callouts appear in order: exec pin, data pin, wire, pill, literal, hollow pin, and wire knot. The final frame shows every label._scoreCounterScoreCounterAddCoinsexecexectargetcount1SetLabelexecexectextexec pindata pinwirepillliteralhollow pinwire knot
One node up close: the header names it, exec pins carry order, data pins carry typed values, a pill reads a value, and a literal holds one that has no wire.

The visual language is inspired by Unreal Engine Blueprint, widely regarded as the best visual scripting language in games, so the white exec wire, typed data wires and pin colors will feel familiar if you have used it. Round Trip takes it further. Blueprint graphs run largely on one thread; a Round Trip visual script is plain C#, so a method can be a Unity coroutine or an async method, and the canvas draws its yield and await statements beside everything else. Those statements stay typed in C# today; everything around them is edited on the canvas.

  • Nodes, pins, and wires: read node anatomy and execution flow, then learn data flow and the color vocabulary.
  • Pills and literals: understand compact GET reads, split a shared pill’s wire into its own pill or recombine it, and set inline values and object references.
  • Variables: create GET and SET nodes from the Variables rail or by dragging a row.
  • Layout, wire knots, and comments: arrange a diagram without changing behavior while keeping source comments visible.
  • Wire knots: bend a long wire around other nodes, branch a new wire out of a knot, and move or remove knots.
  • Snap to grid: let every node and pin settle on the grid so wires run straight.
  • Align nodes: line a selection up on one of its nodes, by edge or by center, from the menu, the toolbar or a Shift key.
  • Shortcuts: use the keyboard and pointer gestures across the Explorer and canvas.

Start at the entry node and follow exec wires. At each node, pause only long enough to read the data wires entering it. A pure node has no exec pins, so trace its colored output toward the statement that uses it. Reading this way keeps a large visual script manageable.

Layout changes and viewport state belong in .rt.json layout files. Those files also hold wire knots and split reads. Comment popup sizes stay there too. C# remains the source of behavior.

Full-size image