How to Optimize 3D Assets for Godot

Godot imports glTF, GLB, Blender, FBX, and other scene formats into engine resources with options that can generate LODs, tangents, shadow meshes, lightmap UVs, and animation data. Those conveniences change size, memory, and runtime behavior. A reliable workflow records the import profile and tests the imported scene in a target export template.

Use stable-version documentation matching the project. Latest documentation can describe features not present in the release you ship.

Establish renderer and device tiers#

Record the Godot release, Forward+, Mobile, or Compatibility renderer, target platform, viewport size, scaling mode, shadow and GI features, and frame deadline.

Profile an exported build. The editor adds its own work and can use a different rendering environment. At 60 Hz all game and rendering work must fit within 16.67 milliseconds; at 30 Hz the interval is 33.33 milliseconds.

Build a representative scene with normal instance counts, lights, shadows, particles, UI, and scripts. Run on the lowest supported device long enough to expose temperature and memory pressure.

Prefer a glTF-centered source path#

glTF/GLB is Godot's primary real-time interchange path and preserves scenes, meshes, materials, skins, animations, and instances within supported semantics. Direct blend import invokes an export path and adds Blender-version dependency.

Whichever route you choose, pin:

exporter and Godot versions;
units, axes, root scale, and naming;
modifier application;
material and image treatment;
animation playback range;
skin influence policy;
instancing behavior;
import preset or post-import script.

Verify a known 1-meter reference after import. Apply Root Scale intentionally: baking scale into meshes and animations differs from retaining it on the root node.

Keep edited engine materials external or use a reimport-safe strategy so source updates do not overwrite production work.

Use Advanced Import Settings#

Inspect the imported hierarchy, meshes, materials, animations, and generated resources. Configure scene-wide defaults and per-mesh exceptions.

Godot's stable import documentation exposes options such as Ensure Tangents, Generate LODs, Create Shadow Meshes, Light Baking, and Lightmap Texel Size. Enable them for a reason.

Generate tangents when normal or height mapping requires them and the source does not provide compatible values. If the material has no tangent-dependent feature, omitting tangents saves attribute data and import work.

Import only vertex colors, UV sets, skins, and animation ranges used by the game. A secondary UV set may be essential for lightmaps. Unused channels still occupy resources.

Use EditorScenePostImport scripts for deterministic validation and transformation. A script should report changes and return the final scene; do not hide destructive cleanup inside an undocumented manual reimport step.

Automatic mesh LOD#

Godot can generate LODs automatically for imported 3D scenes and select them using camera field of view and viewport resolution. This is valuable, but not every asset benefits.

Enable it for geometry shown across meaningful distance ranges. Disable it for a UI model that is always close, a mesh whose reduction produces no passing candidate, or tiny geometry where added LOD data has no runtime benefit.

Review generated levels with wireframe and production materials. Protect:

silhouette and openings;
thin components;
hard edges and UV seams;
skin deformation if applicable;
material regions;
collision handled separately.

Adjust GeometryInstance3D lod_bias only with evidence. Forcing detail higher globally increases vertex work and memory; forcing it lower can expose visible collapse.

Measure the complete scene. Automatic LOD reduces mesh work but does not make an expensive material cheaper.

Visibility ranges and HLOD#

Visibility ranges provide artist-controlled replacement or disappearance for GeometryInstance3D-derived nodes. They can replace several nearby objects with one distant cluster, switch a MeshInstance3D to a Sprite3D impostor, or hide detail that no longer matters.

Set Begin, End, and margins so levels do not flicker at a boundary. Godot documentation notes fade transitions can force transparent rendering, which has a performance cost. Compare an invisible switch at smaller screen coverage with an expensive fade.

HLOD can reduce draws at distance while preserving culling opportunities up close. Cluster spatially. One distant mesh for a whole city can create a large bound and streaming unit.

Automatic mesh LOD and visibility ranges can work together: reduce each mesh within a near cluster, then replace the cluster farther away.

Store transitions with fixed camera paths and check silhouettes, materials, shadows, and frame spikes.

Generate and evaluate shadow meshes#

Godot import can create shadow meshes by welding vertices when possible, reducing memory bandwidth for shadow rendering without changing visible surface quality. The stable documentation notes generation does not itself use a lower source detail, though shadow rendering can use relevant LODs.

Enable shadow meshes when the asset casts meaningful dynamic shadows and the generated result reduces work. Disable casting for tiny or nonessential objects. Check alpha-cut and two-sided casters separately.

A 100000-triangle mesh entering 3 shadow views can multiply geometric work. A simpler authored caster or lower LOD may be appropriate when the silhouette remains correct.

Inspect shadow popping across LOD and HLOD. A visible mesh can transition smoothly while its shadow abruptly loses a handle.

Materials and surfaces#

Each mesh surface carries a material and can create separate render work. Consolidate duplicate StandardMaterial3D or ORM material configurations. Preserve separations needed for transparency, unique shaders, variants, or independent culling.

Prefer opaque materials. Transparent objects require back-to-front behavior and can consume fill rate. If only a small section needs blending, separate it so the opaque majority retains efficient depth behavior.

For distant HLOD, simplify materials as well as geometry: remove normal mapping, expensive shader branches, or layers only when image comparison passes. Additional unique materials also have cost, so profile the net result.

Use shader diagnostics and render captures to identify sampling, branching, overdraw, and screen-wide effects. A lower triangle count will not fix a fragment-bound material.

Texture import and VRAM#

Configure texture import per platform and semantic role. Source PNG bytes do not equal VRAM. Dimensions, mipmaps, channel count, and selected VRAM compression determine allocations.

A 2048 × 2048 RGBA8-equivalent top level contains 16 MiB; full mips approach 21.3 MiB. Four unique maps can exceed 85 MiB before platform compression.

