Animatron

This package includes high performance, modular and scalable animation systems. It is developed with DOTS in mind. As result, it takes advantage of Unity's latest technology stack like SIMD mathematics, Jobs, Burst compiler, EntityComponentSystem and EntityGraphics. Additionally, there is hybrid mode support that enables using it with GameObjects in Object Oriented Programming.

This lightweight animation system is designed with performance and flexibility at its core. Built to be easily extendable, it provides a solid foundation for developers who want full control over their animation pipeline. The system is modular by design—only the features you need are active, ensuring minimal overhead and no wasted resources. Whether you're building something simple or highly customized, this package offers the freedom to tailor it to your specific needs without paying the cost of unused functionality.

This package is designed to work with both concepts DOD (Data oriented design) and OOP (Object oriented programming). Both share the same authoring components.

Animatron vs Animator

Animatron primarily, and most importantly, delivers significantly better performance compared to the Unity Animator. In certain cases, Animatron can have up to 8x lower CPU cost than Animator. However, it's important to understand that much of this performance gain comes from Animatron being designed with more targeted solutions, rather than attempting to solve every use case. Below are the key restrictions of Animatron that enable these optimizations:

• Animation Data Format:
  The Animator stores animation data in curves, which can include not only transformation data but also a wide variety of other properties like light intensity and more—typically features of the FBX format. As a result, Animator must resolve these curves at runtime and bind them to the appropriate properties, adding substantial overhead. In most games, this is unnecessary, as non-transform properties are usually not driven by animations. Animatron takes advantage of this by storing only transformation data, significantly reducing complexity and runtime cost.

• Bone Hierarchy Representation:
  In Unity, the imported FBX bone structure is represented as GameObjects. Therefore, the Animator must use GameObjects and their Transform components for animation, introducing all the associated overhead. Animatron, on the other hand, stores the bone hierarchy in a simple array and minimizes transformation calculations to the bare minimum, avoiding much of that overhead. You can still access bone transforms at runtime for things like attachments.

• Mesh Skinning Method:
  In Unity, mesh deformation (skinning) happens either on the CPU or in compute shaders, rather than in the vertex shader. Both approaches have their advantages and disadvantages. Unity chooses this method for shader simplicity, as handling skinning in the vertex shader would require supporting it across all shader variants, including custom user shaders. Another benefit is that in multi-pass shaders, skinning done once outside the vertex pipeline can reduce GPU cost.
  However, there are major downsides:

  • Each skinned mesh instance requires a unique mesh, preventing the use of GPU instancing, which is highly efficient for reducing CPU load.
  • CPU skinning is extremely expensive.
  • Compute shader skinning is typically not optimal on tile-based GPUs (e.g., on mobile devices).

  For these reasons, Animatron performs skinning directly in the vertex shader, avoiding the downsides of compute or CPU-based skinning.

Animatron vs Other DOTS Animation Solutions

There are other excellent DOTS-based animation solutions on the Asset Store that serve their use cases well. Animatron focuses on the following points, and it's important for users to evaluate whether these align with their needs:

• Support for Hybrid Workflow:
  Designed for users who don't want to work directly with Entities. This approach follows the success of the Agents Navigation Package, offering a familiar workflow while still leveraging DOTS under the hood.

• Simple, Fast, Lightweight:
  Aims to provide a streamlined solution for playing animations without the bizarre overhead often found in more general-purpose systems.

• Scalable Foundation with Performance in Mind:
  Offers a highly customizable animation foundation with maximum performance in mind. Even in hybrid mode, the package uses Entities for the backend. Extending the system will require ECS knowledge—but your game logic does not need to be ECS-based. This design choice is intentional to ensure performance is not compromised.

• Seamless Unity Integration:
  Follows Unity's UI/UX best practices and integrates cleanly with the existing graphics and DOTS tech stack for a smooth development experience.

Quick Start

For minimal quick setup check tutorial Hello Animatron.

Note

Note: It's highly recommended to check out the Architecture page for a deeper understanding of how this package works internally.

Dependencies

• Minimum Unity 2022.3 version
• Package com.unity.entities.graphics

Support

If you have questions, bugs or feature requests use Discord.