GameplayTag Foundation

Hierarchical tags for Unity: typed values, stack counts, data-driven conditions and operations, Burst-ready, with a Project Settings editor and zero string cost at runtime.

• Unity 6 (6000.0) or newer, the oldest version we support; Built-in, URP and HDRP (no rendering dependencies).
• Requires com.unity.collections, com.unity.mathematics, com.unity.nuget.newtonsoft-json; Game Framework and the Toolbox install through the Heathen Toolbox prompt.
• Apache 2.0, full source.

Stop checking if (state == "stunned") and stop growing enums you can't extend. GameplayTags Foundation gives your project a single, shared vocabulary: dot-path tags like Effects.Buff.Strength that know their own hierarchy, carry values, and can be tested, combined and changed as data, not code.

Join the thousands of developers who have shipped hundreds of commercial games on Heathen technology.

GameplayTags Foundation is free and open source (Apache 2.0). The full source is in the package, and nothing is held back for a paid tier. The tag system itself is new to the Store, but the team behind it is not: more than 260 Steam games have self-reported as "Made with Heathen" using one or more of our toolkits, some of them major releases and many of them small passion projects, and more than 3,500 developers are in our Discord. You can build on this knowing it will still be maintained.

A tag is a lightweight struct wrapping a hash. After registration there are no string comparisons anywhere, and asking "is this a kind of Effects.Buff?" is a constant-time range test, not a walk up a tree. Add tags in Project Settings > Gameplay Tags, click Build, and use them in code as generated constants, or type the name and let it convert. No ScriptableObject databases to wrangle, no assembly-scope surprises.

What you can do with it

• Give any entity, character or system a tag collection that holds stack counts and typed values (int, float, long, double), and subscribe to changes on a single tag or a whole branch.
• Ask hierarchy questions the way you'd say them: has any buff, is a kind of status effect, is exactly this tag.
• Author game logic as data: conditions (exists, equals, less than, member of, string contains, and more, chained with AND, OR, XOR) and operations (set, add, multiply, min, max, append) that you can store, serialise and evaluate at runtime, with no bespoke code per rule.
• Share state by name: a named collection registry lets independent systems agree on one "Global" or "Story.Afterlife" bucket.
• Store free-form strings keyed by tag for the things 64 bits can't hold, like a player-entered name.
• Run it inside Burst jobs with caller-owned snapshot and interval-map structs.
• Plug your own systems in: register named condition and operation providers so authored rules can reach into your code.

Fast by design, and not a one-off:

• Tags are hashed once. After that there are no string comparisons and no allocations to check a tag, and "is this a kind of Effects.Buff?" is a constant-time range test however deep your hierarchy goes. Memory grows with the number of tags, not with every parent and child pair.
• Built for Burst and jobs from the start, not retrofitted.
• This is a product with a shape that runs across engines, not a single script that happens to work in one. The same tag model, the same condition and operation data and the same file formats exist in the tools we ship for other game engines, each written natively for its engine. Data you author in one carries across, which matters if your team, your tools or your next project doesn't stay on one engine.
• Actively maintained, Heathen has been in this industry for over a decade and supports this and other tools across a range of platforms/engines.

For designers:

• Author the project's tag vocabulary in a filterable tree inside Project Settings, with rename, delete and a Registered or draft toggle per tag.
• See every tag any other tool contributes in one read-only panel, so nothing in the project is hidden.
• Pair it with the Toolkit's components to wire tag changes to UnityEvents and show tag values in UI without writing code.

For programmers:

• Implicit conversions between string, GameplayTag and ulong; generated constants with no runtime hashing.
• A real public API with an XML-documented surface, plus a complete reference in the Knowledge Base.
• An editor test suite and a bake pipeline that stays out of the way until you ask for a build.

For the team:

• It's the same tag system that powers the rest of the Heathen ecosystem, so your tags aren't isolated to one tool:Ogham Storyteller: story nodes, choice conditions and operations, and story state all run on GameplayTags, so a dialogue choice can read or change the same tags your gameplay code does.
  Toolkit for Steamworks: Steam data is exposed as tag conditions and operations through the steam.* providers, so a story or any authored rule can read and write achievements and stats. Ogham uses this today.
  Lexicon Localisation: localisation keys are GameplayTags too. Lexicon is a dependency of Ogham, so the whole chain is live.
  Heathen Attribute Tag Engine (HATE): our data-oriented attribute, effect and ability system, built on this package. The Foundation is on Codeberg now; a Toolkit preview is available to Direct Code Access clients.
  
• Installed and kept up to date through the Heathen Toolbox, which also handles the rest of the ecosystem when you add more.
• Every package ships with a ready-made SKILL.md, so whatever tooling you use already understands it on day one.
• A hand-written Knowledge Base, live support in our Discord and Fluxer communities, and a few thousand developers already building on Heathen tech.

We've been building tools for game developers for well over a decade, and this one is free for everyone. Come find us, we'd love to see what you make with it.