Animations Export Blender to Unity

A modder finishes a fire-cycle animation in Blender, exports an FBX, drags the file into Unity, and discovers that the bones are oriented sideways, the animation does not play, or the rig type is wrong for the Unturned™ weapon script. The animation looked correct in Blender; it does not look correct in Unity. The most common cause is a small set of export settings and bone-naming conventions that are easy to get wrong on the first attempt.

This article documents the cohort-validated workflow that 57 Studios™ uses to move armature animations from Blender into Unity 2022.3 for Unturned™ mods. The workflow covers bone naming, armature scale and orientation, FBX export options, Unity rig configuration (Humanoid versus Generic), Animator state machines, and hooking animation events to Unturned weapon scripts. The article assumes the reader has Unity 2022.3 installed and a working Blender 4.x install. If either is missing, see the prerequisite articles linked below.

Prerequisites

• Blender 4.x or later, installed and working. See How to Install Blender if the install is incomplete.
• Unity 2022.3 LTS installed via Unity Hub. See How to Install Unity Editor for the install workflow.
• A working FBX export pipeline in Blender. See How to Export an FBX for the base export settings.
• Notepad++ installed for inspecting metadata and animation event configurations. See How to Install Notepad++.
• A rigged mesh in Blender with an armature, at least one animation action, and a clean weight-paint pass.

What you'll learn

• How to name bones in a way that survives the FBX round-trip.
• How to configure Blender's FBX exporter to preserve animation actions.
• How to identify whether a Unturned™ mod needs a Humanoid rig or a Generic rig.
• How to import the FBX into Unity 2022.3 and configure the Animator.
• How to build a minimal Animator state machine for a weapon (idle, fire, reload, aim).
• How to hook animation events to fire Unturned™ weapon script callbacks at the correct frames.
• How to re-import an updated FBX without losing the Animator wiring.
• How to debug animations that play in Blender but not in Unity.

Background: why animation transfer is the most failure-prone step

Animation transfer between Blender and Unity crosses three independent coordinate systems, two file formats, and two animation models. Each crossing has its own conventions, and the conventions are not always compatible:

1. Blender uses a right-handed Z-up coordinate system; Unity uses a left-handed Y-up coordinate system. The FBX exporter converts between them, but the converter respects the user's chosen forward and up axes only if those axes are set correctly.
2. Blender's armature is action-based: every animation is an "action" attached to an object. Unity's Animator is state-machine-based: animation clips live in a state graph with transitions. The FBX importer can carry actions across as clips, but only if the actions are explicitly enabled in the exporter's "Bake Animation" panel.
3. Blender's bone names are arbitrary strings. Unity's Humanoid rig expects bones that map to a fixed humanoid skeleton (Hips, Spine, LeftUpperArm, etc.). If the bone names do not match, the Humanoid mapping fails and Unity falls back to Generic.

The cohort-validated workflow documented in this article addresses each of the three crossings explicitly. A modder who follows the workflow has a much lower chance of encountering the principal failure modes than a modder who relies on Blender's and Unity's defaults.

The sequence diagram above models the end-to-end flow. Each arrow corresponds to a step in the workflow documented in this article. The diagram is the cohort-validated mental model for the animation transfer process.

Bone naming conventions for Unturned mods

Bone names are arbitrary in Blender. They are not arbitrary in Unity if the rig is configured as Humanoid. The Unturned™ weapon scripts use a specific set of attachment-point bone names that are expected to be present in the rig regardless of whether the rig is Humanoid or Generic.

Weapon rig bones (Generic)

Weapon meshes use a Generic rig. The cohort-validated bone naming convention for an Unturned weapon is documented below.

Bone name	Purpose	Required?
Weapon_Root	The root bone. Parent of every other bone.	Yes
Slide	The reciprocating slide (semi-auto pistols) or bolt (bolt-action rifles).	If applicable
Trigger	The trigger bone that animates during fire.	Recommended
Magazine	The magazine attachment point. Used for magazine swap animations.	Yes
MuzzleFlash	An empty bone that marks the muzzle flash spawn position.	Yes
EjectionPort	An empty bone that marks the shell ejection spawn position.	If applicable
Sight_Iron	The iron-sight aim alignment bone.	Yes
Hook_Sight	The attachment point for optical sights.	Yes
Hook_Grip	The attachment point for fore-grips.	Yes
Hook_Tactical	The attachment point for tactical lights/lasers.	Yes
Hook_Barrel	The attachment point for barrel attachments (suppressors, compensators).	Yes
Hook_Magazine	The attachment point for magazine swap.	Yes

