Every game character eventually accumulates a bloated Blender file: walk, run, idle, jump, attack, death — each crammed into one timeline. Without a proper clip management system, accidental edits bleed between actions, exports break, and tracking which take is final becomes guesswork. The NLA (Non-Linear Animation) Editor solves all of this. Here's how to use it correctly for a game pipeline.
What Actions and the NLA Editor Actually Are
In Blender, each named group of keyframes on an armature is called an Action. Think of an Action like a clip: `Idle`, `Walk_Cycle`, `Jump`, `Attack_Slash`. By default, Blender only lets you edit one active Action at a time via the Dope Sheet > Action Editor.
The NLA Editor layers these clips non-destructively on NLA Tracks. You can preview multiple animations in sequence, override specific bones with additional tracks, lock a clip so it can't be accidentally edited, and control which Actions are included in a GLB or FBX export.
The key mental model: Actions are your raw clips; NLA Tracks are where you arrange and lock them for export. This distinction matters when troubleshooting what ends up inside an exported file.
Organizing Your Animation Action Library
Before touching the NLA, get your Action library in order. Go to the Dope Sheet, switch to Action Editor mode, and verify every animation is properly named. Use a consistent convention:
```
CH_Player_Idle_Loop
CH_Player_Walk_F_Loop
CH_Player_Run_F_Loop
CH_Player_Jump_Start
CH_Player_Jump_Land
CH_Player_Attack_01
```
Prefix with the character abbreviation (`CH_Player`) so the list stays filterable in both Blender and the game engine's asset browser. Enable the Fake User (shield icon) on every Action you want to keep. Without a Fake User, Blender purges unreferenced Actions on save — a common source of mysteriously missing clips.
You can bulk-protect all actions at once from the Python console:
```python
import bpy
for action in bpy.data.actions:
action.use_fake_user = True
print(f"Protected {len(bpy.data.actions)} actions")
```
Run this script after adding any new animation. It's cheap to run and prevents data loss.
Pushing Actions to NLA Tracks
Select your armature and open the NLA Editor. For each Action:
- Make sure the Action is active in the Action Editor
- In the NLA Editor, locate the action strip that appears under the armature object
- Click the Push Down button (down arrow icon next to the action name) — this bakes the Action into an NLA strip on its own track
- Press Tab on the strip to exit tweak mode if it's still editable
Each pushed strip is now locked and independent. Place each strip at frame 0 on its own track — no need to sequence them end-to-end unless you're building a cutscene. Name tracks to match their Action for clarity.
Do not overlap strips on the same track unless you intend blended playback. Overlapping strips cause unexpected export artifacts in both Unity and UE5.
For export readiness, verify this NLA state before any export run:
| Check | Status |
|---|---|
| All Actions have Fake User | ✅ |
| All strips are in Tweak-Off mode | ✅ |
| No strips overlapping on same track | ✅ |
| Armature scale applied (`Ctrl+A > All Transforms`) | ✅ |
| Frame range matches action duration | ✅ |
Exporting Animations as GLB for Unity
Unity's native GLB importer (via glTFast) reads embedded animation clips automatically. In Blender's File > Export > glTF 2.0 dialog, expand the Animation section and configure:
- Export animations: ✅ Enabled
- Bake All Actions: ✅ Enabled — this exports every Fake-User-protected Action as a named clip regardless of NLA track state
- Sampling rate: 24 or 30 fps (match your project's frame rate)
- Force sampling: ✅ Enabled — avoids Euler gimbal issues on complex rigs
- NLA strips: Disabled (Bake All Actions supersedes this)
In Unity, after import, select the GLB in the Project window and open the Rig tab. Set Animation Type to Humanoid if you're using Mecanim, or Generic for custom rigs. All embedded clip names appear in the Clips tab automatically — exactly as named in Blender.
Importing Multi-Animation Assets into Unreal Engine 5
UE5 imports GLB via the native glTF importer (enable in Edit > Plugins > glTF Importer). Drag the GLB into the Content Browser. In the import dialog:
- Set Skeleton to your existing Skeleton asset if re-importing for an existing character
- Enable Import Animations
- UE5 creates one AnimSequence asset per embedded clip — names are pulled directly from the GLB, so clean Blender naming pays off immediately
For FBX export to UE5, use these settings in Blender:
```
File > Export > FBX (.fbx)
Apply Modifiers: ✅
Bake Animation: ✅
All Actions: ✅
Step: 1
Simplify: 0.0
Object Types: Armature, Mesh
Forward: -Y Forward
Up: Z Up
```
Each Action bakes into a separate FBX animation take. UE5 imports these as individual AnimSequence assets, which you assign to Blend Trees, State Machines, or Animation Montages inside the Animation Blueprint.
Scale is the most common import failure: Blender works in meters, UE5 in centimeters (100:1 ratio). Always apply all transforms in Blender before export (`Ctrl+A > All Transforms`) — UE5's import dialog has a Scale field but relying on it causes inconsistencies across skeleton and mesh imports.
Pre-Export Checklist
Before any final animation export:
- [ ] All Actions have Fake User enabled
- [ ] Action names follow convention with no spaces or special characters
- [ ] Root bone intent confirmed: root motion vs. in-place loop
- [ ] All transforms applied on armature (`Ctrl+A > All Transforms`)
- [ ] No accidental strip overlaps in NLA
- [ ] Test import into a blank engine project before committing
- [ ] Verify clip count in engine matches clip count in Blender
The clip count check catches a common issue where Blender exports an empty `ArmatureAction` placeholder alongside your real clips — filter these out by name in the engine or delete them from the Blender Action list before export.
Ship It
The NLA Editor turns a chaotic Blender file into a structured, export-ready animation library. Naming Actions consistently, protecting them with Fake Users, and locking them into NLA tracks eliminates the vast majority of multi-animation import failures in both Unity and UE5. Build this workflow once, and it scales to characters with 50+ clips without friction.
Need rigged characters with production-ready animation sets already organized for export? Browse the BitSoul marketplace for assets that drop straight into your Unity or Unreal pipeline — no cleanup required.