Every GLB you drop into Godot 4 passes through the import pipeline before it ever touches your scene — and most developers accept the defaults without a second look. Those defaults are conservative: they preserve quality at the cost of memory, draw calls, and load time. Once you understand what each setting actually does, you can cut texture memory by half and eliminate mesh decompression stalls with a few targeted changes per asset.
Why the Godot 4 import pipeline matters for GLB performance
Godot 4's import system converts every asset at editor time and stores the result in a `.godot/imported/` cache. This is the right moment to make optimization decisions — the conversion runs once, and you pay no runtime cost for the processing. Skip this step and you're paying at runtime, every frame, on every player's device.
Import settings are stored per-file as `.import` files next to each asset. You can edit them directly, set project-wide defaults in Project → Project Settings → Import Defaults, or apply settings in bulk by selecting multiple assets in the FileSystem dock.
For GLB specifically, the pipeline handles three distinct things:
- Mesh data: vertex compression, LOD generation, shadow mesh baking
- Texture data: format, compression, mipmap generation, sRGB/linear handling
- Scene structure: root node type, animation handling, light/camera stripping
Each category has different performance implications depending on your target platform.
GLB import settings that actually affect runtime performance
Open any GLB in the Import dock (select it in FileSystem, then open the Import tab). These are the settings worth understanding:
Mesh compression
Compress compresses vertex data using Godot's internal format. Enable it for static meshes; disable it for meshes that need precise vertex read-back (e.g. custom physics or terrain sampling). The default is on, which is correct for most game assets.
Generate LODs tells Godot to auto-generate lower-detail mesh variants for distance rendering. For complex environment props this is almost always worth enabling — it costs disk space at import time and saves draw budget at runtime.
```gdscript
# You can check the LOD count on an imported mesh at runtime:
var mesh = preload("res://assets/prop.glb")
if mesh is ImporterMesh:
print(mesh.get_surface_lod_count(0))
```
Texture compression format
This is the highest-impact setting. Godot 4 defaults to VRAM Compressed for textures, which is correct — but you need to verify the compression codec matches your target:
| Platform | Recommended format | Setting |
|---|---|---|
| Desktop (PC/Mac) | S3TC / BC7 | VRAM Compressed (default) |
| Android | ETC2 | VRAM Compressed |
| iOS | PVRTC / ASTC | VRAM Compressed |
| Web (WebGL 2) | ETC2 | VRAM Compressed |
For textures that need lossless quality (normal maps, emission masks), set Compress Mode to Lossless and accept the larger file size — the visual difference on normal maps under lossy compression is obvious.
Mipmaps
Always enable mipmaps for any texture applied to a 3D surface. Without them, Godot samples the full-resolution texture even when the object is 10 pixels on screen, burning fill rate and causing aliasing shimmer. The cost is a 33% increase in texture memory — worth it every time.
Scene root and animation stripping
For static props, set Root Type to `StaticBody3D` and disable Import Animations entirely. This strips the animation player and skeleton nodes that Godot imports by default from every GLB, even when there are no animations in the file. Leaner scene tree, faster instancing.
Optimizing meshes and textures at import time in Godot 4
Beyond the per-asset Import dock, Godot 4 lets you set project-wide defaults and apply batch overrides. Here's a practical workflow:
1. Set project-wide texture defaults first. Go to Project Settings → Import Defaults → Texture2D and set your baseline compression and mipmap settings. Every new texture import inherits these.
2. Create import presets for asset categories. Godot doesn't have named presets built in, but you can copy `.import` files as templates:
```bash
# Example .import override for a diffuse texture (sRGB, VRAM compressed, mipmaps on)
[params]
compress/mode=2
compress/high_quality=false
mipmaps/generate=true
flags/srgb=1
```
3. Use the bulk import override. Select multiple assets in the FileSystem dock, then modify Import settings — Godot applies the change to all selected files and re-imports them in one pass.
4. Strip unused data from GLB before import. Use Blender or `gltf-transform` to remove unused UV channels, empty vertex color layers, and zero-weight bone influences before the file reaches Godot:
```bash
# gltf-transform CLI — strip unused data before Godot import
npx @gltf-transform/cli optimize input.glb output.glb \
--prune \
--dedup \
--compress draco
```
Draco-compressed GLB files import and decompress at editor time in Godot 4.1+, so the game binary contains the already-decompressed mesh. This is exactly the right tradeoff for game distribution.
All 747 GLB models on BitSoul's marketplace are exported clean — no embedded cameras, no unused UV sets, no extra animation tracks. They're designed to drop straight into these import workflows.
Profiling and validating your import results
After re-importing, validate the results before shipping:
Check texture memory with the Debugger. Run the game and open Debugger → Video RAM. Godot lists every texture, its compressed size, and format. If you see uncompressed textures (format `RGB8` or `RGBA8`) on 3D assets, the compression setting didn't take — usually because the file has a non-power-of-two size that blocks GPU compression.
Use the rendering profiler. Debugger → Profilers → Rendering shows draw call count per frame. If a single GLB prop is generating 8+ draw calls, it has multiple materials — merge them or use a texture atlas (see the BitSoul marketplace workflow guides for atlas-ready assets).
Watch for import reimport stalls on launch. If Godot reimports assets every time you run the project, your `.godot/imported/` folder may be excluded from version control while the `.import` sidecar files are tracked. Both the `.import` files and the imported cache must be consistent, or Godot invalidates and reimports on every launch.
```gdscript
# Quick runtime texture format check (debugging only)
var tex = preload("res://assets/diffuse.png") as Texture2D
print(tex.get_image().get_format()) # Should be FORMAT_DXT5 or FORMAT_ETC2_RGBA8 etc.
```
The Godot 4 GLB import pipeline gives you tools that most tutorials skip entirely. Used correctly, it's the difference between a project that runs at 60fps on a mid-range GPU and one that struggles on high-end hardware because no one configured compression.
For a library of clean, import-ready GLB assets with correct UV layout and no embedded junk, browse the full collection at bitsoulhosting.com/marketplace.
---
*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.*