Unity Asset · Animation Graph

Node-based animation for Unity

Animation Graph is a visual, node-based editor that replaces and extends Unity's Animator. Build state machines, blend trees and complex transitions in one clear graph canvas, performant via a Burst-compiled evaluation pipeline and fully drivable from C#.

Activate licenseUnity Store
Unity 2022 LTS to Unity 6.3 LTSBuilt-in · URP · HDRPBurst-compiled runtimePer seat, 2 machines
Features

Everything your animation workflow needs

One graph for your entire animation logic, from first blockout to production.

Visual node editor

Drag nodes, wire them up and see your full animation logic on one clear canvas instead of scattered Animator layers.

State machines & blend trees

Compose states, transitions and 1D/2D blend trees with visual conditions and parameters.

Burst-compiled runtime

Runs on a custom Burst-compiled runtime: allocation-free evaluation with job-system parallelism, faster than the classic Animator at scale.

Live preview

Scrub, play and debug your graph in the editor as you work. See exactly which node is active and how weights blend.

Full code API

Set parameters, drive transitions and read node state from C#. Designer-friendly and developer-friendly.

Scales to production

Layering, per-node LOD and parallel evaluation keep large character rigs and hundreds of clips manageable.

In action

See Animation Graph in action.

A short demo of the node-based animation system, live in Unity.

Node editor

One visual graph for your entire animation logic

Clips, blend trees, state machines and transitions sit side by side on one canvas. You wire nodes with live data flow and see exactly how your character moves from one animation to the next, with no hidden state in collapsed tabs.

  • Drag-and-connect nodes with live data flow
  • 90+ built-in nodes across 13 categories
  • Real-time highlight of the active node
State machines

States and transitions you can see

Define states, conditions and parameters and make transitions do exactly what you expect. Any-state transitions, interruptible blends and exit time become visual, instead of buried in inspector fields.

  • Conditions on float, int and bool parameters
  • Interruptible, nested state machines
  • Any-state and exit-time transitions
Layers

Composite with layers and bone masks

Stack a base layer with additive or override layers. With bone masks and per-layer weights you blend upper and lower body independently, additively on top of your locomotion.

  • Override and additive blend modes
  • Bone masks for per-bone blending
  • Per-layer weights, tuned live
Performance

Built for performance

Animation Graph uses a Burst-compiled evaluation pipeline with the C# Job System. Zero managed allocations during evaluation, parallel bone processing and a tighter update loop mean more characters within your frame budget.

90+built-in nodes across 13 categories
6Burst-compiled IK solvers
5physics bone systems
14math nodes for logic in the graph
Job Systemparallel evaluation across cores
Per-node LODskip expensive nodes at a distance
Inertializationblending without crossfade artifacts
Mirroringmirror animations without duplicating clips
Comparison

How it compares to Unity's own systems

Where Legacy Animation, the Animator and the Playables API all evaluate single-threaded with managed overhead, AnimGraph processes bone data in parallel across cores. Your frame budget goes further as character counts grow.

LegacyAnimatorPlayables API
Visual graph editor—State machine—Node graph
IK solvers—OnAnimatorIK—6 (Burst)
Physics bones———5 systems
Blend spaces—1D / 2DManual1D / 2D / graph
Math in graph———14 nodes
Animation LOD——ManualPer-node
Inertialization———Built-in
Pose mirroring——ManualBuilt-in
Debug overlays—State highlight—Per-node
RuntimeC++ nativeC++ + managedC++ + interopBurst + Jobs
AllocationsMinimalPer-framePer-nodeZero managed
Parallelism———Multi-core
Built-in nodes—~5—90+
Visual graph editor
Node graph
Legacy —Animator State machinePlayables API —
IK solvers
6 (Burst)
Legacy —Animator OnAnimatorIKPlayables API —
Physics bones
5 systems
Legacy —Animator —Playables API —
Blend spaces
1D / 2D / graph
Legacy —Animator 1D / 2DPlayables API Manual
Math in graph
14 nodes
Legacy —Animator —Playables API —
Animation LOD
Per-node
Legacy —Animator —Playables API Manual
Inertialization
Built-in
Legacy —Animator —Playables API —
Pose mirroring
Built-in
Legacy —Animator —Playables API Manual
Debug overlays
Per-node
Legacy —Animator State highlightPlayables API —
Runtime
Burst + Jobs
Legacy C++ nativeAnimator C++ + managedPlayables API C++ + interop
Allocations
Zero managed
Legacy MinimalAnimator Per-framePlayables API Per-node
Parallelism
Multi-core
Legacy —Animator —Playables API —
Built-in nodes
90+
Legacy —Animator ~5Playables API —
Node library

