New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Godot Tweening

by thedivergentai in thedivergentai/GD-Agentic-Skills

Expert blueprint for programmatic animation using Tween for smooth property transitions, UI effects, camera movements, and juice.

LGPL-3.0Auto-check passedGame Development

Install Godot Tweening

skills CLI
$ npx skills add thedivergentai/GD-Agentic-Skills --skill godot-tweening -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install thedivergentai/GD-Agentic-Skills godot-tweening --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/thedivergentai/GD-Agentic-Skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/godot-tweening .claude/skills/godot-tweening && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
godot-tweening
GitHub stars
821
Token cost
~2.9k tokens
SKILL.md length
762 words
Files
15 (incl. scripts, references)
Skills in repo
98
Repo updated
First seen
Licence
LGPL-3.0

At a glance

Expert blueprint for programmatic animation using Tween for smooth property transitions, UI effects, camera movements, and juice.

  • Implementing UI animations OR procedural movement
  • SKILL.md covers Decision Tree — Tween vs…, Available Scripts, NEVER Do in Tweening and Lifecycle Golden Path, plus 4 more sections
  • Tasks that involve Game development

What it does

Godot Tweening is an agent skill from thedivergentai/GD-Agentic-Skills. Expert blueprint for programmatic animation using Tween for smooth property transitions, UI effects, camera movements, and juice. Covers easing functions, parallel tweens, chaining, and lifecycle management. Use when implementing UI animations OR procedural movement. Keywords Tween, easing, interpolation, EASEINOUT, TRANSCUBIC, tweenproperty, tweencallback.

Its SKILL.md is about 2.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 16 other files, including scripts and reference files (for example `references/migration-notes.md` and `references/tween-recipes-and-gotchas.md`).

It sits in Game Development, covering Game development. It works with Godot. The repository describes itself as: The official "Long-Term Memory" for Godot 4.7+ AI Agents. A high-density library of 99 expert skills and 27 genre blueprints, providing audited, strictly typed GDScript patterns… The licence is LGPL-3.0.

When your agent uses it

  • Implementing UI animations OR procedural movement
  • Tasks that involve Game development

Example prompts

  • “/godot-tweening”

What it can do on your machine

Read from SKILL.md and the folder at commit 4c4d0ff. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 12 files in scripts/, which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • docs.godotengine.org

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Godot Tweening loads about 2.9k tokens when it runs, and up to ~4.3k if it reads all its reference files. Until then it costs about 95 tokens; SKILL.md has 762 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~95
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~4.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from thedivergentai/GD-Agentic-Skills at commit 4c4d0ff, republished under its LGPL-3.0 licence (© thedivergentai). 762 words, ~2,870 tokens.

Download SKILL.mdSave it as .claude/skills/godot-tweening/SKILL.md (or your agent's skills folder). This skill also uses 14 other files; get the full folder from GitHub.
name
godot-tweening
description
Expert blueprint for programmatic animation using Tween for smooth property transitions, UI effects, camera movements, and juice. Covers easing functions, parallel tweens, chaining, and lifecycle management. Use when implementing UI animations OR procedural movement. Keywords Tween, easing, interpolation, EASE_IN_OUT, TRANS_CUBIC, tween_property, tween_callback.

Decision Tree — Tween vs AnimationPlayer

SituationChoose
One-off UI juice, hover, popup, score count, recoilTween (create_tween)
Authored multi-track clips, scrubbable timelines, blend treesAnimationPlayer / AnimationTree
Camera continuous follow behind a moving targetCamera2D.position_smoothing / spring follow — not a new Tween every _process
Menu motion while Engine.time_scale == 0Tween with set_ignore_time_scale(true) — MANDATORY time_scale_ignored_ui.gd
Retriggerable property (button spam, dodge cancel)Kill-before-recreate — MANDATORY safe_tween_interruption.gd
Physics body / net correction motionTWEEN_PROCESS_PHYSICS + reset_physics_interpolation

Available Scripts

MANDATORY: Read the script for the case above before writing tween glue.

safe_tween_interruption.gd

MANDATORY for any retriggerable tween — kill active tweens before starting new ones.

time_scale_ignored_ui.gd

MANDATORY for pause-menu / time_scale == 0 UI motion.

nested_subtween_cutscene.gd

MANDATORY for composable cutscene timelines via tween_subtween.

parallel_popup_animation.gd

set_parallel(true) + chain() for multi-property UI transitions.

text_counter_method_tween.gd

tween_method for non-property values (score strings).

custom_curve_tween.gd

Curve resources for bespoke easing.

camera_shake_tween_logic.gd

Procedural screen shake with looping tweens (offset, not follow).

relative_recoil_tween.gd

as_relative() / from_current() for recoil nudges.

staggered_inventory_entry.gd

Sequential collection entry on one Tween.

looped_hover_vfx.gd

Infinite ping-pong ambient juice.

juice_manager.gd / tween_builder.gd

Central juice dispatch / builder helpers when many systems share feel presets.

NEVER Do in Tweening

  • NEVER instantiate a Tween using Tween.new() — Always use create_tween() or get_tree().create_tween() [3, 4].
  • NEVER attempt to reuse a finished Tween — Single-use; recreate to replay [4].
  • NEVER manually instantiate PropertyTweener or CallbackTweener — Only via parent Tween methods [5].
  • NEVER create an infinite loop containing only 0-duration animations — Freezes the engine [10].
  • NEVER use multiple Tweens to animate the same property simultaneously — kill() the old reference first [11, 12].
  • NEVER use linear interpolation for UI/Juice — Prefer EASE_OUT + TRANS_QUAD or EASE_IN_OUT + TRANS_CUBIC [22].
  • NEVER create tweens in _process without guards — Creating 60 tweens per second will crash the app.
  • NEVER skip bind_node(self) for non-global tweens — Binding ensures death with the node [13].
  • NEVER use 0-duration tweens for state changes — Set the property directly [20].
  • NEVER forget to call chain() when returning from set_parallel(true) [15].

Lifecycle Golden Path

gdscript
var _tween: Tween

func animate_to(pos: Vector2) -> void:
    if _tween and _tween.is_valid():
        _tween.kill()
    _tween = create_tween().bind_node(self)
    _tween.set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_QUAD)
    _tween.tween_property(self, "position", pos, 0.35)

