How to import low-poly GLB into Unity/Godot/Unreal

GLB is one of the best interchange formats for low-poly game assets because it packages mesh data, materials, textures, hierarchy, and animation into one binary file. It is compact, easy to preview, and friendly to web tools. The catch is that every engine makes slightly different assumptions about scale, materials, collision, animation import, and runtime optimization. A GLB that looks correct in a viewer can still arrive too large, too small, unlit, over-materialed, or awkward to collide with in a game.

This guide walks through a practical import workflow for Unity, Godot, and Unreal Engine. The goal is not only to make the model appear. The goal is to bring it in as a game-ready asset that has correct scale, readable materials, clean origin, sensible collision, and a path to optimization.

Before import: check the GLB once

Before opening an engine, inspect the file in a neutral viewer or Blender. Confirm these basics:

• The model faces the expected forward direction.
• The origin is useful, usually at the base center for props and characters.
• Scale is close to real engine units.
• Materials are named clearly.
• Textures are embedded or stored where the engine can find them.
• Animation clips, if any, have clear names.
• The model has a reasonable triangle count for its role.

If the file is AI-generated or converted from a high-poly source, also check for hidden mesh parts, duplicate objects, extremely tiny loose pieces, and unusual material counts. Low-poly style does not automatically mean optimized data.

Importing GLB into Unity

Unity does not universally treat GLB as a first-class built-in art pipeline in every version and setup. Many teams use packages such as glTFast or UnityGLTF, or they convert GLB to FBX through Blender when they need a more traditional Unity workflow. If your Unity version or project already supports GLB import, you can drag the file into the Project window. If not, install a maintained glTF importer package or convert through Blender.

A reliable Unity workflow is:

1. Put the GLB in Assets/Art/Props or a similar folder.
2. Let the importer create the prefab or imported model asset.
3. Open the asset preview and check orientation and scale.
4. Assign or simplify materials.
5. Create a prefab variant for gameplay use.
6. Add colliders, LODGroup, scripts, and custom settings on the prefab, not on the raw import.

For scale, Unity uses meters as a common convention. A one-meter crate should be about one Unity unit wide. If the object is off by 100x, fix scale in the import settings or in Blender and re-export. Avoid leaving random scale values on the final prefab if the object will be used for physics.

For materials, low-poly assets often work best with one atlas material or vertex colors. If the import produces many materials, ask whether those materials are visually necessary. Fewer materials usually means fewer draw calls and simpler batching. If the model uses flat colors, consider rebuilding it with a shared palette material.

For collision, do not use complex mesh collision by default. Add a Box Collider, Capsule Collider, Sphere Collider, or a few simple primitive colliders. A low-poly rock might look like it invites mesh collision, but primitive collision is usually cheaper and more stable. For a non-moving environment piece, a simplified mesh collider can be acceptable, but keep it intentionally low detail.

Importing GLB into Godot

Godot has strong glTF and GLB support, which makes it a natural fit for low-poly assets. Copy the .glb into your project folder and Godot will import it. Double-click the imported scene to inspect the node hierarchy, meshes, materials, and animations.

A practical Godot workflow is:

1. Put the file under assets/models or a similar folder.
2. Open the imported scene and check the generated nodes.
3. Create an inherited scene or instantiate the model into a new scene.
4. Add collision shapes and gameplay scripts in the wrapper scene.
5. Keep the original import clean so re-importing does not overwrite gameplay setup.

Godot uses meters in 3D workflows, so the same scale advice applies. If a model is wildly too small or too large, fix it at the source or in import settings rather than scaling every placed instance differently.

For materials, Godot may import PBR-style material parameters that are more complex than a low-poly game needs. Review albedo, roughness, metallic, normal maps, and texture slots. Low-poly art often looks cleaner with flat albedo, high roughness, no metallic unless required, and carefully controlled lighting. If the model was meant to be flat shaded, confirm normals survived the export.

For collision, create a StaticBody3D, CharacterBody3D, RigidBody3D, or Area3D depending on use. Add simple CollisionShape3D primitives where possible. For static level geometry, you can generate a collision shape from the mesh, but inspect it before shipping. AI-generated meshes can contain tiny triangles that produce unpleasant collision.

Importing GLB into Unreal Engine

Unreal Engine has glTF import support through plugins and version-dependent workflows, but many studios still convert GLB to FBX before production import because FBX is deeply integrated into Unreal asset pipelines. If your project accepts GLB directly, import and inspect. If not, open the GLB in Blender, clean it, and export FBX.

A practical Unreal workflow is:

1. Enable the relevant glTF importer plugin if needed.
2. Import the file into a clear Content folder.
3. Check the Static Mesh or Skeletal Mesh asset.
4. Confirm scale in centimeters. Unreal convention is one unit equals one centimeter.
5. Review materials and simplify where possible.
6. Set collision complexity intentionally.
7. Create LODs for repeated or distant assets.

Scale is the most common surprise. A one-meter prop should be about 100 Unreal units wide. If a GLB uses meter scale but imports differently, correct it once during import or in Blender. Avoid fixing every placed actor by hand.

For low-poly art, think carefully before enabling heavyweight rendering features. Nanite is excellent for extremely dense static meshes, but traditional low-poly assets often gain little from it. If your mesh has a few hundred or a few thousand triangles, normal LODs and clean materials are simpler and predictable. Use Nanite only when the asset is actually dense enough to benefit and your target platform supports it.

Common problems and fixes

If materials appear white, check whether textures were embedded and whether the importer supports the material model. Reassign albedo textures manually or rebuild a simpler material in the engine.

If the model appears smooth instead of faceted, inspect normals. Low-poly style often relies on flat normals or split normals. Re-export with correct normal settings from Blender if the engine import merged them.

If the model is black, check lighting, material roughness, vertex colors, and whether the asset expects an environment light. A model that looks good in a viewer can look flat or dark in an unlit test scene.

If animation is missing, confirm the GLB actually contains animation clips and that the importer supports them. For characters, also confirm whether the skeleton is valid for the engine workflow.

If performance is poor, look beyond triangles. Count mesh objects, materials, textures, and skinned meshes. A low-poly pack with hundreds of separate nodes can perform worse than a slightly denser merged asset.

A clean import checklist

Before you mark the import done, verify:

• Correct scale in gameplay units.
• Correct forward direction and useful origin.
• Materials are simple and named.
• Texture sizes match the asset role.
• Collision is cheap and intentional.
• LODs exist for repeated or distant assets.
• The raw imported file is separate from the gameplay prefab, inherited scene, or actor.

That separation is the habit that saves time. Let the GLB remain the source import. Put engine-specific behavior in a wrapper. Then you can regenerate, optimize, or replace the model later without rebuilding every gameplay setting from scratch.