Animation Notifications (Notifies)

Animation Notifications (AnimNotifies or just Notifies) provide a way for animation programmers to setup events to occur at specific points during an Animation Sequence. Notifies are commonly used to add effects like footstep sounds during a walk or run animation or spawning a particle system during animation. However, they can have any number of different uses, as the system can be extended with custom notification types to cater to the needs of any type of game.

Notify Types

Different types of Notifies cause different events to be triggered. Camera effects, particle effects, sounds, etc. can all be triggered at any point during an animation through the use of a Notify. Adding a Notify can be done by Right-clicking on a Notify Track at the point in the animation you want the Notify to occur, and then choosing one of the type of Notify to add.

For more information on adding/editing Notifies, see the Animation Sequence Editor page.

Play Particle Effect

The PlayParticleEffect Notify spawns and plays a particle system at a given socket location and at a specific point along an animation's timeline. This is useful for such effects as causing a cloud of dust to appear around a player's feet when they move, fire to spew from an exhaust pipe when the player uses a Nitro-Boost power-up, or other such effects.


A PlayParticleEffect Notify does not use the Animation Blueprint to control behavior. Instead, it uses a few simple properties defined in the Details panel to determine what Particle System is used and from what Socket the particles will originate.


Property Description
Socket Name This contains the Skeletal Mesh socket that will be used as the spawn point for the particle system.
PSTemplate This holds the particle system that will be spawned at the Notifies set point in time.
Attached Determines if the effect should attach to the bone/socket.
Location Offset Location offset from the socket.
Rotation Offset Rotation offset from the socket.
Notify Color Changes the color of the Notify on the Notify bar.

Once set up, the associated Particle System will play, using the Socket location as the spawn point.


Play Sound

The PlaySound Notify provides a simple means to get your sound effects synced with animation. Much like Play Particle Effect, this Notify has a few simple properties that can be set in the Details panel, which allow for fast and easy sound effect setup. This is useful for such things as mechanical whirrs when a robot moves, the rustle of cloth during character motion, and similar types of effects.


The Play Sound Notify uses a few simple properties defined in the Details panel to determine what sound effect is used and from what Socket or Bone the sound will originate.


Property Description
Attach Name This contains the Skeletal Mesh socket or bone that will be used as the spawn point for the sound effect.
Volume Multiplier This scaling multiplier is applied to the volume of the sound effect.
Pitch Multiplier This scaling multiplier is applied to the pitch of the sound effect.
Follow If checked, the sound effect source will follow the Static Mesh as it moves. If unchecked, the sound remains behind at the location it was spawned.
Notify Color Changes the color of the Notify on the Notify bar.

Custom Notifies

The Custom Notify serves as a catch-all for anything an artist may want to do within a Animation Blueprint at a certain point in an animation. Custom Notifies are created by Right-clicking on a Notify track and choosing New Notify from the context menu.


Custom Notifies allow you to create a Notify Event of the same name in the Event Graph or Transition Graphs in the State Machine for a Skeletal Mesh's Animation Blueprint . To add your Custom Notify, Right-click anywhere in your Event or Transition Graphs and there is a section for adding Animation Notifies events.


After adding the Custom Notify, an Event Node will be added to the graph which will be executed when the Notify is called.


Notify States

AnimNotifyStates (Notify States) work much like the standard Notifies above. They have 3 distinct events: a start, the tick, and an end. They start straightforward, firing at the moment the Notify begins and ends, and the Event Graphs in them fire off when their time comes up in the animation. The tick fires off every animation update until the end event is hit. The major difference between normal Notifies and Notify States is that Notify States are self-contained Blueprints .

Creating Notify States (which are the same as Native Notify States but are custom Blueprints that you can provide any logic you need to occurring during an animation) is done the same as adding a regular Notify by Right-clicking in the Notify Track of an animation and selecting Add Notify State... then selecting your custom Notify.

To use a custom Notify, you must first create a Blueprint Class of the AnimNotifyState class.


An AnimNotifyState Blueprint Class called MyAnimNotifyState (above) was created so that we may select it as the Notify State to use in our animation. Once you have created your Anim Notify State Blueprint, you can open it and begin implementing the functions that determine how your Notify is used (below).


It is not necessary to implement every function, but at the bare minimum you should implement Received Notify Tick or both Received Notify Start and Received Notify End. If implementing just Received Notify Start or Received Notify End, you could simply use a standard Animation Notify.


The Notify Start Override.


The Notify End Override.


The Notify Tick Override.

Below is a description of how each pin type is used in the override functions:

Pin Description
Mesh Comp This is the Skeletal Mesh Component of the Animation Sequence or Montage that is triggering this AnimNotifyState.
Anim Seq This is the specific Animation Sequence that is triggering this AnimNotifyState.
Frame Delta Time Only in the Received Notify Tick function, this will give you the time since the last animation update.