MANDATORY pattern source: safe_tween_interruption.gd.

Camera Follow (Correct)

Continuous follow is not a Tween job:

gdscript
extends Camera2D
@export var target: Node2D

func _ready() -> void:
    position_smoothing_enabled = true
    position_smoothing_speed = 5.0

func _physics_process(_delta: float) -> void:
    if target:
        global_position = target.global_position

If you must tween a one-shot camera punch/return, keep one Tween reference and kill before recreate — never create_tween() inside unguarded _process.

Expert Patterns (keep)

Physics-Sync-Tweening
gdscript
func apply_physics_tween(target: Node3D, start_pos: Vector3, goal: Vector3) -> void:
    target.global_position = start_pos
    target.reset_physics_interpolation()
    var tween := create_tween().bind_node(target)
    tween.set_process_mode(Tween.TWEEN_PROCESS_PHYSICS)
    tween.tween_property(target, "global_position", goal, 0.5)
Juice-Config-Resource

Store duration/trans/ease in a Resource (see juice scripts) so feel is data-driven.

Tween-Event-Sequencing

Parallel block → chain() → interval/callback → exit. Prefer nested_subtween_cutscene.gd for nested modules.

Bezier-Path-Tween

Tween PathFollow2D.progress_ratio instead of hand-rolled Bezier math.

Deep recipes (on demand)

LLM-ignorance rule: if a general agent would not know it before reading, it lives here or in scripts/ — never delete, only move.

TopicReference
Chains, kill, gotchastween-recipes-and-gotchas.md

Reference

Progressive disclosure: open Official Documentation links only when researching a specific API; load Related Skills when routing to a peer domain — do not preload the whole lattice.

Show full SKILL.md (321 more words)Show less
Official Documentation
  • Tween — create_tween, parallel/chain, loops, process mode, ignore_time_scale, and kill/lifecycle rules.
  • PropertyTweener — tween_property details: as_relative, from_current, custom interpolators, and per-step ease/trans.
  • MethodTweener — tween_method for non-property values (score counters, shader params, Curve-sampled motion).
  • CallbackTweener — tween_callback for sequenced side effects without inventing fake 0-duration property steps.
  • IntervalTweener — tween_interval delays inside a single Tween timeline.
  • SubtweenTweener — tween_subtween for nested cutscene modules under one parent timeline.
  • Interpolation — lerp/smoothstep foundations behind easing choices and custom interpolators.
  • Beziers, curves and paths — Curve/PathFollow patterns used when property tweens alone cannot describe the path.
  • Introduction to the animation features — when Tween juice is enough versus AnimationPlayer/AnimationTree authored tracks.
  • Using SceneTree — SceneTree.create_tween and node lifetime when bind_node is not enough.
  • Idle and Physics Processing — idle vs physics process modes for TWEEN_PROCESS_PHYSICS sync.
  • Physics interpolation quick start guide — reset_physics_interpolation when tweening transforms on interpolated bodies.
Prerequisites
  • godot-project-foundations — scene tree, Node ownership, and resource basics before create_tween/bind_node lifecycle patterns.
  • godot-gdscript-mastery — typed callables, lambdas, and await/signal idioms used in tween_method and finished handlers.
