How to Fix “Looks Right in Blender, Wrong in Engine”

If your model looks perfect in Blender but imports to Unity/Unreal at the wrong size, rotated weirdly, or with chaotic collisions, you’re probably fighting units, scale, and axes.

This guide shows you exactly how to set things up—first the concepts, then a repeatable workflow you can do manually, and finally how to automate the checks and guards with the Unit & Scale Doctor Blender add-on (so mistakes don’t slip through).

You’ll end this tutorial able to:

1. Author assets at real-world size with correct unit scale
2. Avoid unapplied/non-uniform/negative scale pitfalls
3. Export with correct axes for Unity/Unreal/glTF
4. Verify your dimensions visually in Blender before export
5. Optionally block bad exports with a one-click guard

Supplies (What You Need)

1. Blender 3.0–4.4+ (tested on 3.6 LTS & 4.4)
2. Unity 2021+ or Unreal Engine 5+ (for import checks)
3. (Optional but recommended) Unit & Scale Doctor add-on (ZIP)
4. A test model (e.g., a door that should be ~2 meters tall)

Time: 15–30 minutes

Difficulty: Beginner → Intermediate

Cost: Unit & Scale Doctor $15 (MIT-licensed)

Files / Downloads

1. Unit & Scale Doctor (ZIP) – install in Blender Add-ons
2. (Optional) Sample “2m Door” .blend/.fbx for sanity checks

Why this matters: Every “it’s 10× too big/small in engine” story traces back here.

1. Units
2. Blender’s Unit Scale (Scene › Units › Unit Scale) defines what 1 BU (Blender Unit) represents.
3. 1.0 = meters, 0.01 = centimeters, 0.001 = millimeters.
4. Unity assumes meters; Unreal assumes centimeters.
5. Scale
6. Unapplied (not 1,1,1) breaks colliders and physics.
7. Non-uniform (e.g., 1.0, 2.0, 1.0) introduces shear and bad normals if baked late.
8. Negative (e.g., −1 on X) mirrors geometry; after applying you must recalculate normals.
9. Axes (Up/Forward)
10. Unity FBX: Forward −Z, Up Y
11. Unreal FBX: Forward X, Up Z
12. glTF: meters; exporter handles Y-up

Decide once, document it, and stick to it:

1. Unity / glTF pipelines: Meters (Unit Scale = 1.0)
2. Unreal pipelines: Centimeters (Unit Scale = 0.01)
3. CAD handoff: Millimeters (Unit Scale = 0.001)

With USD: Select Target Profile (Unity/Unreal/glTF/CAD). The tool adapts rulers, labels, and export guards for you.

Create a reference cube. If your project is in meters, make a 2.0 m tall door (or a 2 m cube stack).

If your scene is in centimeters, the same door should read 200 cm high.

With USD: Turn on the Ruler Overlay to see dimensions (AABB/OBB cage + labels) right on the model.

Open each asset and look for:

1. Scale ≠ (1,1,1)
2. Non-uniform scale
3. Negative scale (mirrored)
4. Parent objects that are scaled
5. Scene unit mismatch vs the target profile

With USD: Click Run Detection. You’ll get a compact summary in the UI and a detailed list in the console:

unapplied, nonuniform, negative, parentScaled, sceneMismatch

1. For static meshes: Apply Scale (Object › Apply › Scale).
2. If the object was mirrored (negative): Apply and then Recalculate Normals.
3. Skip armatured meshes unless you intend to freeze them—baking transforms on rigs can break skinning.
4. Align your Scene Unit Scale to match your target profile.

With USD:

1. Align Scene Units (does not rescale vertices).
2. Apply Scale on Meshes (safe on statics).
3. Fix Negative Scales auto-recalculates normals.
4. Skip Armature option protects rigged characters.

1. AABB (Axis-Aligned Bounding Box): quick, world-aligned bounds.
2. OBB (Oriented Bounding Box): “true” extents aligned to the object’s local axes—best for rotated meshes.
3. Place labels inside the box and set precision.
4. Use standard colors (X red, Y green, Z blue).
5. “Draw On Top” helps in dense scenes.

