Work In Progress
The Heathen Attribute (gameplay)Tag Engine (HATE) is a complete, deterministic state, attribute, and action runtime designed for high-performance game logic. While inspired by the comprehensive feature set of Unreal Engine’s Gameplay Ability System (GAS), HATE abandons the heavy, object-oriented paradigms of traditional architecture. Instead, it is built from the ground up to be attribute-first and data-oriented.
By shifting state management into bit-packed, columnar memory structures, HATE decouples your game logic from the heap. The result is a system capable of simulating over massive numbers of active entities, complete with active buffs, status effects, and ticking cooldowns, using branchless vector loops and zero per-effect allocations.
As with all Heathen tools Gameplay Tags is available for multiple engines:
And is composed of two packages:
Foundation
Author data-oriented, ultra-scalable attribute and action systems with a pure columnar architecture. Built directly on top of DataLens and Gameplay Tags, HATE eliminates the heavy object-oriented overhead of traditional ability systems
State resides entirely in bit-packed data columns, massive numbers of entities with ticking buffs, recovery rates, and status effects to simulate as branchless vector loops with zero per-effect allocations. Attributes are grouped into modular traits, ceilings are handled as scalable attributes rather than rigid ranges, and system logic is strictly decoupled through lightweight data flags to maximize hardware-native execution speeds.
- License: Apache 2.0
- Price: Free (Unity)
Toolkit
Built on top of Foundation, Toolkit introduces visual data authoring, runtime validation, and high-level gameplay systems to your development environment.
Toolkit includes the HATE Forge editor to visually construct traits, map archetypes, and wire up progression curves without touching a line of code. It features advanced template libraries for common design patterns like resource costs and stackable status decays, visual node-graph logic authoring, a real-time per-entity inspector debugger, and pre-built engine-bridge adapters to instantly synchronize your raw simulation state to active gameplay objects and components.
- License: Heathen Standard
- Price: $15 GitHub or Patreon
The Core Philosophy: Identity and State #
The Attribute Tag Engine delivers its massive performance scale by composing two distinct technical substrates: GameplayTags for identity, and DataLens for state.
Every concept in your design, whether it is:
- an attribute (
Combat.Attributes.Health) - an effect (
Combat.Status.Stunned) - an ability (
Combat.Abilities.Fireball)
Is assigned a unique, hierarchy-aware 64-bit integer hash. HATE uses these hashes as the direct addressing mechanism over raw memory. Instead of inspecting thousands of individual heap objects every frame, systems run sequential passes across tight data columns, matching and modifying data at hardware-native speeds.
Key Concepts #
The Attribute Tag Engine organizes game design vocabulary into a few high-performance primitives, completely eliminating traditional script-heavy component setups:
- Attributes: Project-wide identifiers mapped to a primitive data type. Range limits like maximum health are not built-in object properties; they are ordinary attributes. This allows ceilings and floors to be scaled, buffed, and clamped using the exact same systems as the base values.
- Traits: The data-oriented equivalent of a component table. A trait groups together related attributes and the specific Trait Systems (passives, recovery rates, and rules) that govern them. If an entity has a trait, it owns a row in that trait’s column store.
- Entities: A HATE entity is simply a lightweight index inside an directory catalog. It requires no referential attachment. A destructible crate, a weather pattern, a map region, or a hero character are all treated identically as rows across matching trait columns.
- Effects and Abilities: Parallel structures composed of static rules and developer-defined instance data. Active buffs, damage-over-time tickers, and cooldown records are stored in specialized tall memory pools. They tick uniformly via vector comparisons, ensuring background simulation costs remain virtually flat regardless of active entity counts.
Data-Driven Authoring #
HATE completely avoids runtime configuration overhead. You author your design vocabulary, status rules, and progression curves inside human-friendly configurations.
The HATE Forge is an editor that validates these definitions for structural consistency before compilation and generates a baked, type-safe runtime. The generated code is your runtime, delivering absolute safety against typos, instant compilation, and native engine portability.