Flow Core

Two Cats Code | Online Documentation | Demo | Discord | Unity Asset-Store | Feature Request | Bug Report

🕹️ Demo Provided.

Flow Core is a production-grade, strongly-typed visual scripting system and universal graph framework for Unity. Build serious Flow / FSM / Behavior Tree logic with Stack-based mode management, built-in searchable knowledge system, one-click node generation, deep call-chain debugging, and predictable low-GC runtime.

✅ Stack System: production-grade mode/state layering (Push/Pop/Pause/Resume) — no more state spaghetti

✅ Flow Knowledge: built-in searchable wiki for 7000+ entries — find the right node in seconds

✅ Predictable Performance: Pooling + Runtime Cost visibility — low-GC graphs that actually ship

Visual scripting isn’t hard to make. It’s hard to ship.

Most node tools build prototypes fast—but real projects die from maintenance debt, debugging blind spots, runtime unpredictability, and performance surprises.

Flow Core is built for shipping. It brings code-level discipline into graphs: strongly-typed dataflow, inspectable execution paths, engineering-grade debugging, and a performance-first runtime design.

Now with Stack-based mode management and Flow Knowledge, Flow Core scales better as your project grows—without turning your graphs into archaeology.

Features

✅ Stack System: Mode/State Layering Done Right

A production-grade stack mechanism for layered gameplay/app modes:

• Push/Pop/Pause/Resume/Update lifecycle designed for predictable behavior
• Only the top layer updates (others pause) — perfect for overlays and modal contexts
• Configurable policies: Busy handling, interrupt behavior, overflow mode, guard rules
• Ideal for Pause/Menu/Dialogue/Tutorial overlays, input context overrides, VR training phases, and “temporary sub-modes”

✅ Pooling: Low-GC Execution for High-Frequency Graph Logic

In visual scripting, the most common performance killer isn’t computation—it’s allocations and GC spikes. Flow Core includes/supports a Pooling mechanism to reuse high-frequency temporary objects and data, reducing runtime jitter and making behavior more predictable in production.

• Reuse temporary objects/data structures to minimize per-frame allocations
• Reduce GC spikes so graphs remain stable under high tick rates and heavy concurrency
• Complements Runtime Cost visibility: measure bottlenecks → pinpoint hotspots → reduce jitter with pooling
• Ideal for high-frequency event flows, BT ticking, real-time input, sensing/perception pipelines, and VR training flows

✅ Flow Knowledge: Built-in Searchable Wiki for Your Node Ecosystem

When you have thousands of nodes, “more nodes” isn’t the solution. Findability is.

• Built-in searchable knowledge system (nodes / instructions / conditions / types)
• See signatures, categories, IDs, sources, and assembly info instantly
• Works great for onboarding teams and scaling large projects
• Turns “node overload” into a productivity advantage

✅ Strong Typing: Graphs that behave like real code

• Strongly-typed ports and connections reduce silent type mistakes
• Variables and Blackboards follow clear type contracts
• Stable Scene Targeting in Blackboard — survives renames, moves, Save/Load
• Less time chasing “it’s connected but wrong” bugs

✅ One-Click Node Generation: Turn your C# API into node commands

• Automatically generate node commands from your custom data and methods
• Remedial Codegen — Fix Missing Types Automatically. Keep Shipping.
• Scale without writing endless glue code
• Add it late in development—without rewriting your project

✅ Serious Debugging: Stop guessing the dataflow and call order

• Visual call-chain / execution-path tracing
• Live (or semi-live) value inspection with debug context
• Clear diagnostics for missing keys, type mismatches, invalid links, and more
• A workflow closer to “breakpoints + call stack + watch” than typical node tools

✅ Multi-Blackboard Support: Real-world data management

• Reference multiple blackboards for layered contexts (global/local/module)
• Great for modular systems and team workflows
• Keep data structured instead of turning everything into globals

✅ Performance Philosophy: Predictable, low-GC, scalable

• Runtime design prioritizes minimizing (near to zero) reflection and allocations
• Zero boxing/unboxing where it matters
• Runtime cost visibility (e.g., execution cost trends) to guide optimization

✅ Universal Graph Framework: Not just Flow

• Support Flow / FSM / BT / (GOAP soon) and your own custom graph types
• Extensible graph + node architecture (you’re not locked into one style of logic)
• Build “your graphs” with one consistent editor philosophy

Use Cases

• Gameplay logic & event orchestration: skills, interactions, quests, combat flows
• AI systems: FSM, behavior trees, branching logic, perception/decision pipelines
• Tooling & content pipelines: procedural setups, UGC editors, workflow automation
• VR/AR logic: input, gestures, mode switching, training flows, device states
• Simulation & research: traceability and reproducibility that teams can trust

Why Flow Core (and not “just another node editor”)

In real projects, teams don’t fail because they can’t connect nodes. They fail because:

• Graphs get big and maintenance becomes archaeology
• Bugs appear and there’s no call stack—debugging becomes guesswork
• Reflection/allocations pile up and shipping becomes a gamble
• Collaboration turns variables into spaghetti and changes ripple unpredictably

Flow Core flips the priorities:

Maintainability, debuggability, and runtime predictability are first-class features—not afterthoughts.

Quick Start Workflow

1. Create a Graph asset (Flow / FSM / custom graph type)
2. Bind one or more Blackboards (global/local/module contexts)
3. Use the Node Generator to convert your C# API into nodes
4. Connect logic, run, and open debug views to trace call chains and inspect values
5. Scale with your project: add nodes, add graph types, refine data layers, extend UI