If you’ve ever exported a model that looks perfect in Blender but shows up in Unity or Unreal at the wrong size — or worse, your colliders go feral — you’ve met the quiet trio that breaks pipelines: units, scale, and axes. This article is a deep, practical walkthrough of how those systems work across Blender, Unity, Unreal, and glTF, how to bulletproof your workflow, and how to audit and enforce correctness without slowing your team down.

Subtle plug, zero fluff: we’ll use examples from Unit & Scale Doctor, a Blender add-on that audits, visualizes, and guards exports. You can do these steps by hand; the tool just makes them fast and repeatable.

1) The three invisible problems 1.1 Units Unity: meters by convention. Unreal: centimeters by default. glTF: meters (Y-up convention in the spec; exporters handle transforms). Blender: configurable; Scene > Units > Unit Scale (scale_length) controls how big one Blender Unit (BU) is. Rule of thumb: if your door is 2 m in Blender but your engine thinks your scene is in centimeters, you’ll be off by 100×.

1.2 Scale Unapplied scale (object scale ≠ 1,1,1) silently affects physics, colliders, and skinning in engines. Non-uniform scale (e.g., 1.0, 2.0, 1.0) introduces shear and bad normals if baked late. Negative scale (−1 on an axis) is a mirror; without a normals fix, your mesh is inside-out. 1.3 Axes (Up/Forward) Engines disagree:

Unity (typical FBX settings): Forward −Z, Up Y Unreal: Forward X, Up Z glTF: exporter handles Y-up; keep scene in meters. Get these wrong and your asset arrives rotated, or your “up” ruler points sideways.

2) How Blender actually measures things Two key facts:

Geometry is authored in BU (Blender Units). Unit scale tells you how many meters a BU represents: 1.0 = meters 0.01 = centimeters 0.001 = millimeters To compute a world-space dimension in meters:

meters = BU_length × scale_length To display in a target unit, multiply meters by the unit factor (100 for cm, 1000 for mm).

Why this matters: if your scene’s scale_length is 0.01 (cm) but your engine expects meters, you’ll see “correct” numbers in Blender and incorrect numbers after export.

3) The exporter gotchas (and how to avoid them) FBX axis settings matter. Typical presets: Unity/glTF: Forward −Z, Up Y Unreal: Forward X, Up Z Applying scale in Blender before export makes colliders behave. Do not apply on armatured characters unless you intend to — bake transforms can wreck skinning. glTF: keep meters; use the exporter’s Y-up option (most Blender glTF exporters handle this). Safety net: block exports if the scene is misconfigured. You can enforce this manually with a checklist — or automatically with a guard.

4) A pipeline-proof checklist (copy this) Authoring (per asset):

Scene set to the intended unit before modeling (m, cm, or mm). Object is real-world size (sanity check with a 2 m “door” cube). Scale applied (1,1,1) on static meshes; skip armatured meshes unless planned. No negative scale; if mirrored, recalc normals after apply. Non-uniform scale eliminated where possible. Export:

FBX axes set for target (Unity/Unreal as above). glTF: meters, Y-up enabled. No violations in the “fail-on” list (see below). Engine import:

Unity: ensure no surprise “scale factor” applied in the importer; verify a 1 m cube = 1 unit. Unreal: verify 100 UU ≈ 1 m; your 2 m door is 200 UU tall. 5) Seeing is believing: in-viewport rulers You can eyeball dimensions — or you can draw them. The most reliable way to debug unit assumptions is to overlay measurements:

AABB cage: quick, world-aligned bounds. OBB cage: “true” extents aligned to the object’s local axes (rotation-aware). Axis lines that respect your target profile’s up/forward. On-mesh labels with units (m/cm/mm) and precision, placed inside the cage. This instantly reveals whether your “Y-up” target profile expects Blender’s Z dimension to be labeled Y (e.g., Unity). It also exposes suspicious non-uniform dimensions.

In Unit & Scale Doctor you toggle AABB/OBB, Draw On Top, Fill Alpha, and Colorized Labels (X red, Y green, Z blue). Do the same if you roll your own overlay.

6) Fixing the actual problems 6.1 Align scene units to the target If your team ships to Unity, set meters (scale_length = 1.0). Unreal pipelines often prefer centimeters (0.01). CAD prep often uses millimeters (0.001). Decide once; document it.

6.2 Apply scale on static meshes Apply transforms so scale reads (1,1,1). This bakes transforms into vertices and keeps physics sane.

6.3 Handle mirrors properly If you mirrored (negative scale), apply scale and recalculate normals so the mesh isn’t inside-out.