90+ built-in nodes, across 13 categories

A complete toolbox for character animation, all Burst-compiled and combinable in a single graph.

IK solvers

6
  • Two Bone IK
  • FABRIK
  • CCDIK
  • Leg IK
  • Spline IK
  • Hand IK Retargeting

Physics bones

5
  • Cloth Bone Simulation
  • Spring Bone
  • Anim Dynamics
  • Rigid Body
  • Trail

Bone controllers

10
  • Modify Bone
  • Copy Bone
  • Copy Bone Delta
  • Look At
  • Twist Corrective
  • Rotation Multiplier
  • Bone Driven Controller
  • Constraint
  • Apply Limits
  • Scale Chain Length

Blend spaces

8
  • 1D
  • 2D
  • Graph-based
  • Evaluator
  • Aim Offset
  • Aim Offset 1D
  • Rotation Offset 1D
  • Rotation Offset 2D

Blending

7
  • Two Way Blend
  • Multi Way Blend
  • Layered Bone Blend
  • Blend Bone By Channel
  • Blend List By Bool
  • Blend List By Int
  • Blend List By Enum

Math & logic

14
  • Float Math
  • Bool Logic
  • Curve Evaluator
  • Time Remaining
  • Float to Bool
  • Bool to Float
  • Int to Float
  • Float to Int
  • Make/Break Vector2
  • Make/Break Vector3
  • Make Vector4
  • Make/Break Quaternion

Additive animation

3
  • Apply Additive
  • Apply Mesh Space Additive
  • Make Dynamic Additive

Space conversion

2
  • Local To Component Space
  • Component To Local Space

Advanced transitions

2
  • Inertialization
  • Dead Blending

Action system

1
  • Slot (montage-style playback)

Pose mirroring

1
  • Pose Mirror (mirror data tables)
Code API

Drive it from C#

Graphs are authored in the editor; from code you set parameters, read node state and control transitions. A full runtime API for driving your animation logic from gameplay code.

PlayerAnimator.cs
// Drive AnimGraph from gameplay codevar player = GetComponent<AnimGraphPlayer>();int speed = AnimGraphPlayer.StringToHash("Velocity"); // Set parametersplayer.SetFloat(speed, velocity.magnitude);player.SetBool("Shoot", fireInput); // Drive a state machine & read bonesplayer.TransitionToState(0, "Jump", 0.15f);Transform hand = player.GetBoneTransform("Hand_R");
Workflow

From idea to in-game animation in three steps

01

Build your graph

Add nodes for clips, blend trees and states and wire them into the logic your character needs.

02

Preview & tune

Play the graph live in the editor, adjust transitions and weights and see the result instantly.

03

Drive it from code

Hook up your gameplay with the C# API: set parameters, drive transitions and read node state from your graph.

Specifications

Compatibility & license

Unity versions2022 LTS to Unity 6.3 LTS
Render pipelinesBuilt-in · URP · HDRP
PlatformsAll Unity build targets
RuntimeBurst-compiled, allocation-free
ScriptingFull C# API with source code
LicensePer seat, up to 2 machines

Ready to animate faster in Unity?

Get Animation Graph on the Unity Asset Store. One-time purchase, usable per seat on up to two machines.

On the Unity Asset Store

Already bought it? Activate your license