Blender to Godot

Getting Blender 5.x models, levels and characters into Godot 4.7: the three import routes, the Import dock and Advanced Import Settings, name-suffix hints for collision and navigation, materials, animations and retargeting, and how to edit an imported scene without losing work on reimport. Godot itself is covered in Nodes, scenes & signals and Resources, saving & export; the Blender prep that applies to every engine is in Blender to the web.

Three routes in

.blend setup: install an official Blender from blender.org (not Flatpak or a distro package), then Editor > Editor Settings > FileSystem > Import > Blender > Blender Path. Godot needs Blender 3.0 or later. To keep .blend files in the project without importing them, turn off FileSystem > Import > Blender > Enabled in the advanced Project Settings.

 scene.blend ─(Blender exports glTF)─┐
 scene.glb / scene.gltf ─────────────┼─► glTF importer
 scene.fbx ─(ufbx)───────────────────┘        │
                                              ▼
   Import dock · Advanced Import Settings · name suffixes
   · import script (EditorScenePostImport)
                                              │
                                              ▼
   .godot/imported/scene.glb-<hash>.scn   (a PackedScene)
                                              │  instance it, or
                                              ▼  New Inherited Scene
   level.tscn / player.tscn

The source file is never modified. Import settings live in scene.glb.import next to it (commit that file; .godot/ is regenerated).

Prepare in Blender

The general checklist (apply transforms, meters, Principled BSDF, bake procedurals, name everything) is in Before you export. Godot-specific points:

Import dock

Select the file in the FileSystem dock, open the Import tab, change options, press Reimport.

Advanced Import Settings

Double-click the file (or Import dock > Advanced…) for a preview and per-object options.

Physics Shape Type rule of thumb: Trimesh for static level geometry, primitives (box, capsule, sphere) for anything that moves, convex decomposition only for large irregular dynamic objects.

Name-suffix import hints

Suffixes on object names in Blender tell Godot what to build. They work with -, $ or _ as the separator, are case-insensitive, and are removed from the imported node name (Floor-col → Floor).

• -colonly with Blender empties (box, sphere, single arrow draw types) only works in Collada files; for glTF use low-poly meshes with -colonly or -convcolonly.
• Import dock > Nodes > Use Node Type Suffixes off disables the body/shape/navmesh hints but keeps -noimp, -loop and -vcol. Use Name Suffixes off disables them all (the glTF importer still reads -loop).
• Same result without renaming: the Advanced Import Settings per-node options.

Materials

The glTF importer builds a StandardMaterial3D per material:

• ORM: one texture with AO in red, roughness in green, metallic in blue. ORMMaterial3D reads that layout directly; bake or pack textures this way to save samplers.
• Edit materials in Godot: Import dock > Materials > Extract (or Advanced Import Settings > Actions > Extract Materials) writes one .tres per material. Reimports don't overwrite them; renaming the material in Blender breaks the link (reassign it under Use External).
• For shaders, set a ShaderMaterial through Use External on that material (Godot shaders).
• Textures: extracted images get their own import settings (VRAM compression, mipmaps, normal-map detection); see texture compression per platform.

Watch for which Principled BSDF inputs survive the trip and how the textures show up in Godot's material.

Animations

• Looping: -loop suffix, or Advanced Import Settings > the animation > Loop Mode. Editing the imported animation in the editor is lost on reimport unless you save it to a file first.
• Animation Library import: set Import As to Animation Library on an animations-only .glb, then add that library to any AnimationPlayer (add_animation_library("moves", lib)).
• Retargeting (one set of animations on several humanoid rigs): select the Skeleton3D in Advanced Import Settings > Retarget > Bone Map > new BoneMap with a SkeletonProfileHumanoid; auto-mapping works best with plain English bone names (Hips, LeftUpperLeg). Then Remove Tracks, Rest Fixer (Overwrite Axis, Fix Silhouette for A-pose rigs) and Bone Renamer options make the animations shareable.
• Root motion: set root_motion_track on the AnimationPlayer or AnimationTree to the root bone track (for example %GeneralSkeleton:Root after retargeting) and move the body with get_root_motion_position() each physics frame.
• State machines and blending: AnimationTree. Rigging concepts: Animation & rigging; Blender actions and NLA: Blender animation.

Collision, navigation & occlusion

Primitive shapes are fastest and most stable; trimesh shapes only collide correctly as static bodies. Bodies, layers and masks: Input & physics.