6.4 Respect rigs Skip applying transforms on meshes with an Armature modifier unless you’re freezing a character with intent. Engines can import rig scale safely if authored consistently.

7) Enforcing standards without slowing down Checklists work — until they don’t. The easiest way to keep teams honest is to gate exports:

Define a fail-on list your pipeline won’t accept: negative, nonuniform, parentScaled, unapplied, sceneMismatch On export, fail fast with a human-readable message and a machine-readable report: Toast: “Export blocked. Violations: negative, sceneMismatch…” Console JSON: profile, scene scale, counts, per-object reasons. This is the “guarded export” pattern. Unit & Scale Doctor implements it for FBX/glTF; you can script your own if you prefer.

8) CI: catch bad assets before they merge Run Blender headless in your CI to scan pull requests or vendor drops. The validator should:

Print a JSON report to disk for artifacts. Exit non-zero when violations exist. Example shape of a report you want to archive:

{ “profile”: “UNITY”, “scene_scale_length”: 0.01, “target_scale_length”: 1.0, “sceneMismatch”: true, “counts”: {“total”:12,“unapplied”:3,“negative”:1,“nonuniform”:2,“parent_scaled”:1}, “issues”: [ {“name”:“Door_L”,“reasons”:“unapplied,nonuniform”}, {“name”:“Panel_A”,“reasons”:“negative”} ] } This makes asset reviews factual, not subjective.

9) Unity & Unreal specifics you should sanity-check Unity: a 1 m Blender cube should measure 1 unit with import scale = 1. If your importer shows 100, you’ll multiply errors you already have. Unreal: default unit is centimeter; 2 m door = 200 UU. FBX axis preset (X forward, Z up) keeps rotations stable. glTF: keep meters; use the exporter’s Y-up option. Good for DCC-to-web, DCC-to-Godot, and PBR-centric pipelines. Avoid “mystery scale factors.” If you must use one, document why and standardize it across the whole project.

10) A minimal, repeatable workflow (single artist) Set Target Profile (Unity m / Unreal cm / glTF m / CAD mm). Run detection; fix sceneMismatch first (align scene units). Apply scale on static meshes; fix mirrored normals if any are negative. Toggle ruler overlay and confirm expected dimensions (AABB for quick, OBB for rotated). Export guarded; if it fails, fix the named objects, re-export. In engine, drop a 1 m reference cube alongside your asset. If the door isn’t 2 cubes tall, something upstream is lying. 11) A minimal, repeatable workflow (team/CI) Pre-merge job: Headless validation with strict fail-on rules. Upload JSON report as a build artifact. Block the PR if exit code ≠ 0. Export job: Guarded export to FBX/glTF; store logs alongside artifacts. Optional: snapshot a screenshot grid with rulers for visual documentation. Press enter or click to view image in full size

12) Where the tool fits (and what it replaces) You can do all of this by hand with discipline:

Manually check scale_length, apply transforms, fix normals, choose FBX axis presets, and run test imports into both engines. Or you can compress it to minutes:

Unit & Scale Doctor scans for unapplied, nonuniform, negative, parentScaled, and sceneMismatch; Fixes scene units and scale safely (skip armatures by default; recalcs normals for mirrors); Visualizes true dimensions with AABB/OBB cages and profile-aware axis lines/labels; Guards FBX/glTF export with fail-on rules and a JSON-style console report; Validates in CI headlessly with exit codes. The “promotion” here is simple: automated enforcement removes human drift. Use any method you like — just enforce it.

13) Common failure stories (and how to not repeat them) “It’s 10× bigger in Unity.” Scene was in centimeters but engine expected meters. Align scene units; verify a 1 m reference in both apps. “Collision bounds are wrong.” Non-uniform or unapplied scale. Apply scale on statics; regenerate colliders; verify with rulers. “Normals flipped after mirroring.” Negative scale left un-fixed. Apply scale and recalc normals. “Character exploded.” Skinned mesh had transforms baked. Keep Skip Armature enabled unless you’re freezing deliberately. 14) Final takeaway Units, scale, and axes don’t announce themselves — they just ruin your day downstream. Decide your target profile, make the truth visible in the viewport, and enforce it at export. Whether you codify a checklist or use a tool that does it for you, the outcome should be the same:

Correct size. Correct axes. Predictable physics. Every time.

If you want the fast path, Unit & Scale Doctor is available on Superhive. If you prefer doing it by hand, feel free to lift the checklists and CI patterns above. Either way, your assets — and your physics — will thank you.