There is currently no way to retrieve the length of the AnimNotifyState within a Blueprint.


  • You are guaranteed to start with a NotifyBegin Event.

  • You are guaranteed to end with a NotifyEnd Event.

  • You are guaranteed to have NotifyTick wrapped between a NotifyBegin and a NotifyEnd event.

  • Order between different AnimNotifies (normal or state) is not guaranteed! If you put two AnimNotifyStates next to each other, the first one is not guaranteed to end before the next one starts. Only use this for individual actions which do not rely on other Notifies.

  • Negative play rates are supported. NotifyBegin is still called first regardless, and NotifyEnd called last.

Order and Logic

When the AnimNotifyState is triggered, first the Start Blueprint will be called, and then the Tick Blueprint is called on the same frame update. Every subsequent tick, only the Tick Blueprint will be called. On the final tick update, the Tick Blueprint will be called followed by the End Blueprint.

If you are modifying something every frame, it should go in the Tick Blueprint. If you need to set variables, flags, or properties, to some value before the ticks hit, it should go in the Start Blueprint. And finally, the End Blueprint can be used to change variables, flags, or properties after the final tick hits.

Native Notify States

When choosing to add a Notify State, you can also assign one of two Native Notify States in the form of a Timed Particle Effect or an Animation Trail.


Timed Particle Effects

The Timed Particle Effect is very similar to the Play Particle Effect Notify in that they both allow you to play a Particle Effect at any given point in an animation, the difference however is that with a Timed Particle Effect, you are given the ability to define the length of the effect inside the Notify itself.


In the image above, a Timed Particle Effect is assigned to an animation. By Left-Clicking on the handle bar at the end (or at the start), you can drag to increase or decrease the length of the effect.

Animation Trails

Animation Trails (or AnimTrail for short) are emitters that allow you to leave trails behind moving objects in a scene. They do this by sampling the positions of two sockets on a Skeletal Mesh each tick and stitching triangles between the sockets, down the length of the trail.

To use an AnimTrail emitter you must:

  1. Create a Particle System that contains an emitter with AnimTrail type data.

  2. Create and add a Notify State of the Trail type to an animation.

Once you have added an AnimTrail, you can adjust its properties from the Details panel:


Property Description
PSTemplate This is the particle system containing the anim trail that was described above.
First Socket Name This is the name of the first Bone/Socket defining the trail.
Second Socket Name This is the name of the second Bone/Socket defining the trail.

The above properties are required but the below are optional. They allow you to alter the width of the trail during the animation. You could also attach the trail to sockets that move as you need but this may not be ideal. This method is based on providing a width scale value. A width scale of 1.0 will keep the trail the same width, 0.0 will cause a trail of zero width.

Property Description
Width Scale Curve The width value comes from a curve sampled each tick. This property is the name of that Curve. See below for details on creating that curve.
Width Scale Mode This alters the way width is applied. The pictures below show how this works. The example shows a Sine like curve going from 0 to 1 in the middle and back to 0 again.


The left image depicts From Centre which scales outwards from center, the middle image shows From First Socket which scales away from the first socket and the right image demonstrates From Second Socket which scales away from the second socket.

There are also some debug rendering options available:

Property Description
Render Geometry This toggles the rendering of the main trail geometry.
Render Spawn Points This toggles the debug rendering of the primary spawn points for the trail. i.e. the positions sampled from the sockets at each tick.
Render Tangents This toggles the debug rendering of the curve tangents.
Render Tessellation This toggles debug rendering of all vertices on the curve. This shows how the curve is tessellated between the spawn points.

Additional Notify Properties

In addition to the properties that can be modified in the Anim Notify section of the Details panel for each type of Notify (when applicable), the properties below can also be used to define how your Notify is used.


Trigger Settings

Notify Trigger Chance Defines the chance of triggering the Notify (0=No Chance, 1=Always Triggers).
Trigger on Dedicated Server If disabled, this Notify will be skipped on Dedicated Servers.
Notify Filter Type Defines a method for filtering notifies (stopping them from triggering). Can be set to filter by the meshes current LOD.


Trigger Weight Threshold Determines how much much weight the animation sequence needs to have to trigger the Notify.
Montage Tick Type The method to determine how the Notify is handled, Queued or Branching Point (See Montage Tick Type below).

Anim Link

Slot The slot index currently being used within the LinkedMontage.
Link Method The method used to calculate times, Absolute (stays at a specific time without moving), Relative (moves with its segment, but not when the segment changes size) or Proportional (moves with its segment and will stay at a certain proportion through the segment).

Montage Tick Type

The key difference between Queued and Branching Point settings for the Montage Tick Type is that Queued Notifies is asynchronous, while Branching Points are synchronous. What this means to the end user is that Branching Points come with a much higher degree of precision for where they will take place along the animation timeline.

High precision is important when you need to jump to a specific animation at a very precise moment in time. While you could use a Queued Notify to do the same job, the asynchronous nature of Queued Notifies means that the event could be fired at the incorrect animation frame, which can lead to hitches and jumps in your motion.

Due to their synchronous nature and the precision resulting from it, Branching Points are more performance expensive than Queued. You should only use them when an event must be fired at a precise moment along the animation timeline, such as jumping directly to another animation that matches up frame-to-frame. If being off by a frame (or some percentage of one) is not important, you should use Queued instead.