You drag a GLB into Unity 6's Project window and get a magenta character, a model 100 times the expected size, or geometry that renders from the inside out. All three are fixable in under five minutes. The problems come from pipeline expectation mismatches, not broken files — and once you understand what Unity 6's importer is doing, the fixes are deterministic.
GLB in Unity 6 goes through three automatic steps: mesh extraction, material slot creation mapped to glTF material names, and shader assignment based on the render pipeline that was active when the import ran. That last step is where most failures originate. This guide covers the exact import settings that prevent the common failures, a one-time C# postprocessor that removes the manual fix step permanently, and a gotchas table for every remaining edge case.
Why Unity 6 gets GLB shaders wrong
Unity reads the active graphics settings *at import time*. If you imported a GLB before switching your project from Built-in to URP — or if Unity auto-selected the wrong pipeline from your project template — every material in that GLB will carry a Standard shader instead of a URP/Lit or HDRP/Lit shader. The mesh data and textures are correct; only the shader binding is wrong, which is why meshes appear solid magenta: the GPU can't find the expected shader pass.
The same import-time sensitivity explains scale drift. Blender's glTF exporter writes coordinates in the scene's native unit — centimetres by default. Unity expects metres. A character that stands 180 cm in Blender arrives as 180 m in Unity: that's the 100× scale issue. It isn't a unit conversion bug; it's two tools with different default unit assumptions reading and writing the same file.
The five import settings that prevent 90% of failures
With your GLB selected in the Project panel, open Inspector → Model tab. Change these five fields before anything else.
Scale Factor. Default is `1`. Set it to `0.01` if your Blender scene uses centimetres and you didn't apply transforms before export. Alternatively, enable *Apply Transforms* in Blender's glTF exporter — cleaner because the scale gets baked into the file rather than compensated at import. Either approach is consistent; mixing them per-asset creates maintenance problems.
Normals. Set to *Import*, not *Calculate*. Calculated normals discard custom split normals and Blender smoothing groups, producing faceted shading on anything with deliberate hard edges.
Material Creation. Set to *Import via MaterialDescription* for URP and HDRP projects. This reads glTF PBR properties directly — baseColor, metallic, roughness, normal — and creates properly typed Lit materials rather than defaulting to Standard.
Read/Write. Enable only for static environment props that will receive baked lightmaps. On everything else it doubles GPU memory usage with no benefit.
Generate Lightmap UVs. Enable for static props in baked-light scenes. Leave off for characters using real-time lighting; the extra UV channel wastes memory and the baking pipeline ignores animated meshes.
| Symptom | Root cause | Fix |
|---|---|---|
| Pink / magenta materials | Shader mismatch at import time | Reimport with URP active, or use the postprocessor below |
| Model 100× too large | Blender cm scale vs Unity m | Scale Factor = 0.01, or enable Apply Transforms in Blender export |
| Faces visible from inside | Backface culling direction | In Blender: Mesh → Normals → Recalculate Outside before export |
| Textures missing after reimport | Extracted .mat holds old shader | Delete the extracted material file, then reimport the GLB |
| Smoothing looks faceted | Normals set to Calculate | Set Normals = Import in the Model tab |
| Animations show wrong root motion | Residual scale on root bone | Enable Apply Transforms in Blender + set Rig → Root motion node correctly |
Automating the shader fix with AssetPostprocessor
If you import GLBs regularly, fixing the shader manually every time costs several minutes per asset. Unity's `AssetPostprocessor` runs automatically whenever a matching file enters the project. Create a file called `GlbUrpFixer.cs` inside any `Editor/` folder in your project:
```csharp
// imports: UnityEditor, UnityEngine
using UnityEditor;
using UnityEngine;
public class GlbUrpFixer : AssetPostprocessor {
void OnPostprocessModel(GameObject root) {
if (!assetPath.EndsWith(".glb", System.StringComparison.OrdinalIgnoreCase)) return;
var urpShader = Shader.Find("Universal Render Pipeline/Lit");
if (urpShader == null) return;
foreach (var r in root.GetComponentsInChildren<Renderer>(true))
foreach (var mat in r.sharedMaterials)
if (mat != null && mat.shader.name.StartsWith("Standard"))
mat.shader = urpShader;
}
}
```
For HDRP projects, swap the target string to `"HDRP/Lit"`. One important limit: `OnPostprocessModel` runs on the in-memory GameObject — it doesn't automatically persist the changed materials to disk as extracted `.mat` files. If you rely on extracted materials downstream (for a master material override or material instancing workflow), call `AssetDatabase.SaveAssets()` at the end; budget a few seconds per import on large projects.
The script handles the shader-assignment failure. For scale, set the constant once in the GLB's import settings rather than in the postprocessor — import settings are version-controlled with your project and travel with the repo, so the correction applies to every team member on first sync.
If the slower half of your pipeline is texture-map preparation in Blender rather than Unity import settings, assets from the BitSoul3D catalog arrive with that work done: PBR maps packed, UV channels clean, and the file tested against Unity 6 URP import. The Character Clockwork Sniper is a 1,500-triangle character with a full texture set — small enough to validate the postprocessor against a real asset in under a minute and confirm your project pipeline is correct. A free account includes two downloads per month for evaluation; commercial use is included with paid memberships (pricing).
For the Blender export settings that feed this pipeline, the companion post on Blender 5.0 glTF export settings covers the six Blender-side switches in detail. Once materials are rendering correctly, normal map compression formats for Unity is the next step — BC5 recovers 10–15% texture memory with no visible quality loss at standard viewing distances.
---
*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.*