Blender • Export and Interoperability

Exporting Models — Export models to OBJ/FBX/GLTF with correct scale and axis orientation

Ensure your 3D assets survive the journey between applications without broken scale, flipped axes, or mangled materials.

A three-dimensional axis with a modeled cube and movement controls.
Inside this lesson 10 sections 5 questions 8 figures

SECTION 1

Historical Context & Motivation

The challenge of moving 3D geometry between applications is as old as computer graphics itself. In the early decades of the field, studios wrote proprietary modeling software and rendered everything in-house, so interoperability was largely unnecessary. As the industry matured through the 1990s and 2000s, however, production pipelines grew to span multiple specialized tools—one for modeling, another for rigging, yet another for rendering or real-time display. The need for reliable interchange formats became acute, and the formats that emerged each reflected the priorities and technical assumptions of their era.

1992 • Wavefront OBJ Format

Wavefront Technologies publishes the OBJ specification as a simple, human-readable text format for polygon meshes. Its minimal design—vertices, normals, UVs, and face indices—makes it almost universally supported, but it carries no animation or material-graph data.

2006 • Autodesk FBX Consolidation

After acquiring Kaydara, Autodesk unifies its exchange pipeline under the FBX SDK. FBX becomes the de facto standard for skeletal animation, blend shapes, embedded textures, and scene hierarchy, though its proprietary binary format limits community tooling.

2015 • glTF 1.0 Published by Khronos

The Khronos Group releases glTF 1.0, designed explicitly as a GPU-friendly transmission format for WebGL and real-time engines. Its JSON-plus-binary architecture streamlines loading without heavy parsing.

2017 • glTF 2.0 & PBR Materials

glTF 2.0 introduces the metallic-roughness PBR material model, aligning neatly with Blender's Principled BSDF. The format quickly earns the moniker 'the JPEG of 3D' for its balance of fidelity and portability.

2020+ • Blender's Export Ecosystem Matures

Blender 2.8x through 4.x overhaul export panels with improved axis-conversion controls, scale multipliers, and format-specific options. Community add-ons further automate batch exports for game engines like Unity and Unreal.

Despite three decades of format development, the fundamental headaches remain surprisingly consistent: axis orientation and unit scale. Blender uses Z-up with meters by default; Unity uses Y-up with meters; Unreal uses Z-up with centimeters. A model that looks perfect in Blender can import into another tool rotated 90°, scaled 100× too large, or buried underground. This lesson equips you to diagnose and prevent those problems by understanding the technical underpinnings of each format and the export settings that govern the transformation.

SECTION 2

Core Principles & Definitions

Before touching any export panel, you need to internalize a small set of foundational concepts. These ideas apply regardless of which format you choose, and mastering them will save you hours of frustrating back-and-forth between applications.

1

Coordinate System Handedness

3D engines define space as either right-handed (Blender, OpenGL, glTF) or left-handed (DirectX, Unreal). Handedness determines the direction of the cross product and, consequently, which way 'forward' faces.
2

Up-Axis Convention

Blender and many CAD tools treat Z as up, while Unity, Maya, and glTF treat Y as up. The exporter must rotate all vertex data by −90° around X when converting from Z-up to Y-up.
3

Scene Scale & Unit System

Blender's default unit is 1 Blender Unit = 1 meter. Unreal Engine expects centimeters, so a 2 m tall character becomes 200 in Unreal. Export scale multipliers handle this conversion, but misusing them leads to giant or microscopic imports.
4

Apply Transforms Before Export

If an object has unapplied rotation or scale in Blender (visible in the N-panel), the exporter may bake those transforms incorrectly. Always Ctrl + A → All Transforms before exporting to avoid skewed geometry.
5

Format-Specific Material Mapping

OBJ uses a simple MTL file with no PBR support. FBX embeds Phong/Lambert materials. glTF 2.0 maps directly to the metallic-roughness PBR model. Choosing the right format means choosing the right material fidelity for your target.
✦

KEY TAKEAWAY

Think of exporting a 3D model like translating a document from one language to another. The 'grammar' of each format (its axis convention and unit system) differs, so you need a reliable translator—Blender's export settings—to rewrite the coordinates without losing meaning. If you skip the translation step, your model arrives in the target application speaking the wrong language: upside-down, sideways, or absurdly large.

SECTION 3

Visual Explanation — Axis Conventions Across Applications

