Blender to Unity and Godot Export Pipeline - A Clean Art Handoff Checklist

Export pipelines are where “almost correct” turns into weeks of rework. Scale is off by 100x. Normals flip. UVs look fine in Blender but stretch in-engine. Materials get reinterpreted. Animations import with the wrong orientation or wrong root motion.

This article gives you a practical, engine-ready checklist to make Blender-to-Unity and Blender-to-Godot handoffs predictable. The goal is not to memorize export buttons. The goal is to build a repeatable workflow that catches problems before you send assets to the next person (or before you yourself rebuild the same fix three times).

If you want a companion learning path on the art side, use the Blender guide chapters on exporting and asset pipeline.

The “clean handoff” mindset (what you are really optimizing)

An art handoff is clean when:

The asset’s geometry matches your intent (scale, pivot, orientation)
The shading matches your bake and material design (normals, tangents, UVs)
The engine import does not require a bespoke ritual every time (consistent settings)
The textures are labeled and imported with correct types (albedo vs normal maps vs packed masks)
Animation and rig rules are consistent (even if you only export one type right now)

Everything in this checklist supports those five bullets.

Blender checklist before you export (do this once, then repeat)

1) Lock scale and units early

Decide your authoring unit target and stick to it.

Practical defaults that avoid surprises:

Model in Blender units that feel natural
Apply scale transforms before export
Export with consistent forward/up axes

Do not leave object scale unapplied and hope the engine importer “just handles it.”

Before exporting:

Select the object(s)
Apply transforms so scale is baked: Ctrl + A → Scale (and usually Rotation)
Keep a single “asset scale reference” object in your scene (for example a 1x1x1 cube) so you can sanity-check exports

Pro tip: If you are exporting many meshes for a kit, test scale with one “hero mesh” first. Then reuse the same export settings for the rest.

2) Set pivots where engines expect them

Unity and Godot both care about pivots because pivots become:

Rotation behavior in gameplay
Placement and snapping in level design
Animation transforms when you rig objects

Rule of thumb:

If the asset is meant to be placed, set the pivot at the logical base (feet/bottom, center-of-mass, or hinge point)
If the asset is a prop with a “use point” (e.g., door handle), pivot at the interaction anchor

Avoid pivots in the middle of nowhere. That turns every placement into a subtraction problem.

3) Fix orientation and axes intentionally

Blender uses different axis conventions than many engines. Export settings translate, but only if you use them consistently.

Checklist:

Confirm your forward axis (usually Blender +Y or -Z depending on your setup)
Confirm your up axis (commonly Blender +Z)
Export with explicit axis mapping

Common mistake: Rotating the object to “look right” in Blender, then letting a wrong export axis mapping create a second rotation in the engine.

If you care about consistent orientation, treat axis mapping as part of your pipeline contract.

4) UV sanity pass (especially for trim sheets)

Before export:

Ensure UV islands are not off-scale or overlapping unintentionally
If you use lightmaps, keep a separate UV layout for lighting (do not reuse the same UVs unless you truly intend to)
Avoid tiny UV islands that produce noisy bakes

Pro tip: Run a quick checker texture in Blender (or view the UV layout with a grid) so you catch distortion before textures ever reach the engine.

5) Normals and tangents: decide your source of truth

The fastest way to lose time is to “fix normals” in-engine because they look off. That often masks a pipeline issue.

Decide:

Are you shipping custom normals from Blender?
Are you relying on engine recomputation?

Practical approach:

If you do custom normals, export normals and ensure the engine import respects them
If you rely on engine recomputation, keep Blender’s normals consistent and let the engine do its job

Common mistake: Shipping custom normals but also enabling engine tangent/normals recomputation with different smoothing settings, which yields mismatched shading.

6) Material slot consistency (so engines map predictably)

Even if engines support automatic material creation, you still want your Blender material slots to be stable.

Checklist:

Use consistent naming for material slots
Keep slot order stable across exports (slot order changes can swap textures)
Avoid per-export random material duplicates created by automation scripts

If your team needs strict material mapping, treat material slots as part of your “API.”

Export format choice (FBX vs glTF vs “just whatever works”)

There is no single winner across every project. But you can choose based on what you need right now.

If you need animation (rigged meshes)

FBX is commonly used for character pipelines and animation-friendly workflows
glTF also supports animation, but pipeline expectations differ by project

If you want predictable PBR material workflow

glTF often preserves PBR material properties cleanly

If you want the shortest path to “engine compiles and looks right”

Choose one format, lock it as your studio default, then optimize after you have consistency

Pro tip: For a cross-engine pipeline (Unity + Godot), prefer fewer “special cases.” A format that behaves consistently across both engines is usually better than the format that is perfect in one engine.

Unity import checklist (the five places assets usually go wrong)

In Unity, the Model Importer settings are where your “pipeline contract” becomes real.

1) Verify scale and pivot in the importer

After import:

Check the preview size in the Model tab
Confirm scale is correct without manual per-mesh adjustments
Confirm forward/up orientation looks right

If you see repeated “fix scale in inspector” behavior, return to Blender transforms and axes instead.

2) Confirm normals mode

