godot-animation

Q: How do I install godot-animation?

Run npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill godot-animation in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/godot-animation/ (personal) or .claude/skills/godot-animation/ (project).

by gamedev-skillsFrontend & Design

Animate in Godot 4.7 three ways: AnimationPlayer for keyframed clips (incl. Call Method tracks), AnimationTree with state machines and blend spaces for character animation, and Tween for short procedural/UI tweens via createtween(). Use when working with AnimationPlayer/AnimationTree nodes in a .tscn, blending character states, sprite-sheet animation, or code-driven Tweens.

Installs: 7K
Last 24h: +346
Trending rank: #882
Security: Pass

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill godot-animation

01
Install
Run the command in your project. The CLI asks which agents to install for.
02
Describe the task
Ask your agent for something this skill covers. It loads godot-animation automatically when relevant.
03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.

Security audits

Independent scans of the skill's instructions and bundled files.

Gen Agent Trust Hub PassSAFE ·The skill provides legitimate documentation and code patterns for Godot 4.7 animation systems. No security risks or malicious behaviors were detected.

Socket PassNo alerts

Snyk PassLOW ·Risk: LOW · No issues

SKILL.md

The instructions your agent reads when the skill is triggered.

Godot Animation (4.x)

Choose and drive the right animation tool: AnimationPlayer (clips), AnimationTree (blending/state machines), or Tween (short procedural moves). Targets Godot 4.7.

When to use

Use when playing keyframed animations, blending walk/run/idle states, animating a sprite sheet, or tweening UI/objects in code.

When not to use: the movement logic that decides which state to play → godot-2d-movement; UI layout (vs. UI tweening) → godot-ui-control; shader-driven effects → godot-shaders.

Core workflow

Pick the tool:
- AnimationPlayer — author keyframed clips (transforms, properties, method calls, audio, even other animations). The source of truth for clip data.
- AnimationTree — blend and transition between those clips at runtime with a state machine and/or blend spaces. Needs an AnimationPlayer to pull clips from.
- Tween — fire-and-forget procedural interpolation in code (create_tween()); ideal for UI pops, fades, and one-off moves.
For 2D sprite sheets: use AnimatedSprite2D + SpriteFrames, or keyframe the frame property in an AnimationPlayer.
For characters: build clips in AnimationPlayer, then add an AnimationTree (active = true), set its anim_player, and design an AnimationNodeStateMachine or AnimationNodeBlendSpace2D as the tree root.
Drive transitions from code via the playback object (travel) or by setting blend parameters.
React to clip events with the animation_finished signal and Call Method tracks.

Patterns

1. AnimationPlayer: play a clip and await it

@onready var anim: AnimationPlayer = $AnimationPlayer

func attack() -> void:
    anim.play("attack")
    await anim.animation_finished     # resume after the clip ends
    anim.play("idle")

2. AnimationTree state machine: travel between states

@onready var tree: AnimationTree = $AnimationTree

func _ready() -> void:
    tree.active = true                # the tree drives animation; AnimationPlayer is the source

func set_state(state: StringName) -> void:
    # The playback object controls an AnimationNodeStateMachine root.
    var sm: AnimationNodeStateMachinePlayback = tree.get("parameters/playback")
    sm.travel(state)                  # transitions using the graph's connections

func _physics_process(_d: float) -> void:
    set_state(&"run" if velocity.length() > 5.0 else &"idle")

3. Blend space: blend run direction by a 2D parameter

# Root is an AnimationNodeBlendSpace2D named "Move" with idle/run points placed in it.
func update_locomotion(input_dir: Vector2) -> void:
    # Parameter path = "parameters/<node name>/blend_position".
    tree.set("parameters/Move/blend_position", input_dir)

4. Tween: fade and scale a UI element (code-driven)

func pop_in(node: Control) -> void:
    node.scale = Vector2.ZERO
    node.modulate.a = 0.0
    var tw := create_tween()                          # bound to this node's tree
    tw.set_parallel(true)                             # run the two tweens together
    tw.tween_property(node, "scale", Vector2.ONE, 0.2) \
      .set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)
    tw.tween_property(node, "modulate:a", 1.0, 0.2)   # sub-property via ":"

Pitfalls

AnimationTree.active left false → nothing animates and travel() appears to do nothing. Set active = true and assign the anim_player path.
Wrong parameter path. Blend/condition paths are "parameters/<NodeName>/..." and must match the node names in the tree exactly (e.g. "parameters/playback", "parameters/Move/blend_position"). A typo silently no-ops.
AnimationPlayer and AnimationTree fighting. When an AnimationTree is active, don't also call AnimationPlayer.play() for the same tracks — let the tree own playback.
3.x Tween node is gone. There is no Tween node to add in 4.x; create tweens in code with create_tween() (which returns a Tween). They auto-start and free themselves.
Tween stalls when its node leaves the tree. node.create_tween() pauses while that node is outside the tree and dies when it is freed. Use get_tree().create_tween() for a tween that must keep running while the node is out of the tree.
Scale/rotation tween on a child of a Container snaps back → the container resets child transforms whenever it re-sorts. In 4.7+ set offset_transform_enabled = true and tween offset_transform_scale / offset_transform_rotation / offset_transform_position instead (visual only by default).
Reusing a finished tween. A tween is one-shot; call create_tween() again for a new animation. Use set_loops() for repetition.
yield/yield(anim, "...") is gone. Use await anim.animation_finished.
Sub-property tweens use a colon: "modulate:a", "position:x". Tweening the whole property instead overwrites siblings.

References

For state machine transitions/conditions, root motion, one-shot/blend nodes, method & call tracks, SpriteFrames/AnimatedSprite2D, and Tween easing/chaining/callbacks, read references/animation-tree-and-tween.md.

Related skills

godot-2d-movement — supplies the velocity/state that selects animations.
godot-ui-control — UI that Tweens animate.
godot-3d-essentials — 3D character scenes driven by AnimationTree.
game-ai — state machines that mirror animation states.

FAQ

What does the godot-animation skill do?

How do I install godot-animation?

Run npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills --skill godot-animation in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/godot-animation/ (personal) or .claude/skills/godot-animation/ (project).

Which AI agents can use godot-animation?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is godot-animation safe to install?

Security partners have reviewed it: Gen Agent Trust Hub passed; Socket passed; Snyk passed. As with any skill, read the SKILL.md and bundled scripts before installing.

Who maintains godot-animation?

It is published by gamedev-skills in gamedev-skills/awesome-gamedev-agent-skills. It has 6,967 recorded installs.