Axis Orientation ComparisonBlender (Z-Up)XYZ (Up)Right-handed1 BU = 1 mUnity / glTF (Y-Up)XY (Up)ZLeft-handed (Unity)1 unit = 1 mUnreal (Z-Up)XYZ (Up)Left-handed1 unit = 1 cmBlender Z-Up → Y-Up conversion:Rotate −90° around X axis
The three columns show the axis conventions of Blender, Unity/glTF, and Unreal Engine respectively. Notice that Blender and Unreal both use Z-up but differ in handedness and unit scale, while Unity and glTF use Y-up. The annotation at the bottom indicates the rotation the exporter applies when converting from Blender's native Z-up to a Y-up target.

The diagram above distills the single most common source of export errors. When you see a model lying flat on its back in Unity or rotated 90° in Unreal, the root cause is almost always a mismatch between the source application's up-axis and the target's expectation. Blender's export dialogs provide explicit "Forward" and "Up" dropdowns that let you remap axes at write-time, but you must set them correctly—or rely on the format-specific defaults, which vary. For FBX export to Unreal, the recommended settings are Forward = −Y, Up = Z. For glTF, the spec mandates Y-up and the Blender exporter handles the rotation automatically if you leave the defaults untouched.

💡

Quick Check

Before exporting, open the N-panel in Blender's 3D viewport and confirm that your object's Location, Rotation, and Scale read (0, 0, 0), (0°, 0°, 0°), and (1, 1, 1) respectively. If they don't, press Ctrl + A → All Transforms to bake those values into the mesh data.

SECTION 4

How Axis Conversion & Scale Mapping Work

Under the hood, converting between coordinate systems is a straightforward matrix operation. Every vertex position (x, y, z) in Blender's Z-up, right-handed space must be transformed into the target's convention before being written to the file. Understanding the math—even at a high level—helps you diagnose unusual rotations or scales that automated presets don't cover.

Z-UP TO Y-UP ROTATION

Rx(−90°)=[100;001;0−10]R_x(−90°) = [ 1 0 0 ; 0 0 1 ; 0 −1 0 ]

This rotation matrix swaps the Y and Z components while negating the new Z, effectively converting Blender's (X, Y, Z) into glTF's (X, Z, −Y). Blender's glTF exporter applies this automatically.

SCALE CONVERSION

vtarget=S×R×vblenderwhereS=diag(s,s,s)v_target = S × R × v_blender where S = diag(s, s, s)

S is the uniform scale matrix. For Blender (meters) → Unreal (centimeters), s = 100. For Blender → Unity (meters), s = 1. The FBX exporter's "Apply Scalings" and "Scale" fields control this multiplier.

COMPOSITE EXPORT TRANSFORM

vexported=S×Raxis×Tapply×vlocalv_exported = S × R_axis × T_apply × v_local

Tapply represents the object's unapplied transforms (location, rotation, scale from the N-panel), Raxis is the axis-conversion rotation, and S is the unit-scale factor. If Tapply ≠ Identity, the final result may include unexpected offsets or shearing.

In practice, you rarely need to compute these matrices by hand—Blender's export panels handle them for you. The critical takeaway is that axis conversion and scale are applied as a single composite transform to every vertex, normal, and bone at export time. If your object has unapplied transforms (Tapply ≠ I), those non-identity values compound with the axis rotation and scale, producing misaligned or distorted results. This is precisely why the "apply all transforms" step is non-negotiable.

SECTION 5

OBJ, FBX, and glTF — Feature Comparison

Choosing an export format is not merely a matter of personal preference—it determines which data survives the transfer and how faithfully your materials, animations, and scene hierarchy are reproduced. The table below provides a detailed comparison, and the diagram that follows visualizes the data pipeline for each format.

FeatureOBJ (.obj)FBX (.fbx)glTF 2.0 (.glb/.gltf)
Mesh Geometry✓ Vertices, normals, UVs, faces✓ Full mesh data✓ Full mesh data
MaterialsMTL file (diffuse color, basic textures)Phong/Lambert; embedded texturesMetallic-roughness PBR; KHR extensions
Skeletal Animation✗ Not supported✓ Bones, skinning, blend shapes✓ Bones, skinning, morph targets
Scene Hierarchy✗ Flat mesh only✓ Nodes, cameras, lights✓ Scene graph with nodes
Default Up-AxisVaries (often Y-up)Y-up (configurable)Y-up (spec-mandated)
File StructureASCII text + MTLBinary or ASCII (binary default).gltf (JSON+bin) or .glb (single binary)
Best Use CaseQuick geometry transfer, 3D printingAnimation pipelines, Unreal/Unity legacyWeb, real-time engines, PBR workflows

