Blender to Godot 4 Export Checklist: glTF Settings, Animations, and Import Hints (2026)

Last updated: September 2026.

Export a GLB from Blender with +Y Up on, transforms applied, Apply Modifiers ticked, Materials set to Export and Compression off, drop it into your Godot project folder, and Godot 4 builds the scene, the materials, a Skeleton3D and an AnimationPlayer for you. The direct .blend import does the same job by calling Blender behind the scenes, which is handy on one machine and a problem for a team. Nearly every "it looks wrong in Godot" report comes down to one of five things: unapplied transforms, a character modelled facing the wrong way, an action that was never stashed to the NLA, a Draco-compressed file, or textures that never left Blender.

Quick answer

• Format: glTF 2.0, as a single .glb. Godot's docs mark it "(recommended)", and the binary form "include[s] the mesh and textures set up in Blender".
• Axes and scale: leave the exporter's +Y Up on, model characters facing -Y in Blender, keep 1 Blender unit as 1 metre, and run Object > Apply > All Transforms (Ctrl-A) before you export.
• Compression: leave Data > Compression off. Godot cannot open Draco-compressed glTF.
• Animations: every action you want must be the active action or stashed to an NLA track. Name looping clips with loop or cycle in the action name, no hyphen, and Godot sets the loop flag.
• Collision and physics: append -col, -convcol, -colonly or -rigid to the Blender object name and Godot creates the body on import.
• Textures missing: export GLB, not glTF Separate, set Materials to Export, and use image textures on a Principled BSDF, not procedural nodes.
• No export dialog at all: the Cinevva Rig add-on has a Godot preset that applies these settings in one click. Its export half is free, runs on your machine offline, and works in Blender 4.2 and newer on Windows, macOS and Linux. Rigging is the paid half, $29 once at the launch price.

Quick reference

The Blender glTF exporter settings that matter for Godot 4, from the Blender manual and the Godot import docs. Everything else can stay at its default.

Exporter setting (File > Export > glTF 2.0)	Value for Godot	Why
Format	glTF Binary (.glb)	One file, textures inside. Godot: "glTF binary files (.glb) are the smaller option"
Include > Selected Objects	On	Keeps cameras, lights and reference meshes out of the scene
Transform > +Y Up	On (default)	glTF and Godot are Y-up, Blender is Z-up. The exporter converts
Data > Mesh > Apply Modifiers	On	Bakes Triangulate, Mirror, Subdivision. Godot: triangulate in Blender for "more consistent results"
Data > Mesh > Normals, UVs	On	Godot needs UVs for textures and normals for shading
Data > Mesh > Tangents	On if you use normal maps	Otherwise Godot's Ensure Tangents generates them on import
Data > Material > Materials	Export	Placeholder and No Export leave a grey model
Data > Material > Images	Default (PNG/JPEG)	glTF "requires that images be in PNG or JPEG format"
Data > Armature > Export Deformation Bones only	On	Required by Godot when the model has shape keys, and it drops control bones
Data > Skinning > Bone influences	4	Godot's compatible skin mode is "4 Influences"
Data > Compression	Off	Godot: "required extension 'KHR_draco_mesh_compression' is not supported"
Animation > Animation mode	Actions	Each stashed action becomes one Godot animation
Animation > Reset pose bones between actions	On	"Needed when some bones are not keyed on some animations"
Animation > Optimize Animation Size	On	"Removing duplicate keyframes when all identical"

Two roads into Godot: direct .blend or a GLB

Godot 4 supports "glTF 2.0 (recommended)", .blend, Collada, OBJ and FBX. The .blend path "works by calling Blender to export to glTF in a transparent manner (requires Blender to be installed)", so both roads end in the same importer.

The .blend road saves you the export step and nothing else: Godot runs Blender's own glTF exporter for you, then imports the result exactly as it would a GLB. Green is an advantage, coral a hard limit, amber a trade-off.

The direct .blend import

