Features

There are several different animation systems available in Unity:

  • Mecanim is Unity’s main animation system. It uses the Animator component with an AnimatorController asset which is configured using the Animator window and controlled by scripts using Magic Strings.
  • Legacy is Unity’s old animation system. It uses the Animation component which is primarily configured via the Inspector and controlled by scripts using Magic Strings.
  • Simple Animation (Abandoned) is another animation system built by Unity as a minor side project which demonstrates how the Playables API can be used. It attempted to replicate the features of the Legacy animation system and was partially successful, but had several significant issues which were never fixed before the project was abandoned.
  • Animancer is also built upon the Playables API and focuses on giving scripts full control over the animations they use to allow for better management of responsibilities and dependencies.
    • Animancer Lite is the free version of Animancer which allows you to try out all the features for free in the Unity Editor, but disables many of them in runtime builds (indicated by [1] in the table below).
  • The Playables API itself is not included in the table because it is so low-level that it doesn't really qualify as an animation system. It allows you to build animation systems like Animancer, but isn't easily useful on its own.
Animation System Feature Comparison
Mecanim
Legacy
Simple Animation
Animancer Lite
Animancer Pro

Workflow

No need for Animator Controllers

Mecanim requires that all possible animation states be defined upfront in the Unity Editor as part of an Animator Controller asset and imposes severe limitations on your ability to have scripts control things at runtime.

Legacy and Simple Animation are primarily designed around assigning the animations you want to an array in the Inspector, but they do allow scripts to add more animations dynamically at runtime.

Animancer supports both Animator Controllers and assigning animations to an Inspector array, but its main focus is on allowing scripts to play any animation on-demand at runtime without requiring any unnecessary preparation beforehand.

By avoiding the need to define everything upfront, it becomes much easier to play animations from any source such as user created mods.
No need for magic strings

Mecanim, Legacy, and Simple Animation are designed around assigning animations upfront so that scripts need to use Magic Strings to refer to them by name.

Animancer instead focusses on allowing your scripts to be responsible for whatever animations they will be using. If a script wants to play an animation it can just get an AnimationClip and play it on demand rather than specifying a name and relying on that animation to have been assigned somewhere else. Refering to animations by name is still supported though.
Powerful Inspector interface for debugging and testing The AnimancerComponent shows all of its internal details in the Inspector so that you can view and modify their parameters in real time. See the Inspector page for more information.
Configure animation and transition details in Edit Mode with previews

Mecanim allows you to configure details like play speed and transition duration when setting up the Animator Controller and gives you live previews so you can see what everything will look like without entering Play Mode.

Legacy and Simple Animation require you to specify those details in your scripts.

Animancer supports both approaches. You can use Transitions to be able to configure the details in the Inspector or you can control all the same details in a script without any additional setup.
[1]
Use Animation Curves to control custom parameters

If a parameter in an Animator Controller has the same name as a curve in any of the animations it is playing, Mecanim will automatically update that parameter every frame with the value of the curve at the current animation time. If it is blending between multiple animations with the same curve, the value of the parameter will also be blended between them.

Animancer supports the same thing with Animated Properties as demonstrated in the Uneven Ground example. They require Unity 2019.1+, though older versions can use Exposed Curves which are a bit less convenient.
Well documented source code included

Animancer Pro includes the full source code so that you can look through it, debug problems, and make any necessary modifications without being dependant on the author for help.

The Animancer.Lite.dll files in the Pro package are empty dummies to ensure seamless upgrades from Lite to Pro. They contain no code and are not included in builds.

Animancer Lite only includes the source code for AnimancerComponent and the scripts in the Assets/Plugins/Animancer/Utilities folder which includes Animancer.FSM (the entire State Machine system), DirectionalAnimationSet, and ExposedCurve, as well as several others (and of course the full source code of all the example scenes).

Control

Control animation details dynamically (transition duration, speed, time, weight, etc.)

Mecanim encourages you to configure parameter based transitions using the Animator window which then cannot be changed at runtime. It gives you no real control over individual animation weights. It does allow you to control speed and time indirectly by creating a parameter to control them then modifying that parameter, however in the case of time this means that you need to manually update the parameter every frame to keep playing (you cannot simply set the time when you want to change it and let it play normally the rest of the time).

The other systems give scripts access to these parameters without any additional steps.
[1]
Control is immediate and reliable

When you command an Animator Controller (such as changing its state), it will not actually respond until the next time it gets updated and it might not even do what you want. For example, if you call Play then check which state is currently playing it will still return the previous state until the next frame and if you call Play again during the same frame it will ignore each call after the first instead of ending up in the last state you told it to play.