Unity may recompute normals/tangents depending on import settings.

If you exported custom normals, set import to use them
If you recompute, keep settings consistent across assets

Treat this as non-negotiable: toggling normals behavior per mesh leads to inconsistent shading.

3) Ensure normal maps are tagged as normal maps

Texture type matters.

Checklist:

Albedo textures: sRGB on
Normal maps: sRGB off (Normal map texture type)
Packed mask textures (R/M/A): keep channels consistent with how you author them

If you skip texture type checks, you get “why does it look flat” bugs that waste hours.

4) Material import strategy

Decide what you want:

Automatic material import and then you tidy
Scripted material creation
Manual material assignment from your library

For a clean handoff, prefer a repeatable method, not ad-hoc manual edits for every mesh.

5) Animation: root and clip sanity checks

If your asset has animation:

Confirm clip name mapping is correct
Confirm orientation and root motion expectations
Test playback on one instance with a quick scene

Pro tip: Add a simple “Animation Sanity” scene that loads one mesh instance, then run it after each export-format or importer setting change.

Godot import checklist (keep nodes and materials predictable)

Godot imports 3D models into scenes and resources. The importer can still reinterpret data, so verify the core assumptions.

1) Scene root: confirm the node type and transform

After import:

Confirm the root node type matches what you expect
Confirm scale/orientation/pivot in the scene tree

If every imported mesh ends up with extra rotation nodes or offsets, fix your export axis mapping rather than building “fix nodes” into your gameplay scenes.

2) Normal mapping and tangent basis

Godot’s shading depends on correct normals/tangents.

Checklist:

Ensure normal textures are imported with correct usage
Ensure you are not accidentally treating normal maps as sRGB

If lighting looks wrong, check material and texture type before you blame the renderer.

3) Materials and texture paths

Godot may create materials automatically. Decide if you:

Accept auto-generated materials
Or replace them with a studio material library

For clean handoffs, prefer the studio material library approach once your pipeline stabilizes.

4) Animation playback sanity

For animated assets:

Confirm animation lengths
Confirm track bindings
Confirm the root orientation matches your gameplay expectations

Cross-engine “handoff rules” (use these to prevent drift)

These rules protect you from differences between Unity and Godot importers.

Rule A: One asset = one contract

Every mesh export must conform to:

Scale/units standard
Pivot standard
Naming standard
UV and normal standard
Material slot standard

If an artist breaks the contract, the engine can still “import,” but your project will slowly accumulate inconsistencies.

Rule B: Maintain naming conventions as data

Examples:

SM_ for static meshes
SK_ for skeletal meshes (if you follow a character pipeline)
TX_ for textures
MAT_ for materials (if you maintain a material library)

Naming is how automation works without fragile manual steps.

Rule C: Make “import profiles” part of your workflow

Create named profiles (even if it’s just a document) for:

Static mesh import settings
Normal map settings
Animation import settings

This makes pipeline reviews possible.

Mini exercise: test your pipeline in 30 minutes

Pick one prop mesh and do this:

Export it from Blender with your standard format and axis mapping
Import into Unity and Godot
Verify:
- scale and pivot
- normals and shading
- textures types (normal maps tagged correctly)
- material slot consistency
If anything is wrong, fix in Blender or in importer profile, not in per-mesh manual tweaks

When you can pass this test reliably, you have the basis of a clean handoff pipeline.

Common mistakes to avoid (quick and painful)

Applying transforms inconsistently (some exports baked, some not)
Letting engine import settings override your intended normals
Forgetting normal maps texture type (sRGB on by accident)
Changing export axes mid-project
Reordering material slots between exports
Using packed texture channels inconsistently with your shader expectations

FAQ

What export format should I standardize for both Unity and Godot?

Standardize based on what you need most: animated characters often lean toward FBX, while PBR material workflows often lean toward glTF. The key is consistency. Pick one format as your default and lock importer profiles so results stay predictable.

Why do my normals look fine in Blender but wrong in-engine?

Usually one of these is happening: custom normals aren’t being preserved, tangents are recomputed differently, or smoothing settings differ. Check normals/tangent import settings first, then confirm texture types (especially normal maps).

Should I export lightmap UVs separately?

If you use baked lighting, yes. Keep a dedicated lightmap UV layout to avoid overwriting your primary UVs and creating fragile rework later.

How do I avoid redoing material setups every export?

Use a repeatable material strategy: either a studio material library that you apply consistently, or a scripted auto-assignment approach. Avoid manual edits per mesh once your project scales.

What is the fastest way to validate a pipeline change?

Update one “golden mesh” test case, then re-import it into both Unity and Godot and check the same five assumptions: transform scale/pivot, normals/shading, texture type correctness, material slot mapping, and animation sanity (if applicable).

Conclusion

Clean art handoffs are not luck. They are agreements: transform contracts, shading contracts, and importer profiles that stay stable over time.

Use this checklist to eliminate the common failure points between Blender, Unity, and Godot. Once your pipeline is boring, your project can move fast without paying for the same export mistakes again and again.

If you found this useful, bookmark it for your next asset export pass and share it with whoever’s doing rigging, materials, or final scene assembly.