Bools multiply, enums get rigid, and casting to check what something is couples everything to everything.

Gameplay Tags are Unreal's answer: a shared, hierarchical vocabulary that scales from a weekend prototype to a shipped game.

Here is what they are, how to use them, and why they keep a project loose.

BRIEFING

A Gameplay Tag is a hierarchical label like State.Combat.Stunned, registered in one central dictionary the whole project shares. Instead of a boolean for every condition (and a cast to read it from somewhere else), you simply ask "does this actor have this tag?" That one shift dissolves sprawling bool-and-enum soup, decouples your systems, and scales cleanly. This piece covers what tags are, the hierarchy and matching that make them powerful, containers and queries, how to define and organise them, replication, where they shine, and the traps to avoid.

Every Unreal project starts the same way. You need to know if a character is stunned, so you add a boolean: bIsStunned. Then bIsBurning. Then bIsInvincible, bCanInteract, bIsAiming, bIsDead. Each new state is a new variable, a new getter, and, worst of all, a new reason for some other system to cast to your character's exact class just to read it. Multiply that across a whole game and you have a character Blueprint the size of a phone book and a web of casts tying everything to everything.

Enums help a little; at least a state machine's states live in one place. But an enum is rigid: a thing is in exactly one enum state at a time, you cannot easily combine them, and adding a value means revisiting every switch that reads it. There is a better tool, it has been in the engine for years, and once it clicks you will reach for it constantly. It is the Gameplay Tag.

What a Gameplay Tag actually is

A Gameplay Tag is a hierarchical label made of words separated by dots, like State.Combat.Stunned or Weapon.Ranged.Bow. Under the hood it is just an FName, but the important part is that every tag is registered in one central dictionary for the whole project. That registration is what makes tags trustworthy: they are validated, so you are picking from a known list rather than scattering raw strings and praying nobody typos "Stuned." A tag is, in effect, a shared vocabulary that your entire game agrees on.

That is the whole mental shift. A boolean lives inside one class and means something only there. A tag is a global, agreed-upon concept that anything can carry and anything can ask about, without knowing what the other thing is.

The superpower: hierarchy and parent matching

The dots are not decoration, they are a tree, and the tree is where the real power lives. Because tags nest, you can match against a parent and automatically catch every child beneath it. If one item is tagged Weapon.Ranged and another Weapon.Melee, a check for the parent tag Weapon is true for both. You get to be exactly as broad or as narrow as the moment needs, with the same system: broad rules match high up the tree, specific rules match a leaf.

Unreal gives you both behaviours explicitly. The regular match functions match parents, so a container holding Weapon.Melee answers yes to "do you match Weapon?" The Exact variants do not: an exact check for Weapon is false for Weapon.Melee, because it ignores parents. Knowing which one you want, broad or precise, is most of using tags well.

Containers and queries: asking rich questions

A single actor is rarely one thing, so tags travel in a Gameplay Tag Container (FGameplayTagContainer): a bag of tags an actor carries at once, like State.Combat.Stunned plus State.Burning plus Team.Enemy. On top of containers, Gameplay Tag Queries let you ask compound questions declaratively, with three basic tests: Any (at least one of these tags is present), All (every one of these is present), and None (not a single one of these is present). "Has any of {Stunned, Rooted} and none of {Invincible}" becomes one readable query instead of a nest of branches. That is a huge amount of conditional logic replaced by a clear, data-shaped question.

How to define and organise them

You add tags in a few ways, and they mix freely. The simplest is right in Project Settings, under Gameplay Tags. For anything beyond a handful you point the project at .ini config files in a GameplayTags folder, which is friendlier to source control and lets designers add tags without opening a single Blueprint. And you can declare native tags in C++ for the ones your code needs to reference directly.

Whichever you use, treat the tag tree like an API, because it is one. Pick a clear convention (Category.Subcategory.Specific), keep it shallow where you can, and prune it as the project grows. As Unreal educator Tom Looman has long argued, tags are the backbone of a data-driven project: a clean tag tree lets designers describe the game in labels instead of asking a programmer for another boolean.

