Mastering the Blender-to-Godot 4 GLB pipeline means fewer import surprises and faster iteration on game-ready assets. This guide covers every decision point: from export settings and collision mesh naming, to shader compatibility and animation clip setup — so your assets arrive in Godot exactly as modelled.
Configure Blender export settings for Godot 4
Godot 4 uses a GLB importer that is strict about transform data, axis conventions, and material structure. Getting these right in Blender's export dialog saves hours of manual correction.
Open File → Export → glTF 2.0 (.glb/.gltf) and configure:
- Format: Binary (.glb) — single file, smaller footprint, no external texture dependencies
- Transform: Enable +Y Up — Godot 4 uses Y-up by default
- Geometry: Enable Apply Modifiers (except Armature), UVs, Normals, Tangents, Vertex Colors if used
- Shading: Set Image Format to *Automatic* (lets Godot handle DXT/ETC2 compression at import)
- Armature: Enable Export Deformation Bones Only if you want to strip helper bones
- Animation: Enable Export and set Group by NLA Track for multi-clip support
```python
# Blender Python equivalent for batch export
import bpy
bpy.ops.export_scene.gltf(
filepath='/path/to/asset.glb',
export_format='GLB',
export_yup=True,
export_apply=True,
export_tangents=True,
export_animations=True,
export_nla_strips=True,
export_def_bones=True
)
```
Material settings before export
Godot 4 maps glTF PBR materials to StandardMaterial3D. Use the Principled BSDF shader exclusively — any other node setup (Emission-only, Mix Shader, custom node groups) will either be dropped or produce a flat-shaded fallback. If you need emissive surfaces, plug them into the Emission input of Principled BSDF; Godot reads this as `emission_enabled = true` with the correct colour.
Export checklist — Blender settings:
| Setting | Value | Why |
|---|---|---|
| Format | GLB | Single-file, no external textures |
| +Y Up | Enabled | Godot 4 Y-up convention |
| Apply Modifiers | Enabled | Bakes subdivision, mirror, etc. |
| Tangents | Enabled | Required for normal maps |
| NLA Strips | Enabled | Multiple animation clips |
| Image Format | Automatic | Engine handles compression |
Handle physics colliders and rigid body export in the GLB workflow
Godot 4's GLB importer supports a naming convention for automatically generating collision shapes at import — no need to add CollisionShape3D nodes by hand.
Create a separate low-poly collision mesh in Blender and name it with the correct suffix:
- `-col` — generates a single ConcavePolygonShape3D (static bodies, terrain)
- `-convcolonly` — generates a ConvexPolygonShape3D (rigid bodies, dynamic props)
- `-colonly` — generates ConcavePolygonShape3D without keeping the visual mesh
- `-convexonly` or `-convex` — ConvexPolygonShape3D only (no visual mesh rendered)
```
# Blender naming examples
Barrel.mesh → visual mesh (rendered)
Barrel-convcolonly → convex collision shape for rigid body simulation
Door.mesh → visual mesh
Door-col → concave collision (for static door frame geometry)
```
For rigid body physics on props like crates or barrels, prefer `-convcolonly` — convex shapes are far cheaper at runtime and work correctly with RigidBody3D. Reserve concave shapes for terrain and complex static objects where player movement must conform precisely to the mesh surface.
Once imported, Godot wraps the asset in a StaticBody3D or you can change it to RigidBody3D in the scene tree. The collision shape is already attached.
LOD and shadow mesh suffixes
Godot 4 also reads:
- `-lod0`, `-lod1`, `-lod2` — explicit LOD levels (Godot selects based on screen size)
- `-shadow` — used only for shadow casting, not rendered directly
Combine these suffixes with your collision naming for a fully optimised import: `Barrel_lod0`, `Barrel_lod1`, `Barrel-convcolonly`.
Animation and shader compatibility for the Blender to Godot 4 pipeline
Animation is where most Blender-to-Godot pipelines break. The two main failure modes are missing clips (all baked into one `AnimationPlayer` action) and wrong bone transforms (root motion offset, or scale applied in Object Mode).
NLA editor setup for multi-clip export
- In Blender, open the NLA Editor
- Push each action down as an NLA strip (click the shield icon next to the action)
- Name each strip clearly: `Idle`, `Walk`, `Attack`, `Death`
- Enable Export NLA Strips in the glTF export dialog
Godot 4 imports each NLA strip as a separate `Animation` resource inside an `AnimationPlayer` node. You can reference them directly: `$AnimationPlayer.play("Walk")`.
Root motion
If your character uses root motion (bone driving locomotion), enable Export Root Motion in Blender's glTF export. In Godot, set the Root Motion Track on the `AnimationPlayer` or use `AnimationTree` with a `RootMotionView`.
Shader compatibility at a glance
| Blender Node | Godot 4 Result |
|---|---|
| Principled BSDF | StandardMaterial3D (full PBR) |
| Emission socket | emission_enabled, emission_color |
| Alpha Blend mode | transparency = ALPHA |
| Alpha Hashed | transparency = ALPHA_HASH |
| Custom node group | Fallback to white/flat |
| Glass BSDF | Unsupported, use Principled + transmission |
For glass or transparency, use Principled BSDF with Transmission set to 1.0 and Blend Mode set to *Alpha Blend* in Blender's Material Properties panel. Godot 4 reads the glTF transmission extension (`KHR_materials_transmission`) and maps it to a StandardMaterial3D with transparency enabled.
Putting it all together: the asset pipeline
The complete blender to godot 4 glb export workflow in sequence:
- Model with Principled BSDF materials only
- Create low-poly collision meshes, apply the correct suffix (`-convcolonly`, `-col`)
- Set up NLA strips for each animation clip
- Apply all transforms (Ctrl+A → All Transforms) before export
- Export as GLB, +Y Up enabled, tangents enabled, NLA strips enabled
- In Godot 4: FileSystem → import settings — set the import mode (Mesh, Scene, or Animation Library)
- Instantiate the imported scene; collision shapes and animation clips are ready
For free game-ready assets to test this workflow immediately, browse the BitSoul 3D marketplace — 747 GLB models optimised for Unity, Unreal Engine 5, and Godot 4. Each asset ships with clean topology and Principled BSDF materials, making them ideal import targets for this exact pipeline.
Apply these settings consistently across every asset and you'll spend zero time debugging Godot's importer — every mesh, collider, and animation clip will land exactly where expected. Start your next project by sourcing ready-to-import GLB assets from bitsoulhosting.com/marketplace and applying this workflow from day one.
---
*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.*