Welcome

Foundation

Define, query, and evaluate game state through a high-performance hierarchical tag system with zero
runtime string cost. Tags compile from dot-path names to xxHash3 hashes at import — ancestry and
descendant lookups run in O(1) via pre-built maps, values stack with full arithmetic, conditions chain
with AND/OR/XOR logic, and a Burst-safe native snapshot API keeps everything job-friendly.

Toolkit

Wire hierarchical game-state tags into your scenes and UI without writing code. Components bind
tag-value changes to events, fire condition triggers from serialised rule sets, and surface live
values to labels and sliders — while dedicated editor windows let you build and preview
condition logic and visualise tag usage across your entire project.

Where to Get GameplayTags Toolkit #

Get GameplayTags Toolkit and all of our tools via GitHub Sponsors or Patreon.

All Tools, Yours Forever! #

Get a permanent, perpetual site license to all of our tools for all supported engines.

  • One License, Your Whole Team: Our site-based license covers you, your employees, and your contractors. No “per-seat” fees.
  • Keep What You Build: If you cancel your subscription, you keep the license to the versions you’ve downloaded. You only need an active subscription to access the Source Repos for the latest updates, patches, and new features.
  • Full Source Access: No DRM, no obfuscation. You get the raw source code (C++, C#, GDScript) to ensure your project’s stability is always in your own hands.

Do More with Heathen’s Foundation for Gameplay Tags #

More than just another tag system.

Foundation for Gameplay Tags is a robust, hierarchy-aware tagging system built for performance and ease of use. Every node, every option, every stat and item can be identified with a human-friendly tag. Tags organise by dot-path and can be searched, set, tested, and have values set.

This knowledge base covers every function and feature of the toolkit, and goes beyond into guides and articles on the practical use of tags in game development.

Key Features #

Rich Hierarchy

A structured, hierarchy-aware tag system built on three core types: GameplayTag (a single named tag stored as a ulong xxHash3 value), GameplayTagCollection (a container of tags with optional numeric stack values and set operations), and GameplayTagRegistry (a static registry that tracks parent-child relationships between tags).

Tags follow a dot-separated hierarchy. Registering "Effects.Buff.Strength" automatically makes it a descendant of both "Effects.Buff" and "Effects". Hierarchy lookups are O(1) hash-set operations at runtime — no string comparisons in hot paths.

Conditions and Operations

GameplayTagCondition with full numeric comparison operators (Exists, Equal, Less, Greater, etc.) and AND/OR/XOR logic chains via EvaluateAll.

GameplayTagOperation bundles a tag, arithmetic, value, and optional condition list so operations can be stored as data and evaluated at runtime. Use them to modify narrative state, track inventory, manage abilities, or any system that needs tagged data.

Burst-Safe

GetSnapshot(Allocator) and GetNativeDescendantsMap(Allocator) return caller-owned NativeHashMap / NativeDescendantsMap structs safe to pass into Burst-compiled jobs. No allocations, no GC pressure.

Editor Tooling

Settings panel manages all tag databases. Unified tree view with inline rename (hierarchical), delete with confirmation, filter, and drag-drop pinning. Multiple databases are supported; all are merged into the registry at load time.

Engine Native

More than just a data structure; Foundation for Gameplay Tags is a toolkit of proven, trusted, efficient systems that feel native to the engine you choose. We provide the core tag types and registry at the API level. Then we build on top of that with editor tooling, component wrappers, visual scripting hooks, and data-driven workflows that map tag concepts to your engine’s native concepts.

For example

  • In Unity: ScriptableObject-backed tag databases, custom property drawers, Project Settings integration, Burst job support.
  • In O3DE: DataAsset-backed tag databases, AZ reflection, editor window integration, C++ native runtime.

Then we build on top of that with systems, components, and templates that work with your engine’s concepts to address common use cases and boilerplate needs.

    GameplayTags vs Unity Tags

    Unity’s native tag system is a flat string list. There are no hierarchies, no hierarchy lookups, no numeric values, and no structured query capabilities. Tags are strings with no performance optimisation beyond equality comparison.

    GameplayTags provides a proper hierarchical tag system with dot-path organization, O(1) hash-set lookups (highly performant), numeric stack semantics, condition evaluation, and operations stored as data. It is not just a tag system, it is a structured data system for game development.

    In short:

    • Unity’s native Tags are flat strings with no hierarchy or query capabilities and exceedingly slow to compare.
    • GameplayTags provides a full hierarchy-aware tag system with performance, flexibility, and tooling. Capable of set operations, valuation and single operation comparison costs.

    GameplayTags vs Flat Tag Systems

    Many game engines and frameworks provide flat tag systems, string lists with no hierarchy, no values, and no structured query. These systems work for simple cases but break down as your project grows.

    GameplayTags provides hierarchy (parent-child relationships), numeric stack semantics (tags can have values that stack and decay), condition evaluation (AND/OR/XOR chains), and operations (tag + arithmetic + value + conditions). These features are not optional extras, they are essential for any system beyond simple flag tracking.

    In short:

    • Flat tag systems are limited to simple yes/no flags.
    • Foundation for Gameplay Tags provides a full system for tracking, querying, and modifying tagged data including full support for set operations (contains, parent of, has any, etc.)

    Rate This Article!

    Contents