# Anima gives Godot UI animations a CSS-like syntax and 89 presets

> Anima is a Godot editor add-on that replaces Tween boilerplate with a compact, CSS-like syntax, 89 built-in animations and 33 easing options, and it adds sequencing, parallel and concurrent animation, pivot points, grids and dynamic values. Installation is a folder copy, the licence is MIT, and the built-in animations come from animate.css.

**ceceppa/anima** — Godot: run sequential and parallel animations with less code 

- Repository: https://github.com/ceceppa/anima
- Website: https://anima.ceceppa.me/
- Stars: 769 · Forks: 23
- Language: GDScript
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/ceceppa-anima

## A Godot add-on aimed at interface animation

Anima is an add-on for the Godot game engine that simplifies the process of creating dynamic and impactful UI animations.

The problem it names is specific. Working with Godot's Tween to create UI animations can be quite challenging, and what Anima replaces is the verbosity of that work rather than the animation system itself. The result is described as clear and concise syntax with just a few lines of code, and the README quantifies the library: 89 built-in animations and 33 easing options.

The syntax is the second selling point. You can easily add your animations using a syntax similar to CSS, which the README calls a convenient tool for developers, and the difference table confirms it with a row that simply says CSS-like animations, yes for Anima and no for Tween.

The scope is worth stating clearly at the outset, because the word animation in a game engine covers a lot. Anima's own description is about UI animations, dynamic and impactful, and the difference table is entirely about interface concerns: opacity, scale, pivots, grids, labels, groups. Nothing in the README suggests it replaces Godot's AnimationPlayer, skeletons, or 3D transforms.

The project is by Alessandro Senese, with the MIT licence and copyright marked 2021-present. The homepage is anima.ceceppa.me, and the repository is not archived, with the last push on 2026-09-03.

## Installation is copying a folder and ticking a box

The installation section is two sentences, which tells you the delivery model.

This is a regular editor plugin. Copy the contents of addons/Anima into the same folder in your project, and activate it in your project settings.

There is no asset library entry, no package manager step and no version constraint to resolve. You take a directory, put it in the right place, and turn it on. For a Godot project that already vendors its add-ons that is a familiar ritual, and for a team that wants its add-on versions pinned in the repository, the copy is also easy to review in a diff.

The trade is that you are responsible for the update. There is no manifest in the README describing how to upgrade the add-on in place, and the repository itself carries a separate README file named README.ADDON-REPO.md, which suggests the source repository and the add-on distribution are related but distinct things.

The documentation is split across two places as well. There is a documentation site, with the README linking it and the demo code in the demos directory of the repository, plus live examples hosted separately. The API reference is generated: the package.json has a docs:api script that runs node scripts/generate-api-docs.js, and the dev script regenerates the API docs and then serves the documentation folder with Hugo. The docs site is a Hugo site, and the API pages are written into it by that script.

So the extension point for documentation is the script rather than a hand written file, which means the reference stays in step with the code at the cost of needing a Node and a Hugo toolchain to regenerate it.

## The difference table against Tween is the real specification

The most useful part of the README for an adopter is the table comparing Anima with Tween, because it is specific enough to check against your project.

Chaining: Anima supports sequential, parallel and concurrent animations, while the table says only Godot 4 for Tween. Easing: 33 built-in options with more that can be added programmatically, against limited for Tween. Use Curve as easing: yes for Anima, no for Tween, which is a Godot animation curve resource being usable directly as an easing function. Set pivot point: yes, and 2D only, against no. Create and reuse custom animations: 89 built-in with more that can be added programmatically, against no.

Then the ones that indicate a different data model rather than a different API. Animate elements in groups or grids, yes for Anima, no for Tween. Multiple distance formulas for grid animations, yes against no. Loop, where Anima offers infinite, times and delayed loops while Tween is infinite only. Animate relative values, yes against only Godot 4. Play and loop backwards, yes against no. Dynamic values, yes against no.

Two rows deserve a note. The chaining and relative values rows say only Godot 4 for Tween, which is a statement about the version of the engine rather than about the engine's capability, so a project already on Godot 4 has less to gain there than a project on Godot 3. And the pivot point row is marked 2D only, which is consistent with the UI focus.

If you are evaluating this against Godot's own system, the table is the shortest route to a verdict, and it is more honest than a feature list would be.

## The API in a dozen lines, and where the presets come from

