BTGraph

Publisher

MoeTheCoderGuy

Please Note

This entry is from Friday February 6, 2026. The price of the asset may have changed since then.
Please visit our homepage for recent offers and sales. Official and private Unity Asset Store™ sales usually last about 14 days.

Overview

BTGraph is a modern, production-ready Behavior Tree system for Unity that combines a powerful visual graph editor with a high-performance runtime engine. It is designed for developers who want clean architecture, scalable AI systems, and full control over execution flow—without relying on heavyweight frameworks or tightly coupled scripts.

Built from the ground up for modularity and long-term maintainability, BTGraph allows you to design, debug, and reuse AI logic as data-driven ScriptableObject assets, keeping gameplay code structured and easy to extend.

🚀 Modern Execution Architecture

Unlike traditional tick-only behavior tree implementations, BTGraph supports:

• Tick Execution Mode
• Event-Driven Execution Mode
• Hybrid Execution Mode

Event-Driven mode allows behavior trees to evaluate only when necessary, eliminating redundant per-frame reevaluations and improving performance in large multi-agent systems. Hybrid mode combines responsiveness with safety ticks for complex use cases.

This makes BTGraph suitable for:

• Stealth AI
• Combat systems
• Simulation systems
• Large NPC populations
• Strategy games
• RTS units
• Modular decision-making systems

🌳 Modular Subtree System

BTGraph includes a fully implemented Subtree architecture, enabling you to build reusable behavior modules that can be composed into larger AI systems.

Features include:

• Type-safe blackboard parameter bindings
• Circular reference detection
• Collapsible subtree visualization
• Clean status propagation
• Zero runtime reflection in hot paths
• No per-frame string parsing or unnecessary allocations

Subtrees make it easy to create reusable logic for patrol systems, investigation behavior, combat routines, dialogue trees, or ability execution.

🧬 Archetype-Based AI Templates

Define reusable AI templates using Archetypes, then safely instantiate them across your project.

Archetypes allow you to:

• Duplicate behavior trees without shared node IDs
• Create standardized AI patterns (e.g., Guard, Ranged, Melee, Civilian)
• Build structured AI libraries
• Maintain consistency across large projects

This makes BTGraph ideal for scalable game development and team workflows.

🗂 Data-Driven Blackboard System

BTGraph includes a robust Blackboard system for structured data sharing between nodes.

• Type-safe key bindings
• Runtime value change detection
• Clean separation between logic and state
• Efficient event-driven wake behavior
• No redundant notifications

This keeps AI state management predictable and easy to debug.

🖥 Professional Visual Graph Editor

The BTGraph editor is built for clarity and speed:

• Clean visual Behavior Tree graph workflow
• Collapsible nodes and subtrees
• Comment boxes and grouping
• Undo/Redo safe editing
• Minimap navigation
• Fast node search
• Assembly-safe runtime/editor separation

The editor avoids clutter and focuses on usability, making it suitable for both rapid prototyping and production pipelines.

⚙ Performance & Build Safety

BTGraph is designed with runtime correctness and performance safety in mind:

• Allocation-free idle Event-Driven mode
• No reflection in runtime evaluation loops
• Clean runtime/editor assembly separation
• Safe for standalone builds
• No hidden UnityEditor dependencies in runtime
• Suitable for mobile, PC, and console projects

This ensures stable performance in real production environments.

🎮 Ideal For

• Indie developers building structured AI systems
• Studios needing scalable decision architectures
• Projects requiring modular AI design
• Developers who want a lightweight alternative to legacy AI frameworks
• Teams that prioritize maintainability and clean architecture

🧩 What Makes BTGraph Different?

BTGraph is not just a Behavior Tree editor—it is an architectural AI framework.

It emphasizes:

• Event-driven execution
• Modular subtree composition
• Reusable archetype workflows
• Clean runtime isolation
• Predictable performance
• Long-term maintainability

All without unnecessary boilerplate or heavy runtime overhead.