6 releases (breaking)

new 0.6.0 Jul 8, 2024
0.5.0 Jun 8, 2024
0.4.0 Apr 8, 2024
0.3.1 Apr 4, 2024
0.1.3 Mar 6, 2024

#121 in Game dev

Download history 20/week @ 2024-03-17 1/week @ 2024-03-24 198/week @ 2024-03-31 141/week @ 2024-04-07 15/week @ 2024-04-14 4/week @ 2024-04-21 12/week @ 2024-05-19 1/week @ 2024-05-26 138/week @ 2024-06-02 83/week @ 2024-06-09 15/week @ 2024-06-16 1/week @ 2024-06-23

224 downloads per month


2.5K SLoC

Crates.io Version Crates.io License Docs.rs


Bevy procedural and keyframe animation library.

This is a young plugin and APIs are to be fleshed out. Breaking changes are to be expected!

See changelog here.


  • Ergonomic and user-friendly API: You can always spawn the animator manually but this crate provide APIs that abstracted over most boilerplate code. Animation can be built using the builder with function combinators.

    let sprite_id = commands.spawn(SpriteBundle { ... }).id();
    let sprite = sprite_id.into_target();
            sprite.with(translation(pos0, pos1))

    You can also abstract animation!

    fn my_animation(
        target: TargetComponent,
        duration: Duration
    ) -> impl FnOnce(&mut AnimationCommands, &mut Duration) {
            tween(duration, EaseFunction::QuadraticOut, target.with(translation(...))),
            tween(duration, EaseFunction::QuadraticOut, target.with(rotation(...))),
    let sprite_id = commands.spawn(Sprite { ... }).id();
    let sprite = sprite_id.into_target();
    commands.animation().insert(my_animation(sprite, Duration::from_secs(1)))
  • Flexible and Extensible: This crate is built on top of bevy_time_runner which mean we can extend this crate by adding any components and systems.

    • Tween anything from anywhere, built-in or custom system.
    • Interpolate with any curve, built-in or custom system.
    • Anything else.
  • Parallelism: Tweens are typed and can be query over by their typed system which increase chances for system parallelism.

  • Rich timer control:

    • Looping
    • Time scaling
    • Skip backward or forward
    • Jumping to anywhen

See demos


  • Flexible 🎉
  • integration with other crates (?)
    • bevy_animation
    • bevy_lookup_curve
  • Editor. While the original goal for this crate is tweening from code, this crate absolutely has the capability to work on any complex animations. The editor will aid in such jobs.
    • Real-time display at any point in time in the animation.
    • Editing path from point A to point B with arbitary curve.


The main motivation for this tweening crate is that the previous existing tweening crates is not flexible enough and so the main goal is to solve it.

Differences to bevy_tweening or bevy_easings:

  • Tweening is not tied to a certain entity. You can create an entity specifically for tweening any where in the world.
  • Complex animations, such as sequential or parallel tweening, are solved using child-parent hierarchy:
    • Solved the issue of modifying animation at runtime presents in the previous crates.
    • Everything exists in the ECS world with no hidden structure, everything can be freely accessed.
    • Makes a very extendable system, thanks Bevy's ECS!
    • It's possible to have multiple Interpolator (or Lens if you came from bevy_tweening) tweening the same component/asset/resource because of the design of this crate and so it is not limited by '1 component type per entitiy'.
  • Advanced timer. This crate has custom timer implementation.
  • Dependency injection. Systems communicate through various specific components, allowing you to extends the behavior to your needs by supplying those components and reduce duplication.
  • Users of this crate are free to decide if they want to only use generic, only trait object, or even both for tweening, or even something else entirely.

Feature gates

  • Defaults
    • bevy_asset
      Add tweening systems for asset.
    • bevy_render
      Currently add nothing but required by the bevy_sprite feature.
    • bevy_sprite
      Add some built-in interpolators related to sprite.
    • bevy_ui
      Add some built-in interpolators related to ui.
    • bevy_eventlistener
      Add entity-targeted events with bevy_eventlistener.
  • Optional

Bevy Version Support

bevy bevy_tween
0.14 0.6
0.13 0.2–0.5


  • bevy_tweening

    The first crate I discovered and tried to do tweening with in Bevy. Their method of Lens is great and so it's present in this crate. Now called Interpolator. Usages may be similar but is implemented differently.

  • godot

    Godot's tween make it simple to animate something which is the inspiration for this crate. The multi-entity architecture is mainly inspired by Godot's node child-parent hierarchy system and that most of the engine APIs utilizes this to define behavior.


Contributions are welcome!


Licensed under either of

at your option.

Your contributions

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


cargo run --example follow -F bevy/bevy_winit
A square will follow your circle with configurable animation.


cargo run --example click -F bevy/bevy_winit
Click left to spawn a circle. Hold right click to repetitively spawn a circle every frame.


cargo run --example hold -F bevy/bevy_winit
Hold left click to increase the effect intensitiy.


cargo run --example event -F bevy/bevy_winit
Showcasing the tween event feature.


cargo run --example sprite_sheet -F bevy/bevy_winit
Sprite Sheet animation.



~1M SLoC