With USD: Toggle Use OBB, Fill Alpha, On Top, Label Precision, Colorize Labels.

FBX axis presets that just work:

1. Unity/glTF: Forward −Z, Up Y
2. Unreal: Forward X, Up Z
3. glTF exporter typically handles Y-up for you.

With USD: Use Export (Guarded) for FBX/glTF. If violations exist, export is blocked with a clear toast and a JSON-style report in the console.

Import your FBX/glTF.

Ensure Import Scale = 1 (avoid mysterious importer scale factors).

A 1 m Unity cube should match your 1 m Blender cube.

Your 2 m door should be ~2 units tall.

Default unit is centimeter (1 Unreal Unit = 1 cm).

Your 2 m door should be 200 UU tall.

If it isn’t, your Blender unit scale or FBX axis preset is wrong.

Catch issues before assets merge:

1. Run Blender headless in your pipeline.
2. Emit a JSON report and exit non-zero on violations.
3. Archive the report as a build artifact.

With USD: Headless validation is built-in. Example shape of the report:

Set Scene Unit Scale for your target (m/cm/mm).

Check each object’s scale; apply on statics; recalc normals after mirrors.

Ensure parent objects aren’t scaled.

Use the proper FBX axis preset on export.

Keep a reference cube in Unity/Unreal to confirm size.

Maintain a written checklist (see next step).

Authoring

1. Scene units match target (m/cm/mm)
2. Object is real-world size
3. Scale applied on statics (1,1,1)
4. No negative scale (or normals fixed)
5. No non-uniform scale
6. Parent not scaled

Export

1. FBX axes set (Unity/glTF: −Z/Y; Unreal: X/Z)
2. glTF Y-up enabled if applicable
3. No violations in fail-on list

Engine Import

1. Unity Import Scale = 1
2. Unreal grid sanity check (2 m = 200 UU)

Troubleshooting & FAQs

It’s 10× bigger/smaller in engine.

Your Scene Unit Scale didn’t match the engine. Fix units (m vs cm), re-export.

Colliders behave weirdly.

Apply unapplied/non-uniform scale. Regenerate colliders. Check negative scales.

After mirroring, my mesh looks inside-out.

Apply scale, then Recalculate Normals.

Will fixes break rigs?

Don’t apply scale on meshes with Armature unless you intend to freeze them.

Why do Y/Z labels “swap” with Unity?

Unity is Y-up. If your Blender scene is Z-up, profile-aware overlays will remap labels so what you see matches engine expectations.

Why Use Unit & Scale Doctor Here?

You can do all of this manually. USD just makes it faster and repeatable:

1. Detects the real problems (unapplied, nonuniform, negative, parentScaled, sceneMismatch)
2. Fixes scene units and scale safely (with normals after mirror; skip armatures by default)
3. Visualizes truth with AABB/OBB cages, axis lines, and on-mesh labels (colorized, precision, on-top)
4. Guards exports (FBX/glTF) with a configurable fail-on list and a JSON-style console report
5. Validates headlessly for CI (JSON + exit codes)

If your goal is “no surprises in engine,” automation is the easiest win.

Credits & License

1. Tool: Unit & Scale Doctor (MIT)
2. Author: Anvil Interactive Solutions
3. Works on Windows/macOS/Linux; Blender 3.0–4.4+

What to Upload to Instructables With This Guide

1. Screenshots:
2. Scene Units panel
3. Detection summary
4. AABB vs OBB cages with labels
5. Export guard toast
6. Unity and Unreal size checks
7. Optional sample files (2 m door)
8. USD add-on ZIP (or link)
9. PDF of the Printable Checklist

Final Thought:

Units, scale, and axes don’t shout when they’re wrong—they just ruin your day downstream. Decide your profile, make dimensions visible, and enforce correctness at export. Whether you use the manual workflow or Unit & Scale Doctor, your assets—and your physics—will behave.