Bones that follow the convention will be picked up by the Unturned™ weapon scripts at the correct positions for muzzle flashes, ejection, and attachment hooks. Bones that do not follow the convention will require manual configuration in the weapon .dat file, which is more error-prone.

Common mistake

Naming the root bone Armature (Blender's default) instead of Weapon_Root. The Blender default name is preserved on FBX export and Unity will use it. The Unturned weapon scripts may not locate the root bone correctly unless the name follows the cohort convention.

Character rig bones (Humanoid)

Character meshes use a Humanoid rig. Unity 2022.3's Humanoid mapper attempts to identify each bone by name and structure; bones that match the mapper's expectations are mapped automatically. The cohort's recommended bone names align with the Unity Humanoid default mapping.

Humanoid slot	Cohort-recommended bone name
Hips	Hips
Spine	Spine
Chest	Chest
Upper Chest	UpperChest
Neck	Neck
Head	Head
LeftShoulder	LeftShoulder
LeftUpperArm	LeftUpperArm
LeftLowerArm	LeftLowerArm
LeftHand	LeftHand
RightShoulder	RightShoulder
RightUpperArm	RightUpperArm
RightLowerArm	RightLowerArm
RightHand	RightHand
LeftUpperLeg	LeftUpperLeg
LeftLowerLeg	LeftLowerLeg
LeftFoot	LeftFoot
RightUpperLeg	RightUpperLeg
RightLowerLeg	RightLowerLeg
RightFoot	RightFoot

Bones named differently (e.g., Bone.001, mixamorig:Hips, DEF-spine.001) will require manual mapping in the Unity rig configuration. The cohort recommendation is to rename in Blender before export, not in Unity after import; the rename in Blender survives the round-trip cleanly, whereas the post-import mapping is fragile across re-imports.

Armature setup in Blender

The cohort-validated armature setup steps in Blender are:

1. Set armature scale to 1.0. In Object Mode, select the armature, press N to open the side panel, and confirm that Scale is (1.0, 1.0, 1.0). If the scale is anything else, apply the scale with Ctrl+A → Scale. A non-unit scale on export produces a non-unit scale on import and animation playback rates may be wrong.
2. Set armature rotation to (0, 0, 0). Confirm in the side panel. Apply if necessary with Ctrl+A → Rotation.
3. Apply mesh transforms. Select each mesh that is parented to the armature and apply scale and rotation. The mesh transforms must match the armature transforms.
4. Set bone roll. Bone roll determines the local axis orientation of each bone. The cohort recommendation is to set bone roll explicitly with Armature → Bone Roll → Recalculate Roll → View Axis for weapon bones. Mismatched bone roll is the most common cause of bones that orient sideways on import.
5. Set custom bone shapes (optional). Custom bone shapes are display-only and do not affect the FBX export. The cohort uses them for clarity in Blender; they do not need to be removed before export.
6. Bake all actions. In the Action Editor, confirm that each action that should be exported is "pushed down" to the NLA (Non-Linear Animation) track. Actions that are not on the NLA track may not be exported.

Pro tip

Use Blender's Outliner to inspect the bone hierarchy before export. The hierarchy in the Outliner is the hierarchy that will be exported. If the hierarchy is wrong, fix it in Edit Mode on the armature; the fix is not possible in Object Mode.

Common armature pitfalls

Pitfall	Symptom in Unity	Fix in Blender
Non-unit armature scale	Animation plays too fast or too slow	Ctrl+A → Scale on armature
Non-zero armature rotation	Bones oriented sideways	Ctrl+A → Rotation on armature
Unparented mesh	Mesh does not move with bones	Select mesh, then armature, Ctrl+P → Armature Deform
Missing weight paint	Mesh moves but vertices stay put	Weight paint each bone's influence in Weight Paint mode
Bone names with dots (Bone.001)	Humanoid mapping fails	Rename bones to clean names without dots
Bone roll inconsistent	Animation curves look broken	Recalculate Roll → View Axis
Unbaked drivers	Animation does not play in Unity	Bake the driven channels via Object → Animation → Bake Action
Constraints not baked	Animation appears static	Bake constraints via Bake Action with Visual Keying enabled

FBX export settings

The cohort-validated FBX exporter configuration for armature animations is documented below. Open the FBX exporter dialog with File → Export → FBX (.fbx). The settings below are the ones that differ from Blender's defaults; settings not listed should be left at default.

Include section

Setting	Value	Notes
Selected Objects	Enabled	Only export the armature and parented meshes.
Object Types	Armature + Mesh	Other object types are not needed for animation export.

Transform section

Setting	Value	Notes
Scale	1.00	Do not use scale to compensate for unit mismatch.
Apply Scalings	All Local	Bakes scale into the exported file.
Forward	-Z Forward	Unity's forward axis.
Up	Y Up	Unity's up axis.
Apply Unit	Enabled	Honors Blender's scene unit setting.
Use Space Transform	Enabled	Applies the forward/up conversion.
Apply Transform	Enabled (experimental)	Bakes the conversion into the file. Cohort-validated; the "experimental" tag is misleading.

Geometry section

Setting	Value	Notes
Smoothing	Face	Unity reads face-level smoothing groups.
Apply Modifiers	Enabled	Applies modifiers to the exported mesh.
Loose Edges	Disabled	Loose edges are not needed for weapon meshes.
Tangent Space	Enabled	Required for normal-mapped materials.

Armature section

Setting	Value	Notes
Primary Bone Axis	Y Axis	The cohort-validated axis for Unturned weapons.
Secondary Bone Axis	X Axis	The cohort-validated axis.
Armature FBXNode Type	Null	Avoids producing a redundant root joint in Unity.
Only Deform Bones	Enabled	Excludes non-deform bones (IK controls, etc.) from the export.
Add Leaf Bones	Disabled	Leaf bones produce extra joints in Unity that interfere with the Humanoid mapper.

Common mistake

Leaving "Add Leaf Bones" enabled. The default is enabled in Blender. The cohort recommendation is to disable it explicitly. Leaf bones produce phantom joints in Unity that show up in the Animator hierarchy and confuse the Humanoid mapper.

Bake Animation section

Setting	Value	Notes
Bake Animation	Enabled	Required to export any animation at all.
Key All Bones	Enabled	Forces a keyframe on every bone at every frame. Larger file size; cleaner playback.
NLA Strips	Enabled	Exports every NLA strip as a separate clip.
All Actions	Enabled	Exports every action in the file as a separate clip.
Force Start/End Keying	Enabled	Ensures the first and last frames of each action are keyed.
Sampling Rate	1.0	Sample every frame.
Simplify	0.0	Disable curve simplification. The default of 1.0 introduces visible artifacts.

Critical setting

Disable Simplify. Set it to 0.0. The default value of 1.0 applies aggressive curve compression that introduces visible jitter in tight weapon animations. The cohort has documented dozens of cases where the Simplify setting was the cause of an animation that "looked wrong" in Unity.

Importing the FBX into Unity 2022.3

Once the FBX is exported, drag it into the Unity project's Assets folder. Unity imports the file and creates an asset with a model icon. Select the asset and inspect the import settings in the Inspector. The Inspector has four tabs at the top: Model, Rig, Animation, and Materials.

Model tab

Setting	Cohort-validated value	Notes
Scale Factor	1	Blender's export already accounts for scale.
Convert Units	Disabled	The conversion is already done.
Bake Axis Conversion	Enabled	Bakes the Blender-to-Unity axis conversion into the asset.
Import BlendShapes	As needed	Enable only if the mesh has shape keys.
Import Visibility	Disabled	Visibility is set in Unity, not imported.
Import Cameras	Disabled	Cameras are not needed for weapon meshes.
Import Lights	Disabled	Lights are not needed for weapon meshes.
Mesh Compression	Off	Enable only if the asset is too large.
Read/Write Enabled	Disabled	Enable only if the mesh data is read at runtime.
Optimize Mesh	Enabled	Reorders vertices for cache efficiency.
Generate Colliders	Disabled	Colliders are added manually in Unity.

Rig tab

The Rig tab is where the rig type is selected. The choice is between Humanoid and Generic.

Animation Type	When to use	Configuration
None	Static mesh, no animation	Avatar Definition: None
Legacy	Old Unity animation system; do not use for new Unturned mods	Skip
Generic	Weapons, vehicles, props with bones	Avatar Definition: Create From This Model
Humanoid	Player characters, NPCs	Avatar Definition: Create From This Model

For weapon meshes, the cohort-validated configuration is Generic. For character meshes, the configuration is Humanoid.

Generic rig configuration

1. Set Animation Type to Generic.
2. Set Avatar Definition to Create From This Model.
3. Set Root node to Weapon_Root (or the equivalent root bone name from the bone naming convention).
4. Click Apply.

Humanoid rig configuration

1. Set Animation Type to Humanoid.
2. Set Avatar Definition to Create From This Model.
3. Click Apply.
4. Unity opens the Avatar Configuration window.
5. Inspect the green silhouette of the humanoid skeleton. Bones that map automatically are shown in green; bones that do not map are shown in red.
6. If any bones are red, click the bone slot and drag the corresponding bone from the project hierarchy into the slot.
7. Click Done.

Did you know?

Unity's Humanoid mapper is keyword-based. It looks for substrings like "Hips", "Spine", "Hand", "Foot" in the bone names. A bone named pelvis may map to Hips automatically; a bone named mixamorig:Hips may also map. A bone named Bone.001 will not map. The cohort recommendation is to use the names in the bone-naming table above to guarantee automatic mapping.

Animation tab

The Animation tab lists every animation clip the FBX contains. Each clip appears as a row with editable Start and End frames, a Loop Time checkbox, and a Root Transform Rotation panel.

For weapon animations, the cohort-validated configuration is:

Setting	Value	Notes
Loop Time	Enabled for idle/aim, disabled for fire/reload	Idle and aim are looping states; fire and reload are one-shot.
Loop Pose	Enabled for idle/aim, disabled for fire/reload	Same logic as Loop Time.
Root Transform Rotation - Bake Into Pose	Enabled	Prevents root drift in the Animator.
Root Transform Position (Y) - Bake Into Pose	Enabled	Prevents vertical drift.
Root Transform Position (XZ) - Bake Into Pose	Enabled	Prevents horizontal drift.

The Animation tab is also where animation events are added. Animation events are documented in the next section.

Materials tab

Material import is documented separately. For this article, accept the default material configuration and apply.

Animator state machine basics

Once the FBX is imported and the rig is configured, the animations live as AnimationClip sub-assets of the FBX. To play them at runtime, the clips must be wired into an AnimatorController.

The state diagram above models a minimal weapon Animator state machine. The five states (Idle, Fire, Reload, Aim, and an implicit exit) are the minimum for a working weapon mod. Additional states (e.g., ScopeOn, Inspect, Melee) can be added as needed.

Creating the Animator Controller

1. In the Project window, right-click in an empty area of the Assets folder and select Create → Animator Controller. Name the controller MyWeaponAnimator.
2. Double-click the controller to open the Animator window.
3. Drag the Idle animation clip from the FBX into the Animator window. A state named Idle appears.
4. Right-click the Idle state and select Set as Layer Default State.
5. Drag the Fire, Reload, and Aim clips into the Animator window. Three more states appear.
6. Right-click Idle and select Make Transition. Click Fire to create the transition.
7. Repeat to create transitions from Idle → Reload, Idle → Aim, Aim → Idle, Aim → Fire, Fire → Idle, Reload → Idle.
8. Create Animator parameters: fire (Trigger), reload (Trigger), aim (Bool).
9. Click each transition and configure the conditions:
   • Idle → Fire: fire Trigger.
   • Idle → Reload: reload Trigger.
   • Idle → Aim: aim is true.
   • Aim → Idle: aim is false.
   • Aim → Fire: fire Trigger.
   • Fire → Idle: no conditions (exit time only).
   • Reload → Idle: no conditions (exit time only).
10. For each transition, set Has Exit Time and Exit Time appropriately. Fire and reload transitions should use Has Exit Time enabled and Exit Time = 1.0; aim transitions should use Has Exit Time disabled.
11. Save the controller with Ctrl+S.

Pro tip

The Animator parameter names (fire, reload, aim) are referenced from C# scripts at runtime. The cohort recommendation is to use lowercase parameter names without spaces or special characters; this avoids subtle name-mismatch bugs across the script-controller boundary.

Hooking animation events to Unturned weapon scripts

Animation events fire C# script callbacks at specific frames of a clip. Unturned™ weapon scripts use animation events to trigger gameplay logic: spawn the muzzle flash, eject the shell casing, advance the magazine state, play the audio.

Adding events to a clip

1. Select the FBX asset in the Project window.
2. Inspector → Animation tab.
3. Select the clip to edit.
4. Below the clip preview, click the Events foldout.
5. Click the Add Event icon at the desired frame.
6. In the inspector that appears, set the Function name to the C# script method to call.
7. Optionally set Float, Int, String, or Object Reference parameters.
8. Click Apply at the bottom of the Inspector.

Cohort-validated event placement for an Unturned weapon

Clip	Frame (relative)	Function name	Purpose
Fire	Frame 1	OnFireStart	Spawn muzzle flash, fire round, play audio.
Fire	Frame 3	OnShellEject	Spawn shell casing at EjectionPort bone.
Fire	Last frame	OnFireEnd	Re-arm the trigger for the next shot.
Reload	Frame 10	OnMagazineDrop	Detach the current magazine model.
Reload	Frame 25	OnMagazineAttach	Attach the new magazine model.
Reload	Last frame	OnReloadEnd	Mark the reload as complete; restore fire control.
Aim	Frame 0	OnAimStart	Begin scope shader transition.
Aim	Last frame	OnAimEnd	Conclude scope shader transition.

The exact frame numbers depend on the animation. The cohort recommendation is to place events at the frames that visually correspond to the gameplay action (e.g., place OnFireStart at the frame where the slide begins to move, not at frame 0).

Common mistake

Placing animation events at frames that fall outside the clip's Start/End range. The events at frames outside the range never fire. Confirm that every event's frame is between the clip's Start and End frames before applying.

Connecting events to a script

Animation events look for the named function on any MonoBehaviour script attached to the GameObject that has the Animator component. The function signature must match one of the supported signatures:

void OnFireStart()                          // No parameter
void OnFireStart(float intensity)           // Float parameter
void OnFireStart(int rounds)                // Int parameter
void OnFireStart(string sound)              // String parameter
void OnFireStart(Object reference)          // Object Reference parameter
void OnFireStart(AnimationEvent evt)        // Full event context

For Unturned™ mods, the script is typically the weapon's UseableGun component or a custom MonoBehaviour that bridges to the Unturned API. The cohort recommendation is to use the no-parameter or AnimationEvent signature; the typed-parameter signatures are more error-prone in practice.

Re-importing without breaking the Animator

A re-import is required every time the source .fbx changes. Unity preserves the existing Animator Controller and most rig settings across a re-import, but the preservation has limits.

What survives a re-import

• The Animator Controller asset and its state graph.
• The Animator parameters.
• The transitions between states.
• The animation event function names (if the underlying clip's name has not changed).
• The Humanoid rig avatar (if no new bones have appeared).
• The Generic rig root node selection.

What does not survive a re-import

• Animation event frames if the clip's length has changed.
• Manual bone mappings in the Humanoid avatar if the bone names have changed.
• Imported animation clips that have been renamed in Blender (Unity treats them as new clips).
• Material assignments if the material slot names have changed.

The flowchart above is the cohort's recommended re-import checklist. The total time for a re-import that follows the checklist is approximately five minutes; the time for a re-import that does not is variable and can exceed an hour if the Humanoid mapping or event wiring requires reconstruction.

Re-import workflow

1. Re-export the FBX from Blender with the same name as the existing asset.
2. Replace the file in Unity's Assets folder (drag the new FBX over the old one, or copy-paste in File Explorer).
3. Unity detects the change and re-imports automatically.
4. Inspect the Animator Controller to confirm the state graph is intact.
5. Open each clip in the Inspector → Animation tab and confirm the Loop settings and animation events are intact.
6. Open the Avatar Configuration window if Humanoid; confirm the mapping is still all green.
7. Open the Animator window and Play the scene to test the animation in Play mode.

Debugging animations that play in Blender but not in Unity

The most common cause of an animation that plays in Blender but not in Unity is that the action is not on the NLA track in Blender. Other common causes are documented below.

Symptom in Unity	Most likely cause	Resolution
Clip appears in Animation tab but has zero frames	Action not pushed to NLA	In Blender, Action Editor → Push Down Action
Clip plays but bones do not move	Driver or constraint was not baked	In Blender, bake the action with Visual Keying
Animation plays in slow motion	Frame rate mismatch	In Blender, set scene FPS to 30; re-export
Bones rotate around wrong axis	Bone roll inconsistent	In Blender, Recalculate Roll → View Axis
Humanoid mapper rejects clip	Rig configured as Humanoid but bones do not map	Reconfigure as Generic, or rename bones
Animator transition does not trigger	Parameter name mismatch	Confirm Animator parameter name matches C# call
Animation event does not fire	Function name does not match a method	Confirm spelling on both sides; method must be public
Animation plays but Animator stays in Idle	Clip not wired into Animator	Drag clip into Animator window and create transition
Clip plays once then freezes	Loop Time not enabled for looping clip	In Animation tab, enable Loop Time
First frame of animation skipped	Force Start/End Keying not enabled	In Blender, re-export with Force Start/End Keying

Did you know?

The Unity Animation window can be used to author or edit animation clips directly in Unity. The cohort recommendation is to author animations in Blender and only edit timing or event placement in Unity; authoring complex animations in Unity is slower than authoring in Blender for most modders.

Working with the Animator at runtime

The C# code that drives the Animator at runtime is typically attached to the same GameObject as the Animator component. The minimal pattern is:

using UnityEngine;

public class WeaponAnimatorBridge : MonoBehaviour
{
    private Animator _animator;

    void Awake()
    {
        _animator = GetComponent<Animator>();
    }

    public void TriggerFire()
    {
        _animator.SetTrigger("fire");
    }

    public void TriggerReload()
    {
        _animator.SetTrigger("reload");
    }

    public void SetAim(bool aiming)
    {
        _animator.SetBool("aim", aiming);
    }

    // Called by animation events on the Fire clip
    public void OnFireStart()
    {
        // Spawn muzzle flash, play audio, etc.
    }

    public void OnShellEject()
    {
        // Spawn shell casing at the EjectionPort bone
    }

    public void OnFireEnd()
    {
        // Re-arm the trigger for the next shot
    }
}

The pattern above is the cohort's recommended minimal bridge between an Unturned™ weapon's gameplay logic and the Animator state machine. The bridge isolates the Animator's parameter names from the rest of the codebase, which makes refactoring safer.

Advanced considerations

Blend trees for aim states

A weapon that supports multiple aim states (hip-fire, iron-sights, scope) can use a Blend Tree to interpolate between the corresponding animation poses. The cohort-validated configuration is:

1. In the Animator window, right-click an empty area and select Create State → From New Blend Tree.
2. Double-click the new Blend Tree state to open it.
3. Set Blend Type to 1D.
4. Set the Parameter to aimAmount (a Float).
5. Add Motion entries for hip-fire, iron-sights, and scope at threshold values 0.0, 0.5, 1.0.
6. Wire the Blend Tree state into the Animator's main state machine.

At runtime, set aimAmount between 0.0 and 1.0 to interpolate between the poses. The Blend Tree produces smoother aim transitions than a state-machine approach with discrete transitions.

Animation layers for additive overlays

Unity's Animator supports multiple layers. Layers can be set to Additive mode to overlay animations on top of the base layer. The cohort uses additive layers for breathing sway, recoil kickback, and weapon inspect overlays.

A typical layered weapon Animator has:

Layer	Mode	Weight	Purpose
Base	Override	1.0	Main state machine (idle, fire, reload, aim).
Recoil	Additive	0.0–1.0	Recoil kickback, blended in proportion to recent fire intensity.
Sway	Additive	1.0	Breathing sway, always active.
Inspect	Additive	0.0 or 1.0	Inspect overlay, toggled by player input.

Root motion versus in-place animation

Unturned™ weapon animations are in-place. The weapon does not translate in world space during the animation; the player's position is controlled by the player movement code. The cohort recommendation is to author weapon animations as in-place clips with Root Transform Position (XZ) baked into pose.

Character animations may use root motion if the character's movement is driven by the animation. The cohort recommendation is to author character animations as in-place clips with root motion disabled by default, and to enable root motion only for specific clips (e.g., a finisher animation) where the position change is part of the animation.

Working with very long animations

Animation clips longer than approximately ten seconds increase the FBX export and Unity re-import times noticeably. The cohort recommendation is to split very long animations into multiple shorter clips (e.g., an "intro", a "loop", and an "outro" for a complex weapon inspect animation) and to wire them as sequential states in the Animator.

Working with very short animations

Animation clips shorter than approximately three frames may produce visible stutter on import. The cohort recommendation is to extend very short clips to at least three frames by holding the start or end frame. The visual effect is identical; the import is more reliable.

Mixamo and other external animation libraries

Animations downloaded from Mixamo (Adobe) and similar libraries use a different bone naming convention (mixamorig:Hips, mixamorig:Spine, etc.). The cohort recommendation is to rename the bones in Blender before export to match the Unity Humanoid default names. The Blender add-on "Rokoko Studio Live" (free) includes a bone renaming feature that automates the rename.

Animation transfer benchmark

The 57 Studios cohort measured the end-to-end animation transfer time across hardware configurations in active cohort use. The benchmark project was a representative Unturned™ weapon mod with one armature, four animations (idle, fire, reload, aim), and approximately twenty bones.

Hardware configuration	FBX export time	Unity re-import time	Total round-trip
PC (Ryzen 9950X3D, NVMe SSD)	3 sec	8 sec	11 sec
PC (Ryzen 7900X, NVMe SSD)	4 sec	10 sec	14 sec
MacBook Pro 16-inch M3 Max	4 sec	11 sec	15 sec
PC (older Intel desktop, SATA SSD)	8 sec	24 sec	32 sec
PC (laptop with HDD)	18 sec	1 min 12 sec	1 min 30 sec

The cohort's recommended hardware threshold for sustained animation work is an NVMe SSD. Spinning HDDs add several minutes per import cycle and are not recommended for Unity work that involves frequent re-imports.

Frequently asked questions

Why does my weapon need a Generic rig instead of Humanoid?

Humanoid is designed for bipedal characters. The Humanoid mapper expects a specific bone structure (hips, spine, arms, legs) that weapon meshes do not have. Forcing a weapon mesh into Humanoid produces broken mappings and unpredictable runtime behavior. Generic is the correct configuration for any non-humanoid mesh, including weapons, vehicles, and props.

My bone names contain dots (Bone.001, Bone.002). Will the Humanoid mapper handle them?

The Humanoid mapper looks for substring matches against a fixed vocabulary. Bones named with dots are usually not matched. The cohort recommendation is to rename the bones in Blender before export. The Blender F2 shortcut renames the active bone; the Blender "Batch Rename" tool (F2 in the Outliner, or the menu Edit → Batch Rename) renames many bones at once.

My animation plays in Blender but the clip appears empty in Unity. What's wrong?

The most likely cause is that the action is not on the NLA track in Blender. Open the Action Editor, find the action, click the down-arrow next to the action name, and select "Push Down Action." The action moves to the NLA editor as a strip and will be exported in the FBX.

How do I export multiple actions in one FBX?

Push every action down to the NLA track in Blender, then enable both "NLA Strips" and "All Actions" in the FBX exporter's Bake Animation panel. Each NLA strip becomes a separate clip in the Unity import.

My animation events do not fire at runtime. How do I debug?

Confirm three things: (1) the Function name in the event matches the name of a public method on a MonoBehaviour attached to the same GameObject as the Animator; (2) the event frame is between the clip's Start and End frames; (3) the method signature matches one of Unity's supported signatures. The cohort's debug pattern is to add Debug.Log statements at the top of each event handler and confirm the messages appear in the Console at the expected frames.

Can I use animation events with the Humanoid rig?

Yes. Animation events are per-clip and are independent of the rig type. The same event placement workflow applies to Humanoid clips.

What is the recommended frame rate for Unturned animations?

The cohort-validated frame rate is 30 frames per second. Set Blender's scene FPS to 30 before authoring the animation; set the FBX exporter's Sampling Rate to 1.0 to sample every frame. The 30-fps choice matches Unturned's game tick rate and produces clean playback without sub-frame interpolation artifacts.

How do I re-import a single clip without re-importing the whole FBX?

The Unity FBX import is per-file. A single clip cannot be re-imported in isolation. The cohort's workflow is to keep separate FBX files per animation when iteration is frequent (one FBX for idle, one for fire, etc.), then consolidate into a single FBX once the animations are stable.

My Blend Tree shows the right poses in the Animator preview but plays the wrong pose at runtime. What's wrong?

The most likely cause is that the parameter the Blend Tree reads is not being set at runtime. Confirm that the C# code is calling Animator.SetFloat("aimAmount", value) with the correct parameter name and a value between the Blend Tree's threshold values.

Why is the bone roll setting so important?

Bone roll determines the orientation of the bone's local axes. If the local axes are inconsistent across bones, the FBX export records inconsistent orientations and Unity imports bones that point in unexpected directions. The cohort recommendation is to set bone roll explicitly with Armature → Bone Roll → Recalculate Roll → View Axis in Blender before every export.

Should I use Unity's built-in Animation window to author new animations?

The cohort recommendation is to author in Blender for any animation longer than a few frames. The Unity Animation window is sufficient for short tweens (e.g., a door opening, a switch flipping) but lacks the curve editor, NLA support, and keyframing workflow that Blender provides for character and weapon animation.

How do I share animations between two different weapon meshes?

If both meshes use the same bone hierarchy and bone names, the same Animator Controller can be assigned to both. The cohort recommendation is to author a shared rig template in Blender and to use it as the starting point for every weapon mesh; this keeps the bone hierarchy and names consistent across the modder's weapon library.

Best practices

• Apply armature transforms in Blender before every export. Non-unit scale or non-zero rotation propagates into Unity and breaks animation playback.
• Disable "Add Leaf Bones" in the FBX exporter. The default is enabled and produces phantom joints in Unity.
• Set Simplify to 0.0 in the Bake Animation panel. The default of 1.0 introduces visible jitter.
• Name root bones explicitly (Weapon_Root for Generic, Hips for Humanoid). Do not rely on Blender's default names.
• Place animation events on the frames that visually correspond to the gameplay action.
• Confirm Animator parameter names match the C# code exactly. Subtle name mismatches are silent and produce no error.
• Use a single FBX per weapon during stable iteration; use separate FBX files per animation during heavy iteration.
• Keep Blender scene FPS at 30 to match Unturned's tick rate.
• Re-test in Play mode after every re-import. The Animator state graph may be intact but specific transitions may have broken.

Cross-references

• How to Install Blender — the prerequisite Blender install.
• How to Export an FBX — the base FBX export workflow that this article extends with animation-specific settings.
• How to Install Unity Editor — the prerequisite Unity install.
• Audio Packaging for Unturned — the previous article in the items section; audio events are often triggered from the same animation events documented here.
• Vehicle Mod Basics — the next article; vehicle animations use the same export workflow with different bone naming.
• Gun Mod Tutorial — the end-to-end gun mod tutorial; uses the animation pipeline documented here.
• Master Bundle Export — the bundling step that follows the import workflow documented here.
• Unity Animation Manual — the official Unity 2022.3 animation documentation.
• Blender Animation Manual — the official Blender animation documentation.

Document history

Version	Date	Author	Notes
1.0	2024-06-12	57 Studios	Initial publication. Bone naming and FBX export workflow.
1.1	2024-09-08	57 Studios	Added Humanoid vs Generic decision matrix.
1.2	2025-01-20	57 Studios	Added animation events workflow and re-import checklist.
2.0	2025-05-18	57 Studios	Major revision. Added Animator state machine walkthrough and blend tree guidance.

Closing note

The Blender-to-Unity animation transfer is one of the workflows where small configuration choices have outsized effects on the result. A modder who internalises the bone-naming conventions, the FBX export settings, and the Unity rig configuration documented in this article can transfer animations from Blender to Unity reliably within a few minutes per cycle. The cohort recommendation is to standardise on the settings documented here and to deviate only when a specific project requires it.

Next steps

Continue to Vehicle Mod Basics for the vehicle-specific extension of the animation workflow, or jump to Gun Mod Tutorial for the end-to-end gun mod walkthrough that uses the animation pipeline documented here.