Animation Graph Editor

The Animation Graph Editor is a visual, node-based tool that empowers technical artists and animators to build complex animation logic directly within Roblox Studio. By providing a streamlined interface for creating behaviors like blend trees, it removes the traditional dependency on manual scripting for character motion.

This system works in tandem with your existing animation workflow:

• Animation Editor: Continue using the Animation Editor as your primary tool for authoring individual clips and fine-tuning keyframes and curves.
• Animation Graph Editor: Use this tool to take those clips and organize them into a logic tree to drive sophisticated gameplay behavior.

Designed to enhance collaboration, the visual graph allows developers to quickly inspect, debug, and understand the logic created by animators. While artists focus on refining interactive motion, developers can still access animation graph nodes programmatically for direct control over blended animations and states.

Build a graph

To begin building logic for an animatable character, access the Animation Graph editor via the Avatar tab in the Studio ribbon. The following steps demonstrate how to initialize a rig and construct a basic node network using default walking and waving animations.

For a deeper dive into practical applications, you can explore the Animation Graph Reference File, which contains both foundational and complex implementation examples.

To create your own animation graph, similar to the basic example provided in the reference, use the following steps:

1. In Studio, add an animatable rig by navigating to the Avatar tab and selecting Character ⟩ My Avatar.

   

2. Open the Animation Graph Editor by navigating to Graph Editor in the Avatar tab.

   

3. Select the animatable rig in the 3D viewport and select Create Graph.

4. In the Graph Editor, right-click and select Clip.

   

5. In the new Clip node, set the Animation ID.

   1. Select the Animation ID dropdown.

   2. To submit a specific animation asset ID, click Import.

      

   3. In the Animation ID field, add the default Walk animation: 507777826.

   4. Select Import.

6. Add another clip node by repeating steps 4-5 using the default Wave animation: 507770239.

   

7. In the Graph Editor, right-click and select Add.

   

8. Connect the Clip nodes to the Add node by dragging the top-right output connector to the appropriate port:

   1. Connect the Clip node with the Walking animation to the Base port.
   2. Connect the Clip node with the Waving animation to the Additive port.

   

9. From the Add node, connect the top-right output connector to the Graph Output Pose port.

   

10. OPTIONAL

    Assign a parameter to your Speed variable.

    1. Click and drag the green Speed port to an empty area. A new parameter node displays.

       

    2. In the top left of the graph editor, use the parameter pane to quickly modify parameters in your nodes. You can also access this programmatically.

       

11. Test the animation by pressing the play button.

    

12. Try testing various weights, speeds, playmodes, and other animations. For more information on individual nodes, see the Node reference.

API integration

Creating and deploying an Animation Graph follows the standard Roblox animation pipeline. After selecting a rig in the Animation Graph Editor, a new AnimationGraphDefinition asset is created. This asset serves as the container for your nodes, connections, and parameters. Once your logic is finalized, you publish the graph to receive a standard Asset ID.

In your scripts, you interact with these graphs by loading them onto an Animator as you would a traditional animation. To drive the graph's internal logic, use AnimationTrack:SetParameter() to pass real-time values—such as movement speed or state booleans—directly into the graph's variables.

local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://123456789" -- Your Published Graph ID

local animationTrack = animator:LoadAnimation(animation)
animationTrack:Play()

-- Dynamic parameter updates via RunService
game:GetService("RunService").Stepped:Connect(function(_, dt)
    local currentSpeed = humanoidRootPart.AssemblyLinearVelocity.Magnitude
    animationTrack:SetParameter("humanoidSpeed", currentSpeed)
end)

Node reference

Every animation graph node serves as a logic gate or data source that processes animation data before it reaches the character rig. This section provides a technical breakdown of the functional blocks within the Animation Graph Editor. All nodes currently output an animation pose.

Each node section includes:

• Definition – A summary of the node's purpose and role within the graph.
• Inputs – The data streams entering the node. Multiple inputs are represented as Input1, Input2, ..., InputN.
• Input properties – Settings tied directly to a specific input (an Idle input assigned to a Position of 0.5 on a Blend1D node).
• Event Data – Events emitted or consumed by the node to trigger internal graph logic or external Luau scripts. This behavior may change over the course of the beta development.

