Unreal Animation Framework (UAF)

Written By Eyad Hussein

Introduction

I started this blog post as part of my journey to learn the Unreal Animation Framework (UAF).

UAF is a relatively new and evolving system in Unreal Engine, and as I explore it, I wanted to document my understanding in a structured and practical way. This page serves as a collection of notes, explanations, and examples based on what I learn over time.

I will continue updating this document as I gain more experience with UAF, refining the content and adding new insights along the way. The goal is not only to deepen my own understanding, but also to create a clear and accessible reference for anyone interested in learning UAF.

While UAF is still experimental, it represents the future direction of animation systems in Unreal Engine.

UAF in The Witcher 4

To get a general understanding of how Unreal Animation Framework (UAF) is used in a real production environment, it is highly recommended to watch this Unreal Fest presentation by CD Projekt Red and Epic Games. The talk provides an overview of how UAF is integrated into The Witcher 4 tech demo as part of a next-generation animation pipeline.

The presentation demonstrates how UAF is used to drive large-scale, high-quality character animation in an open-world setting, working alongside systems such as Mass AI and motion-based animation techniques. It highlights UAF’s role as a modular and scalable framework capable of evaluating hundreds of animation graphs efficiently and supporting complex scenes with many characters.

This demonstrates how UAF is not just experimental, but already being explored in AAA production pipelines.

Plugins to Enable

Before working with Unreal Animation Framework (UAF), the first step is to enable the required plugins in the project. The exact set may vary depending on your workflow, but the following are the core UAF-related plugins:

(Open the Plugins window, search for “UAF”, enable the plugins, and restart the editor)

  • Unreal Animation Framework (UAF)

  • UAF Anim Graph

  • UAF Chooser

  • UAF Control Rig

  • UAF Pose Search

  • UAF State Tree

  • UAF Warping

These plugins expose the UAF workflow inside the Content Browser and enable access to UAF-specific assets such as animation graphs and modules.

Where to Begin?

After enabling the required plugins, UAF introduces a new set of assets inside the Content Browser under the Animation Framework category. From here, you can create different types of assets such as:

  • UAF Workspace

  • UAF System

  • UAF Animation Graph

  • UAF State Tree

A typical starting workflow is:

  1. Create a Workspace
    This acts as the main environment where UAF graphs and systems are organized.

  2. Create a System
    The system represents the runtime logic that will be attached to an actor.

  3. Create a UAF Animation Graph
    This is where animation logic is defined.

  4. Add the graph to the workspace and connect it to the System

  5. Assign the system to a character using the appropriate component

This workflow reflects how UAF separates animation logic into modular pieces, instead of relying on a single Animation Blueprint.

UAF Asset Wizard

The UAF Asset Wizard is the main entry point for starting with Unreal Animation Framework. Instead of manually creating and wiring multiple assets, the wizard allows you to quickly generate a preconfigured setup based on a template. By selecting a template (such as the basic boilerplate), choosing a character blueprint, and assigning a skeletal mesh, the wizard automatically creates the core UAF assets, such as the animation graph and system, along with a ready-to-use structure in your project. This significantly simplifies the initial setup and provides a solid starting point for experimenting with UAF without needing to build everything from scratch.

In this example, a simple UAF setup is created with a clear and organized structure. The project contains a dedicated UAF folder along with the following core assets:

  • A UAF Workspace (UAF_W_Character) used to organize UAF assets

  • A UAF System (UAF_S_Character) responsible for executing animation logic

  • A UAF Animation Graph (UAF_AG_Character) that defines the animation behavior

  • A Character Blueprint (BP_Character) used to run the system in-game

  • A Skeletal Mesh (SKM_Quinn_Simple) assigned to the character

What the Wizard Configures Automatically in The Blueprint

After running the UAF Asset Wizard, several important changes are applied to the generated Character Blueprint to integrate it with the UAF pipeline.

First, a new component called AnimationFramework is added to the character. This component is responsible for running the UAF system at runtime. If you inspect it, you will see that the System field is automatically assigned (for example, UAF_S_Character), which connects the character to the UAF animation logic.

Second, the Skeletal Mesh Component is configured differently from a traditional setup. The standard animation system is disabled (Enable Animation is turned off), meaning the character is no longer driven by an Animation Blueprint. Instead, animation evaluation is fully handled by the UAF system.

The wizard replaces the default animation pipeline with the UAF workflow by:

  • Adding the AnimationFramework component to execute animation logic

  • Assigning a UAF System to the character

  • Disabling the built-in animation system on the skeletal mesh

This setup ensures that all animation behavior is driven through UAF, rather than the traditional Animation Blueprint approach.

Validate that UAF is Correctly Connected

To validate that the UAF pipeline is correctly connected, I started with the simplest possible animation setup: an idle animation.