Feature comparison of the three primary export formats available in Blender.

Export Pipeline: Blender → Target ApplicationBlender SceneZ-Up, MetersRight-HandedEXPORT ENGINE1. Apply Transforms (T)2. Axis Rotation (R)3. Scale Factor (S)4. Material ConversionOBJ ExportForward: −Z Up: Y (default)Scale: 1.0 | No animationFBX ExportForward: −Z Up: YScale: 1.0 or 100 for UEglTF / GLB ExportY-Up mandated by specAuto axis conversion | PBRComposite transform per vertex: v_exported = S × R_axis × T_apply × v_local
This pipeline diagram shows how Blender's export engine applies transforms (T), axis rotation (R), scale (S), and material conversion before writing data to each format. The OBJ path yields the simplest output, FBX preserves animation and hierarchy, and glTF enforces Y-up and PBR material mapping automatically.

A few nuances deserve emphasis. The OBJ format has no formal spec for up-axis; different applications interpret it differently, making the Forward/Up dropdown in Blender's OBJ exporter especially important. The FBX format stores axis information in its header, so the importing application can (in theory) auto-correct—but in practice, Unreal's FBX importer expects specific settings and will misbehave if the header disagrees with its assumptions. glTF eliminates ambiguity by mandating Y-up, right-handed coordinates and meters in its spec, making it the most predictable choice for web and cross-engine projects.

SECTION 6

Worked Example — Exporting a Character to Unreal Engine via FBX

Let's walk through a complete export scenario. You have modeled and rigged a humanoid character in Blender 4.x, standing upright at 1.8 meters tall on the world origin. You need to export it to Unreal Engine 5 as an FBX file with correct scale, orientation, and skeletal hierarchy.

FBX Export to Unreal Engine 5

  1. 1

    Step 1 — Verify Scene Units

    Open Properties → Scene → Units. Confirm Unit System is set to "Metric" and Unit Scale is 1.0. If your scene was authored at a different scale (e.g., 0.01 for centimeters), note this—you will need to compensate in the export dialog.
    Unit System = Metric, Unit Scale = 1.0 (1 BU = 1 m)
  2. 2

    Step 2 — Apply All Transforms

    Select the armature and all mesh objects (A to select all, then filter if needed). Press Ctrl + A → All Transforms. Check the N-panel to verify that Location = (0, 0, 0), Rotation = (0°, 0°, 0°), and Scale = (1, 1, 1) for every selected object. This zeros out Tapply in our composite formula.
    All transforms applied — T_apply = Identity
  3. 3

    Step 3 — Open FBX Export Dialog

    Go to File → Export → FBX (.fbx). In the sidebar panel, expand the Transform section. Set Scale = 1.00 (Unreal handles the meter-to-centimeter conversion on import). Set Apply Scalings = 'FBX All', Forward = −Y Forward, Up = Z Up.
    Scale = 1.00 | Apply Scalings = FBX All | Forward = −Y | Up = Z
  4. 4

    Step 4 — Configure Armature & Animation Settings

    Under the Armature tab, enable Add Leaf Bones: OFF (Unreal doesn't need Blender's leaf bones and they clutter the skeleton). Set Primary Bone Axis to Y and Secondary Bone Axis to X. If exporting animations, ensure "Bake Animation" is checked and the frame range matches your action.
    Leaf Bones OFF | Bone Axis: Y primary, X secondary
  5. 5

    Step 5 — Export & Verify in Unreal

    Click "Export FBX". In Unreal Engine, drag the .fbx file into the Content Browser. The import dialog should show the character at approximately 180 cm tall (1.8 m × 100 cm/m), standing upright with the skeleton hierarchy intact. If the character appears on its side, revisit the Forward/Up settings. If it appears 100× too large or too small, adjust the Scale field or check whether Unreal's import scale override is set to something other than 1.0.
    Character imports at 180 UU (Unreal Units = cm), upright, skeleton intact ✓
⚠

Common Pitfall

If you set Scale = 100 in the Blender FBX exporter AND Unreal's import dialog also applies a ×100 multiplier, your character will be 10,000× too large—a 1.8 m human becomes 18 km tall. Keep Blender's export scale at 1.0 and let the receiving engine handle unit conversion.

SECTION 7

Strengths & Limitations of Each Format

No single export format is universally superior. Each occupies a niche defined by its historical origins, target audience, and technical priorities. The table below synthesizes practical strengths and limitations to guide your format selection in production scenarios.

