Blender to Unreal Engine Export Checklist: FBX Settings, Bone Axes, and Scale (2026)

Last updated: September 2026.

Getting a Blender character into Unreal Engine cleanly comes down to six FBX exporter settings and one scene setting. In File > Export > FBX (.fbx): Selected Objects on, Apply Unit on with Apply Scalings set to FBX All (or leave it on All Local and set the scene's Unit Scale to 0.01), Smoothing set to Face, Add Leaf Bones off, Primary Bone Axis Y with Secondary X, and Bake Animation with NLA Strips or All Actions depending on how you store clips. Rename the armature object to root before you press Export, because Unreal turns that object into your root bone. Everything below explains why each setting matters, what the failure looks like when you skip it, and how to retarget the result onto the UE5 Mannequin or a MetaHuman.

Quick answer

• Scale: Unreal works in centimetres, Blender's internal unit is a metre. Either set Scene Properties > Units > Unit Scale to 0.01 and model at Unreal size, or keep 1.0 and export with Apply Scalings: FBX All so the file's header carries the conversion. Leaving both at defaults is what puts a scale of 100 on your root bone.
• Axes: leave Forward -Z and Up Y (Blender's default). Unreal's Convert Scene import option reads the FBX header and rotates into its Z-up, X-forward frame. Model the character facing -Y in Blender (looking at you in Numpad 1 front view) and it faces +X in Unreal.
• Bones: Primary Bone Axis Y, Secondary Bone Axis X. These are Blender's defaults and also what Epic's own Send to Unreal add-on ships. Changing them is the usual cause of "my bones import rotated 90 degrees".
• Root bone: the armature object becomes Unreal's root bone under the object's name. Rename it root, keep the hips as its first child, and don't skin anything to it.
• Leaf bones and smoothing: Add Leaf Bones off (otherwise every chain grows a _end bone), Smoothing set to Face (otherwise Unreal warns about missing smoothing groups).
• Animation: one Action per clip, Bake Animation on, Key All Bones on, Simplify 0. Import onto the existing Skeleton asset with Import Mesh off.
• One-click route: the Cinevva Rig add-on has an Unreal export preset that applies these conventions for you and shows a size analysis first. It runs on your own machine, offline, for one $29 purchase (launch price), on Blender 4.2 and newer for Windows, macOS and Linux.

Quick reference

The matrix. Find the symptom you're seeing in Unreal, read across.

Symptom in Unreal	Cause	Fix in Blender
Root bone shows Scale 100, or the character is tiny once you reset it	Unit Scale 1.0 with Apply Scalings: All Local bakes the metre-to-centimetre factor into the armature object's transform	Set Unit Scale to 0.01 and model at Unreal size, or export with Apply Scalings: FBX All
Character faces -X or lies on its side	Modelled facing +Y, or Forward/Up changed away from a consistent pair	Face the character toward -Y in Blender and apply rotation. Leave Forward -Z, Up Y
Bones point the wrong way, animation retargets twisted	Primary/Secondary Bone Axis changed from Y/X	Set Primary Y, Secondary X
A bone named "Armature" sits above the hips	The armature object is exported as a Null node and Unreal makes it the root bone	Rename the armature object to root
Extra bones ending in _end on fingers, head, feet	Add Leaf Bones is on (the exporter's default)	Turn Add Leaf Bones off
"No smoothing group information was found in this FBX scene"	Smoothing left on Normals Only	Set Smoothing to Face
"Found multiple roots. The importer only supports one root per mesh."	Several top-level bones and no single parent	Parent every top-level bone to root
"Scene does not contain a Bind Pose"	Bind pose data missing from the file	Import with Use T0 As Ref Pose on, or re-export with the armature in rest pose
Materials arrive with only Color and Normal wired	Unreal auto-connects only those two inputs	Export textures separately and rebuild roughness and metallic in the material editor
One long animation instead of separate clips	Clips stored in one Action, or NLA Strips and All Actions both off	One Action per clip, All Actions on, or one NLA strip per clip with NLA Strips on
Animation plays but the mesh doesn't move	Mesh not parented to the armature, or Only Deform Bones dropped a bone the skin needs	Parent mesh to armature with an Armature modifier, check deform flags

Units and scale: where "scale 100" comes from

Unreal's FBX importer works in centimetres. Its Convert Scene Unit option is described in the FBX Import Options Reference as converting "from the FBX units of measurement to UE's unit of measure, centimeters." Blender's internal unit is a metre. The exporter's source says it plainly: "Default Blender unit is equivalent to meter, while FBX one is centimeter". So something has to multiply by 100, and the only question is where that 100 gets written.

Blender's exporter (io_scene_fbx, version 5.12.4 in Blender 4.2) gives you two settings for it. Apply Unit, on by default, means "take into account current Blender units settings". Apply Scalings decides where the factor lands. Its first option, All Local (FBX_SCALE_NONE), applies "custom scaling and units scaling to each object transformation, FBX scale remains at 1.0". Its last, FBX All (FBX_SCALE_ALL), applies "custom scaling and units scaling to FBX scale", meaning the file's header.

Read the code and the famous symptom falls out. With Unit Scale 1.0 and All Local, the exporter multiplies every top-level object transform by 100 and writes a UnitScaleFactor of 1.0. The mesh arrives the right size because its transform carries the 100. So does the armature object, and Unreal turns that object into the root bone, which is why the root reads Scale 100.0 in the skeleton tree. The Scale field's own tooltip warns "Some importers do not support scaled armatures!", and this is the case it means.

The exporter computes the unit factor as 100 times the scene's Unit Scale. All Local multiplies object transforms by that factor and writes a header factor of 1.0, which is how the armature object, and therefore Unreal's root bone, ends up at scale 100. The two clean paths either make the factor 1 (Unit Scale 0.01) or move it into the header (FBX All) where Unreal's Convert Scene Unit handles it.

You have two clean ways out, and both are fine.

The 0.01 trick. In Properties > Scene > Units set Unit Scale to 0.01 and Length to Centimeters. The Blender manual describes Unit Scale as the "scale factor to use when converting between internal units and values displayed in the user interface", and notes it "only influences the values displayed in the user interface and not how things behave internally". A 180 cm character is now 180 Blender units tall, the exporter's factor becomes 100 times 0.01, which is 1, and the root bone imports at scale 1. Downsides: existing metre-scale assets need scaling up by 100, physics and cloth run at the wrong scale (the manual says exactly this), and viewport clip distances need raising. Unreal-first pipelines tend to settle here because everything made afterwards is already at Unreal size.

FBX All. Keep Unit Scale at 1.0 and set Apply Scalings to FBX All. The header now carries UnitScaleFactor 100, transforms stay at 1, and Unreal's Convert Scene Unit turns metres into centimetres on import. The tooltip cautions that "Blender uses FBX scale to detect units on import, but many other applications do not handle the same way". Unreal does, so this is the setting that lets you keep modelling in metres.

Whichever you pick, leave the exporter's Scale field at 1.0. It multiplies on top of the unit factor and is one more place for a stray 100 to hide.

Axes: Z-up in both, but not the same Z-up

Both applications are Z-up, which is why people expect this part to be free. It isn't, because the forward axis and the handedness differ. Blender's manual states that "Blender uses Y Forward, Z Up (since the front view looks along the +Y direction)". Numpad 1 puts the camera on the -Y side looking toward +Y, so a character modelled to face the front view faces -Y. Unreal is Z-up with X forward, and its importer's Force Front XAxis option is described as converting the scene "with the front X axis instead of -Y axis", which tells you the importer assumes an FBX file's front is -Y unless you say otherwise.

The exporter writes the file's up and front axes into the FBX header from whatever Forward and Up you chose, and Unreal's Convert Scene reads that header and rotates into its own frame. That's why the default -Z Forward, Y Up works, and why what actually matters is which way the character faces in Blender.

Here's the part most tutorials skip. The Forward and Up dropdowns don't rotate your model into Unreal's frame by themselves. The exporter builds a conversion matrix from them and, in the same pass, writes the matching UpAxis and FrontAxis values into the file's GlobalSettings. Unreal's Convert Scene, described as converting "the scene from the FBX coordinate system to use UE's coordinate system", reads those values, so any consistent pair works. Blender's default -Z Forward, Y Up writes a Y-up file. Epic's Send to Unreal ships Y Forward, Z Up, Blender's axes verbatim. Both import facing the same way.

What does change the result is the character's facing inside Blender. Model it facing -Y, apply rotation (Ctrl+A > Rotation), and it arrives in Unreal facing +X, the engine's forward direction. If a downloaded model faces +Y or +X, rotate it in Object Mode, apply, re-export. Don't fix facing with the Forward dropdown, or the header and the geometry disagree and later animation exports won't match.

Leave Use Space Transform on and Apply Transform off. Apply Transform (bake_space_transform) is labelled in the exporter's own tooltip as a "WARNING! experimental option, use at own risk, known to be broken with armatures/animations". It exists for static props where you want the axis conversion baked into vertex data. Never use it on a rigged character.

Bone axes: why bones import rotated

Blender bones have a fixed local frame. The manual's bone structure page says "The Y axis is always aligned along the bone, oriented from root to tip, this is the 'roll' axis of the bones." Many Maya-built rigs, and the tutorials written around them, run X along the bone instead. FBX doesn't care which axis points down a bone. It stores each bone's full transform. What matters is that the mesh's skin weights, the bind pose, and every animation key agree on the same frame.

The exporter's Primary and Secondary Bone Axis settings define the frame each bone is written in. Y and X are Blender's own convention and the exporter's defaults. Switching to X because a Maya-oriented tutorial said so re-expresses every bone frame in the file, which shows up as bones that look rotated in Unreal's skeleton view and as twisted limbs when you retarget.

Keep Primary Bone Axis at Y and Secondary Bone Axis at X. They're the exporter's defaults, and they're the defaults Epic ships in Send to Unreal's FBX settings. Unreal imports the bones in whatever frame the file declares, so a Blender rig with Y-along-bone works, animates and retargets correctly. Where the mismatch bites is mixing: exporting the mesh with one primary axis and an animation with another, or exporting Blender animations for a skeleton that was originally authored in Maya. If you're targeting a skeleton that already exists in Unreal, either export from the same Blender file every time, or import the Unreal skeleton into Blender first and animate on that.

The root bone question

Unreal's skeletal mesh pipeline page says the pivot of a skeletal mesh "is always located at the root bone/joint of the skeleton", and its importer wants exactly one. The FBX Import Errors page lists the message you get otherwise: "Found multiple roots. The importer only supports one root per mesh."

Blender's exporter writes your armature object as its own node above the bones. The Armature FBXNode Type option controls what kind: the default is Null, "similar to Blender's Empty", with Root and LimbNode as alternatives the tooltip advises against unless "you experience issues with the other app". Unreal reads that node as the top of the bone hierarchy and makes it the root bone, named after the armature object. Epic documents this behaviour in Send to Unreal's export settings: its "Export object name as root bone" option "uses the armature object's name in blender as the root bone name in Unreal, otherwise the first bone in the armature hierarchy is used as the root bone".

This is why a bone called "Armature" shows up above your hips. The fix is renaming the armature object, not the armature data block, to root in the Outliner. Keep it at the world origin with unit scale and zero rotation, parent your hips (or pelvis) to nothing so it becomes the first child of that node, and don't skin any vertices to it. You now have the same shape as Epic's skeletons: a root at the floor, a pelvis above it. That shape matters later, because Unreal's IK Retargeter asks you to designate a pelvis bone on both rigs to transfer root motion between characters.

If you'd rather the armature node disappear entirely, that's what Send to Unreal's "first bone in the armature hierarchy" mode does, and Better FBX Importer & Exporter does the equivalent. Blender's built-in exporter can't drop it, so rename it.

Leaf bones and deform bones

Add Leaf Bones is on by default, and the exporter's source even carries a comment marking it as meant to be off. Its tooltip: "Append a final bone to the end of each chain to specify last bone length (use this when you intend to edit the armature from exported data)". The code generates one hidden bone per chain end, named <bone>_end. Unreal shows every one of them in the skeleton tree, on each fingertip, the head, both toes. They're harmless but they pollute the hierarchy, break retarget chain auto-matching, and add bone tracks to every animation. Turn it off for engine exports.

Only Deform Bones is worth turning on if your armature has control bones: IK targets, pole targets, Rigify's control layers. The tooltip says it writes "only deforming bones (and non-deforming ones when they have deforming children)". Rigify users should export the generated rig with Only Deform Bones on so the deforming bones go across and the control machinery stays behind. Check that every bone the mesh is weighted to has its Deform flag ticked, or the vertices weighted to it will freeze in place in Unreal.

Smoothing groups, normals and triangulation

Unreal's importer expects smoothing groups. If it doesn't find them, the FBX Import Errors page lists the exact warning: "No smoothing group information was found in this FBX scene. Please make sure to enable the 'Export Smoothing Groups' option in the FBX Exporter plug-in before exporting the file." Blender's exporter defaults Smoothing to Normals Only, described as "Export only normals instead of writing edge or face smoothing data", with a note to "prefer 'Normals Only' option if your target importer understand split normals". Set Smoothing to Face and the warning stops. On import, Preserve Smoothing Groups is described as splitting "triangles with non-matching smoothing groups", which is how hard edges survive.

The skeletal mesh pipeline page states that meshes "must be triangulated as the graphics hardware only deals with triangles". Ticking Triangulate Faces in the exporter gives you control over which diagonal each quad splits on, which matters for normal maps baked in Blender. Tangent Space is optional and, per its tooltip, "will only work correctly with tris/quads only meshes". If your mesh has n-gons, turn Tangent Space off or triangulate first.

Textures and materials

Path Mode set to Copy with the Embed Textures toggle ticked packs your images into the FBX binary, and Unreal's Import Textures option pulls them out into texture assets. Expect a partial material. The static mesh pipeline page says "Only Color and Normal will automatically be connected" and the skeletal mesh page says the same in different words, "diffuse and normal map only". Roughness, metallic, emissive and ambient occlusion arrive as textures but not wired to anything. Blender's manual also lists "Material textures" as a known gap in the exporter.

The workable pattern is to embed nothing and treat the FBX as geometry plus skeleton. Export your textures from Blender's Image Editor or straight from Substance, import them into Unreal alongside the FBX, then build one master material with the Principled BSDF inputs you use and make Material Instances per character. Unreal's Material Import Method has a "Create New Instanced Materials" mode that lets you pick a base material for exactly this.

Skeletal mesh versus static mesh

Unreal decides what you've sent it by looking for a skin deformer. A mesh parented to an armature with an Armature modifier imports as a Skeletal Mesh, creates a Skeleton asset (the Skeleton option in the import dialog says "If no existing Skeleton is selected, a new one will be created"), and a Physics Asset. A mesh with no armature imports as a Static Mesh. The Import Content Type option lets you force geometry only or skinning only on a skeletal import.

For static props, two Blender-side conventions from the static mesh pipeline page save you work. Collision: Unreal reads meshes named UBX_, UCP_, USP_ and UCX_ followed by the render mesh's name as box, capsule, sphere and convex collision, in the form [PREFIX]_[RenderMeshName]_##, so a prop called Crate with a child mesh called UCX_Crate_01 arrives with its collision built. The page adds one caveat: "when importing multiple meshes with custom collision in a single file, only the first mesh's collision will be imported", so export props one per file. Vertex colors: "Vertex colors for Static Meshes can be transferred using the FBX pipeline. No special setup is necessary", which Blender writes from the active Color Attribute (the exporter's default is sRGB).

For skeletal meshes, the pipeline page confirms a character can be "a single, contiguous mesh or several separate meshes all skinned to the same skeleton", so you needn't join everything, but every piece must be parented to the same armature. Apply Modifiers is on by default and its tooltip warns it "prevents exporting shape keys". For facial shape keys, turn it off, apply the non-armature modifiers by hand, and tick Import Morph Targets in Unreal.

Animation: actions, NLA and the Skeleton asset

Blender's exporter always bakes: every animated bone is sampled at Sampling Rate (1.0 means every frame), and constraints, IK and drivers are written as plain keys. Three toggles decide how many clips come out.

All Actions writes "each action as a separated FBX's AnimStack", and the manual clarifies these are "all actions compatible with the selected armatures". NLA Strips writes "each non-muted NLA strip as a separated FBX's AnimStack". With both off, you get one clip covering the scene's frame range with the armature's current action. Unreal imports each AnimStack as its own Animation Sequence, and the animation import page confirms "Unreal allows content creators to import multiple animations in a single FBX file". So keep one Action per clip, named as you want the sequence named, and tick All Actions. If you assemble clips in the NLA editor instead, tick NLA Strips and leave All Actions off, or you'll get both.

Key All Bones forces "at least one key of animation for all bones (needed with some target applications, like UE4)". Leave it on. Force Start/End Keying adds a key at the first and last frame so Unreal's Animation Length set to Exported Time gets the range you meant. Simplify defaults to 1.0 and the tooltip says "0.0 to disable". Set it to 0 for game animation, because simplified curves can lose the exact contact frames.

On the Unreal side, do two imports. First the character with Import Animations off, which creates the Skeletal Mesh and Skeleton. Then the animation FBX (same armature, same bone axes, same scale settings, mesh not required) with Import Mesh off and the Skeleton dropdown pointed at the one you just made. Use Default Sample Rate is 30 frames per second per the reference, and Custom Sample Rate "when set to 0, the best sample rate is automatically determined". Match your Blender frame rate. If the import reports "Scene does not contain a Bind Pose", import with Use T0 As Ref Pose enabled, which uses frame 0 "to replace the Skeletal Mesh's reference pose".

Newer engine versions may show a different dialog. Epic's Interchange Framework is its "import and export framework. It is file format agnostic, asynchronous, customizable, and can be used at runtime", and the 5.5 release notes call it "production ready for asset imports and beta for level imports". Its import reference uses different names for familiar things: Offset Uniform Scale, Use 30Hz to Bake Bone Animation, Import Only Animations for the animation-onto-existing-skeleton case, and Skeleton where "Leaving this empty creates a new skeleton". The Blender-side checklist is identical either way.

Retargeting onto the UE5 Mannequin or a MetaHuman

Your Blender skeleton won't share bone names with Epic's, and it doesn't need to. Unreal 5's IK Retargeter is built to "transfer animation between skeletons with varying numbers of bones, bone names, and orientations". The process, from Epic's IK Rig retargeting page:

1. Create an IK Rig asset for your imported Skeletal Mesh (Animation > IK Rig in the Content Browser). Right-click your pelvis bone in the hierarchy and choose Set Pelvis. Press Auto Create Retarget Chains. Do the same for the target character if it doesn't already have an IK Rig.
2. Create an IK Retargeter, set the Source IK Rig to yours and the Target IK Rig to the Mannequin's (or the reverse if you're bringing Epic's animations onto your character).
3. Check the chain mapping. Epic uses fuzzy string matching, so a chain named ArmLeft matches left_arm when nothing better exists. Fix any chain it mapped wrong.
4. If your character was rigged in an A-pose and the target is a T-pose, open Edit Retarget Pose and align the arms, or use the Auto Align option.
5. Select the animations in the Asset Browser and click Export Selected Animations. You get new Animation Sequences on the target skeleton, with an optional prefix or suffix.

Two Blender-side details make this painless. Name bones by side and segment (upperarm_l, lowerarm_l, hand_l) so auto-mapping lands, and keep the root-then-pelvis hierarchy from the section above so Set Pelvis has an obvious bone and root motion transfers "proportionally between characters", as the page puts it. A Mixamo-named rig auto-maps well too, because the chain names come from bone names like LeftArm and LeftForeArm and the matcher reads words, which is one reason the Cinevva Rig add-on rigs to Mixamo names.

Send to Unreal: what Epic's add-on automates, and its state in 2026

Epic's BlenderTools repository holds Send to Unreal, "a one-click solution for sending data from Blender to Unreal Engine", and UE to Rigify. Send to Unreal wraps Blender's own FBX exporter ("All the standard FBX export settings that are in the blender FBX addon are available in this section to be customized") and adds the pipe: it writes the FBX, then uses Unreal's Python remote execution to import it into your open project. Setup on the Unreal side is the Python Editor Script Plugin, remote execution in Project Settings, and turning off "Use Less CPU when in Background" so the editor listens while Blender has focus. In Blender you move assets into a collection named Export and run Pipeline > Export > Send to Unreal.

Its defaults are what Epic chose, so they're a good sanity check: All Local scaling, Y Forward and Z Up, Face smoothing, Primary Bone Axis Y with Secondary X, leaf bones off, and the armature object's name as the root bone. It also does what the built-in exporter can't: drop the armature node, export LODs, and stash the active action into the NLA so each clip becomes its own sequence.

Maintenance is the caveat. The last release is Send to Unreal 2.4.3 from November 9, 2023, whose notes list tests passing on Blender 3.3 and 3.6 with Unreal 5.3, and the add-on's metadata sets Blender 3.3 as the minimum. The repository isn't archived, has around 3,300 stars, and took a documentation commit in September 2026, but the last code merge was July 2024 and close to a hundred issues sit open. It predates Blender's 4.2 extensions system, so test it on your version before building on it. If it works, it's the most complete free pipeline there is. If not, the checklist below gets you the same file.

CGDive compares Send to Unreal with a manual FBX export on the same custom character, and shows the root bone and scale differences in Unreal's skeleton tree. The manual settings match this checklist.

On the import side, Better FBX Importer & Exporter deserves the credit it gets. It's a paid add-on from Mesh Online, around $25 for a single seat and one of Superhive's best sellers, and it exists because imports kept breaking. Its product page says it was built "with official FBX SDK from scratch", that the "exported armature and 3d models have unit scale and zero rotations", that it "supports automatic bone orientation" on import, and that its output was "verified in Unity Engine 2019, Unreal Engine 4/5 and Godot Engine v3.2". If you round-trip Epic's Mannequin or Marketplace animations into Blender and back, that automatic bone orientation is the feature you're paying for. For a one-way Blender-to-Unreal trip of your own character, the built-in exporter with the settings below is enough.

The checklist

Do these in order. Steps 1 to 5 are once per project, 6 to 13 once per export.

1. Properties > Scene > Units: Unit System Metric. Either Unit Scale 0.01 with Length Centimeters (then scale existing metre-scale assets by 100), or Unit Scale 1.0 and remember to pick FBX All in step 9.
2. Model the character facing -Y, feet on the floor at the origin. Numpad 1 should show its face.
3. In Object Mode select mesh and armature, Ctrl+A > All Transforms. Both should read location 0, rotation 0, scale 1.
4. Rename the armature object to root in the Outliner. Make sure the hips are the only top-level bone, or that every top-level bone has a real parent. Give root no weights.
5. Check every deforming bone has Deform ticked (Bone Properties). If you use Rigify or control bones, plan to export with Only Deform Bones on.
6. One Action per clip, named as you want the Animation Sequence named. Set the scene frame rate to what you'll use in Unreal (30 is Unreal's default sample rate).
7. Select the mesh objects and the armature. Nothing else. Cameras, lights and empties become extra nodes.
8. File > Export > FBX (.fbx). Include: Selected Objects on, Object Types limited to Armature and Mesh.
9. Transform: Scale 1.00, Apply Scalings FBX All (or All Local if your Unit Scale is 0.01), Forward -Z, Up Y, Apply Unit on, Use Space Transform on, Apply Transform off.
10. Geometry: Smoothing Face, Apply Modifiers on (off if you need shape keys), Triangulate Faces on, Tangent Space off unless the mesh is all tris and quads.
11. Armature: Primary Bone Axis Y, Secondary Bone Axis X, Armature FBXNode Type Null, Only Deform Bones as decided in step 5, Add Leaf Bones off.
12. Bake Animation: on for the character export only if you want clips in the same file, otherwise off here and on in a second animation-only export. Key All Bones on, NLA Strips off, All Actions on, Force Start/End Keying on, Sampling Rate 1.0, Simplify 0.
13. Path Mode Copy with Embed Textures only if you want Unreal to create placeholder materials, otherwise leave it and import textures separately.
14. In Unreal, drag the FBX into the Content Browser. Import as Skeletal Mesh with Skeleton empty, Import Animations off, Convert Scene on, Convert Scene Unit on, Import Uniform Scale 1.0. Open the result and confirm the root bone reads Scale 1.0, the character faces +X, and the bone count matches Blender's deform bone count.
15. Import the animation FBX with Import Mesh off and Skeleton set to the one from step 14. Play a clip and watch feet and hands.

If step 14 shows Scale 100 on the root, go back to step 1 or 9. If the character faces the wrong way, step 2. If there's a bone called Armature, step 4. If the tree has _end bones, step 11.

The one-click route

Every setting above is a convention, and conventions are what software is for. The Cinevva Rig add-on ships an Unreal export preset that writes FBX with forward -Y and up Z, unit scale applied with FBX_SCALE_NONE, primary bone axis Y and secondary X, no leaf bones, face smoothing, and textures embedded and capped at 2048 px, so a rigged character from the add-on goes to Unreal without touching the exporter dialog. Before it exports, a size analysis splits the estimated file into geometry, textures, animation and shape keys, which is how you find out that the 40 MB character is 36 MB of 4K textures on a 3,000-triangle mesh. Against a plain Blender GLB export, the presets produced files 68%, 89%, 92% and 98% smaller on four real models. Export needs no key, no account and no network. The rigging half rigs a mesh to a skinned, Mixamo-named humanoid armature on your own machine, offline, after a one-time engine download of about 2.4 GB, for one $29 purchase (launch price) with no per-rig charge, and it runs on Blender 4.2 and newer on Windows, macOS and Linux. The same 260 CC0 clips it retargets in Blender come along in the FBX as separate actions, ready for step 15.

Common Questions

How do I export from Blender to Unreal Engine 5?

Select the mesh and armature, File > Export > FBX (.fbx), tick Selected Objects, set Apply Scalings to FBX All (or use a 0.01 Unit Scale scene with All Local), Smoothing to Face, Add Leaf Bones off, Primary Bone Axis Y and Secondary X, and Bake Animation with All Actions on. Rename the armature object to root first. In Unreal, drag the file into the Content Browser and import with Convert Scene and Convert Scene Unit on.

What are the correct Blender FBX export settings for Unreal?

Scale 1.0, Apply Unit on, Apply Scalings FBX All, Forward -Z, Up Y, Use Space Transform on, Apply Transform off, Smoothing Face, Apply Modifiers on, Primary Bone Axis Y, Secondary Bone Axis X, Armature FBXNode Type Null, Add Leaf Bones off, Key All Bones on, All Actions on, Simplify 0. These match what Epic's Send to Unreal add-on ships apart from the scaling choice, where Send to Unreal uses All Local and expects you to work at Unreal scale.

Why is my Blender model scale 100 in Unreal?

Because Blender's metre and Unreal's centimetre differ by 100, and with the exporter's defaults (Unit Scale 1.0, Apply Scalings All Local) that 100 gets multiplied into the armature object's transform, which Unreal then reads as the root bone. Either set the scene's Unit Scale to 0.01 and model at Unreal size, or export with Apply Scalings set to FBX All so the factor goes into the file header and Unreal's Convert Scene Unit applies it.

Why do my bones import rotated in Unreal?

Blender bones always run along their local Y axis, and the exporter's Primary Bone Axis Y with Secondary X writes that frame as-is. If you changed Primary to X because a Maya tutorial said to, every bone frame in the file turns 90 degrees relative to the skin and animation data. Set the axes back to Y and X and re-export both mesh and animations from the same file.

How do I get rid of the Armature root bone in Unreal?

You can't remove it with Blender's built-in exporter, but you can name it. Unreal turns the armature object into the root bone under the object's name, so rename the armature object (not the armature data) to root, keep it at the origin, and make the hips its first child. Send to Unreal and Better FBX Importer & Exporter can both drop the node and promote the first bone instead.

Is the Send to Unreal Blender add-on still maintained in 2026?

Barely. The last release is 2.4.3 from November 2023, tested on Blender 3.3 and 3.6 with Unreal 5.3, and the last code merge was July 2024. The repository is still public, not archived, and picked up a documentation commit in September 2026, but there's been no release for Blender 4.x. Test it on your Blender version before building a pipeline on it, and keep the manual checklist as the fallback.

How do I retarget Blender animations to the UE5 Mannequin?

Import your character as a Skeletal Mesh, create an IK Rig for it, Set Pelvis on the hips bone and press Auto Create Retarget Chains. Create an IK Retargeter with your IK Rig as Source and the Mannequin's shipped IK Rig as Target, check the chain mapping, fix the retarget pose if your rig is an A-pose, then select your animations and click Export Selected Animations. The same steps work in reverse to put Epic's animations on your character.

Related

• How Automatic Rigging Works: what a skeleton, bind pose and skin weights are, and how to prepare a mesh for rigging
• Free Character Animations and Auto-Rigging: CC0 clip libraries and free riggers to fill the Actions you'll export
• Blender to Unity Export Checklist: the same walk for Unity, where the axis and scale answers differ
• Blender to Godot Export Checklist: glTF instead of FBX, and why Godot skips most of this
• GLB Viewer: inspect a skeleton hierarchy, bone count and animations in the browser before you import
• Cinevva Rig for Blender: the add-on with the Unreal export preset and size analysis described above