Work as a team
Share scripts and project settings while each teammate keeps a personal Round Trip canvas layout by default.
On this page
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.
The task
Section titled “The task”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.
When this applies
Section titled “When this applies”- 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.
What each teammate installs
Section titled “What each teammate installs”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.
What it looks like
Section titled “What it looks like”Share settings, keep layouts personal, and pass an edit between two people
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.
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.
Set personal preferences
On each machine, open Preferences > Round Trip.
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.
Compile into the script
Press the toolbar Compile, the one button that saves every pending change into the script.
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.
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.
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.
Handing an edit to a programmer
Section titled “Handing an edit to a programmer”These four details make a canvas edit easier for a programmer to review:
- I changed the Method on Class.
- It now calls this, or branches on this value.
- I pressed Compile.
- 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
Section titled “When it goes wrong”When it goes wrong
| Symptom | Check | Fix |
|---|---|---|
| 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. |
- Settings and preferences: see the full project and user boundary.
- Layout and configuration files: understand what
.rt.jsonstores. - External edits: follow a script change back onto the canvas.








