> For the complete documentation index, see [llms.txt](https://flow-core.gitbook.io/flow-core-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://flow-core.gitbook.io/flow-core-docs/documentation/readme.md).

# Welcome

Flow Core is a strongly typed visual logic system for Unity. It focuses on explicit data flow, stable behavior contracts, editor-first graph authoring, and runtime execution without hidden control flow.

Use these docs to build your first graph, connect it to a scene, understand the runtime model, choose the right gameplay module, and extend supported APIs without depending on internals.

## Start Here

| Goal                                       | First page                                                                                            |
| ------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
| Learn the shortest path to a working graph | [Start Here](/flow-core-docs/documentation/getting-started/start-here.md)                             |
| Build a first result in the editor         | [First 15 Minutes](/flow-core-docs/documentation/tutorials/first-15-minutes.md)                       |
| Connect a graph to a scene object          | [Run a Flow Graph in a Scene](/flow-core-docs/documentation/tutorials/run-a-flow-graph-in-a-scene.md) |
| Understand the mental model                | [What Is Flow Core](/flow-core-docs/documentation/core-concepts/what-is-flow-core.md)                 |
| Author and debug graphs in Unity           | [Graph Editor](/flow-core-docs/documentation/editor-guide/graph-editor.md)                            |
| Integrate runtime execution from code      | [Run Flow Core from Code](/flow-core-docs/documentation/getting-started/run-flow-core-from-code.md)   |
| Extend Flow Core safely                    | [Extension Points](/flow-core-docs/documentation/api-extension-guide/extension-points.md)             |

## Module Map

| Area                                    | What it covers                                                                                                                                  | Start with                                                                                            |
| --------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| Flow Graph Foundation                   | Graph assets, nodes, ports, entries, exits, chains, branches, guards, payloads, and subgraphs.                                                  | [Concepts Overview](/flow-core-docs/documentation/core-concepts/concepts-overview.md)                 |
| Blackboard and Data Flow                | Typed data storage, scopes, FlowValue paths, payload values, and runtime data choices.                                                          | [Work with Blackboard Data](/flow-core-docs/documentation/how-to-guides/work-with-blackboard-data.md) |
| Editor Authoring                        | Graph creation, node search, connections, inspector workflows, blackboard UI, debug context, and detail levels.                                 | [Editor Workflow](/flow-core-docs/documentation/editor-guide/editor-workflow.md)                      |
| Runtime Execution                       | Runtime architecture, lifecycle, data flow, process integration, TempPayload, and execution behavior.                                           | [Lifecycle and Dataflow](/flow-core-docs/documentation/runtime-guide/lifecycle-and-dataflow.md)       |
| Scene Stack                             | Authored scene-switch transactions, transition scenes, manual activation, progress, and save/load restore timing.                               | [Scene Stack Runtime Model](/flow-core-docs/documentation/runtime-guide/scene-stack-runtime.md)       |
| Events, Triggers, Input, UI, and Timers | Event-driven starts, UI component triggers, EventSystem triggers, old and new Input System triggers, timer nodes, and cache/save/load triggers. | [Flow Node Kinds](/flow-core-docs/documentation/reference/flow-node-kinds.md)                         |
| Flow Control Nodes                      | Branching, gating, loops, waits, retries, delays, cooldowns, remote routing, error handling, and weighted choices.                              | [Node Reference](/flow-core-docs/documentation/reference/nodes.md)                                    |
| FSM                                     | Long-lived state logic, state entry, updates, transitions, exclusive groups, and graph-backed states.                                           | [Flow, FSM, and BT Patterns](/flow-core-docs/documentation/gameplay-modules/flow-fsm-bt-patterns.md)  |
| Behavior Tree                           | Priority and sequence decision logic, BT roots, selectors, sequences, decorators, services, subgraphs, and cookbook patterns.                   | [Behavior Tree Authoring](/flow-core-docs/documentation/gameplay-modules/behavior-tree-authoring.md)  |
| Stack                                   | Layered gameplay modes with push, resume, update, pause, pop, and runtime stack control.                                                        | [Stack Root and Stack Layer](/flow-core-docs/documentation/gameplay-modules/stack-root-and-layer.md)  |
| GOAP                                    | Goal-oriented planning, goals, actions, costs, preconditions, effects, replanning, and runtime planner control.                                 | [GOAP Authoring](/flow-core-docs/documentation/gameplay-modules/goap-authoring.md)                    |
| Flow Character                          | Character motion, facing, animation states, gestures, markers, IK, event graphs, speed curves, and locomotion authoring.                        | [Flow Character](/flow-core-docs/documentation/gameplay-modules/flow-character.md)                    |
| Flow Interaction                        | Owner and target interaction flow, focus, blur, interact, target selection, and practical interaction scenarios.                                | [Flow Interaction](/flow-core-docs/documentation/gameplay-modules/flow-interaction.md)                |
| Flow Camera                             | Main and output camera controllers, Camera Shots, Channels, priority selection, transitions, lens settings, and graph-driven camera changes.    | [Flow Camera](/flow-core-docs/documentation/gameplay-modules/flow-camera.md)                          |
| Instructions and Conditions             | Built-in actions, checks, logic groups, generated catalogs, and custom instruction or condition extension points.                               | [Built-in Catalog Overview](/flow-core-docs/documentation/reference/built-in-catalog-overview.md)     |
| API and Extension                       | Supported runtime APIs, extension APIs, persistence handlers, generated items, codegen, graph wrappers, and integration boundaries.             | [API & Extension Guide](/flow-core-docs/documentation/api-extension-guide.md)                         |
| Troubleshooting and Migration           | Debugging, common pitfalls, runtime cost monitoring, failure modes, BT debugging, and upgrade notes.                                            | [Troubleshooting](/flow-core-docs/documentation/troubleshooting.md)                                   |

## Documentation Model

* Tutorials teach by producing a working result.
* How-to guides solve focused tasks.
* Core concepts explain mental models and behavior contracts.
* Editor and runtime guides describe workflows and observable execution behavior.
* Gameplay module pages explain higher-level systems such as Flow Character, Flow Interaction, Flow Camera, BT, FSM, Stack, and GOAP.
* API and extension pages describe supported integration surfaces.
* Reference pages provide precise lookup information.

## Public API Boundary

Flow Core documentation distinguishes supported user-facing APIs from implementation details. A public C# type is a supported contract only when it is documented as `Supported Runtime API` or `Supported Extension API`. Generated internals, editor implementation details, and Unity-serialization-only public types are not stable integration contracts.
