Cascade vs PrimeTween vs LitMotion for UI Toolkit

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 on this page 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, LitMotion or DOTween for gameplay: use the same library for simple UI Toolkit tweens (DOTween's UI Toolkit shortcuts are newer and smaller, see What about DOTween?). 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

PrimeTweenLitMotionCascade
Built forTransforms, materials, uGUI, also UI ToolkitAny value, very fast (DOTS)UI Toolkit only
Pricefree (PRO edition $32.99 adds Inspector animations)freeLite free; Pro paid
Licensecustom (free for commercial use)MITLite MIT; Pro Asset Store EULA
Unity2018.4+ (per its package)2021.3+6000.0+
DependenciesnoneBurst, Collections, Mathematicsnone
UI Toolkit tweens built inopacity, color, background color, translate/rotate/scale, left/top/width/heightopacity, colors, translate, scale, rotate, transform-origin, left/right/top/bottom, width/height, font size, text, progress baropacity, 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 stylesTween.CustomBindValue
Sequencingyes (Sequence)yes (LSequence, since 2.0)yes (Then(), At(seconds))
Awaityesyesyes
Physics springsno (elastic/overshoot easing)no (elastic easing)Pro
Stagger helperno (use delays)no (use delays)Pro
Shake / punchTransform onlyyes (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 panelno (measured: keeps writing to it)no (measured: keeps writing to it)yes
Reduced motion settingnonoyes (Lite and Pro)
AI coding assistant supportno 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 componentnono (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.Validate returns the exact step, field and a suggested fix for a typo, and Lint flags 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.

SetupRight first timeOutput tokensCost per runLines of code
Cascade 1.2, set-up project10/101,546$0.1442
PrimeTween + its docs10/104,841$0.3887
LitMotion + its docs10/103,636$0.25115
PrimeTween, no docs10/103,466$0.1490
LitMotion, no docs10/102,866$0.12104
No library (plain UI Toolkit)10/103,932$0.15163

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:

SetupRight first timeOutput tokensCost per runLines of code
Cascade 1.2, set-up project5/56,659$0.29153
PrimeTween + its docs5/511,046$0.56212
LitMotion + its docs5/510,134$0.43251
No library (plain UI Toolkit)5/59,422$0.31310

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):

The six tasks (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:

ElementsPrimeTweenLitMotionCascade
1000.1 ms0.1 ms0.1 ms
5000.5 ms0.3 ms0.4 ms
1,0000.8 ms0.5 ms0.7 ms
2,0001.5 ms0.9 ms1.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.

What about DOTween?

DOTween is the most widely used Unity tween library, and since February 2026 (versions 1.2.815 and 1.2.825) it has UI Toolkit shortcuts too. Its documentation lists these for a VisualElement: DOMove, DOMoveX/Y/Z, DORotate, DOScale, DOPunch and DOShake. Its changelog says the move, scale and rotate shortcuts are for Unity 6.3.

  • Covered: moving, scaling, rotating, punching and shaking an element, with DOTween's usual sequences, callbacks and easing.
  • Not in the list: fades, colours, sizes and other styles. For those you'd write a generic DOTween.To tween that reads and writes the style yourself, as with PrimeTween's Tween.Custom.
  • Not mentioned in its docs: springs, a stagger helper, screen transitions, or stopping when an element leaves the panel.

So if your game already uses DOTween, its shortcuts now cover the basic transform moves on UI Toolkit in Unity 6.3 and later. For anything beyond that, or on Unity 6.0 to 6.2, you'd write custom tweens. I haven't tested DOTween in the same project as the other three, so it isn't in the tables above. This section comes from its documentation and changelog, checked November 2026.

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