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

Work as a team

Share scripts and project settings while each teammate keeps a personal Round Trip canvas layout by default.

A designer changes a call on the canvas. A programmer edits the same script in their code editor. Both changes land in the same file, and where each person has dragged their nodes never gets in the other’s way.

Teams need a clear line between shared game behavior and each person’s own canvas arrangement. Round Trip keeps behavior in the project’s .cs scripts. Which folders Round Trip reads is a shared project setting. Node positions and the view of the canvas stay on each person’s machine unless the team chooses to share them.

  • Designers and programmers change the same gameplay components, one on the canvas and one in a code editor.
  • One teammate reads behavior as nodes and wires while another reads the script.
  • You need to decide which Round Trip files go into version control and which stay on one machine.

Round Trip is a Unity package in the project, so everyone who opens the project gets it. A designer opens Graph view and works on the canvas. A programmer can change the same scripts in their usual code editor and open Graph view whenever a picture helps. Both are working on the same scripts.

Every teammate uses a Unity version the project supports and lets Unity finish resolving packages and compiling scripts before opening a visual script.

Agree on shared source folders and layout storage in the setup wizard

Select a screenshot to enlarge it.

Wizard Sources screen with the Platformer runtime folder selected.
Figure 1. Choose shared source folders Source folders belong to the project; appearance and interaction preferences belong to each editor.
Wizard Layout screen with Local only selected and the Shared with the team alternative below.
Figure 2. Decide whether to share layouts Local only, shown selected, keeps arrangements under UserSettings/RoundTrip. Shared with the team uses the project RoundTrip folder instead.

Share settings, keep layouts personal, and pass an edit between two people

  1. Share the source folders

    Open Project Settings > Round Trip. Under Source indexing, open Include paths and add the folders the team expects Round Trip to read.

    Project Settings on the Round Trip page. A note at the top says the settings are stored in ProjectSettings/RoundTripSettings.asset and should be shared with the project. Under Source indexing, the Include paths list, highlighted, has one element, Assets/Platformer/Runtime.
  2. Keep layouts on each machine

    Leave Layout scope under Layout storage on Local for the normal team setup. Choose Shared only when the team has agreed to arrange canvases together.

    Under Layout storage, the Layout scope dropdown, highlighted, reads Local.
    Under Layout storage, the Layout scope dropdown, highlighted, now reads Shared.
  3. Set personal preferences

    On each machine, open Preferences > Round Trip.

    Preferences on the Round Trip page, with the Round Trip entry in the list on the left highlighted and an arrow pointing at it. Switches and sliders sit above the grid and canvas preview. They include Show coverage, Split long read wires, Scroll moves viewport and Zoom sensitivity.
  4. Make a canvas change

    Give one person the open method while a canvas change is in progress. That person watches the Previewing your changes. panel at the top of the right rail and steps back anything unwanted with its Revert or the toolbar undo.

    The CoinAnnouncer.AnnounceCoin canvas with the name pill wired into the Log node's message pin. Compile is amber in the top rail and the Previewing your changes panel at the top of the right rail, highlighted with an arrow, says 2 nodes aren't in the C# yet. It offers Revert and Compile.
  5. Compile into the script

    Press the toolbar Compile, the one button that saves every pending change into the script.

    The same AnnounceCoin canvas after Compile, with the toolbar Compile button highlighted and an arrow below it. Compile is gray, the Previewing your changes panel is gone and the name wire into Log is still in place.
  6. Review it as a script change

    The programmer reviews the change in version control the way they review any script change. The designer’s new wire shows up there as an ordinary edit to the method.

    A rendered diff of CoinAnnouncer.cs. One removed line reads Debug.Log with the text Hello from Round Trip. One added line reads Debug.Log(name). The surrounding lines are unchanged.
  7. Take the programmer's edit onto the canvas

    Now have the programmer change the same script in their code editor and save. Round Trip watches the included folders and reads the changed script again. On the designer’s screen, once Unity is ready, the canvas shows the new statement.

    The ReportCoin canvas after an outside edit to the script: Coin entry, a Log fed by count, the PlayCoin call fed by the _audio variable pill, and a second Log fed by the literal saved, which the outside edit inserted between the first Log and the PlayCoin call.
  8. Stop when both sides changed

    If the programmer saves the script while the designer still has an uncompiled change open, stop and agree before anyone presses Compile. Round Trip checks the script on disk first and refuses to save over a change it has not seen.

    The toolbar on ReportCoin(int count). A red banner reads ExternalEditsExamples.cs changed while compiling; discard and try Compile again. Below it the Previewing your changes panel is still open with Revert and Compile.

These four details make a canvas edit easier for a programmer to review:

  1. I changed the Method on Class.
  2. It now calls this, or branches on this value.
  3. I pressed Compile.
  4. The script change should be this one focused edit.

Use the mirror when a programmer hands a script edit to a designer: name the class, the method, any renamed member, and the gameplay reason. Round Trip redraws the canvas from the script; the handoff explains why.

When it goes wrong

SymptomCheckFix
A teammate cannot find a class in Graph view.Compare Include paths under Project Settings > Round Trip on both machines.Add the shared folder there and let Round Trip finish reading it.
Node positions differ between two machines.Read Layout scope under Layout storage.Keep Local if personal arrangements are expected, or agree on Shared before treating layout as common.
The canvas still shows the old method after a programmer saved the script.Confirm the saved script is in an included folder and Unity is idle.Use Reload once Unity finishes compiling.
Compile reports that the file changed.Ask whoever saved the script what they changed.Reopen the method, redo your canvas change on top of the new version, then Compile.
Full-size image