Complements
  • godot-2d-animation — sprite/skeleton motion that often coexists with Tween juice and needs shared kill/lifecycle discipline.
  • godot-animation-player — authored clips for complex timelines; Tweens stay for runtime/procedural UI and one-off juice.
  • godot-ui-containers — Control size/pivot/layout context for popup scale-fade and staggered inventory entry tweens.
  • godot-signal-architecture — finished/callback wiring without dangling connections when Tweens are killed and recreated.
  • godot-camera-systems — camera follow, shake offsets, and look targets driven by procedural Tweens.
  • godot-resource-data-patterns — JuiceConfig-style Resources that store duration/trans/ease outside gameplay scripts.
  • godot-particles — burst timing and one-shot VFX that should start from tween_callback steps, not parallel ad-hoc timers.
  • godot-shaders-basics — shader params animated via tween_method / set when property paths are not enough.
Downstream / consumers
  • godot-inventory-system — slot/item entry, drag feedback, and equip juice built on staggered and interruptible Tweens.
  • godot-genre-card-game — hand arcs, draw/discard flights, and resolve polish that depend on Tween chaining.
  • godot-ui-theming — theme-driven hover/focus motion that still needs safe Tween interruption under the same Control.
Master
  • godot-master — library router and mirrored module entry for cross-skill discovery.

© thedivergentai, LGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 14 other files (scripts, references) in skills/godot-tweening of thedivergentai/GD-Agentic-Skills.

  • SKILL.md
  • references/migration-notes.md
  • references/tween-recipes-and-gotchas.md
  • scripts/camera_shake_tween_logic.gd
  • scripts/custom_curve_tween.gd
  • scripts/juice_manager.gd
  • scripts/looped_hover_vfx.gd
  • scripts/nested_subtween_cutscene.gd
  • scripts/parallel_popup_animation.gd
  • scripts/relative_recoil_tween.gd
  • scripts/safe_tween_interruption.gd
  • scripts/staggered_inventory_entry.gd
  • scripts/text_counter_method_tween.gd
  • scripts/time_scale_ignored_ui.gd
  • scripts/tween_builder.gd

Open the folder on GitHubat commit 4c4d0ff

Compare with similar skills

Godot Tweening next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Godot Tweening compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Godot Tweening this skillthedivergentai/GD-Agentic-Skills821—~2.9kAutomated safety check: PassLGPL-3.0
Godot Gdscript Patterns925236118/AlphaAgent10310 repos~5kAutomated safety check: PassMIT
2D Map and Scene Generator0x0funky/agent-sprite-forge4.4k—~2.9kAutomated safety check: PassMIT
Godot UI Integrationzimo-xiao-zheng/godot-ui-integration285—~1.5kAutomated safety check: PassMIT
Godot Wechat Minigame Adaptergodothub/godot-minigame187—~1.5kAutomated safety check: PassMIT
AI Game Art Pipelineybuild-ai/ai-game-art-pipeline-skill297—~1.1kAutomated safety check: PassMIT

Similar skills

  • Godot Gdscript Patterns

    925236118/AlphaAgent

    Master Godot 4 GDScript patterns including signals, scenes, state machines, and optimization.

    103 GitHub starsUsed in 10 repos~5k tokens
    Game DevelopmentAuto-check passed

  • 2D Map and Scene Generator

    0x0funky/agent-sprite-forge

    Plans and builds 2D game maps and scenes, from tilemaps and parallax backgrounds to HD-2D plates, with collision checks, a playable HTML preview and Tiled, Godot or LDtk export.

    4.4k GitHub stars~2.9k tokensUpdated 4 days ago
    Game DevelopmentAuto-check passed

  • Godot UI Integration

    zimo-xiao-zheng/godot-ui-integration

    Build or revise Godot UI from an approved design, separated art, or a visual reference when scene structure, gameplay binding, and runtime visual verification all matter.

    285 GitHub stars~1.5k tokensUpdated 1 mo ago
    Game DevelopmentAuto-check passed

  • Godot Wechat Minigame Adapter

    godothub/godot-minigame

    Apply the bundled self-contained Godot WeChat Mini Game adapter kit to an official Godot checkout.

    187 GitHub stars~1.5k tokensUpdated 25 days ago
    Game DevelopmentAuto-check passed

  • AI Game Art Pipeline

    ybuild-ai/ai-game-art-pipeline-skill

    Provider-neutral open-source skill for planning and producing game-runtime art assets and animation: static props/icons, canonical character sheets, combat sprites, 3D/video motion references…

    297 GitHub stars~1.1k tokensUpdated 3 mo ago
    Game DevelopmentAuto-check passed

  • MCP Driver

    RandallLiuXin/GodotMaker

    Runtime debugging and live project inspection via godot-mcp.

    550 GitHub starsUsed in 1 repo~1.1k tokens
    Game DevelopmentAuto-check passed