FormatStrengthsLimitations
OBJNear-universal import support; human-readable ASCII; excellent for static meshes and 3D printing; minimal dependenciesNo animation, no skeletal data, no scene hierarchy; basic MTL material system; ambiguous axis convention across importers
FBXRich animation support (bones, blend shapes, keyframes); embeds textures; deeply integrated with Autodesk and game-engine pipelines; stores scene hierarchyProprietary Autodesk format; binary version is opaque; Blender's implementation relies on reverse-engineered SDK; axis/scale headers can confuse non-Autodesk importers; material model is pre-PBR
glTF 2.0Open spec (Khronos); PBR metallic-roughness model maps to Principled BSDF; GPU-optimized binary buffers; mandated Y-up eliminates axis ambiguity; rapidly growing adoption in web, AR/VR, and game enginesLimited support for complex node-based Blender shaders (only Principled BSDF maps well); some older engines lack importers; certain advanced features require KHR extensions not all viewers support

Practical strengths and limitations for production use.

✦

KEY TAKEAWAY

Think of these three formats as three shipping containers of different sizes. OBJ is a flat cardboard box—cheap, simple, and works for a single item with no moving parts. FBX is a reinforced crate with custom foam inserts—it holds animated, articulated objects safely but requires proprietary packing materials. glTF is a standardized ISO container—engineered for maximum interoperability, efficient loading, and a modern material spec that any compliant port (engine) can unpack identically.

SECTION 8

Connections to Advanced Pipelines & Emerging Formats

The OBJ/FBX/glTF triad covers the majority of export needs today, but the interoperability landscape continues to evolve. Pixar's Universal Scene Description (USD) is emerging as the backbone for large-scale collaborative pipelines in film VFX, offering a compositional scene graph that can layer contributions from multiple artists and tools non-destructively. Blender 4.x now ships with a native USD exporter, and understanding its axis and scale conventions—Y-up, meters, right-handed—will become increasingly important as USD adoption grows.

AspectCurrent Workflow (OBJ/FBX/glTF)Advanced Pipeline (USD & Beyond)
Collaboration ModelSingle artist exports → single file → single importLayered composition; multiple artists contribute to a shared scene graph via references
Axis/Scale HandlingPer-format conventions; manual configuration in export dialogsmetersPerUnit and upAxis metadata in the USD stage; engines auto-correct
Material SystemMTL / Phong / metallic-roughness PBRUsdPreviewSurface (PBR), MaterialX for full shader graphs
Typical UsersSolo artists, indie studios, game development, web 3DFeature film VFX, large game studios, AR platform pipelines (Apple, NVIDIA Omniverse)

Current export workflows compared to emerging USD-based pipelines.

Even as USD matures, the principles you've learned here remain directly applicable. Every interchange format must resolve the same fundamental questions: which direction is up, what does one unit mean, and how do we encode surface appearance? By internalizing these questions now with OBJ, FBX, and glTF, you build a conceptual framework that transfers seamlessly to any future format.

SECTION 9

Practice Problems

Question 1: CONCEPTUAL