The available formats page spells out the requirements. It "requires Blender 3.0 or later", with 3.5 or later recommended "as it includes many fixes to the glTF exporter", and "an official Blender release downloaded from blender.org, as opposed to a Linux distribution package or Flatpak". You "must install Blender before opening the Godot editor". If Blender lives in its default location Godot finds it. If not, set Editor Settings > Filesystem > Import > Blender > Blender Path. The payoff is iteration speed: "you can save the scene in Blender, alt-tab back to Godot then see your changes immediately", and you don't commit an exported copy.

The Import dock then shows a Blender-only section: Nodes > Visible (All, Visible Only or Renderable), Modifiers, Meshes > Skins (4 Influences (Compatible) or All Influences, "up to 8 in Godot"), Materials > Unpack Enabled, which writes the original images into the Godot filesystem and "should be left checked", and Animation > Group Tracks, which keeps stashed actions separate. Untick that last one and "all the currently assigned actions become one glTF animation".

When to avoid it: the docs are blunt that "using .blend files in your project will require all team members to have Blender installed", and the import "is also not available on the Android and web editors, as these platforms can't call external programs". A fresh clone imports nothing until Blender is present, so a build machine needs Blender too, and you only get the exporter options Godot exposes in the dock. If you don't want Godot touching .blend files that live in the project, turn off Filesystem > Import > Blender > Enabled in the advanced Project Settings.

The GLB export

Blender's exporter offers three forms. glTF Binary (.glb) is "a single .glb file with all mesh data, image textures, and related information packed into a single binary file". glTF Separate writes a .gltf, a .bin and loose image files, and the manual warns that "sharing this format requires sharing all of these separate files together as a group". glTF Embedded base64-encodes everything into JSON and the manual calls it "the least efficient of the available forms". Godot's docs give two reasons to pick Separate: a text-based scene for version control diffs, or needing the texture files apart from the material. "If you don't need either of those, glTF binary files are fine." Pick GLB.

Why not FBX, Collada or the old ESCN exporter

FBX in Godot 4 comes in two eras. Before 4.3 the importer was FBX2glTF, and the docs note that this "requires installing an external program that links against the proprietary FBX SDK", which is why Godot can't ship it and why you had to set Filesystem > Import > FBX > FBX2glTFPath yourself. Since Godot 4.3 (August 2024) the built-in ufbx library reads FBX directly and "it will no longer be necessary to download the external FBX2glTF converter". FBX now works, then, but it adds a conversion step glTF doesn't need, and the same article warns that Blender's FBX exporter writes objects at 100x scale by default unless you set Apply Scalings to FBX Units Scale. If you must live in FBX, the third-party Better FBX Importer & Exporter (12,600+ sales on Superhive, $25 for one seat, Blender 3.6 to 5.1) exists because, in its author's words, Blender's native FBX "often fails" on files from other packages. For Godot you don't need any of that.

Collada is a step down: Blender's built-in exporter "does not work properly for the needs of game engines and shouldn't be used as-is", though simple static scenes may survive. OBJ "doesn't support skinning, animation, UV2 or PBR materials". And the Godot Blender Exporter that wrote .escn files for Godot 3 "is not maintained or supported in Godot 4.x" per its own docs page. If a tutorial tells you to install it, the tutorial is for Godot 3.

Axes, metres and applied transforms

Three conventions have to agree, and two of them are already the same. The glTF 2.0 specification says "glTF defines +Y as up, +Z as forward, and -X as right", that "the front of a glTF asset faces +Z", and that "the units for all linear distances are meters". Godot's model export considerations page says Godot "uses a right-handed, Y-is-up coordinate system, with the -Z axis as the camera's forward direction", so an oriented asset faces +Z, and "Godot uses the metric system for everything in 3D, with 1 unit being equal to 1 meter". Blender is the odd one out with Z up, and the exporter's Transform > +Y Up option ("Export using glTF convention, +Y up") does the conversion. Leave it on. Turning it off is the fastest way to a model lying on its side.