// Currently Playing Idle.
animator.Play("Jump");
// Still playing Idle. Will only be playing Jump next frame.
animator.Play("Attack");
// Will still play Jump next frame. Not going to play Attack at all.

The other systems will respond to commands immediately and can properly handle multiple commands in the same frame.

// Currently Playing Idle.
animancer.Play("Jump");
// Now Playing Jump.
animancer.Play("Attack");
// Now Playing Attack.
Custom event system

All the animation systems mentioned here support Unity's inbuilt Animation Events.

Animancer has its own Event System which is often more convenient to use.
[1]
Begin transitions before the previous animations finish

When configuring a transition in Mecanim or Animancer, you can adjust its timing independantly of the actual end of the animation to tweak the result as you see fit.

Legacy and Simple Animation allow you to queue animations to play or cross fade one after the other, but the transition always occurs when the previous animation finishes.
[1]
Easily wait for animations to finish Animancer supports several easy ways of Waiting for Animations to End, including Events and the ability to simply yield return an AnimancerState in a Coroutine.
Play animations in Edit Mode Animancer allows animations to be played in Edit Mode just as easily as in Play Mode. The Doors example uses this to show how far open each door is when editing the scene.
Access details of animations that aren’t currently playing

Mecanim only allows scripts to access the details of the current state or the next state being transitioned towards.

The other systems give scripts full access to the details of any animation at any time.
Unscaled Time Update Mode All animation systems support Animate Physics and Manual update modes, but only Mecanim and Animancer support Unscaled Time mode which can be useful for things like GUI animations which should always play at their regular speed even while the game is paused.
Easily use Animation Jobs and custom state types Animancer allows you to easily utilise Animation Jobs for low level access to the animation stream as well as creating your own state types by inheriting from AnimancerState (or any of its child classes) so that you can implement custom behaviour. For example, you might inherit from AnimationMixer to implement a new blending algorithm.
[1]

Blending

Smoothly transition between animations over time

Blending between animations over time is often called Cross Fading and is supported by all animation systems.

Animancer Lite doesn't allow you to specify a custom fade duration in runtime builds (you can try out any value in the Unity Editor, but it will only use the default 0.25 seconds in a build).
[1]
Smoothly transition back into an animation that is currently ending

Imagine you want to repeatedly perform an action consisting of a single animation with a smooth transition from the end of one action to the start of the next.

Most systems only allow each state to have one set of values; it can either be near the end and fading out or near the start and fading in, but not both. Attempting to do so will cause it to either snap back to the start without a smooth transition or ignore you completely, depending on the system.

Animancer has a CrossFadeFromStart method which checks if the animation state is still in use and will simply create another state for the same animation if necessary. This allows the new state to fade in from the start while the previous state continues fading out. You could potentially do the same thing with the other systems, but it isn't built in and Mecanim in particular would require significantly more effort because it doesn't allow states to be created dynamically at runtime.

The Playing And Fading example covers this concept in greater detail.
Custom fade curves Animancer has a Custom Fade system which makes it easy to replace the default Linear Interpolation with a different algorithm of your choice.
[1]
Mix and blend between multiple Animator Controllers Mecanim only allows one Animator Controller at a time while Animancer's Controller States allow you to mix multiple controllers with each other and with individual animations controlled directly by scripts.
[1]
Animation Layers

Layers allow you to manage multiple animations at the same time (generally on different body parts). See Layers for more information.

Also note that Animancer and Legacy allow you to change which layer an animation is playing on at runtime while Mecanim does not.
[1]
Blend Trees / Animation Mixers

Blend Trees allow you to interpolate between multiple animations based on a parameter. For example, you might blend between idle, walk, and run based on how fast you want to move so that you can have your character animate appropriately for any speed based on how far the user tilts a joystick instead of only having a few specific speeds you can move at.

Animancer can play Blend Trees inside Animator Controllers, but also has Mixer States which serve the same purpose and allow much greater control over their internal details.
[1]
Root Motion

Traditional animations generally remain fixed in place and rely on other systems to move characters around such as Rigidbodies or Character Controllers. For example, a walk animation would move the character's arms and legs naturally, but the character itself would remain in place as if walking on a treadmil.

Root motion allows animations to move the character around more naturally. This allows you to trade some dynamic scripting control in exchange for more natural motion.
Linear Root Motion Blending

Animancer's Animation Mixers blend linearly between the Root Motion of each animation so that if you blend 50% of the way between two animations, the resulting movement speed will be 50% of the way between them.

For some unknown reason, this is not the case with Blend trees. The Root Motion Interpolation page contains more details.
[1]

Humanoids

Animation Retargeting All animation systems except Legacy allow animations from any humanoid rig to be played on any other humanoid rig.
Animation Mirroring (on import)

The import settings for humanoid animations has a toggle to flip the animation from left to right.