Editing imported scenes

An imported .glb or .blend is read-only in Godot: edits to it are thrown away on reimport. Four ways to customize it:

A good default for game objects: player.tscn with a CharacterBody3D root, collision shape and script, and the imported model instanced as a child. Swap the model file without touching gameplay.

Axes & scale

The glTF exporter's +Y Up option does the conversion; don't rotate models by hand. When turning a model to face a target, pass use_model_front = true to look_at(). A model imported at 100× or 0.01× size means unapplied scale or a non-1 Unit Scale in Blender, or an FBX in centimeters (use Root Scale).

From GDScript

Instance an imported model and play one of its clips:

extends Node3D
 
const CRATE := preload("res://models/crate.glb")
 
func _ready() -> void:
    var obj := CRATE.instantiate() as Node3D
    obj.position = Vector3(0, 0, -3)
    add_child(obj)
    var ap: AnimationPlayer = obj.get_node("AnimationPlayer")
    ap.animation_finished.connect(_on_done)
    ap.play("Bob")
 
func _on_done(clip: StringName) -> void:
    print("finished ", clip)

A .glb loads as a PackedScene, just like a .tscn (Instancing scenes). Clip names are Blender's action names without the -loop suffix.

Common problems

Recipes

Blocked-out level with collision

Use to walk around a Blender blockout in minutes.

1. Model the level; for each walkable or blocking part add a low-poly copy named <name>-colonly.
2. Big walls: duplicate as boxes named <name>-occonly if the level is large.
3. Floor copy named Floor-navmesh if NPCs need to walk.
4. Export level.glb into res://levels/.
5. Instance it in main.tscn, drop in a CharacterBody3D player, run.

Post-import script

Use to apply the same fixes to every import: groups, collision layers, material swaps.

@tool
extends EditorScenePostImport
 
# Runs after every (re)import of the scene it is set on.
func _post_import(scene: Node) -> Object:
    for n in scene.find_children("*", "MeshInstance3D"):
        n.add_to_group("props", true)  # true: saved
    for n in scene.find_children("*", "StaticBody3D"):
        (n as StaticBody3D).collision_layer = 1 << 1
    return scene

Set it under Import dock > Import Script > Path, then Reimport. The returned node is what gets saved.

Edit materials in Godot

Use when a material needs Godot-only features (triplanar, rim, a shader).

1. Import dock > Materials > Extract: Extract Once; set a folder (res://materials/); Reimport.
2. Edit the generated .tres files; they now override the embedded ones.
3. Re-exports from Blender keep your edits as long as the material names stay the same.

Shared animations for several characters

Use when several humanoids share one set of moves.

1. Export the moves as an animations-only anims.glb (armature plus actions, no mesh needed).
2. Import As: Animation Library; in Advanced Import Settings on its Skeleton3D, set a Bone Map with SkeletonProfileHumanoid, and enable the Remove Tracks options.
3. On each character file, set the same Bone Map profile so their skeletons are renamed the same way.
4. Add the library to each character's AnimationPlayer, drive it with an AnimationTree.

.glb exports for a team

Use when not everyone has Blender, or CI builds the game.

• Keep .blend sources outside res://, or in a folder with an empty .gdignore file.
• Export with a script so settings never drift (the command-line recipe in Blender to the web; drop the WebP option).
• Commit the .glb and its .import file; CI runs godot --headless --path . --import (Command line).

References

• Godot docs: Available 3D formats (opens in a new tab): glTF, .blend, FBX (ufbx), OBJ, DAE
• Godot docs: Model export considerations (opens in a new tab): axes, triangulation, rest pose
• Godot docs: Import configuration (opens in a new tab): Import dock, import scripts, animation libraries, scene inheritance
• Godot docs: Advanced Import Settings (opens in a new tab): per-node physics, navmesh, occluders, material extraction
• Godot docs: Node type customization using name suffixes (opens in a new tab): the suffix list
• Godot docs: Retargeting 3D skeletons (opens in a new tab): Bone Map, SkeletonProfileHumanoid, rest fixer
• Godot class reference: ResourceImporterScene (opens in a new tab): every import option by name
• Blender Manual: glTF 2.0 (opens in a new tab): the exporter Godot runs for .blend files
• Khronos glTF-Blender-IO (opens in a new tab): exporter issues and changelog