Rigging in Blender for a Unity Humanoid Avatar Without Errors

Unity’s Humanoid rig is what lets you drop a Mixamo run cycle or an Asset Store animation pack onto your own character and have it just work. But it is picky. Get the bone hierarchy, pose or export settings slightly wrong and you get a red Avatar, a “not in T pose” warning, or a character whose arms twist into knots. This guide covers rigging in Blender for a Unity Humanoid Avatar: which bones Unity needs, how to lay out and name them, the T-pose, what to do with Rigify, the FBX settings for rigs, and how to fix the common Avatar errors.

What Unity’s Humanoid Rig Expects

A Humanoid Avatar is a map from your bones to Unity’s standard human skeleton. Once the map exists, animations are stored as muscle values instead of raw bone rotations, which is why they can be shared between characters with different proportions.

Unity needs 15 required bones:

• Body: Hips, Spine
• Head: Head
• Legs: Left/Right Upper Leg, Lower Leg, Foot
• Arms: Left/Right Upper Arm, Lower Arm, Hand

Everything else is optional: Chest, Upper Chest, Neck, Shoulders, Toes, Eyes, Jaw, and three bones per finger (Proximal, Intermediate, Distal). Map the optional ones you have. Neck and Shoulders are worth having, because without them the head and arms rotate from odd pivots.

The hierarchy matters as much as the names. Hips must be the top of the human skeleton. Spine is a child of Hips. Legs hang off Hips. Arms come off the spine chain (through Shoulder if you have one). A bone can have unmapped bones between it and its mapped parent, but it can’t be outside that chain.

Humanoid supports at most Spine, Chest and Upper Chest in the torso. Extra spine bones are allowed but won’t be driven by humanoid animations, so a five-bone spine gives you nothing extra in Unity. Three is the sweet spot.

Twist bones, IK targets, pole targets and control bones have no place in the humanoid map. Unity handles forearm and upper-arm twist itself with its muscle settings.

Building the Armature in Blender

Start from a clean mesh:

1. Model the character facing -Y in Blender (the Front view, numpad 1, looks at its face). Feet on the ground at Z = 0, centred on the origin.
2. Apply transforms on the mesh: Object > Apply > All Transforms. Scale must be 1 before you rig.
3. Add an armature with Add > Armature, then build bones in Edit Mode (E to extrude). Turn on X-Axis Mirror in the tool settings so left and right stay symmetrical.

A simple, Unity-friendly layout:

Hips
├── Spine
│   └── Chest
│       └── UpperChest
│           ├── Neck
│           │   └── Head
│           ├── Shoulder.L
│           │   └── UpperArm.L
│           │       └── LowerArm.L
│           │           └── Hand.L  (fingers here)
│           └── Shoulder.R ... (mirror)
├── UpperLeg.L
│   └── LowerLeg.L
│       └── Foot.L
│           └── Toes.L
└── UpperLeg.R ... (mirror)

Make Hips the root bone, with its head near the pelvis. Don’t add a separate “root” bone at the feet unless you plan to use root motion from a Generic rig. Humanoid computes its own root from the Hips and a stray root bone only confuses auto-mapping.

Naming. Unity’s auto-mapper looks at both names and hierarchy. Blender’s .L/.R suffixes are recognised, as are common conventions like Left/Right prefixes and Mixamo-style names. The names above usually map with zero manual work. Use Blender’s Symmetrize (Armature > Symmetrize) to build one side and generate the other with the right suffix.

Bend direction. Give knees a slight forward bend and elbows a slight backward bend in the rest pose. Perfectly straight limbs make IK and Unity’s muscle limits less predictable.

Rest Pose: T-Pose or A-Pose

Unity wants the Avatar in a T-pose: arms straight out sideways, palms down, legs straight, facing forward. If your model is in an A-pose (arms angled down), that is fine. You don’t have to remodel. Unity can force a T-pose during Avatar configuration (covered below).

What matters in Blender is that the armature’s rest pose matches the mesh. Bind the mesh in rest pose, and don’t leave a modified pose on the armature when you export unless you mean to. If you want to check, toggle between Pose Position and Rest Position in the Armature properties: the mesh should not move.

Fingers should be roughly straight and spread a little. Thumb pointing forward at about 45 degrees works well with Unity’s finger muscles.

Skinning and Weight Limits

Parent the mesh to the armature: select the mesh, then Shift-select the armature, press Ctrl+P and choose With Automatic Weights. Then fix problem areas in Weight Paint mode (armpits, groin, shoulders).

Unity skins with up to four bone influences per vertex by default. The Rig tab’s Skin Weights setting and the project’s Quality settings control this. Extra influences get dropped on import, which can cause small pops. Clean them up in Blender first:

1. In Weight Paint mode, use Weights > Limit Total with Limit set to 4.
2. Then Weights > Normalize All so each vertex’s weights add up to 1.
3. Use Weights > Clean to remove tiny weights that do nothing.

Only bones used for deformation should have weights. Mark helper bones as non-deforming by unticking Deform in Bone properties. That way they can be left out of the export.

Using Rigify for a Unity Character

Rigify is Blender’s bundled auto-rigger. It gives animators great controls, but its generated rig isn’t game-ready as it is. A generated Rigify rig contains three kinds of bones:

• DEF- bones that actually deform the mesh.
• ORG- and MCH- bones used internally.
• Control bones (no prefix) that the animator moves.

