Your first project
This page walks you from an empty editor to a small runnable project: five nodes, one variable, two branching paths that both reach a clean ending. The goal is to teach the moves you will use on every page after this one. Reading Editor tour first will save you from looking for any of the panels named below.
You will build a scene with two opening choices. One sets a flag, the other does not. Each opener unlocks a different follow-up, and both follow-ups jump to a shared End node that completes the project. You build the nodes one at a time, so each new concept lands by itself: dialogue first, then a dependency, then a logic node and project completion, then a variable and the event that sets it, and finally a variable-gated visibility condition.
Start a new project
Open the editor. File → New. The editor drops you into an empty Node Graph with one scene called Main in the Left sidebar and one node called node_start on the graph. That starter node is what you will turn into your first beat below.
Saving is up to you. You can run everything below entirely in memory; File → Save (⌘S) opens a native file dialog when you are ready to put it on disk.
Build A1, the first opener
The starter node node_start is already on the graph. Repurpose it into A1, the first of the two openers.
Select node_start. In the Inspector, replace the editable part of its
Id with a1 and click Rename. The stored id is now node_a1. Visible
when is already true, leave it as is.
Scroll to the Events section and click Add event → Dialogue. Set the text to
Selected A1. Speaker stays empty; the editor renders that as Narrator
(no speaker). A1 is now complete: a single node with a single dialogue
event.
The dialogue text is utility text, not story flavor. Selected A1 makes A1
easy to recognize in the simulator timeline later. You will do the same on
every other node.
Build A2 and the dependency
A2 should only appear after the player picks A1. The relationship is drawn
in the Node Graph: drag from A2’s top up to A1, and the editor writes a
Played(...) reference into A2’s Visible when.
Right-click empty space in the Node Graph and pick New Node. Select the new node,
rename its Id to a2, and add a Dialogue event with the text
Selected A2.
Now drag from the top of A2’s card up to A1. A line appears between the two nodes, and A2’s Visible when flips.
The box marks the Visible when expression field. After the drag it
reads Played(node_a1), which the engine evaluates to true once A1 has
played at least once. The line you drew is a Dependency: the Node
Graph and the inspector are mirrors of each other, describing the same
authored relationship.
Build End and close the A path
End is the hidden terminator both branches will jump to. It is a Logic Node: the editor’s term for a flow-only node that is hidden by default. Build End now, then immediately wire A2’s jump to it so the A path runs end-to-end.
Right-click empty space in the Node Graph and pick New Logic Node (not New Node).
Rename its Id to end. Visible when is preset to false, which is what
you want for a node only ever reached by jump.
Add a Dialogue event with the text End was played, then add a Complete
Project event after it. Complete Project has no fields to fill; its
presence is the event.
Now wire A2 → End. Select A2 and drag from the bottom of A2’s card down to End. A line appears between them, and A2’s Events list gains a new event.
(1) The new event has its kind set to Jump and (2) its Target set to
node_end; the Node Graph wrote both fields based on the line you drew.
This line is a Connection. Where a dependency reflects A2’s Visible when (when A2 may appear), a connection reflects A2’s Jump event (where the flow goes once A2 is selected). Drawing the line authored the Jump into A2’s event list; the two are again mirrors of each other.
The A path is now complete: A1 → A2 → End.
Add a variable for the B path
The B path uses a bool variable to decide whether B2 appears. Add it now so the Set Variable event in the next section has something to point at.
Switch to Data mode and pick the Variables tab. Click Add Variable.
Type flag in the editable part of the Id field. The var_ prefix is
fixed to its left, so the stored id is var_flag. Set (1) Type to
bool and (2) leave Default Value as false. Switch back to Nodes when
you are done.
Build B1 and set the flag
B1 is the other opener: the one that flips the flag. It carries two events, a Dialogue and a Set Variable (the editor’s name for “change a variable’s value”).
Right-click empty space in the Node Graph and pick New Node. Rename its Id to b1.
Add a Dialogue event with the text Selected B1. Then click Add event
→ Set Variable.
- Event kind. Set Variable.
- Variable picker. Pick
var_flagfrom the dropdown. - Value. Type
true.
Events fire top to bottom, so leave Dialogue above Set Variable. A1 stays with just its dialogue event; it is the simple opener.
Build B2 and close the B path
B2 closes the B path. Its Visible when references the variable B1 just set. There is no graph gesture for “depend on a variable”; you type the expression directly into the Visible when field.
Right-click empty space in the Node Graph and pick New Node. Rename its Id to b2.
Add a Dialogue event with the text Selected B2.
Select B2. Inspector → Visibility → Visible when → type var_flag.
That is the full expression. Because var_flag is a bool, the engine reads
the variable’s value directly; you do not need == true for it to evaluate.
No new line appears in the Node Graph. Dependencies are drawn for node-to-node relationships only; variable references stay invisible on the graph but visible in the Visible when field.
Finally, draw the jump to End: drag from the bottom of B2 down to End. The B path is now complete: B1 → B2 → End.
That is the finished build. A1 and B1 sit at the top as always-visible openers. A2 and B2 sit below them, each gated on a different condition so the player only sees them after picking the right opener. End sits at the bottom, reached only by jumps from A2 and B2.
Run it
Switch to Simulator mode. The simulator starts the project on entry, so the Choice panel already shows both openers.
Two things to find in the shot: (1) the Debug toggle in the toolbar at the top, and (2) the Choice panel below, listing A1 and B1. Toggle Debug on so the timeline shows each event as it fires, then click B1.
Two things happened. (1) The Debug timeline at the top shows B1’s dialogue event and the Set Variable event that fired alongside it. (2) The Choice panel below lost B1 (the default Repeatable policy is Once per run, so B1 will not appear again this run) and gained B2 (the flag is now true, so its Visible when evaluates to true). A1 is still on the panel; you have not picked it, and nothing has hidden it.
Click B2.
The run is over. (2) The bottom of the timeline shows the final beats: B2’s dialogue, the jump to End, End’s dialogue, and the Complete Project event that closed the run. (3) The Project complete line below the timeline confirms the project finished.
Try the other path yourself. Click (1) Restart in the toolbar, pick A1 instead of B1, and watch A2 unlock on the Played gate while B2 stays hidden (the flag is still false). Pick A2 to reach the same End.
Turn on Exclusive selection
You may have noticed that both openers stay around until you pick them. Pick A1 and B1 is still there; pick B1 and A1 is still there. That is the default behavior: each node is consumed when you pick it, but its siblings are not.
If you want the openers to be mutually exclusive, the Scene has a setting for it. Select the Main scene in the Left sidebar, open the Inspector, scroll to the Transitions section, and look at Exclusive selection.
The picker has three values. inherit takes whatever the project-level
default says (for a new project that is false, so the effective behavior
right now is off). Set it to true.
Run it again
Restart the simulator and pick B1.
(1) The Debug timeline shows the same B1 events as the previous run: B1’s dialogue and its Set Variable. The run was identical up to this point. (2) The Choice panel is where the difference shows. Both openers were consumed by the selection sweep, not just B1. A1 is gone, B1 is gone, and the only choice left is the unlocked B2. Pick B2 to reach End.
Restart and pick A1 to see the same thing happen on the other branch: A1 and B1 are both consumed, A2 unlocks, B2 stays hidden. The two paths through the project are now exclusive.
Check it before you ship
Two tools in Tools mode confirm the project is wired the way you think.
The Validator checks the project for structural issues without running it.
Switch to Tools → Validator. The panel runs on mount and on every edit, so there is nothing to click. On a clean project it reads No issues found in this project.; any findings would appear above as a list. The validator’s full feature set covers structural checks across every entity type in your project; you will meet it again in the validation authoring chapter.
The Path Tester samples reachable paths through the project and reports what it found.
Switch to Tools → Path Tester and click Run. The tester plays 100 random walks through the project and shows what it found. (1) 100/100 paths completed, 100% coverage (5/5), and No issues found mean every walk reached Complete Project, every node appeared on at least one path, and nothing dead-ended, looped, or stayed unreachable. (2) The Coverage Heatmap tints each node by visit-frequency. The collapsed sections above hold deeper analysis you will meet in the path-tester authoring chapter.