Forward is the one you have to model for. Godot's docs translate it: "In Blender, this means that +Y is rear and -Y is front for an asset." Build your character looking down Blender's -Y axis (the default front view, Numpad 1, looks at the character's face) and it will face +Z in Godot, which is what look_at with use_model_front and the Vector3.MODEL_* constants expect. A character modelled facing +Y walks backwards the first time you attach movement code.

Scale is simpler than it looks. The exporter has no unit option: one Blender unit becomes one glTF metre. Blender's Unit Scale in Properties > Scene > Units "only influences the values displayed in the user interface and not how things behave internally", so a centimetre-scale scene with Unit Scale at 0.01 still exports its raw values. Keep the default metric setup, make a human about 1.8 units tall, and Godot agrees with you. If a downloaded model arrives 100x too big, scale it in Object Mode and apply, or use the Import dock's Apply Root Scale, which "will be applied on the meshes and animations directly, while keeping the root node's scale to the default (1, 1, 1)".

Apply transforms every time. Object > Apply > All Transforms (Ctrl-A) bakes rotation and scale into the vertices, and the Blender manual says "It is recommended to apply transforms before rigging and animation." Godot asks for the same thing "to avoid issues with 3D selection in the editor", and its retargeting docs name the failure: "a glTF exported from Blender with no 'Apply Transform' executed" gives the skeleton a node transform that the Apply Node Transform import option has to undo. Also make sure "the skeleton is reset to its T-pose or default rest pose before exporting". A mesh exported mid-pose bakes that pose into the skin.

Export settings, in the order the dialog shows them

File > Export > glTF 2.0 (.glb/.gltf), Format glTF Binary, Include > Selected Objects on. Cameras and Punctual Lights stay off, since Godot's advice is to "design the scene's lighting in the Godot editor after importing the scene". The table above has the full list. Four settings deserve the reasoning.

Data > Mesh > Apply Modifiers. Godot "can triangulate meshes on import, but results may be unpredictable or incorrect, especially with N-gons", and its fix is "adding a Triangulate modifier to your objects and making sure Apply Modifiers is checked in the export dialog". Turn on Tangents if any material uses a normal map, otherwise Godot's Ensure Tangents import option generates them with Mikktspace at import time.

Data > Armature > Export Deformation Bones only. Godot's docs carry a warning box: if the model has blend shapes (shape keys), this "needs to be configured to Enabled", because "exporting non-deforming bones anyway will lead to incorrect shading". It also strips the helper bones a control rig carries. Keep Use Rest Position Armature on so the rest pose, not the current frame, becomes the joint rest.

Data > Compression off. The Draco option writes the KHR_draco_mesh_compression extension, and Godot's importer refuses it with GLTF: Can't import file, required extension 'KHR_draco_mesh_compression' is not supported (issue #73738). Godot compresses meshes its own way at import, so you lose nothing.

Animation > Reset pose bones between actions on. The manual says it "is needed when some bones are not keyed on some animations", otherwise a bone left unkeyed in your idle inherits its last pose from the walk. Set all glTF Animation starting at 0 "can be useful for looping animation" when your actions start at frame 1.

On the Godot side, the Import dock's defaults are mostly right. Root Type should inherit from Node3D or you "lose the ability to position the node directly in the 3D editor". Animation > FPS bakes curves to points, and "there is usually not much benefit in going above 30 FPS". glTF > Embedded Texture Handling decides what happens to the images inside your GLB: Extract Textures pulls them out as image files, which the docs say gives "smaller file sizes and more control over import options", while the two Embed options keep them inside the scene.

Import hints: suffixes Godot reads from object names

This is Godot's oldest and best trick. The glTF node name is the Blender object name, and the name suffix page lists suffixes the importer acts on. Name a wall Wall-col and the import produces the mesh plus a static collision child. No Godot-side clicking, and it survives every re-import.

Blue and pink hints add or replace physics nodes, coral removes, green adds navigation and culling helpers. The amber pair goes on material names and the purple one on the action name. Everything on this card is set in Blender and survives every re-import.

Two of these do more than the card can say. -colonly "will remove the mesh upon importing and will create a StaticBody3D collision instead", which is how you ship a hand-made low-poly collision mesh next to the visible one: model it, name it Room_collision-colonly, and only the physics survives. And -noimp removes "nodes and animations" of any type, so reference geometry and scratch actions can stay in the .blend without reaching the game.

The animation hint is the odd one. "Animation clips in the source 3D file that start or end with the token loop or cycle will be imported as a Godot Animation with the loop flag set. Unlike the other suffixes described above, this does not require a hyphen." Walk_loop, loop_walk and WalkCycle all count.

If you'd rather not touch names, the Advanced Import Settings dialog (double-click the file, or Advanced… in the Import dock) does the same per node: Skip Import, Generate > Physics with Body Type (Static, Dynamic, Area) and Shape Type (Trimesh for static level geometry, primitives or Decompose Convex for dynamic bodies), Generate > NavMesh and Generate > Occluder. Names win when the same model is reimported often or shared between projects, because the settings travel with the file.

Animations: actions, NLA tracks and loops

The Blender exporter's default Actions mode has one rule that causes most missing-animation reports. From the manual: "An action will be exported if it is the active action on an object, or it is stashed to an NLA track (e.g. with the Stash or Push Down buttons in the Action Editor). Actions which are not associated with an object in one of these ways are not exported. If you have multiple actions you want to export, make sure they are stashed!" Open the Action Editor in the Dope Sheet, and for each action you want, select it and press Stash (or Push Down). Each ends up on its own NLA track, and each becomes one Godot animation named after the action. You can rename the NLA track to override the name. One version note: "Before Blender 4.4, tracks were merged regarding their name. With Blender 4.4, and the introduction of slotted actions, this default behavior has been changed. Now, tracks are merged by the action they are using, and not by their name."

Only three kinds of animation survive the trip: "Object transform (location, rotation, scale)", "Pose bones" and "Shape key values". Animated materials, lights, modifiers and physics don't export, so bake them or rebuild them in Godot.

Looping is Godot's decision, not the file's. The glTF spec "defines only storage of animation keyframes, so this specification doesn't define any runtime behavior, such as: order of playing, auto-start, loops". So Godot reads the name: "In Blender, this requires using the NLA Editor and naming the Action with the loop or cycle prefix or suffix." If you forgot, select the animation in the AnimationPlayer panel and set its Loop Mode. The Animation class offers None ("the animation will stop playing"), Linear ("repeated without changing the playback direction") and Ping-Pong ("repeats playback and reverse playback at both ends").

Godot puts everything into one AnimationPlayer under the imported root with an AnimationLibrary holding each clip. To share one set of animations across several characters, select the GLB in the FileSystem dock and change its import mode to Animation Library, which "allows you to use one set of animations for several characters, without having to duplicate animation data". Pair that with the retargeting options below so the clips fit skeletons that aren't identical.

CGDive's rigged-character walkthrough is from 2021, so the Godot side is Godot 3. The Blender half still holds: a separate game rig with deform bones only, actions stashed to NLA tracks, glTF export, then looping and blending in the engine.

Materials and textures

Blender's exporter only understands one shader. The manual: "The exporter supports Metal/Rough PBR (core glTF) and Shadeless (KHR_materials_unlit) materials. It will construct a glTF material based on the nodes it recognizes in the Blender material." Base colour comes from the Base Color input of a Principled BSDF, either the colour swatch or an Image Texture connected to it. Metallic and roughness come from the sliders or from one image with "metallic values to be encoded in the blue (B) channel, and roughness to be encoded in the green (G) channel", split with a Separate RGB node and with the Image Texture's Color Space set to Non-Color. A normal map goes through a Normal Map node in Tangent Space, also Non-Color. Emission goes into the Emission input. Anything else, a noise texture, a colour ramp, a mix of two shaders, doesn't exist in glTF, and Godot's docs add that "procedural Blender materials may not work correctly". Bake procedural work to an image first.

On the Godot side that lands in a StandardMaterial3D, whose docs describe the same packing: "Instead of separate settings and textures for occlusion, roughness, and metallic, there is a single ORM texture." Normal maps must be "OpenGL style" (+Y up), which is what glTF and Blender's Normal Map node produce, so nothing to flip. Colour space follows the rule you set in Blender: base colour images stay sRGB, data maps are Non-Color. Get that backwards and the roughness map is gamma-shifted before Godot ever sees it.

"Textures missing" has a short list of causes. You exported glTF Separate and moved only the .gltf, leaving the .bin and images behind. You used the .blend import with Materials > Export Materials set to Named Placeholder or Placeholder, where the docs say "textures will have to be reassigned manually". Data > Material > Materials was left on Placeholder in the exporter. The Image Texture node points at a file Blender itself can't find (magenta in the viewport), so there's nothing to pack. Or the material was procedural. GLB plus Export plus image textures fixes all five.

Two more surprises. Backface culling: "By default, Blender has backface culling disabled on materials and will export materials to match how they render in Blender. This means that materials in Godot will have their cull mode set to Disabled", so every backface renders. Tick Backface Culling in the Blender material's Settings panel for anything that's a closed surface. And transparency: the exporter picks Opaque, Mask or Blend from what's wired into the Alpha socket, and Godot maps that onto its Transparency modes. For leaves and grilles, round the alpha with a Math node so it exports as Mask, which Godot renders far cheaper than blended alpha.

If you want to edit materials in Godot without losing them on the next re-import, use Actions… > Extract Materials in the Advanced Import Settings dialog. Godot "will not overwrite changes made to extracted materials when the source 3D scene is reimported", though renaming the material in Blender breaks the link.

Skeletons: Skeleton3D, bone names and retargeting

An armature imports as a Skeleton3D, which "provides an interface for managing a hierarchy of bones, including pose, rest and animation", with the skinned meshes as MeshInstance3D children pointing at it. Godot's retargeting docs explain the catch with Blender rigs: "the bones of a glTF model output from Blender have 'Edit Bone Orientation' as the Bone Rest rotation", so two Blender characters with the same bone names can still have different rests, and an animation authored on one twists the other.

The fix is built into the importer. In Advanced Import Settings, select the Skeleton3D node and the right-hand panel shows a Retarget section with a single bone_map property. Create a BoneMap, give it the SkeletonProfileHumanoid profile, and "auto-mapping will be performed when the SkeletonProfile is set". The profile is Godot's standard humanoid, 56 bones in four groups (Body, Face, LeftHand, RightHand), read-only, with names like Hips, Spine, Chest, UpperChest, Neck, Head, LeftUpperArm, LeftLowerArm, LeftHand, LeftUpperLeg, LeftLowerLeg, LeftFoot. Its reference pose is a T-pose facing +Z. Auto-mapping "uses pattern matching for the bone names. So we recommend to use common English names for bones." Name bones upper_arm.L or LeftUpperArm rather than Bone.014, and check for magenta buttons in the map, which flag "any missing, duplicate or incorrect parent-child relationship mappings".

Then the Rest Fixer options. Overwrite Axis rewrites every bone rest to match the profile and the docs call it "the most important option for sharing animations in Godot 4", with the warning that it "can produce horrible results if the original Bone Rest set externally is important". Fix Silhouette bends the model into the profile's T-pose, which "does not need to be enabled for T-pose models, but should be enabled for A-pose models". Apply Node Transform fixes the unapplied-transform case from the axes section. Normalize Position Tracks scales root motion by hip height so a tall and a short character share a walk without foot sliding. Under Remove Tracks, the docs recommend enabling Except Bone Transform, Unimportant Positions and Unmapped Bones for a shared AnimationLibrary, and leaving them off for a scene whose accessories are animated.

A rigging note for Blender users. Whether your skeleton comes from Rigify, Auto-Rig Pro or an auto rigger, export with Export Deformation Bones only so control bones stay in Blender, export in rest pose, and keep the English bone names (Hips, Spine, LeftArm) that Mixamo-style rigs use, because that's what the auto-mapper pattern-matches against.

Symptom, cause, fix

Read left to right. Five of the seven are fixed in Blender's export dialog or with Ctrl-A, and the last two in Godot's Import dock and Advanced Import Settings. None of them needs a script.

The longer list, including the ones that don't fit on a card.

Symptom in Godot	Cause	Fix
Model lies on its side or is rotated 90 degrees	Rotation not applied, or +Y Up off	Object > Apply > All Transforms, keep +Y Up on
Character walks backwards, look_at faces away	Modelled facing +Y in Blender	Model facing -Y (Blender front view). Godot: "-Y is front for an asset"
100x too big or too small	Centimetre-scale modelling, Unit Scale changed	1 Blender unit = 1 m, scale and apply, or Apply Root Scale in the Import dock
required extension 'KHR_draco_mesh_compression' is not supported	Data > Compression on	Turn it off and re-export, or decompress an existing file with gltf-transform
An animation is missing	Action not active or stashed, -noimp in its name, or Animation > Import off	Stash it in the Action Editor, check the name, tick Import
Animation plays once and stops	No loop/cycle token	Rename the action Walk_loop, or set Loop Mode on the Godot animation
Idle pose inherits a limb from the walk	Unkeyed bones carried over between actions	Tick Reset pose bones between actions
Grey model, no textures	glTF Separate moved without its images, Placeholder or Named Placeholder materials, procedural nodes, missing source image	GLB, Materials: Export, image textures on a Principled BSDF
Inside faces visible, or a performance drop	Blender's default is backface culling off, so Godot cull mode is Disabled	Tick Backface Culling in the Blender material settings
Shape keys shade wrong	Non-deforming bones exported	Data > Armature > Export Deformation Bones only
Skeleton has a stray transform, animations offset	Armature exported without applying transforms	Ctrl-A in Blender, or Rest Fixer > Apply Node Transform on import
Shared animation twists limbs	Bone rests differ from the profile	BoneMap with SkeletonProfileHumanoid, Overwrite Axis, Fix Silhouette for A-pose
Feet slide on a shared walk	Different hip heights	Normalize Position Tracks
Faceted shading or broken normal map	Modifiers not applied, or no tangents	Apply Modifiers, Tangents on export or Ensure Tangents on import
No collision on level geometry	No hint and no physics generated	-col suffix, or Generate > Physics with Trimesh
.blend doesn't import at all	Blender not installed or not found	Install from blender.org, set Filesystem > Import > Blender > Blender Path, restart the editor

The checklist

Run it top to bottom before every export. Most steps are one keypress.

1. In Blender, select everything that should ship and nothing else. Delete or hide reference meshes, or name them -noimp.
2. Face characters and props down -Y. Numpad 1 should show the character's face.
3. Check Properties > Scene > Units is metric with Unit Scale 1.0, and the character is about 1.8 units tall.
4. Object > Apply > All Transforms (Ctrl-A) on every mesh and the armature.
5. Put the armature in rest pose. Godot: "make sure that the skeleton is reset to its T-pose or default rest pose before exporting".
6. Add a Triangulate modifier if you have n-gons. Confirm every material is a Principled BSDF with image textures, Non-Color on data maps, and Backface Culling ticked on closed surfaces.
7. Open the Action Editor and Stash every action you want in Godot. Name looping ones with loop or cycle.
8. Rename objects with import hints: -col for level geometry, -convcol for props, -rigid for things that fall.
9. File > Export > glTF 2.0. Format: glTF Binary. Include > Selected Objects on. +Y Up on. Apply Modifiers on. Materials: Export. Export Deformation Bones only on. Compression off. Animation mode: Actions, Reset pose bones between actions on.
10. Drop the .glb into the Godot project folder and click back into the editor. Godot imports when the window gets focus.
11. In the Import dock, set Root Type to a Node3D type, Animation > FPS to your Blender frame rate, and glTF > Embedded Texture Handling to Extract Textures if you want per-image compression settings.
12. Open Advanced Import Settings. Check the animation list, set any missing loop modes, add a BoneMap on the Skeleton3D if you'll share animations, and Extract Materials if you'll edit them in Godot.
13. Instance the scene, press play, and bend an elbow. If it looks right here, it will look right in the build.

The one-click route: the Godot preset in Cinevva Rig

Steps 9 to 11 are the part people get wrong on the third export of the day, when one checkbox drifts. The Cinevva Rig add-on folds them into a preset. Before it writes anything it runs a size analysis that splits the estimated file into geometry, textures, animation and shape keys, so you can see whether an 80 MB export is a 4K texture problem or an unsampled-animation problem before Godot ever loads it. The Godot preset then exports GLB, +Y Up, no Draco because Godot 4 imports plain glTF cleanly, textures capped at 2048 px, and animation size optimisation on. Against a plain Blender GLB export, its presets produced files 68%, 89%, 92% and 98% smaller on four real models, most of that from texture caps rather than mesh tricks.

The facts that matter for a Blender user: the export half and the 260 CC0 animation clips work without a key, an account or a network connection, on your own machine. Rigging is what the $29 launch-price key turns on, also local and offline after a one-time engine download of about 2.4 GB, with no per-rig count. It supports Blender 4.2 and newer on Windows, macOS and Linux, installs as a standard extension, and the current version is 0.4.0 from September 5, 2026. If you'd rather keep your own workflow, the checklist above is exactly what the preset does, and the GLB viewer will show you the scene graph, skeleton and animation list of the result before you hand it to Godot.

Common Questions

How do I import a Blender file into Godot 4?

Two ways. Save the .blend inside your Godot project folder and Godot imports it by calling Blender's glTF exporter, which needs Blender 3.0 or later installed (3.5+ recommended) and found at Editor Settings > Filesystem > Import > Blender > Blender Path. Or export a .glb from File > Export > glTF 2.0 and drop that in the project instead. The GLB works for teammates without Blender and on every editor platform.

Should I use glTF or FBX for Blender to Godot?

glTF, as a single .glb. Godot's docs list glTF 2.0 as the recommended format, and the .blend import is glTF underneath. FBX works since Godot 4.3 through the built-in ufbx importer, and needed the external FBX2glTF program before that, but it adds a conversion step and Blender's FBX exporter applies a 100x scale by default. Use FBX only when a downstream tool demands it.

Why is my Blender model the wrong size in Godot?

Godot treats 1 unit as 1 metre and so does glTF, and Blender's exporter writes one Blender unit as one metre regardless of the scene's Unit Scale, which only changes what the interface displays. A model built at centimetre numbers arrives 100x too big. Scale it to about 1.8 units for a human, apply the scale with Ctrl-A, and re-export, or use Apply Root Scale in Godot's Import dock.

How do I import Blender animations into Godot 4 and make them loop?

Stash every action to an NLA track in the Action Editor, because the exporter only writes actions that are active or stashed. Export with Animation mode set to Actions and each action becomes one animation in the imported AnimationPlayer. To loop, put loop or cycle at the start or end of the action name (Walk_loop) and Godot sets the loop flag on import, or set Loop Mode to Linear on the animation afterwards.

What do -col and -rigid mean in Godot import?

They're import hints Godot reads from node names. -col adds a child StaticBody3D with a triangle-mesh collision shape matching the mesh, -convcol uses a convex shape instead, -colonly drops the mesh and keeps only the collision, and -rigid imports the mesh as a RigidBody3D. Type them onto the object name in Blender, and the physics setup survives every re-import.

Why are my textures missing when I import from Blender to Godot?

Usually one of five things: you exported glTF Separate and copied only the .gltf, the exporter's Materials option was Placeholder, the .blend import's Export Materials was set to Named Placeholder, the material used procedural nodes glTF can't store, or the Image Texture node pointed at a file Blender couldn't find. Export a GLB with Materials: Export and image textures wired into a Principled BSDF.

Does Godot 4 use Skeleton3D for Blender armatures?

Yes. A Blender armature imports as a Skeleton3D node with the skinned meshes as MeshInstance3D children, and the actions become animations on an AnimationPlayer. To share animations between characters, give the Skeleton3D a BoneMap with the SkeletonProfileHumanoid profile in Advanced Import Settings and enable Overwrite Axis, because Blender bone rests differ per rig even when the names match.

Related

• Blender to Unity Export Checklist: the FBX side of the same problem, with the 100x scale and Humanoid Avatar mapping
• Blender to Unreal Export Checklist: centimetres, Z-up, bone axes and retargeting onto the UE5 Mannequin
• Godot vs Unity for Web Games (2026): if you're still choosing the engine
• How to Optimize GLB Files for the Web: texture caps, quantization and when Draco or Meshopt is worth it
• GLB Viewer and glTF Inspector: inspect the scene graph, materials, skeleton and animations of your export before Godot sees it
• Cinevva Rig for Blender: rig, animate and export for Godot from one panel in Blender