The example in the README is short and shows the whole shape of the library.

```gdscript
var anima = Anima.Node($Node).anima_keyframes({
    from = {
        opacity = 0,
        scale = Vector2(0.5, 0.5),
    },
    to = {
        opacity = 1,
        scale = Vector2.ONE
    },
    easing = Anima.EASING.EASE_OUT_BACK,
})

await anima.play()

anima.play_reverse_with_delay(1)
```

Read it as three things. You target a node, you describe the animation as a dictionary with a from block, a to block and an easing, and you get an object back. The properties you animate are named the way you would name them in the inspector, opacity and scale, and the easing is a named constant from Anima.EASING rather than a curve you build. The play call is awaitable, so a sequence can be written as straight line code, and the reverse-with-delay call is the kind of thing that otherwise turns into a timer and a signal.

The built-in animations have a clear origin. The README credits the original source as the animate.css project, which is where the CSS-like syntax comes from as well as the catalogue of 89 presets, and the difference table notes that more can be added programmatically for both animations and easing options.

That last point is what separates Anima from a preset library. A fixed set of animations would be a lookup table, and a set of animations you can define and reuse in code is a small animation system that happens to come with a catalogue.

## The repository holds a plugin, a docs site and a version 2 experiment

The top level listing shows a repository that is more than the add-on folder, and the extra directories tell you about the project's stage.

There is the addons directory, which holds the plugin you copy into a project. There is a docs directory with the Hugo site and a scripts directory holding the API documentation generator. There is an examples directory with a demo selector scene and a.tscn, and subfolders for the editor, the playground and the demo set. There is a tests directory, and the README links to demo code in a demos path while the repository's own example code lives in an examples directory.

Two directory names are worth a closer look. There is a _mano directory and a _mano_output directory, which look like a generator and its generated output, and there is a v2_stuff directory, which reads as work in progress on a second generation of the library rather than a released v2.

The project files show how the pieces fit together. There is a project.godot, an export_presets.cfg and a default_env.tres, so the repository is itself a Godot project that can be opened and run. The package.json is the docs toolchain, named Anima at version 0.0.1, with the description field left empty, whose only real content is the three documentation scripts and the MIT licence. There is a reference.json, a.gdignore, an icon and logo set, and AGENTS.md and CLAUDE.md at the root next to the LICENSE.

The repository publishes no GitHub releases, so the version a user gets is whatever they copy, which is consistent with the copy-and-activate installation model and with the project's own versioning living in the plugin rather than in a release feed.

## Conclusion

Godot developers who build menus and screens with a lot of motion should try Anima, because the table of differences against Tween is specific and checkable, covering chaining, easing, pivots, grids and dynamic values rather than promising a general animation overhaul. It is the wrong tool if you are animating 3D objects or gameplay timelines rather than UI, and the wrong choice if you need an installable package, since the plugin is a folder you copy by hand. Before adopting, read the differences table in the README against the features your project already uses from Tween, and check the documentation site, because the API reference is generated separately from this repository.

## FAQ

### How do I install the Anima add-on in Godot?

It is a regular editor plugin. Copy the contents of addons/Anima into the same folder in your project, then activate it in your project settings. There is no asset library or package manager step.

### What does Anima add that Godot's Tween does not have?

The README's comparison table lists sequential, parallel and concurrent chaining, 33 built-in easing options, using a Curve as an easing, setting a 2D pivot point, 89 reusable built-in animations, group and grid animation with multiple distance formulas, infinite, times and delayed loops, relative values, playing and looping backwards, dynamic values, and CSS-like syntax.

### Where do Anima's built-in animations come from?

The README credits the animate.css project as the original source of the built-in animations. The difference table also notes that more animations and more easing options can be added programmatically.

### Is Anima limited to Godot 4?

The README does not state a Godot version requirement for the add-on itself, but the comparison table marks chaining and animating relative values as only Godot 4 for Tween, so the engine version matters when weighing the switch. The pivot point feature is marked 2D only.

## Sources

- [ceceppa/anima on GitHub](https://github.com/ceceppa/anima)
- [Issues](https://github.com/ceceppa/anima/issues)
- [License: MIT](https://github.com/ceceppa/anima/blob/main/LICENSE)
- [Project website](https://anima.ceceppa.me/)
- [README](https://github.com/ceceppa/anima/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ceceppa-anima