Where Gameplay Tags shine

Once you have them, you start seeing uses everywhere. The most valuable ones:

• State, instead of boolean soup. Add State.Stunned to an actor to stun it, remove it to un-stun it, and let anyone query it. One system replaces a dozen bools, and nobody has to cast to your class to read them.

• Abilities, especially with GAS. Unreal's Gameplay Ability System is built on tags: abilities have tags, cooldowns are tags, and abilities can require or be blocked by tags on the owner. If you use GAS, you are already living in tags.

• Damage types and resistances. Tag damage as Damage.Fire and let armour ask whether it resists that tag, no giant switch statement required.

• Input and interaction. Tag what an actor can do, and let an input or ability system trigger the right response by tag rather than by class, which keeps input decoupled from the specific actor.

• Messages and events. Broadcast game events keyed by tag, so senders and listeners agree on a label rather than on each other's types.

• Content organisation. Label assets themselves, loot rarity, faction, biome, so tools and systems can filter and query your content by tag.

Notice the thread running through all of those: a tag check needs no cast and no knowledge of the other thing's class. Asking "does this have State.Stunned?" is dramatically looser than casting to BP_Enemy to read a boolean, which makes tags one of the cleanest decoupling tools in the engine, a natural partner to interfaces and events. And, like everything worth doing in Unreal, this is entirely a Blueprint affair: no C++ required, as I argued at length in the C++ myth piece.

Scalability and replication

Tags scale in the two ways that matter. First, the hierarchy means you can add specificity without breaking anything: introducing Weapon.Ranged.Crossbow does not disturb the code that only ever checks for Weapon. Second, the central registry keeps a large team consistent, because everyone is drawing from the same validated vocabulary instead of inventing private booleans in a hundred Blueprints.

For multiplayer, tags are network-friendly. Containers can be replicated efficiently, and with Fast Replication enabled the engine sends tags by a numeric index instead of the full name, which is much cheaper on the wire. The one condition to remember: fast replication needs the tag list to be identical on client and server, which is part of why heavily-networked projects often declare their core tags natively so they are locked in early.

The traps

Tags are powerful enough to misuse, so a few cautions. Do not tag things you could simply compute, or you end up maintaining a label that can drift out of sync with reality. Keep the tree disciplined: a sprawling, inconsistent tag hierarchy is every bit as painful as spaghetti code, just quieter. And remember that a tag is a label, not a value. State.Stunned says the actor is stunned; it does not say for how long. When you need a number, pair the tag with data (a duration, a stack count) rather than trying to encode the value into tags themselves. Used for what it is, a clean vocabulary of states and capabilities, the system pays you back for years.

Glossary

Gameplay Tag.  a hierarchical, dotted label (for example State.Combat.Stunned) registered in a central project dictionary and used to mark and query state, capability or identity.

Gameplay Tag Container.  a set of tags an actor carries at once (FGameplayTagContainer), so a single object can be Stunned, Burning and on the Enemy team simultaneously.

Parent matching.  matching against a parent tag catches all of its children; a check for Weapon is true for Weapon.Melee and Weapon.Ranged.

Exact matching.  the strict variant that ignores parents; an exact check for Weapon is false for Weapon.Melee.

Gameplay Tag Query.  a declarative compound condition over a container, testing Any, All or None of a set of tags.

Native vs config tags.  tags can be declared in C++ (native, locked early, good for replication) or added via Project Settings and .ini config (data-driven, designer-friendly).

Fast Replication.  a project setting that replicates tags by numeric index instead of full name, cheaper on the network but requiring identical tag lists on client and server.

GAS (Gameplay Ability System).  Unreal's ability framework, which is built heavily on Gameplay Tags for ability identity, cooldowns, and requirements.

Drowning in booleans and casts?

A well-designed Gameplay Tag vocabulary is one of the highest-leverage things you can add to an Unreal project, and getting the tree right early saves years of cleanup.

I design tag-driven, decoupled architectures in clean 100% Blueprint, for state, abilities, input and content.

If your project is turning into flag soup, that is exactly the kind of structure I build.