Resource
Gameplay Ability System
Reference GAS abilities, effects, attributes, cues, execution calculations, prediction, and the component architecture introduced in UE 5.3.
Start here
The essentials
GAS is wide, but it rests on a handful of ideas. Skim these eight, then drop into the reference below when you need the exact class, signature, or policy name.
The five pieces
GAS has five core pieces: the ASC, abilities, effects, attributes, and tags. Everything else on this page is one of these or the connection between them.
Ability System Component
The Ability System Component (ASC) holds the abilities, effects, attributes, and tags for one actor. Each GAS actor has exactly one, and it's where you grant abilities and apply effects.
Gameplay abilities
A UGameplayAbility is granted first, then activated. Commit its cost and cooldown inside ActivateAbility; if you don't commit, the cost and cooldown are never applied.
Gameplay effects
Gameplay effects are data assets, not code, and are the intended way to change an attribute. Use Instant for one-off changes, Duration for timed buffs, and Infinite for passives.
Attributes
An attribute is defined in a UAttributeSet and has a base value and a current value. The base value is permanent; active modifiers stack on top to produce the current value.
Gameplay tags
Gameplay tags control what can activate, what gets blocked, what cancels what, and which cues fire. Most GAS logic is tag matching rather than branching code.
Gameplay cues
Gameplay cues handle visuals and audio: hit flashes, looping particles, and sounds. They run on clients but not on a dedicated server, and are decoupled from the gameplay logic that triggers them.
Client prediction
The client predicts an ability's effects and shows them immediately, then the server confirms or rolls them back. This hides latency while the server stays authoritative.
Reference
The base class for all abilities. Subclass this to define what an ability does, what it costs, and when it can activate.
Lifecycle functions
ActivateAbility()What the ability does. Override this in subclasses. Called after CanActivate passes.
CanActivateAbility()Const check with no side effects. Verifies cooldowns, costs, tags, and requirements.
CommitAbility()Commits resources (mana, stamina). Call this from ActivateAbility. Last chance to fail.
CommitAbilityCost()Commits only the cost portion. Use when you want to separate cost from cooldown.
CommitAbilityCooldown()Commits only the cooldown. Use when you want to separate cooldown from cost.
EndAbility()Called when the ability finishes, whether it succeeded or was cancelled.
CancelAbility()Called when the ability is forcibly interrupted from outside.
CheckCooldown()Returns whether the ability is off cooldown. No side effects.
CheckCost()Returns whether the owner can afford the ability cost. No side effects.
Instancing policies
NonInstancedDeprecated since 5.5. Shared CDO, no per-instance state. Use InstancedPerActor instead.
InstancedPerActorOne instance per owning actor. Shared across activations. Recommended default.
InstancedPerExecutionNew instance each activation. Most flexible but higher memory cost.
Net execution policies
LocalPredictedClient predicts activation, server confirms. Best for responsive gameplay.
LocalOnlyRuns only on the local machine that has control. No server involvement, no prediction.
ServerInitiatedThe server activates the ability, then replicates it to the owning client. The server has authority and there's no client prediction.
ServerOnlyRuns only on the server. Use for abilities that don't need client-side prediction.
The central component that manages abilities, effects, attributes, and tags on an actor. Every actor using GAS needs one.
Ability management
InitAbilityActorInfo(Owner, Avatar)Initialize the ASC with the owning actor and avatar actor. Call once during setup.
GiveAbility(Spec)Grant an ability to this component. Returns a handle for later reference.
GiveAbilityAndActivateOnce(Spec)Grant and immediately activate. The ability is removed after it finishes.
TryActivateAbility(Handle)Attempt to activate an ability by its spec handle.
TryActivateAbilitiesByTag(Tags)Attempt to activate all abilities matching the given tags.
CancelAbilityHandle(Handle)Cancel the ability matching the given spec handle. (CancelAbility itself takes a UGameplayAbility*; the handle variant is named CancelAbilityHandle.)
CancelAbilities(WithTags, WithoutTags)Cancel active abilities matching tag filters.
CancelAllAbilities()Cancel every active ability on this component.
Effect application
ApplyGameplayEffectToSelf(GE, Level, Context)Apply a gameplay effect to this component.
ApplyGameplayEffectToTarget(GE, Target, Level, Context)Apply a gameplay effect to another ASC.
RemoveActiveGameplayEffect(Handle)Remove an active effect by its handle. Pass StacksToRemove for partial removal.
RemoveActiveGameplayEffectBySourceEffect(GE, Source)Remove effects matching a class and source ASC.
Attribute access
GetSet<T>()Get an attribute set by type. Returns null if not found.
GetNumericAttribute(Attribute)Get the current value of an attribute.
GetNumericAttributeBase(Attribute)Get the base (permanent) value of an attribute.
SetNumericAttributeBase(Attribute, Value)Set the base value directly, bypassing the GE system.
Tag queries
HasMatchingGameplayTag(Tag)Returns true if the component has the exact tag or a parent of it.
HasAllMatchingGameplayTags(Tags)Returns true if the component has all of the specified tags.
HasAnyMatchingGameplayTags(Tags)Returns true if the component has any of the specified tags.
AddLooseGameplayTag(Tag)Add a tag directly, not through a gameplay effect. It isn't replicated, so add it on every machine that needs it, or use UAbilitySystemBlueprintLibrary::AddLooseGameplayTags(Actor, Tags, bShouldReplicate=true) to apply on the server and replicate.
RemoveLooseGameplayTag(Tag)Remove a directly-added tag.
Data-only asset that defines what happens when applied: damage, buffs, debuffs, stat changes. You don't subclass this; you configure it.
Duration policies
InstantApplies once and disappears. Damage hits, one-off heals, permanent stat changes.
HasDurationActive for N seconds, then expires. Timed buffs like +10 speed for 5 seconds.
InfiniteStays active until explicitly removed. Passives, equipment bonuses, persistent states.
Modifier operations
Evaluation order: ((Base + AddBase) * MultiplyAdditive / DivideAdditive * MultiplyCompound) + AddFinal. Override replaces everything.
AddBaseAdd to base value before multipliers.
MultiplyAdditiveStack multipliers additively. Author each +50% buff as the magnitude 1.5; the engine subtracts a bias of 1.0 per mod, so two combine as (1.5-1) + (1.5-1) + 1 = 2x.
DivideAdditiveStack divisors additively.
MultiplyCompoundCompound multipliers. Two 1.5x buffs = 1.5 * 1.5 = 2.25x.
AddFinalAdd to the final value after all multipliers.
OverrideReplace the entire value and short-circuit the rest of the equation, ignoring all numeric modifiers. Evaluated first, not last; when multiple Overrides qualify, the first applied wins.
Magnitude calculation types
ScalableFloatFixed value that optionally scales with level via a curve table.
AttributeBasedDerived from a captured source- or target-attribute. Formula: (Attribute + PreMultiplyAdditive) * Coefficient + PostMultiplyAdditive.
CustomCalculationClassSubclass UGameplayModMagnitudeCalculation and override CalculateBaseMagnitude_Implementation.
SetByCallerValue set at runtime by the ability code. Look up by tag or name.
Stacking types
NoneEach application is independent. Multiple DoTs from different sources all tick separately.
AggregateBySourceStacks when the same source reapplies. Two warriors hitting the same target get separate stacks.
AggregateByTargetStacks on reapplication to the same target regardless of source.
Defines gameplay attributes (Health, Mana, Damage, and so on) as FGameplayAttributeData properties. Each attribute has a BaseValue (permanent) and CurrentValue (base plus active modifiers).
Lifecycle callbacks
PreGameplayEffectExecute(Data)Called before a GE modifies the base value. Return false to reject the modification.
PostGameplayEffectExecute(Data)Called after a GE modifies the base value. Use for reactions like triggering death when Health hits zero.
PreAttributeChange(Attribute, NewValue)Called before any attribute change. Can clamp NewValue.
PostAttributeChange(Attribute, OldValue, NewValue)Called after any attribute change. React to changes here.
Replication
Mark attribute properties with ReplicatedUsing and call GAMEPLAYATTRIBUTE_REPNOTIFY in the OnRep callback to sync attribute changes across the network.
Asynchronous operations that run inside an ability: wait for input, play an animation, wait for an event. They broadcast delegates when they complete.
PlayMontageAndWaitPlay an animation montage. Broadcasts OnCompleted, OnBlendedIn, OnBlendOut, OnInterrupted, OnCancelled.
WaitTargetDataSpawn a target actor and wait for the player to confirm targeting. Broadcasts ValidData, Cancelled.
WaitGameplayEventWait for a gameplay event with a specific tag. Broadcasts EventReceived.
WaitDelayWait for N seconds. Broadcasts OnFinish.
WaitInputPress / WaitInputReleaseWait for the ability's bound input to be pressed or released.
WaitConfirm / WaitCancelWait for the ability system's generic confirm or cancel input.
WaitAttributeChangeWait for an attribute to reach a threshold value. Broadcasts OnChange.
WaitGameplayEffectApplied_Self / _TargetWait for a gameplay effect to be applied to self or a target.
WaitGameplayTagWait for a specific tag to be added or removed from the owner.
SpawnActorSpawn an actor with ExposeOnSpawn support. Broadcasts Success, DidNotSpawn.
NetworkSyncPointWait for server confirmation before proceeding. Used for prediction synchronization.
ApplyRootMotion_*Apply movement during ability. Variants for jumps, constant forces, and curves.
Decouple visual and audio feedback from gameplay logic. A gameplay effect tag fires them, or an ability triggers one directly. They're cosmetic, so they run on clients and a listen server's local player, and are skipped on dedicated servers.
UGameplayCueNotify_Static
- +UObject-based, no actor spawned
- +Lightweight, good for one-shot effects
- +Handles Execute, Active, WhileActive, Remove
AGameplayCueNotify_Actor
- +Spawns an actor in the world
- +Can attach to the target, auto-destroy on remove
- +Use for persistent effects (burning, shields)
Event types
ExecutedOne-shot cue. Damage hit, impact effect, pickup flash.
OnActiveStart a persistent cue. Buff begins, shield activates.
WhileActiveFires once when a duration cue is first seen as active, even if not just applied. Handles join-in-progress, so late joiners start the looping sound or particle. (Periodic effect ticks fire Executed, not this.)
RemovedEnd a persistent cue. Buff expires, shield deactivates.
GAS uses gameplay tags extensively for ability requirements, blocking, cancellation, and effect filtering.
Ability tag properties
AbilityTagsTags this ability has, for identification and queries. The AbilityTags field is deprecated (5.5+); read it via GetAssetTags() and set defaults in the constructor with SetAssetTags().
ActivationOwnedTagsTags applied to the owner while the ability is active. ReplicateActivationOwnedTags is on by default in AbilitySystemGlobals, so these replicate to the owner; only when it is disabled (for legacy code) are they applied as non-replicated loose tags.
ActivationRequiredTagsOwner must have all of these tags for the ability to activate.
ActivationBlockedTagsOwner must have none of these tags for the ability to activate.
CancelAbilitiesWithTagWhen this ability activates, cancel other active abilities with matching tags.
BlockAbilitiesWithTagWhile this ability is active, block other abilities with matching tags from activating.
Effect tag properties
UTargetTagsGameplayEffectComponentTags granted to the target while the effect is active. Replaces the deprecated InheritableOwnedTagsContainer (5.3+).
UAssetTagsGameplayEffectComponentMeta tags on the effect itself for identification and filtering. Replaces InheritableGameplayEffectTags (5.3+).
UImmunityGameplayEffectComponentBlocks the effect if the target has matching immunity tags. Replaces GrantedApplicationImmunityTags (5.3+).
UTargetTagRequirementsGameplayEffectComponentTags the target must have (or must not have) for the effect to apply. Replaces ApplicationTagRequirements (5.3+).
URemoveOtherGameplayEffectComponentRemoves other active effects that match specified tags when this effect is applied (5.3+).
Runtime data for a granted ability: its level, input binding, activation state, and source.
HandleUnique FGameplayAbilitySpecHandle. Use this to reference the ability later.
AbilityAlways the class default object (CDO), regardless of instancing policy. Spawned instances live in ReplicatedInstances / NonReplicatedInstances; reach them via GetPrimaryInstance() or GetAbilityInstances().
LevelAbility level. Affects scalable float curves and damage scaling.
InputIDInput binding index. INDEX_NONE if not bound to input.
SourceObjectWhat granted this ability, such as an item, a talent, or a pickup.
ActiveCountHow many instances are currently active.
InputPressedWhether the bound input is currently held down.
RemoveAfterActivationAbility is removed from the ASC after this activation completes.
GetDynamicSpecSourceTags()Source tags for GEs created by this spec. Replaces the deprecated DynamicAbilityTags field (5.5+).
UGameplayEffectExecutionCalculation runs custom logic when a gameplay effect executes. Use it when the logic needs multiple attributes from source and target: damage formulas, distance scaling, or conditional modifiers.
Execute(ExecutionParams, OutExecutionOutput)BlueprintNativeEvent. In C++, override Execute_Implementation (not the base Execute). Read captured attributes from ExecutionParams, write modifier results to OutExecutionOutput.
AttemptCalculateCapturedAttributeMagnitude(CaptureDef, EvalParams, OutMagnitude)Read a captured attribute's current value (base + modifiers). Returns false if capture failed.
AttemptCalculateCapturedAttributeBaseValue(CaptureDef, OutBaseValue)Read only the base value of a captured attribute, ignoring active modifiers.
DECLARE_ATTRIBUTE_CAPTUREDEF(PropertyName)Macro to declare a capture definition in your header. Creates PropertyName##Property and PropertyName##Def members.
DEFINE_ATTRIBUTE_CAPTUREDEF(Set, Prop, Source, bSnapshot)Macro to initialize a capture definition in your constructor. Source is Source or Target, bSnapshot freezes the value at spec creation.
UGameplayModMagnitudeCalculation computes a custom base magnitude for a modifier. Simpler than execution calculations: you return a single float and the modifier uses it directly.
CalculateBaseMagnitude(Spec)BlueprintNativeEvent. In C++, override CalculateBaseMagnitude_Implementation (not the base) and return the calculated magnitude. The Spec gives you access to source/target tags and SetByCaller values.
K2_GetCapturedAttributeMagnitude(Spec, Attribute, SourceTags, TargetTags)Blueprint-accessible helper to read a captured attribute value with tag filtering.
GetSetByCallerMagnitudeByTag(Spec, Tag)Read a SetByCaller value from the spec using a gameplay tag.
Gameplay effects use a component architecture since UE 5.3. Each component adds one behavior to a GE: granting abilities, blocking tags, applying additional effects, or checking requirements. Add the components you need in the editor.
UAbilitiesGameplayEffectComponentGrants gameplay abilities to the target while the effect is active. Configurable level and input binding.
UAdditionalEffectsGameplayEffectComponentApplies additional GEs on application, on normal completion, on premature removal, or always.
UAssetTagsGameplayEffectComponentTags that the GE itself has for identification and queries. Not transferred to actors.
UBlockAbilityTagsGameplayEffectComponentBlocks activation of abilities with matching tags while the effect is active.
UCancelAbilityTagsGameplayEffectComponentCancels active abilities with matching tags on application or execution.
UChanceToApplyGameplayEffectComponentProbabilistic application. Uses FScalableFloat for dynamic chance calculation.
UCustomCanApplyGameplayEffectComponentCustom application requirements via UGameplayEffectCustomApplicationRequirement subclasses.
UImmunityGameplayEffectComponentBlocks application of other GEs matching a FGameplayEffectQuery. Requires duration.
URemoveOtherGameplayEffectComponentRemoves active GEs matching a FGameplayEffectQuery when this effect is applied.
UTargetTagRequirementsGameplayEffectComponentTag requirements on the target for application, continuation, and removal.
UTargetTagsGameplayEffectComponentGrants tags to the target actor while the effect is active.
Target data structures carry targeting information from the ability to effect application. Wrap them in FGameplayAbilityTargetDataHandle for network serialization.
FGameplayAbilityTargetData_SingleTargetHitSingle hit result from a line trace or projectile. Contains an FHitResult.
FGameplayAbilityTargetData_ActorArrayMultiple actor targets with a source location. Use for AOE or radial attacks.
FGameplayAbilityTargetData_LocationInfoLocation-based targeting with source and target transforms. Supports literal, actor, and socket transforms.
FGameplayEffectContext carries metadata about who caused an effect and how. Passed through the entire effect pipeline. Subclass it for game-specific data like critical hit flags or damage type info.
GetInstigator()The actor that initiated the effect chain (the character who fired).
GetEffectCauser()The physical actor that caused the effect (the projectile that hit).
GetAbility()The ability CDO that created this context.
GetAbilityLevel()Level of the ability when the context was created.
GetSourceObject()Abstract source: an item, weapon, or talent that triggered the chain.
GetHitResult()FHitResult from the targeting system, if available.
GetOrigin()World location where the effect originated.
GetInstigatorAbilitySystemComponent()The source ASC, cached for performance.
FGameplayAbilityActorInfo caches actor references for the ability system. Set up once via InitAbilityActorInfo and accessed from any ability.
OwnerActorThe actor that owns the ability system. Always valid.
AvatarActorThe physical actor executing abilities. May differ from owner: the player state often owns the ASC while the pawn is the avatar.
PlayerControllerCached controller reference. Null for AI-controlled actors.
AbilitySystemComponentThe ASC itself. Always valid after initialization.
SkeletalMeshComponentCached mesh for montage playback. Null if no skeletal mesh.
AnimInstanceCached anim instance for animation-driven abilities.
MovementComponentCached movement component for movement abilities.
IsLocallyControlled()True on the machine that locally controls the avatar: the owning client, or the listen-server or standalone host for its own pawn. Use it for local-control logic, not as a client-only check.
IsNetAuthority()True on the server. Use for authority-only logic.
GAS uses FPredictionKey to synchronize client-side prediction with server authority. The client creates a key when activating an ability, and the server either confirms or rejects it.
- 01Client calls TryActivateAbility, which generates an FPredictionKey.
- 02Side effects inside ActivateAbility (applied GEs, spawned cues) are tagged with this key.
- 03The key is sent to the server via the activation RPC.
- 04Server runs the same activation. If it succeeds, the key is confirmed via FReplicatedPredictionKeyMap.
- 05If the server rejects, all predicted side effects tagged with that key are rolled back.
FPredictionKey::CreateNewPredictionKey(ASC)Generate a new prediction key for client-side prediction.
FScopedPredictionWindow(ASC, Key)Create a prediction window on the server when receiving a client RPC. Side effects inside this scope use the key.
IsValidKey()Returns true if the key has a valid ID (Current > 0).
IsLocalClientKey()True if generated locally on a client.
NewRejectedDelegate()Register a callback that fires if the server rejects this prediction.
NewCaughtUpDelegate()Register a callback that fires when replicated state catches up to this prediction.
Common GAS mistakes and what to reach for instead.
Related Content
Unreal Directive is free and ad-free.
If it saved you time, you can help keep it that way.