Coordinate mismatches waste hours. Export a prop from Blender without the right settings and Godot 4 imports it rotated 90°, scaled by 100×, with missing textures — a frustrating but fully avoidable problem once you know the four parameters that matter.
Why GLB is the right format for Godot 4
Godot 4 treats GLTF 2.0 (and its binary sibling, GLB) as a first-class format. Unlike FBX, which requires Autodesk's proprietary SDK and produces inconsistent results across versions, GLB is an open standard that Godot's importer handles natively without any third-party bridge.
Key advantages of GLB for Godot 4:
- Single-file delivery — meshes, materials, textures, and animations are packed into one binary file
- PBR-native — GLTF 2.0's material model maps directly to Godot's `StandardMaterial3D`, so roughness, metallic, and normal maps arrive intact
- No FBX SDK dependency — no version mismatch errors, no missing DLLs
- Lossless animation — skeletal rigs and shape keys transfer without the float-precision issues common in FBX
If your pipeline already uses FBX for Unity, keep a separate GLB export pass for Godot. The BitSoul marketplace distributes all 747 models in GLB format precisely for this reason — one format, any engine.
Setting up Blender export options for Godot 4
In Blender, go to File → Export → glTF 2.0. The dialog has several tabs; here are the settings that matter:
### Format
Choose glTF Binary (.glb) — not the JSON variant. Binary keeps everything in one file.
### Include
- ✅ Selected Objects (if exporting a single asset)
- ✅ Custom Properties (needed if you use Godot metadata)
- ❌ Cameras and Lights — uncheck these unless your scene specifically needs them
### Transform
This is where most errors originate. Set:
- +Y Up — Godot uses Y-up; Blender's default is also Y-up, but verify this is checked
- Leave rotation at default (0, 0, 0)
### Geometry
- ✅ Apply Modifiers — bake subdivision, mirror, and boolean modifiers into the export
- ✅ UVs, Normals, Tangents — all three are required for correct normal map rendering
- ✅ Vertex Colors if your materials use them
- ❌ Loose Edges and Loose Points — no use in game assets
### Animation
- ✅ Export if the asset is animated
- Set Mode to `Actions` for character rigs, `Scene` for scene-level animation
Here's a minimal Python script to batch-export selected objects from Blender's scripting console:
```python
import bpy, os
export_dir = "/path/to/exports/"
os.makedirs(export_dir, exist_ok=True)
for obj in bpy.context.selected_objects:
if obj.type == 'MESH':
bpy.ops.object.select_all(action='DESELECT')
obj.select_set(True)
bpy.context.view_layer.objects.active = obj
filepath = os.path.join(export_dir, f"{obj.name}.glb")
bpy.ops.export_scene.gltf(
filepath=filepath,
export_format='GLB',
use_selection=True,
export_apply=True,
export_yup=True,
export_tangents=True,
export_normals=True,
export_texcoords=True
)
print(f"Exported: {filepath}")
```
Run this once per project and every selected mesh exports as a clean, engine-ready GLB.
Fixing scale and axis mismatches
The most common Godot import complaint: the model arrives 100× too large or rotated 90° on the X axis.
The scale problem
Blender works in metres by default. Godot 4 also uses metres internally. The problem arises when Blender's Unit Scale is set to something other than 1.0, or when artists model at centimetre scale without updating scene unit settings.
Fix before exporting:
- Open Scene Properties → Units
- Set Unit System to `Metric`, Unit Scale to `1.0`, Length to `Meters`
- If your mesh looks wrong after this, select all and use Object → Apply → Scale (`Ctrl+A → Scale`) to bake the current scale into the mesh
| Scenario | Blender unit | Godot result | Fix |
|---|---|---|---|
| Correct setup | 1 BU = 1 m | 1 Godot unit = 1 m ✅ | None |
| Centimetre scale | 1 BU = 1 cm | Model 100× too small ❌ | Apply scale, set Unit Scale = 1.0 |
| Legacy FBX import | 1 BU = 0.01 m | Model 100× too large ❌ | Apply scale after import |
| Accidental transform | Non-uniform XYZ | Stretched on import ❌ | Apply scale before export |
The axis rotation problem
GLTF 2.0 specifies Y-up, right-handed coordinates. Blender exports correctly when +Y Up is checked. If you previously exported with the FBX convention (+Z Up), Godot receives a mesh rotated -90° on the X axis.
If you receive a pre-existing GLB that arrives rotated, fix it inside Godot:
```gdscript
# Rotate the root node to correct a Z-up import
$MeshInstance3D.rotation_degrees = Vector3(-90, 0, 0)
```
Better practice: fix at export time. Correct Blender settings mean zero rotation corrections in Godot.
Embedding textures and PBR materials in GLB
GLB embeds textures as binary blobs inside the file — but only if Blender's material is set up correctly. A material using an Image Texture node connected to Principled BSDF will export properly. Procedural nodes (Noise, Voronoi, etc.) will not export — Blender will silently skip them.
PBR channel mapping
| Principled BSDF input | GLTF slot | Godot 4 slot |
|---|---|---|
| Base Color | `baseColorTexture` | Albedo |
| Metallic | `metallicRoughnessTexture` (B channel) | Metallic |
| Roughness | `metallicRoughnessTexture` (G channel) | Roughness |
| Normal Map | `normalTexture` | Normal |
| Emission Color | `emissiveTexture` | Emission |
| Alpha | `baseColorTexture` (A channel) | Transparency |
Both metallic and roughness must plug into the same Principled BSDF — not into separate materials. Blender's GLTF exporter handles the channel packing automatically.
Verify textures are embedded
After exporting, run a quick sanity check:
```python
import struct, json
with open('your_asset.glb', 'rb') as f:
f.read(12) # skip header
length = struct.unpack('<I', f.read(4))[0]
f.read(4) # chunk type
data = json.loads(f.read(length))
print('Textures:', len(data.get('images', [])))
print('Materials:', len(data.get('materials', [])))
```
If textures shows 0, your materials are using procedural nodes or unlinked image texture nodes. Fix the node graph and re-export.
Four checkpoints for a clean export
A reliable Blender → Godot 4 GLB pipeline comes down to these four checks before every export:
- Scene units set to metres, scale applied — no accidental 100× size surprises
- +Y Up checked in the GLTF exporter — correct orientation on import
- Apply Modifiers on, Loose Edges/Points off — clean geometry only
- Principled BSDF with image texture nodes — textures actually embed
With those four in place, assets arrive in Godot correctly oriented, correctly scaled, and with full PBR materials intact — no manual corrections in the inspector needed.
Browse 747 game-ready GLB models at the BitSoul marketplace — all exported with these settings applied, ready to drop into your Godot 4 project.
---
*This post is part of the Ultimate Guide to Free 3D Game Assets — BitSoul's complete reference for formats, texturing, rigging, optimization, and engine integration.*