Start here

The player touches a coin. PlayerController.CollectCoin checks that the coin is usable, collects it, updates the score and HUD, then asks the optional audio service to play a sound.

You can build that method on a canvas without typing a line, and this is what Round Trip writes to your project:

C#

public void CollectCoin(Coin coin)
{
    if (coin == null || coin.IsCollected)
    {
        return;
    }

    if (_scoreCounter == null || _hud == null)
    {
        _logger?.LogWarning(
            "player controller cannot collect a coin; its score counter or HUD reference is " +
            "unassigned. wire both on the player to enable coin collection.");
        return;
    }

    coin.Collect();
    _scoreCounter.AddCoins(CoinsPerPickup);
    _hud.RefreshCoins(_scoreCounter.Coins, _scoreCounter.Score);
    _audio?.PlayCoin();
}

Open the same method in Round Trip and it is a graph: two guard branches, followed by four calls. It is still the same method in the same file. Build it from nodes, read it, change it, or edit the C# in your IDE; each side follows the other.

Code and graph in one loop: the parsed method, the same method after a line was typed into the file, a method drafted in the graph, and that draft compiled into the file.

Three ways to work

Make the game without writing code. Create a class and a method from the Unity menus, build the body out of branches, loops, calls and values on the canvas, and press Compile. The result is ordinary C# in your project. It has no dependency on Round Trip and compiles without the package installed.

Let an AI write the code, then check it. An assistant edits your scripts and the result looks plausible. Open each changed method as a graph, follow the guards and calls, compare it with HEAD from the modified-classes list, and keep or revert one method at a time.

Use code from anywhere. A script from a tutorial, a forum answer, an asset, or an old project. Add its folder, read it as a graph, and change it on the canvas like code you built yourself.

Code, canvas, or both

Most visual scripting tools keep your logic in their own format. Round Trip writes C# and reads C# back, so you are never tied to the canvas. File edits re-parse into the graph. Graph edits stay as drafts until Compile writes the smallest source change it can.

C# produces the graph. A visual draft returns to C# only when you press Compile, then Round Trip parses the file again.

Graph configuration files remember layout and view choices. They do not replace the method in your C# file.

Who gets value

• The designer who does not code can make gameplay rules on the canvas and ship ordinary C#.
• The project owner using an AI assistant can inspect what the assistant changed through the graph and the built-in source diff before accepting it.
• The coder who likes visuals can use the canvas to reason about a busy method, then keep working in an IDE whenever text is faster.
• The team gets one source file that a programmer and a non-programmer can discuss together.

Where to go next

Pick the route that matches the project in front of you. A new game can start with your first method. An assistant’s edit can start with check what the AI did. A script someone else wrote can start with read a class you did not write.

Next

• What you get: meet the Explorer, canvas, authoring tools and Compile flow.
• C# is the truth: see exactly what lives in source and what lives in configuration.
• Three ways in: build without code, check an AI’s edit, or bring in existing scripts.
• Install: add the package and open the Platformer example.