More from thedivergentai/GD-Agentic-Skills

All 98 skills in this repo

  • Godot 2D Animation

    thedivergentai/GD-Agentic-Skills

    Expert patterns for 2D animation in Godot using AnimatedSprite2D and skeletal cutout rigs.

    821 GitHub stars~3.6k tokensUpdated 1 mo ago
    Auto-check passed

  • Godot 3D World Building

    thedivergentai/GD-Agentic-Skills

    Expert patterns for 3D level design using GridMap with MeshLibrary, CSG constructive solid geometry, occlusion, and runtime GridMap builders.

    821 GitHub stars~3.3k tokensUpdated 1 mo ago
    Auto-check passed

  • Godot Adapt 2D To 3D

    thedivergentai/GD-Agentic-Skills

    Expert patterns for migrating 2D games to 3D including node type conversions, camera systems (third-person, first-person, orbit), physics layer migration, sprite-to-model art pipeline, and control…

    821 GitHub stars~4.7k tokensUpdated 1 mo ago
    Auto-check passed

  • Godot Adapt 3D To 2D

    thedivergentai/GD-Agentic-Skills

    Expert patterns for simplifying 3D games to 2D including dimension reduction strategies, 2.5D fake-depth, isometric ports, camera flattening, physics conversion, 3D-to-sprite art pipeline, and…

    821 GitHub stars~4.5k tokensUpdated 1 mo ago
    Auto-check passed

  • Godot Agent Vision

    thedivergentai/GD-Agentic-Skills

    Agentic eyes for Godot work: cross-platform screenshot CLI (asset/region/window/screen) to budgeted WebP, TEMP editor viewport bridge under .gdskills/, and Taste Receptor Atlas v2 (~237…

    821 GitHub stars~3.5k tokensUpdated 1 mo ago
    Auto-check passed

  • Godot Animation Tree Mastery

    thedivergentai/GD-Agentic-Skills

    Expert patterns for AnimationTree including StateMachine transitions, BlendSpace2D for directional movement, BlendTree for layered animations, root motion, transition conditions, advance…

    821 GitHub stars~3.6k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Godot Tweening

What does Godot Tweening do?

Expert blueprint for programmatic animation using Tween for smooth property transitions, UI effects, camera movements, and juice. Godot Tweening is an agent skill from thedivergentai/GD-Agentic-Skills. Expert blueprint for programmatic animation using Tween for smooth property transitions, UI effects, camera movements, and juice.

When should I use Godot Tweening?

Godot Tweening fits situations like: implementing UI animations OR procedural movement; tasks that involve Game development.

How do I install Godot Tweening in Claude Code?

Run `npx skills add thedivergentai/GD-Agentic-Skills --skill godot-tweening -a claude-code`. Or copy the skill folder (skills/godot-tweening in thedivergentai/GD-Agentic-Skills) into .claude/skills/godot-tweening in your project. Claude Code loads it when a task matches its description.

How do I install Godot Tweening in Codex?

Run `npx skills add thedivergentai/GD-Agentic-Skills --skill godot-tweening -a codex`. Or copy the skill folder (skills/godot-tweening in thedivergentai/GD-Agentic-Skills) into .agents/skills/godot-tweening in your project. Codex loads it when a task matches its description.

Can I use Godot Tweening in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add thedivergentai/GD-Agentic-Skills --skill godot-tweening -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/godot-tweening, .gemini/skills/godot-tweening, .github/skills/godot-tweening and .opencode/skills/godot-tweening in your project.

What does Godot Tweening need to run?

SKILL.md names no scripts, command-line tools or credentials: Godot Tweening is instructions for the agent only.

Does Godot Tweening access the network?

SKILL.md names 1 domain. As links in the text: docs.godotengine.org. This is read from the text; nothing was executed.

Is Godot Tweening safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Godot Tweening use?

Godot Tweening is published under the LGPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Godot Tweening use?

About 2.9k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.4k tokens, read only when the agent opens those files.

What are the alternatives to Godot Tweening?

Skills that share tags, products or a category with Godot Tweening: Godot Gdscript Patterns (925236118/AlphaAgent, 103 stars), 2D Map and Scene Generator (0x0funky/agent-sprite-forge, 4.4k stars), Godot UI Integration (zimo-xiao-zheng/godot-ui-integration, 285 stars) and Godot Wechat Minigame Adapter (godothub/godot-minigame, 187 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Godot Tweening?

thedivergentai (a GitHub user) maintains it in thedivergentai/GD-Agentic-Skills, which has 821 GitHub stars. The repository holds 98 skills in this directory. The repository was last updated on September 9, 2026.

Source: thedivergentai/GD-Agentic-Skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.