Explain why a model exported from Blender might appear rotated 90° when imported into Unity. In your answer, identify the specific axis-convention mismatch and describe the transformation the exporter should apply to correct it.
Show answer
Blender uses a Z-up coordinate system while Unity uses Y-up. If the exporter does not apply the −90° rotation around the X-axis (the RxR_x(−90°) matrix), the model's vertical Z-axis aligns with Unity's depth axis (Z), causing the model to lie flat on its back. The exporter must swap the Y and Z components of every vertex, rotating Z-up data into Y-up space. Enabling the correct Forward/Up settings in the export dialog (or relying on glTF's automatic conversion) resolves this mismatch.

Question 2: BASIC CALCULATION

A character in Blender is 1.75 meters tall. You export it to Unreal Engine using FBX with an export scale of 1.0. What height in Unreal Units (centimeters) should the character appear at import? If you accidentally set the export scale to 100 and Unreal also applies its default ×1 cm conversion, what height would result?
Show answer
With export scale = 1.0, Blender writes the character as 1.75 units. Unreal interprets FBX units as centimeters by default and applies its internal conversion, reading 1.75 m correctly as 175 cm (175 Unreal Units). If you set export scale = 100 in Blender, the file encodes the character as 175 units. Unreal then reads those 175 units as 175 cm—which happens to be correct in this specific case. However, this accidental double-intent can cause problems with physics, lighting, and other scene elements that rely on consistent unit interpretation. Best practice: keep Blender's export scale at 1.0 and let Unreal handle the conversion.

Question 3: INTERMEDIATE

You have a scene in Blender with three objects: a table, a chair, and a lamp. The table has an unapplied scale of (1.0, 1.0, 2.0) in the N-panel. You export the entire scene to glTF without first applying transforms. Describe specifically how the table will appear in a glTF viewer versus the chair and lamp, and explain what Blender operation would have prevented the issue.
Show answer
The chair and lamp, assuming their transforms are clean (scale = 1,1,1), will appear correctly in the glTF viewer. The table, however, has an unapplied scale of 2.0 on the Z-axis. When the glTF exporter applies the Z-up to Y-up axis conversion, this non-uniform scale interacts with the rotation matrix, potentially causing the table to appear stretched along an unexpected axis (the former Z, now mapped to Y) or producing skewing artifacts if the scale isn't cleanly decomposable after rotation. Pressing Ctrl+A → All Transforms on the table before export would bake the (1, 1, 2) scale into the mesh vertices themselves, making the object-level scale identity and ensuring the axis conversion applies cleanly.

Question 4: APPLIED

You are building a portfolio website that displays 3D models in the browser using Three.js. You need to export an environment scene from Blender that includes PBR materials (metallic surfaces, rough wood, emissive signage) and should load as a single file with no external dependencies. Which format do you choose, what specific export settings should you use, and why?
Show answer
Choose glTF 2.0 in the GLB container format (.glb). GLB packs JSON metadata, binary mesh data, and all texture images into a single self-contained file—no external dependencies. The glTF metallic-roughness PBR model maps directly to Blender's Principled BSDF, so your metallic, roughness, and emissive channels will transfer faithfully. In the export dialog, ensure 'Format' is set to 'glTF Binary (.glb)', leave the axis conversion at its defaults (the exporter auto-converts Z-up to the spec-mandated Y-up), and check 'Include → Materials' and 'Images → Include' to embed textures. Three.js has a native GLTFLoader that parses these files efficiently, and the PBR materials will render correctly with Three.js's MeshStandardMaterial without manual remapping.

Question 5: CRITICAL THINKING

A colleague argues that since Blender and Unreal Engine both use Z-up, you should be able to export an FBX from Blender with no axis conversion at all—just pass the raw coordinates through. Critically evaluate this claim. Under what circumstances might it seem to work, and under what circumstances would it fail? Discuss handedness, forward-axis convention, and how FBX header metadata factors in.
Show answer
While both applications use Z-up, they differ in handedness: Blender is right-handed (Y-forward, Z-up) while Unreal is left-handed (X-forward, Z-up). This means that even with the same up-axis, the forward direction and the cross-product direction are different—a model facing 'forward' in Blender's +Y will face sideways in Unreal. Additionally, the FBX format stores its own axis metadata in the file header. When you set Forward = −Y and Up = Z in Blender's exporter, it writes these conventions into the header, and Unreal's importer reads them to apply any necessary correction. If you bypass Blender's axis conversion entirely (e.g., by setting Forward = Y, Up = Z), the FBX header will declare a coordinate system that Unreal may or may not auto-correct, depending on version. The approach might appear to work for simple static meshes viewed from certain angles, but it will produce incorrect facing direction for characters (they'll look sideways), mirror-flipped normals on some faces, and potentially inverted winding order on animated skeletons. The safe practice is always to use Blender's recommended FBX export presets and test-import before committing to a pipeline.

SUMMARY

Lesson Summary

Summary

Exporting 3D models from Blender requires understanding three interrelated concepts: axis orientation (Z-up vs. Y-up, and right-handed vs. left-handed), unit scale (meters in Blender vs. centimeters in Unreal, for example), and applied transforms (ensuring that object-level Location, Rotation, and Scale are baked into the mesh with Ctrl+A before export). The composite export transform, vexported = S × Raxis × Tapply × vlocal, encapsulates these operations in a single matrix multiplication per vertex.

Among the three primary formats, OBJ is best for quick static-mesh transfers and 3D printing, FBX remains essential for animated assets destined for game engines, and glTF 2.0 is the modern standard for PBR-ready, GPU-optimized delivery on the web and in real-time engines. Regardless of format, always verify your export by test-importing into the target application, checking that the model stands upright, is the correct size, and retains its materials and hierarchy. As the industry moves toward USD and collaborative scene graphs, the foundational concepts of axis convention and unit mapping will remain the bedrock of every interoperability workflow.

Varsity Tutors • Blender • Exporting Models — Export models to OBJ/FBX/GLTF with correct scale and axis orientation