First, make sure the UAF System is correctly linked to the UAF Animation Graph. Open the generated UAF System (UAF_S_Character), and under Item Label, select Graph. Then assign the Graph field to your animation graph (for example, UAF_AG_Character). This step ensures that the system knows which graph to evaluate at runtime.

In the generated UAF System Graph, the animation flow is split into two stages. The Initialize event prepares the setup by calling Make Reference Pose, which creates a reference pose from the skeletal mesh component. The PrePhysics event handles runtime evaluation: it calls Run Graph to execute the assigned UAF Animation Graph and generate a pose result, then calls Write Pose to apply that pose to the skeletal mesh. In simple terms, the system first prepares the character’s reference data, then evaluates and writes animation every frame.

Next, open the UAF Animation Graph (UAF_AG_Character) and add a Sequence Player node. The Sequence Player is the most basic way to play an animation in UAF. Assign an Idle animation to the Sequence Player and connect it to the graph output.

At this stage, playing the level should result in the character staying in an idle pose. Since the default animation system is disabled on the Skeletal Mesh, seeing the idle animation confirms that UAF is correctly evaluating and driving the animation.

Trait Stack

One of the key concepts in Unreal Animation Framework (UAF) is the Trait Stack.

A Trait represents a small unit of animation logic, such as playing an animation, modifying a pose, or applying a specific behavior. Instead of building all logic inside a single graph, UAF organizes animation as a stack of these traits.

The Trait Stack is an ordered collection of traits that are evaluated together to produce the final animation pose. Each trait contributes to the result, either by generating a pose or modifying an existing one.

This approach allows animation to be built in a modular and layered way. For example, a typical stack might include:

  • A base reference pose

  • A locomotion trait

  • Additional traits for adjustments such as warping or IK

By stacking these traits, UAF creates a flexible pipeline where animation behavior can be extended or modified without changing the entire system.

Traits

UAF provides a wide range of traits that can be added to the Trait Stack. These traits define how animation is generated, blended, modified, and controlled.

Pose Generation (Animation Sources)

These traits are responsible for generating animation data:

  • Reference Pose
    Provides a base pose from the skeleton. Often used as the starting point for animation.

  • Sequence Player
    Plays a single animation sequence. Commonly used for simple animations such as idle.

  • Blend Space Player
    Plays a Blend Space using input values like speed or direction. Typically used for locomotion.

  • Motion Matching
    Selects the best animation pose from a database based on movement context.

  • Pose Search Result Emulator
    Used for testing or simulating pose search results.

Blending and Composition

These traits combine multiple poses together:

  • Blend Two Way
    Blends between two poses using a weight value.

  • Blend by Bool
    Switches between two poses using a boolean condition.

  • Blend Layer
    Allows blending animations per bone or per layer (e.g., upper body vs lower body).

  • Blend Stack / Blend Stack Core / Blend Stack Requester
    Handle layered blending of multiple poses within the Trait Stack.

  • Passthrough / Passthrough Blend
    Passes animation through without significant modification.

  • Dead Blending
    Handles fallback blending when no valid animation is available.

Additive and Adjustment

These traits modify existing animation:

  • Apply Additive
    Adds animation on top of a base pose (e.g., breathing on top of idle).

  • Modify Curve
    Adjusts animation curves at runtime.

  • Mirroring
    Mirrors animation (left/right).

Smoothing and Transitions

These traits improve animation transitions:

  • Blend Inertializer / Blend Inertializer Core
    Smooths transitions using inertial blending.

  • Blend Smoother / Blend Smoother Core / Blend Smoother Per Bone Core
    Reduces abrupt changes between animations.

Input and Alpha Control

These traits control blending weights:

  • Alpha Input Args / Float Alpha Input Args / Bool Alpha Input Args / Curve Alpha Input Args / Simple Float Alpha Input Args
    Provide different ways to calculate blend weights based on input values.

Motion Adjustment and Warping

These traits adapt animation to gameplay:

  • Strafe Warping
    Adjusts animation to match movement direction.

  • Steering
    Modifies animation based on directional movement.

  • WarpTest
    Experimental or testing trait related to motion warping.

Logic and Control

These traits control execution and behavior:

  • State Tree
    Integrates animation with Unreal’s state-based logic system.

  • Call Function
    Executes custom logic during animation evaluation.

  • Injection Site
    Defines where additional traits can be inserted in the stack.

  • Synchronize Using Groups
    Keeps multiple animations in sync (e.g., locomotion cycles).

Events and Debugging

These traits handle events and debugging:

  • Notify Dispatcher / Notify Filter
    Handle and filter animation notifies.

  • Pose History
    Stores previous poses, often used for motion matching.

Structure and Composition

These traits help organize animation logic:

  • Input Pose
    Represents incoming pose data.

  • Sub Graph
    Allows splitting animation logic into reusable sub-graphs.

Procedural and Rigging

These traits integrate advanced animation systems:

  • Control Rig
    Enables procedural control of bones inside the animation pipeline.

  • RigLogic
    Used for advanced deformation systems (e.g., MetaHuman facial animation).

