If you search for a way to animate Unity UI Toolkit, three libraries come up: PrimeTween, LitMotion and Cascade. All three can fade and move a VisualElement. They were built for different jobs, and that shows once your UI gets bigger than one button.
Disclosure: I make Cascade. I've tried to be fair to the other two. Every claim about PrimeTween and LitMotion below comes from their source code and docs (PrimeTween 1.5.2, LitMotion 2.0.2, checked November 2026). The Cascade version is 1.2. Every code sample here was compiled and run in one Unity 6000.4 project with all three libraries installed, and checked against what the text says it does. If something is wrong or out of date, tell me and I'll fix the page.
The short answer
- Your project already uses PrimeTween or LitMotion for gameplay: use the same library for simple UI Toolkit tweens. One tween library is easier than two.
- You need the fastest possible tweens for thousands of objects: LitMotion (Burst and the Job System) or PrimeTween. In my UI Toolkit benchmark below, LitMotion was the fastest, Cascade second and PrimeTween third.
- Your UI is built in UI Toolkit and has a lot of motion (screens that come and go, lists, interruptible buttons, springs): Cascade was written for exactly that.
- You write most of your UI code with an AI assistant: Cascade is the only one of the three with official assistant support. See AI coding assistants.
- You're on Unity 2022 or older: Cascade needs Unity 6, so pick PrimeTween or LitMotion.
At a glance
| PrimeTween | LitMotion | Cascade | |
|---|---|---|---|
| Built for | Transforms, materials, uGUI, also UI Toolkit | Any value, very fast (DOTS) | UI Toolkit only |
| Price | free (PRO edition $32.99 adds Inspector animations) | free | Lite free; Pro paid |
| License | custom (free for commercial use) | MIT | Lite MIT; Pro Asset Store EULA |
| Unity | 2018.4+ (per its package) | 2021.3+ | 6000.0+ |
| Dependencies | none | Burst, Collections, Mathematics | none |
| UI Toolkit tweens built in | opacity, color, background color, translate/rotate/scale, left/top/width/height | opacity, colors, translate, scale, rotate, transform-origin, left/right/top/bottom, width/height, font size, text, progress bar | opacity, translate, scale, rotate, colors, width/height, left/top/right/bottom, border radius/width/color, font size, padding, background-image tint, slide-in from an edge, any float |
| Other styles | Tween.Custom |
Bind |
Value |
| Sequencing | yes (Sequence) |
yes (LSequence, since 2.0) |
yes (Then(), At(seconds)) |
| Await | yes | yes | yes |
| Physics springs | no (elastic/overshoot easing) | no (elastic easing) | Pro |
| Stagger helper | no (use delays) | no (use delays) | Pro |
| Shake / punch | Transform only | yes (float/Vector values, bind to any style) | yes: Shake, Punch (Lite); PunchScale, PunchRotate, Pulse, Wiggle, Pop (Pro). Additive, always end at rest |
| Stops when the element leaves the panel | no (measured: keeps writing to it) | no (measured: keeps writing to it) | yes |
| Reduced motion setting | no | no | yes (Lite and Pro) |
| AI coding assistant support | no official support (community-made agent skills exist) | no official support (community-made agent skills exist) | official agent skill, AI guide in the package, compile-time code checks; Pro: validated JSON animations |
| Screen transitions, hover/press, no-code component | no | no (the Inspector component has no UI Toolkit tracks) | Pro |
The same animation in all three
A panel fades in while it slides up 40 px, a common way to show a window.
PrimeTween
using PrimeTween;
Tween.VisualElementOpacity(panel, startValue: 0f, endValue: 1f, duration: 0.3f, ease: Ease.OutCubic);
Tween.Position(panel, startValue: new Vector3(0, 40, 0), endValue: Vector3.zero, duration: 0.3f, ease: Ease.OutCubic);
Tween.Position, Rotation and Scale accept a VisualElement and write style.translate, rotate and scale on Unity 6.2 and newer.
LitMotion
using LitMotion;
using LitMotion.Extensions;
LMotion.Create(0f, 1f, 0.3f).WithEase(Ease.OutCubic).BindToStyleOpacity(panel);
LMotion.Create(new Vector2(0, 40), Vector2.zero, 0.3f).WithEase(Ease.OutCubic).BindToStyleTranslate(panel);
Every motion takes an explicit start value. LitMotion has the widest set of built-in style bindings of the three.
Cascade
using Cascade;
panel.Animate()
.Fade(1f, 0.3f).From(0f).Ease(Ease.OutCubic)
.MoveY(0f, 0.3f).From(40f).Ease(Ease.OutCubic);
Without From(), Cascade starts from the value the element has on the frame the animation begins, including values that come from USS.
A sequence: fade in, then pop
PrimeTween
Sequence.Create()
.Chain(Tween.VisualElementOpacity(panel, startValue: 0f, endValue: 1f, duration: 0.2f))
.Chain(Tween.Scale(panel, endValue: new Vector3(1.1f, 1.1f, 1f), duration: 0.2f, ease: Ease.OutBack))
.ChainCallback(() => Debug.Log("done"));
LitMotion
LSequence.Create()
.Append(LMotion.Create(0f, 1f, 0.2f).BindToStyleOpacity(panel))
.Append(LMotion.Create(Vector3.one, new Vector3(1.1f, 1.1f, 1f), 0.2f).WithEase(Ease.OutBack).BindToStyleScale(panel))
.Run(b => b.WithOnComplete(() => Debug.Log("done")));
Cascade
panel.Animate()
.Fade(1f, 0.2f).From(0f)
.Then()
.ScaleTo(1.1f, 0.2f).Ease(Ease.OutBack)
.OnComplete(() => Debug.Log("done"));
All three read well. All three can also place a tween at an exact time inside a sequence: PrimeTween and LitMotion with Insert, Cascade with At(seconds).
Where the differences show up
When the element leaves the screen
PrimeTween stops a tween when its target is a destroyed UnityEngine.Object, and LitMotion links motions to a GameObject with AddTo. A VisualElement isn't a Unity object, so neither check applies. Neither library listens for an element being removed from its panel, so when a screen closes or a list row is recycled mid-tween, stop it yourself. I measured it: a 2-second fade, with the element removed after 0.3 s, keeps changing the removed element's opacity in both libraries.
// PrimeTween
panel.RegisterCallback<DetachFromPanelEvent>(_ => Tween.StopAll(onTarget: panel));
// LitMotion: keep the handles and cancel them
panel.RegisterCallback<DetachFromPanelEvent>(_ => handle.TryCancel());
Cascade cancels an animation when its element leaves the panel and never writes to an element that isn't displayed. In a UI with many screens, that's the bug class I most wanted to remove.
Interrupting an animation
Buttons and drawers get interrupted all the time: hover out before the hover-in finishes, close a drawer while it's opening. With PrimeTween or LitMotion you stop the old tween and start a new one, usually from the current value. The new tween starts from rest, so the motion visibly loses its momentum.
Cascade Pro has physics springs. A spring that gets a new target keeps its current velocity, so the motion bends toward the new target instead of restarting:
drawer.Animate().MoveX(open ? 0f : -320f, 0f).Spring(SpringPreset.Snappy);
Neither PrimeTween nor LitMotion has a velocity-based spring. Their elastic and overshoot easings look springy on a single run, but they restart on interruption.
Lists
Making ten items enter one after another is a loop with a growing delay in PrimeTween (startDelay) or LitMotion (WithDelay). That works well. Cascade Pro has a helper for it:
items.AnimateEach().Fade(1f, 0.3f).From(0f).MoveY(0f, 0.3f).From(16f).Stagger(0.05f);
Reduced motion
Cascade has a global setting, MotionSettings.Mode: Reduced shortens animations and removes bounce, Crossfade replaces movement with fades, and None jumps to the end state but still fires OnComplete, so code that waits on an animation keeps working. Connect it to a "reduce motion" option in your settings menu. PrimeTween and LitMotion have no equivalent; you'd add the checks yourself.
AI coding assistants
A lot of UI code is now written by asking Claude Code, Cursor, Copilot or Codex. How well that goes depends on what the assistant knows about the library.
PrimeTween and LitMotion have been public since 2023 and 2024, so assistants have seen plenty of code that uses them. Neither project ships official assistant material, but community-made agent skills for both exist on GitHub. The catch for UI Toolkit is that most of that code animates Transforms, so assistants tend to reach for transform APIs, and don't know which VisualElement methods exist in the version you have.
Cascade is new, so an assistant without help will guess its API. To fix that, it ships three things:
-
An official agent skill (
npx skills add twitchedd/cascade-skill) for any agent that reads SKILL.md files. It checks whether your project has Lite or Pro and writes only code that tier can compile. -
An AI guide inside the package (
Documentation~/AI-GUIDE.md, both tiers), so the assistant reads instructions that match your installed version. -
Validated JSON animations (Pro). An assistant can describe an effect as JSON;
SequencePreset.Validatereturns the exact step, field and a suggested fix for a typo, andLintflags animations that would do nothing, such as a fade-in without a start value. The assistant can correct itself before you ever press Play.
Here's what that looks like. An assistant writes this entrance, with a verb name that doesn't exist:
{ "steps": [ { "actions": [
{ "verb": "SlideIn", "edge": "Bottom", "distance": 40, "duration": 0.4, "ease": "OutCubic" },
{ "verb": "FadeIn", "to": 1, "duration": 0.4, "ease": "OutCubic" }
] } ] }
Validate says where the mistake is and what to use instead:
MotionError err = SequencePreset.Validate(json);
// err.Path → steps[0].actions[1].verb
// err.Suggestion → Fade
After the assistant renames it to Fade, the JSON is valid, but the fade still has no start value, so it would fade to where it already is and nothing would appear to happen. LintSummary catches that:
steps[0].actions[1]: 'Fade' animates to 1, which is where the element already rests, and nothing earlier in this sequence moved it — so this action will run and change nothing — add "from" to say where it starts (e.g. "from": 0), or drop the action
Adding "from": 0 clears both checks. All three messages above are the real output of Cascade.
I tested how much this matters. Claude Opus 5.5, running headless in Claude Code with no web access, wrote six common UI Toolkit animations: a panel entrance, a fade-then-pop sequence, a staggered list, a drawer that can be reversed mid-move, an endless pulse that stops when the element is removed, and an error shake. Every answer was compiled and run in Unity against a check for each task. When an answer failed, the compiler errors or failed checks went back to the model until it passed, and every token of every round was counted. Each setup ran 10 times.
The first round caught three mistakes in Cascade's own AI guide. It didn't say that Loop() repeats only the step right before it, it called Delay() a wait when it delays the step before it, and one example used a method overload that doesn't exist. Only 5 of 10 Cascade answers were right first time. I fixed the guide in the current Cascade 1.2, and the numbers below are from the fixed guide.
Each library got the setup you'd give it in practice. PrimeTween and LitMotion ship no assistant setup, so the model got each library's official docs plus a list of its UI Toolkit methods, and separately no docs at all, since it already knows both. Cascade ran in a Unity project with the package installed and its Set Up AI Assistants menu already run, which writes a short Cascade section into CLAUDE.md pointing at the guide in the package. Its prompt didn't mention any docs.
| Setup | Right first time | Output tokens | Cost per run | Lines of code |
|---|---|---|---|---|
| Cascade 1.2, set-up project | 10/10 | 1,546 | $0.14 | 42 |
| PrimeTween + its docs | 10/10 | 4,841 | $0.38 | 87 |
| LitMotion + its docs | 10/10 | 3,636 | $0.25 | 115 |
| PrimeTween, no docs | 10/10 | 3,466 | $0.14 | 90 |
| LitMotion, no docs | 10/10 | 2,866 | $0.12 | 104 |
| No library (plain UI Toolkit) | 10/10 | 3,932 | $0.15 | 163 |
The numbers are medians of 10 runs. Cost is what Claude Code reported, at list API prices.
A bigger task tells the same story: a settings screen with a modal that can be reopened while it's closing, a toggle, a toast that stays up while it's re-triggered, a number that counts up, and press feedback. Each setup ran 5 times:
| Setup | Right first time | Output tokens | Cost per run | Lines of code |
|---|---|---|---|---|
| Cascade 1.2, set-up project | 5/5 | 6,659 | $0.29 | 153 |
| PrimeTween + its docs | 5/5 | 11,046 | $0.56 | 212 |
| LitMotion + its docs | 5/5 | 10,134 | $0.43 | 251 |
| No library (plain UI Toolkit) | 5/5 | 9,422 | $0.31 | 310 |
What I take from it:
- Every setup got every task right in the end, so this compares cost, not ability.
- Cascade's answers were the shortest and used the fewest output tokens, because one fluent call covers what takes a loop or a helper in the others.
- In dollars, a set-up Cascade project cost about the same as plain UI Toolkit or PrimeTween without docs. LitMotion without docs was the cheapest on the small tasks, about 13% cheaper than Cascade. Giving PrimeTween or LitMotion their docs made them the most expensive, because reading the docs is most of the cost.
Here's one Cascade answer, exactly as the model wrote it:
public static void EnterPanel(VisualElement panel)
{
panel.Animate()
.Fade(1f, 0.3f).From(0f).Ease(Ease.OutCubic)
.MoveY(0f, 0.3f).From(40f).Ease(Ease.OutCubic);
}
public static void FadeThenPop(VisualElement panel, Action onDone)
{
panel.Animate()
.Fade(1f, 0.2f).From(0f)
.Then()
.ScaleTo(1.1f, 0.2f).From(1f).Ease(Ease.OutBack)
.OnComplete(onDone);
}
public static void StaggerIn(IList<VisualElement> items)
{
// From(0) is applied to every item immediately, so not-yet-started items stay invisible.
items.AnimateEach().Fade(1f, 0.3f).From(0f).Stagger(0.05f);
}
public static void SetDrawerOpen(VisualElement drawer, bool open)
{
// MoveX replaces any running MoveX and continues from the current value.
drawer.Animate().MoveX(open ? 0f : -320f, 0.3f).Ease(Ease.OutCubic);
}
public static void PulseForever(VisualElement badge)
{
// Cascade cancels animations automatically when the element leaves the panel.
badge.Animate().ScaleTo(1.1f, 0.5f).From(1f).Ease(Ease.InOutSine).Loop(LoopMode.PingPong);
}
public static void ShakeOnError(VisualElement field)
{
field.Animate().Shake(10f, 0.4f);
}
This was the prompt for PrimeTween with docs. The others changed only the library name and namespace. The no-docs runs replaced the docs sentence with “You have no documentation for the library: write it from what you already know about its API.” Cascade's runs had no docs sentence, and the plain UI Toolkit runs were told to use only built-in UI Toolkit APIs.
Using PrimeTween 1.5.2 (com.kyrylokuzyk.primetween), complete the six tasks in tasks.md (read it). Use the namespace AiTok.s_PTdocs_01. The file docs.md in this folder is the library's documentation; read it first and rely on it. Do not search the web. Write your answer as a single C# file named Tasks.cs in the current folder, then reply with one line saying you are done.
And the six tasks it was given (tasks.md):
# Six Unity UI Toolkit animation tasks
Write one C# file that compiles in a Unity 6 project with the library installed. Use this exact shape
(replace NAMESPACE with the namespace you were given; keep the class and method names and signatures):
~~~csharp
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UIElements;
// add the library's using directives
namespace NAMESPACE
{
public static class Tasks
{
public static void EnterPanel(VisualElement panel) { ... }
public static void FadeThenPop(VisualElement panel, Action onDone) { ... }
public static void StaggerIn(IList<VisualElement> items) { ... }
public static void SetDrawerOpen(VisualElement drawer, bool open) { ... }
public static void PulseForever(VisualElement badge) { ... }
public static void ShakeOnError(VisualElement field) { ... }
}
}
~~~
All elements are already in a visible UIDocument panel. Durations are in seconds. Each method starts the
animation and returns immediately (no blocking, no coroutines that the caller must start).
1. **EnterPanel**: the panel fades in from opacity 0 to 1 and slides up from 40 px below its resting
position (translate Y from 40 to 0), both over 0.3 s with an ease-out cubic curve.
2. **FadeThenPop**: fade the panel from opacity 0 to 1 over 0.2 s; when that finishes, scale it from 1 to
1.1 over 0.2 s with an "out back" ease; when the scale finishes, call `onDone` exactly once.
3. **StaggerIn**: every item fades from opacity 0 to 1 over 0.3 s. Item i starts 0.05 × i seconds after
item 0 (item 0 starts immediately). Items that haven't started yet must be invisible (opacity 0).
4. **SetDrawerOpen**: move the drawer horizontally (translate X) to 0 when `open` is true and to -320 when
false, over 0.3 s with an ease-out curve. It may be called again while the previous call is still
animating: the drawer must then continue smoothly from wherever it is now (no jump) to the new target,
and the old animation must not keep fighting it.
5. **PulseForever**: scale the badge from 1 to 1.1 and back, continuously (0.5 s each way), forever. When
the badge is removed from the hierarchy, the animation must stop (nothing keeps writing to it).
6. **ShakeOnError**: shake the field horizontally (translate X), up to about 10 px either side, for about
0.4 s, ending exactly at translate X = 0 (it starts at 0).
It's one model in one tool, Claude Code with Opus 5.5, so other assistants may land differently. Where medians are within a few cents of each other (Cascade, PrimeTween without docs, plain UI Toolkit), the run-to-run ranges overlap, so treat those as about equal.
Details are on the AI assistants page.
Raw speed
LitMotion runs on Burst, and PrimeTween is built to make zero allocations. I measured all three on UI Toolkit: a release (Mono) player on an Apple M-series Mac, N elements each animating opacity and translate X back and forth forever, the same curve and timing in every library, 5 seconds measured after a 2-second warm-up, 3 runs each. The numbers are the extra milliseconds per frame over the same elements with no animation:
| Elements | PrimeTween | LitMotion | Cascade |
|---|---|---|---|
| 100 | 0.1 ms | 0.1 ms | 0.1 ms |
| 500 | 0.5 ms | 0.3 ms | 0.4 ms |
| 1,000 | 0.8 ms | 0.5 ms | 0.7 ms |
| 2,000 | 1.5 ms | 0.9 ms | 1.3 ms |
None of the three allocated any memory per frame. The player's frame timer moves in 0.1 ms steps, so treat a difference of 0.1 ms as a tie. LitMotion is the fastest, Cascade is in between, and for typical UI, where tens of elements move at once, the difference doesn't matter: all three cost about 0.1 ms.
Where Cascade is the weaker choice
- Unity 6 only. Projects on 2022 LTS or older can't use it.
- UI Toolkit only. It doesn't animate Transforms, uGUI or materials. If you need those too, you'll have a second library anyway.
- Springs, stagger, transitions and the no-code component are paid. PrimeTween and LitMotion are free. Cascade Lite is free and MIT licensed, and covers the tweens, sequences, await and reduced motion.
- Younger and smaller. PrimeTween and LitMotion have years of use and large communities. Cascade launched in 2026.
- Assistants don't know it by default. With no setup, an assistant guesses Cascade's API, while it already knows PrimeTween and LitMotion. One menu in the package fixes that, but it's a step the other two don't need.
Which one should you pick?
- A few UI Toolkit tweens in a game that already uses PrimeTween or LitMotion: keep it.
- Performance-critical tweening of many objects: LitMotion.
- A simple, free, well-documented tween API for everything: PrimeTween.
- A UI Toolkit interface with a lot of motion: start with Cascade Lite (free), and move to Cascade Pro if you need springs, stagger or screen transitions.
Sources
- PrimeTween: GitHub (README, changelog, benchmarks) and the 1.5.2 package source.
- LitMotion: GitHub (2.0.2 source,
LitMotionUIToolkitExtensions.cs) and its docs. - Cascade: the Cascade docs and the API reference.
Top comments (0)