Unity only needs the DEF bones. You can tick Only Deform Bones in the FBX exporter, but the DEF bones are often parented to ORG or MCH bones rather than to each other, so you can end up with a hierarchy that doesn’t form a clean chain. Rigify also splits limbs into extra DEF segments for twist (for example DEF-upper_arm.L and DEF-upper_arm.L.001), which you would leave unmapped in Unity.

Practical options, from simplest to most robust:

1. Skip Rigify for game characters. A hand-built armature like the one above takes less than an hour and maps cleanly. Use Blender’s IK constraints for animating if you need them.
2. Use a separate export skeleton. Keep Rigify for animating, but build a clean deform skeleton with the hierarchy Unity expects. Give each of its bones a Copy Transforms constraint targeting the matching DEF bone, skin the mesh to the export skeleton, then bake the actions onto it (Pose > Animation > Bake Action with Visual Keying) before export.
3. Use a community game-rig add-on that automates option 2. Several exist. Test the output in Unity before you commit to one.

FBX Export Settings for Rigs

Most settings are the same as for static models, which our Blender to Unity FBX export settings guide covers in detail. For rigs, these matter most:

• Object Types: Armature and Mesh only.
• Add Leaf Bones: off. Otherwise Blender adds an extra _end bone at the tip of every chain, which clutters the hierarchy and can confuse auto-mapping.
• Only Deform Bones: on, if your armature has helper or control bones.
• Apply Transform (Bake Space Transform): leave off for armatures. Blender marks it as experimental and it is known to cause problems with armatures and animation.
• Apply Scalings: FBX Units Scale, with your armature and mesh both at scale 1.

As a script, for a repeatable export:

import bpy

bpy.ops.export_scene.fbx(
    filepath=bpy.path.abspath("//Character.fbx"),
    use_selection=True,
    object_types={'ARMATURE', 'MESH'},
    apply_unit_scale=True,
    apply_scale_options='FBX_SCALE_UNITS',
    axis_forward='-Z',
    axis_up='Y',
    use_mesh_modifiers=True,
    add_leaf_bones=False,
    use_armature_deform_only=True,
    bake_anim=True,
    bake_anim_use_all_actions=False,
    bake_anim_use_nla_strips=True,
    path_mode='AUTO',
)

Select the armature and mesh before running it. For how actions and NLA strips turn into Unity clips, see Blender animations not showing in Unity. A common pattern is to export the character mesh once, then export animations separately from files that contain only the armature.

Setting Up the Avatar in Unity

1. Select the FBX and open the Rig tab.
2. Set Animation Type to Humanoid.
3. Set Avatar Definition to Create From This Model.
4. Click Apply. A tick next to Configure means the Avatar is valid.
5. Click Configure… to check the mapping. Green bones are mapped, red ones have a problem.

In the configuration view, the Mapping menu at the bottom has Clear and Automap. The Pose menu has Reset, Sample Bind-Pose and Enforce T-Pose. Use Enforce T-Pose for A-pose models, then Apply and Done.

Check optional bones carefully. Auto-mapping sometimes assigns a hair, accessory or weapon bone to Jaw or Eye. Your character’s ponytail then animates with every talking clip. Clear any slot that is mapped to the wrong bone.

For animation-only files, set Avatar Definition to Copy From Other Avatar and pick the character’s Avatar. All clips then share one bone map.

To confirm the result at runtime, drop this on the character:

using System;
using UnityEngine;

public class HumanoidCheck : MonoBehaviour
{
    void Start()
    {
        var animator = GetComponent<Animator>();
        if (animator == null || animator.avatar == null)
        {
            Debug.LogError("No Animator or Avatar assigned", this);
            return;
        }

        Debug.Log($"Avatar valid: {animator.avatar.isValid}, humanoid: {animator.isHuman}", this);
        if (!animator.isHuman) return;

        foreach (HumanBodyBones bone in Enum.GetValues(typeof(HumanBodyBones)))
        {
            if (bone == HumanBodyBones.LastBone) continue;
            Transform t = animator.GetBoneTransform(bone);
            Debug.Log($"{bone}: {(t != null ? t.name : "not mapped")}", this);
        }
    }
}

If animations then play wrong or not at all, the Animator setup is the next suspect. Our animation not playing fix guide covers controllers, transitions and the usual Animator mistakes.

Troubleshooting

Required human bone ‘Hips’ not found

Unity couldn’t map a required bone. Open Configure, find the empty slot and drag the right bone in. If no suitable bone exists (for example the legs are not under Hips), fix the hierarchy in Blender.

Character is not in T pose

Your rest pose is an A-pose or the arms are rotated. Use Pose > Enforce T-Pose in the Avatar configuration and Apply. If it keeps coming back, fix the rest pose in Blender.

Extra bones ending in _end in Unity

Add Leaf Bones was on during export. Turn it off and re-export.

Arms or fingers twist badly during animations

Bone rolls or the rest pose don’t match the T-pose Unity expects, or a twist bone was mapped as Lower Arm. Check the mapping, then adjust the twist values in the Avatar’s Muscles & Settings tab.

Avatar Rig Configuration mis-match

The animation file’s skeleton differs from the character’s, usually because they were exported with different bones or scale. Export both from the same armature with the same settings, and use Copy From Other Avatar.

Mesh explodes or stretches when animated

Unapplied scale on the armature or mesh, or vertices weighted to bones that weren’t exported. Apply transforms before parenting and check that every weighted bone has Deform ticked.

FAQ