Adding Walk

Now let’s extend the setup by adding a simple walk cycle to the character.

In this step, I used a Blend Space Player trait and introduced a Velocity variable in the UAF System, which is bound to the Character Blueprint.

Step 1: Replace Sequence Player with Blend Space Player

First, I disconnected the Sequence Player that was previously used for the idle animation.

Then, I added a Blend Space Player to the Trait Stack.
This trait requires two inputs:

  • A Blend Space asset

  • A value representing the character’s speed

Step 2: Create a Blend Space

Next, I created a simple 1D Blend Space:

  • Axis: Speed (Vertical / Y axis)

  • Value 0 → Idle animation

  • Value 1 → Walk animation

This allows the animation to smoothly interpolate between idle and walk.

Step 3: Add and Bind Velocity in UAF System

Open the UAF System (UAF_S_Character) and add a new variable:

  • Type: Vector

  • Name: Velocity

Then bind this variable to:

Current Actor → Get Velocity

This binding allows the UAF system to receive real-time movement data from the Character Blueprint.

Step 4: Drive the Blend Space from Velocity

In the UAF Animation Graph:

  1. Assign the created Blend Space to the Blend Space Player

  2. Drag the Velocity variable into the graph

  3. Normalize the vector

  4. Calculate its length (magnitude) to get speed

  5. Connect this value to the Blend Space Player input

Result

When playing the level:

  • At low speed → the character remains in idle

  • As the character moves → it smoothly blends into walk

This confirms that the Velocity is correctly bound from the Character Blueprint, the UAF system is receiving runtime data, and the Blend Space Player is correctly driving animation

References and Useful Links

The following resources were helpful while learning Unreal Animation Framework (UAF). Since UAF is still evolving and not yet widely documented, official sources like Epic Games’ knowledge base are especially valuable.

Glossary

A

  • AnimationFramework Component
    A component added to a character that is responsible for running the UAF system. It replaces the traditional animation pipeline and drives animation evaluation at runtime.

B

  • Blend Space
    An asset that blends between multiple animations based on input values such as speed or direction. It is commonly used for locomotion systems like idle, walk, and run.

C

  • Character Blueprint
    A Blueprint class that represents a playable or non-playable character. It typically contains components such as a skeletal mesh and is responsible for running animation systems like UAF.

  • Chooser
    A system used to select animations or assets based on conditions or context. It allows dynamic decision-making by choosing the most appropriate animation at runtime.

  • Control Rig
    A system in Unreal Engine that allows procedural animation and rigging directly inside the engine. It enables developers to create, modify, and control character animations without relying entirely on external tools.

D

E

F

G

H

I

J

K

L

M

N

O

P

  • Pose Search
    A system used to find the best matching animation pose from a database. It is commonly used in motion matching workflows to produce realistic and responsive character movement.

Q

R

  • Rewind Debugger
    A debugging tool in Unreal Engine that allows developers to record and replay gameplay frames. It is especially useful for analyzing animation behavior and understanding how systems like UAF evaluate over time.

S

  • Sequence Player
    A node used to play a single animation sequence inside a UAF Animation Graph. It is commonly used as a starting point for testing animation playback.

  • Skeletal Mesh
    A 3D model with a skeleton (bones) used for animation. It is the visual representation of a character and is required for playing animations defined in systems like UAF.

  • State Tree
    A hierarchical, state-driven system used to manage complex logic and behavior. It can be used to control animation flow, AI behavior, and gameplay states in a structured and scalable way.

T

U

  • UAF (Unreal Animation Framework)
    Epic’s next-generation animation system for Unreal Engine, intended to eventually replace Animation Blueprints.

  • UAF Animation Graph
    An asset used to define animation logic in Unreal Animation Framework. It contains nodes and connections that control how animations are evaluated and blended at runtime.

  • UAF System
    A runtime asset that executes animation logic defined in UAF graphs. It acts as the bridge between authored animation graphs and the character, allowing the system to evaluate and apply animation behavior during gameplay.

  • UAF System Graph
    A graph that defines how and when animation logic is executed in UAF. It typically contains events such as Initialize and PrePhysics, and nodes responsible for evaluating and applying animation (such as Run Graph and Write Pose).

  • UAF Workspace
    An asset used to organize and manage UAF-related assets such as animation graphs and systems. It acts as a container that brings together different parts of the UAF setup, making it easier to structure and work with animation logic in a modular way.

V

  • Velocity
    The rate of change of an actor’s position over time, usually represented as a vector. In animation systems, the magnitude of velocity (speed) is often used to drive locomotion logic.

W

  • Warping
    A technique used to adjust animations dynamically to match gameplay conditions. For example, it can modify an animation so a character aligns correctly with a target position or object during runtime.

X

Y

Z

Eyad Hussein
Next

Eyad.tv Is Live