If you need both mirrored and un-mirrored versions of a particular animation, you will need to create two copies of it.
Animation Mirroring (per state) In addition to the import settings toggle, Animator Controllers also have a toggle to allow individual animation states to mirror their animation. This allows you to save some drive space and memory usage if you need both the mirrored and original version of an animation, but it also has a small cost to performance at runtime.
[2] [2]
Inverse Kinematics

The Playables API exposes standard IK features which Mecanim and Animancer can utilise, however Simple Animation does not support these features because it was designed to replicate Legacy which does not support them.

Also note that due to limitations in the Playables API, Unity will only ever call OnAnimatorIK on layer 0 when using Animancer.
Target Matching

Mecanim has a Target Matching system which essentially manages the application of Inverse Kinematics over time.

Unfortunately that system is only usable with Animator Controllers so it does not work with any of the other animation systems.

Finite State Machines

General purpose Finite State Machine

Animator Controllers can be used to manage the gameplay state of an object as part of its animation state.

Animancer is not tied to a specific state machine implementation, but it does include a general purpose Finite State Machine system in the Animancer.FSM namespace which is entirely separate from the animation system and is flexible enough for most needs. They work well together, but you can very easily modify it or use any other system you prefer.

Like Animancer itself, controlling the Animancer.FSM is immediate and reliable. It doesn't need to wait for the next update to respond to your commands. It doesn't actually have an update loop of its own, but you can easily give your states an update method (or methods) for whatever rate you need (Update, FixedUpdate, LateUpdate, etc.)
Visual configuration interface

Mecanim provides a Graphical User Interface for configuring animation states, transitions, and other details in the Unity Editor instead of allowing those details to be controlled using scripts like the other systems. One of the main advantages of this visual interface is the ability to preview the transitions between animations in Edit Mode.

Animancer primarily focusses on the use of scripts to control animations, however it does allow you to create AnimatorController assets using Mecanim's visual interface and play them using Controller States.
[2] [2]
Constructed by scripts The Animancer.FSM system is entirely configured and controlled by scripts so the logic for what happens during a particular state can be defined alongside the logic for when it will transition to other states rather than having some of that logic in an Animator Controller and the rest in scripts.
Structure can change dynamically at runtime

The full structure of an Animator Controller must be defined in the Unity Editor and cannot be changed at runtime

But the Animancer.FSM system can be changed based on any criteria you want and doesn't even need to have all its states defined in the same place or configured on startup.
States can be MonoBehaviour, ScriptableObject, or any other type The only requirement for a class to be used as a state in the Animancer.FSM system is to inherit from IState<TState>. This means they can be MonoBehaviour components to receive updates, collision events, and other messages, or ScriptableObject assets which can be referenced anywhere in the project, or even just regular classes which are fully constructed and managed by scripts.
Inbuilt networking support

Mecanim allows Animator Controllers to be synchronised across a network using the Network Animator component (though that system is now deprecated).

Animancer and the other systems do not have anything similar.

[1] Animancer Lite includes these features in the Unity Editor so you can try them out, but they will not be available in runtime builds unless you purchase Animancer Pro. All Pro-Only features are commented as such and using them will log a message to make sure you are aware of the restriction.

[2] While Animancer itself does not have these features, you can still use them while configuring an Animator Controller for use in a Controller State (Pro-Only, see [1]).

Compatibility

Animancer is based on the Playables API, which means most systems developed for regular Mecanim Animator Controllers should work with it.

Feature Works Description
AnimationClips Yes Any AnimationClip that can be played in an Animator Controller (Humanoid or Generic) can also be played in Animancer so any source of animations or animation editor will be fully compatible. See the Getting Animations page for a list of common ways to get and create them.
LateUpdate Yes Scripts that modify the animated objects separately from the animations will work exactly the same as usual. This includes plugins like Final IK and Dynamic Bone.
OnAnimatorIK Yes You can enable IK by setting AnimancerLayer.ApplyAnimatorIK = true instead of enabling the IK Pass toggle in an Animator Controller. Note that the layer index will always be 0. See Inverse Kinematics for more details.
Unity's Animation Rigging package Yes Seems to work out of the box, but the package is currently in preview so anything could change. The official Working with Animation Rigging tutorial explains how to use it.
Curve Driven Parameters No Anything that uses an Animator Controller Parameter to access the value of an animation curve at runtime will not work directly, but the same can be achieved by using an ExposedCurve to extract the curve from the AnimationClip in the Unity Editor so that it can be accessed at runtime. See the Exposed Curves section for more details.
StateMachineBehaviour No StateMachineBehaviours will not work with Animancer unless you use a ControllerState to play an actual Animator Controller. See Finite State Machines for details about the state machine system included with Animancer.