Global event rules

For all nodes and transitions, the following rules apply by default:

• Events propagate upward from their source node through the graph. Each event carries a weight representing its source's influence in the final blend. If the weight reaches zero at any point, the event is silenced.
• Nodes without custom event logic pass all events through unchanged; nodes that blend or select between inputs may scale the weight or block events from non-primary inputs (see per-node Event section).
• Marker events that reach the top of the graph can be observed via AnimationTrack:GetMarkerReachedSignal().

Clip

A reference to an AnimationClip asset. This serves as a leaf node in the graph, generating the raw animation data that feeds into other nodes for blending, selection, or modification.

Inputs

• None

Properties

Property	Type	Description
AnimationId	String	The animation asset to play (e.g. rbxassetid://12345).
PlayMode	Enum.AnimationNodePlayMode	Defines the behavior of the clip once it reaches the end of its duration. Loop (default): Automatically restarts from the beginning once the clip finishes. PingPong: Plays from start to end, then immediately plays in reverse from end to start. OnceAndHold: Plays once and maintains the final pose upon completion. OnceAndReset: Plays once and snaps back to the initial start pose upon completion.
Reverse	Boolean	Controls the direction of playback.
Speed	Number	A multiplier for the playback rate. 0.0 pauses the graph, 1.0 is normal speed, and 2.0 is double speed.
Trim	Boolean	Toggles whether the clip's duration should be truncated.
TrimStart	Number	The absolute timestamp (in seconds) where playback should begin.
TrimEnd	Number	The absolute timestamp (in seconds) where playback should terminate.

Event data

• Event Handling: None. This is a leaf node with no children.
• Event Emission: Reads custom markers embedded in the animation clip (e.g., "Footstep", "WeaponSwing") and emits them as named events at the precise frame they occur. If the clip is trimmed, only markers within the defined [TrimStart, TrimEnd] interval (inclusive) are emitted.

Select

Selects between any number of inputs via the Selection property. Whenever the current selection changes, it triggers a new transition.

Inputs

• Input1...InputN

Properties

Property	Type	Description
Selection	String	The unique ID of the input to be selected, matching the name of the input connection (e.g., "Walk").

Event data

• Event Handling: Events from the currently selected input pass through with their weight unchanged.
• Event Emission: Passes through all events from the currently selected input only. During a transition, event emission follows global event rules.

PrioritySelect

Evaluates a list of connected inputs from top to bottom and plays the first one whose condition evaluates to true. This allows for hierarchical animation selection based on specific logic. Whenever the current selection changes, it triggers a new transition.

Inputs

• Input1...InputN

  • Trigger (Boolean): A logical condition that must be true for this input to activate. In current versions, this is wired to a boolean parameter.
  • TransitionOverrideInterruptible (Enum.AnimationNodeInterruptible): Defines the rule for when this active animation can be interrupted by a higher-priority input. Overrides the node-level DefaultInterruptible setting.

    • Always (default): The input can be interrupted at any time by a higher-priority condition.
    • Finished: The current animation must complete its playback before a higher-priority input can take over.
    • Trigger: The input is only interruptible when the InterruptibleTrigger is set to true.
  • InterruptibleTrigger (Boolean): Only available if TransitionOverrideInterruptible is set to Trigger. The input can be interrupted when this specific expression is true.

Properties

Property	Type	Description
DefaultInterruptible	Enum.AnimationNodeInterruptible	The baseline interruption rule applied to all inputs. Each input can override this with its own TransitionOverrideInterruptible input property.

Event data

• Event Handling: Events from the currently selected input pass through with their weight unchanged.
• Event Emission: Passes through all events from the currently selected input only. During a transition, event emission follows global event rules.

Sequence

Activates connected inputs in a specific sequential order based on defined wait conditions. Whenever the current selection changes, it triggers a new transition.

Inputs

• Input1...InputN

  • TransitionOverrideWaitFor (Enum.AnimationNodeWaitFor): Specifies the condition that must be met before the sequence advances to the next input. Overrides the node-level DefaultWaitFor setting.

    • Finished (default): Advances to the next input when the current input completes a cycle. The advancement behavior depends on the connected input:

      • Play-once clip: Advances when the clip finishes.
      • Looping clip: Advances after one full loop completes.
      • Sequence with infinite loops: Advances after one full cycle through all inputs.
      • Sequence with finite loops: Advances after all loops complete.
    • Trigger: Activates the next input when a custom logical expression evaluates to true.
  • WaitForTrigger (Boolean): Only available when TransitionOverrideWaitFor is set to Trigger.

Properties

Property	Type	Description
LoopCount	Number	The number of times to cycle through the entire sequence. A value of 0 (default) indicates an infinite loop. Once the count is reached, the node respects the looping or hold setting of the final input.
DefaultWaitFor	Enum.AnimationNodeWaitFor	The baseline wait condition applied to all inputs. Each input can override this with its own TransitionOverrideWaitFor input property.

Event data

• Event Handling: Events from the currently active input pass through with their weight unchanged.
• Event Emission: Passes through all events from the currently active input in the sequence only. During a transition, event emission follows global event rules.

RandomSequence

Selects and plays one of its connected inputs at random. When the currently selected animation completes, the node randomly picks another input to play. Assign each input a specific weight to influence the probability of it being chosen. Whenever the current selection changes, it triggers a new transition.

Inputs

• Input1...InputN

  • Weight (Number): Determines the probability of this input being selected; higher weights increase the chance of selection.

Properties

Property	Type	Description
PlayCount	Number	The number of inputs the node will play through before stopping. Once reached, the node respects the looping or hold setting of the final input. Default is 0 for infinite
Seed	Number	A value used to initialize the Random Number Generator (RNG), ensuring the sequence remains consistent across different clients. Defaults to -1 for random Seed.

Event data

• Event Handling: Events from the currently active input pass through with their weight unchanged.
• Event Emission: Passes through all events from the currently active input in the sequence only. During a transition, event emission follows global event rules.

Over

Layers the Over pose on top of the Base pose. When combined with a Mask node, masked-out joints in the Over pose reveal the Base pose entirely, creating a transparent overlay effect.

Inputs

• Base: The background or bottom layer, typically a full-body animation like locomotion or an idle state.
• Over: The foreground or top layer to be applied over the base, such as a hand gesture or tool-use animation.

Properties

Property	Type	Description
Weight	Number	The blend weight used to attenuate the Over pose. Defaults to 1.0 (full override) and is unclamped.

Event data

• Event Handling:

  • The node listens for events from both the Base and Over inputs.
• Event Emission:

  • Base Events: All events from the Base input are passed through unmodified.
  • Over Events: Events from the Over input are scaled by the Weight property.

    • At Weight 0.5, Over events propagate at half weight
    • At Weight 0, they are silenced.

Add

Adds the Additive pose to the Base pose, attenuated by a specific Weight (unclamped).

Inputs

• Base: The primary animation pose.
• Additive: The pose to be layered onto the base.

Properties

Property	Type	Description
Weight	Number	Determines the strength of the additive pose applied to the base.

Event data

• Event Handling: The node listens for events from both the Base and Additive inputs.
• Event Emission: All events from both the Base and Additive inputs are passed through unmodified.

Subtract

Converts an animation into an additive pose by subtracting a relative base pose from the target pose ($A - \text{Weight} \times B$). The Weight scales the B pose before subtraction (unclamped).

Inputs

• A: The target animation pose.
• B: The relative base pose to be subtracted.

Properties

Property	Type	Description
Weight	Number	Scales the B pose before it is subtracted from A. At 1.0 (default), B is fully subtracted; at 0.0, no subtraction occurs.

Event data

• Event Handling: The node listens for events from both Input A and Input B.
• Event Emission: All events from both Input A and Input B are passed through unmodified.

Blend1D

Linearly interpolates between the two animation poses closest to the current input position on a single axis.

Inputs

• Input1...InputN

  • Position (Number): The specific coordinate for each subsequent input on the blend axis.

Properties

Property	Type	Description
Position	Number	The current active value on the blend axis used to sample the animations. If Position is outside the range of defined input positions, the node extrapolates using the two nearest inputs.
PhaseSync	Enum.AnimationNodePhaseSync	Configures whether the timing of children inputs should be synchronized. Synced (default): Normalized synchronization. The node calculates a "virtual duration" based on the weighted average of active inputs. Each input node’s time step is adjusted so that all children converge to the same phase, keeping animations of different lengths in lockstep. Unsynced: Standard blending where clips advance independently at their own playback rates.

Event data

• Event Handling: The node listens for events from all currently active child nodes.
• Event Emission: Only events from the highest-weight active input propagate, scaled by its blend weight. Events from the secondary input are silenced.

Blend2D

Blends multiple animation poses together based on two input parameters within a 2D coordinate space. This generalizes the Blend1D node to handle complex scenarios, such as blending based on both movement direction and speed simultaneously.

Inputs

• Input1...InputN

  • X (Number): The X-coordinate for each subsequent input.
  • Y (Number): The Y-coordinate for each subsequent input.

Properties

Property	Type	Description
InputMode	Enum.AnimationNodeBlend2DInputMode	Defines the coordinate system used to evaluate the blendspace: Cartesian (default): Uses standard 2D grid coordinates. X and Y represent the current position within the blendspace. Polar: Uses angular and magnitude values. X represents the direction in radians, while Y represents the magnitude or strength of movement. Direction is weighted more heavily than magnitude, so inputs at similar angles but different magnitudes blend more smoothly than inputs at different angles.
X	Number	The current X-coordinate (Cartesian) or Direction in radians (Polar).
Y	Number	The current Y-coordinate (Cartesian) or Magnitude (Polar).
PhaseSync	Enum.AnimationNodePhaseSync	Configures whether the timing of children inputs should be synchronized. Synced (default): Normalized synchronization. The node calculates a "virtual duration" based on the weighted average of active inputs. Each input node’s time step is adjusted so that all children converge to the same phase, keeping animations of different lengths in lockstep. Unsynced: Standard blending where clips advance independently at their own playback rates.

Event data

• Event Handling: The node listens for events from all currently active child nodes.
• Event Emission: Only events from the highest-weight active input propagate, scaled by its blend weight. Events from the secondary input are silenced.

Mask

Applies a predefined mask to the input Pose. A mask is defined by a weight per object (e.g. joint) in the rig hierarchy, allowing for precise control or "feathering" of the animation.

Inputs

• Pose: The animation pose to be masked.

Properties

Property	Type	Description
Mask	ObjectValue	An ObjectValue (created as a direct child of the Mask AnimationNodeDefinition) that defines the mask weights. It can function in one of two ways: Directly: The ObjectValue itself contains attributes mapping rig object names to specific weight values. By Reference: The ObjectValue references another Instance that contains the mapping attributes. This allows for shared masks across different nodes in the graph. When creating a mask, you can choose a rig schema (HumanoidRigDescription or Picker) to populate the hierarchy. HumanoidRigDescription: Standardizes the mask for humanoid characters. Picker: Allows the user to select any specific rig in the workspace to populate the mask hierarchy.
Invert	Boolean	When true, applies weight values as 1 - weight. This allows for reusing a mask inversely without creating a new asset.

Event data

• Event Handling: The node listens for all events from the input Pose.
• Event Emission: All events from the input Pose are passed through unmodified.

Speed

Modifies the playback rate of an incoming animation pose.

Inputs

• Pose: The animation pose or subgraph whose playback speed will be modified.

Properties

Property	Type	Description
Speed	Number	A multiplier applied to the time delta ($dt$). 0.0 pauses the graph, 1.0 is normal speed, and 2.0 is double speed.

Event data

• Event Handling: The node listens for events from the input Pose.
• Event Emission: All events from the input Pose are passed through unmodified. Note that while the visual playback speed changes, the timing of emitted events (such as markers) will scale accordingly with the modified playback rate.

GraphOutput

Represents the final evaluated pose of the graph. This node is automatically included in all new graphs in the Animation Graph Editor. Its presence ensures that the graph is always valid and consistently produces an animation pose.

Inputs

• Pose: The final processed animation data to be applied to the rig.

Properties

• None

Event data

• Event Handling: The node listens for all events passed through the final connected input.
• Event Emission: This node serves as the exit point for the animation pipeline and does not emit signals back into the graph.

Transitions

Several nodes in the Animation Graph (such as Select, Priority Select, Sequence, and Random Sequence) manage how animations blend when switching between active inputs. To prevent redundancy in the node reference, these behaviors are defined by standardized transition property groups.

Default transition

The baseline blending behavior applied to the node whenever it switches to a new active input.

• DefaultTransitionDuration (number): The time (in seconds) it takes to fully blend into the new pose.
• DefaultTransitionCurve (Enum.PoseEasingStyle): The easing function applied during the blend. Currently only supports Enum.PoseEasingStyle.Linear and Enum.PoseEasingStyle.CubicV2.

Transition override

Input-specific link properties that supersede the default transition. These are applied when the node transitions to that specific input.

• TransitionOverrideDuration (number): Overrides the default transition duration.
• TransitionOverrideCurve (Enum.PoseEasingStyle): Overrides the default transition curve. Currently only supports Enum.PoseEasingStyle.Linear and Enum.PoseEasingStyle.CubicV2

Replication

Animation graph parameters and internal node state replicate automatically. The replication mode is determined by Workspace.AuthorityMode at the time the Animate script is created:

• In Enum.AuthorityMode.Automatic: Parameters set via AnimationTrack:SetParameter() replicate automatically to other peers.
• In Enum.AuthorityMode.Server: The server drives the full graph simulation. All node states, such as elapsed time for Enum.AnimationNodeType.ClipNode, and graph parameters replicate automatically from server to clients. The owning player's client uses prediction for smooth local playback.

Sample Animate Scripts

To generate example scripts to drive an animation graph for a rig, use Graph -> Create Animate script in the Animation Graph Editor. This produces a script hierarchy placed under StarterCharacterScripts (for player characters) or directly on the rig (for NPCs):

Animate (ModuleScript)
├── RunClient (LocalScript)
└── RunServer (Script, RunContext = Legacy)

The Animate ModuleScript contains the graph-loading logic. The RunClient and RunServer scripts invoke it in the appropriate context. Which scripts are included depends on the use case:

The following attributes are stored on the Animate script and configure its behavior:

Parameter replication in Automatic mode

When Workspace.AuthorityMode is Automatic:

• The owning client drives player character graphs; the server drives NPC graphs.
• Parameters set via AnimationTrack:SetParameter() are automatically replicated to other peers. Multiple SetParameter calls within a single frame are coalesced (last-writer-wins).
• No additional scripting is needed for parameter transport — the engine handles replication internally.
• Other clients see parameter updates with a small delay (one send interval plus network latency).

Server authority

When Workspace.AuthorityMode is Server:

• The server is authoritative for all graphs — it runs the simulation and replicates the full graph state.
• What is replicated: Both parameters and internal node state, including elapsed time, current selections, transition progress, loop counts, and RNG seeds. This ensures all clients see identical animation behavior.
• Player characters: The server drives the graph. The owning client's RunClient script automatically enables Enum.PredictionMode on the Animator, so the local player sees smooth, predicted animation that reconciles with the server on mismatch.
• NPCs: The server drives the graph exclusively; clients observe the replicated state with no local simulation.

Driving parameters

Use AnimationTrack:SetParameter() from every script that runs the graph:

• NPC (any mode): Call SetParameter from RunServer (or any server Script with access to the AnimationTrack).
• Player character in Enum.AuthorityMode.Server: Call SetParameter from both RunServer and RunClient. The server needs parameters to drive the authoritative simulation, and the owning client needs the same parameters to drive its local prediction.
• Player character in Enum.AuthorityMode.Automatic: Call SetParameter from RunClient (or any client LocalScript with access to the AnimationTrack).

The generated Animate script includes a commented-out SetParameter block as a starting point. Uncomment and modify it to drive parameters from gameplay state (movement speed, humanoid state, input direction, etc.).