Choose dimensions from maximum projected use. Review VRAM Compressed quality for base color, normals, masks, alpha, and HDR separately. Keep base color in the correct color space and numeric masks linear.

Enable mipmaps for ordinary 3D materials to avoid shimmer. Provide UV padding. Large atlases can reduce surfaces but load unrelated content and waste texels.

Unpack Blender images when you need direct Godot import control; if Blender conversion performs necessary channel packing, verify the alternative behavior described by the import settings.

Instance repeated geometry#

MeshInstance3D reuses a Mesh resource when multiple nodes reference the same resource. For thousands of nearby instances, use MultiMeshInstance3D to reduce per-object and submission overhead.

MultiMesh trades individual node behavior and fine culling for high-volume drawing. Partition large populations spatially instead of putting an entire world into one MultiMesh bound.

Use GPU instance import where supported and verified so source instances do not become thousands of unique Mesh3D objects.

Measure instance data, visible triangles, shadows, and overdraw. Ten thousand grass blades remain fragment-heavy even with one submission. Apply distance ranges, density tiers, and shadow rules.

Do not duplicate Mesh resources merely to change one material. Use material overrides or a controlled variant architecture, considering batching consequences.

Culling and bounds#

Godot performs frustum culling. Large scenes can benefit from occlusion culling and level design that creates occluders. A depth prepass can reduce shading but still submits and transforms unnecessary objects.

Generate or author occluders for appropriate static structure. Test dynamic doors and moving objects so visibility is not incorrect.

Keep AABBs correct. Skinned, animated, shader-displaced, or particle geometry can need custom bounds, but making every bound enormous disables useful culling. Avoid ignore_occlusion_culling except for intentional always-visible cases.

Split large environments into useful spatial chunks. Too-small chunks increase nodes and draws; too-large chunks draw hidden geometry. Profile typical paths.

Lightmaps and GI#

Static Lightmaps import can generate UV2 and uses Lightmap Texel Size. Smaller texel size means higher resolution, storage, bake time, and memory.

Set density by projected need and world importance. Doubling per-axis texel density creates roughly 4 times as many texels. Repeated instances can receive independent lightmap allocation depending on bake setup.

Check UV2 overlap, padding, and scale. Apply transforms consistently to avoid lightmap density variation.

Choose GI mode matching gameplay: static, dynamic, or disabled. Do not bake resources for meshes that never participate. Review probes, SDFGI, VoxelGI, and LightmapGI costs at the scene level.

Animation, skins, and physics#

Limit imported animation to intended playback range and clips. Remove constant or redundant tracks within pose and contact tolerances. Reuse AnimationLibrary resources where several characters share clips.

Choose 4 Influences for broad renderer compatibility or All Influences when the target and deformation require it. More influences add precision and cost. Test extreme poses and low tiers.

Import only deforming bones where appropriate. Strip unused skins and animations from static variants.

Use simple CollisionShape3D primitives or authored convex/trimesh shapes according to physics role. The visual Mesh should not automatically become complex dynamic collision. Measure physics separately.

Profile systematically#

Use Godot's Profiler, Monitors, visual profiler tools, rendering statistics, and external GPU profilers supported by the platform. Capture frame time, draw calls, objects, primitives, texture and buffer memory, script, physics, and animation.

Run controls:

force lower LOD or HLOD;
replace materials with simple opaque ones;
reduce viewport scale;
disable shadows;
hide half the instances;
disable particles and transparency;
stop animation and physics;
replace textures with tiny placeholders.

If resolution scaling helps, investigate fragments. If MultiMesh helps CPU, instance management mattered. If shadow removal helps, changing source texture size is unlikely to fix the main frame limit.

Reimport-safe automation#

Use import scripts and CI checks to report:

node and surface count;
triangles and attributes;
material and texture count;
image dimensions and settings;
generated LOD and shadow mesh policy;
UV2 and lightmap density;
animation clips, bones, and influences;
collision type;
dimensions and bounds;
renderer compatibility.

Version import presets with the project. Test a clean checkout so imported resources do not depend on one developer's .godot cache.

Store reviewed exceptions with asset ownership. Reimport should not silently reset external materials or remove manual HLOD mapping.

Godot shipping checklist#

Make the optimization report part of the import review. Include the source hash, imported resource size, surface and triangle counts, texture VRAM estimates, visibility-range settings, and target-build frame capture. A 12% triangle improvement is not a win if a new surface adds a draw to every instance or an import preset doubles texture residency.

For a representative stress scene, place the real population rather than duplicating one easy prop. A forest sample might include 800 trees, 2,400 shrubs, terrain, lights, and gameplay effects. Capture the same camera path in Forward+, Mobile, and Compatibility only when those renderers are genuine targets. Store frame percentiles and renderer counters beside screenshots so visual regressions and timing changes remain connected.

Documentation and import behavior match the shipping Godot release.
Exported builds, not only the editor, meet target-device budgets.
glTF or Blender source route and versions are reproducible.
Root scale, axes, pivots, and bounds match references.
Tangents and attributes exist only for used features.
Automatic LOD is enabled only where it produces passing savings.
Visibility ranges include margins and measured fade cost.
Shadow meshes and caster policy improve the actual scene.
Material surfaces, transparency, and shaders are bounded.
Texture VRAM format, dimensions, mips, and color space are verified.
MultiMesh and culling partitions balance draws with visibility.
Lightmap, animation, skin, and collision data follow explicit roles.

Sources and further reading#

Godot optimization is an import-and-scene contract. Generate only useful derived data, combine automatic LOD with deliberate HLOD and culling, control materials and VRAM, instance repetition intelligently, and verify every setting in the exported target build.