GLTF 2.0 has quietly become the JPEG of 3D — a universal format that every engine, browser, and AR runtime can consume without a custom pipeline. But most developers only scratch the surface. Ship uncompressed assets with unoptimized textures and you'll see bloated load times, stuttering frame rates, and buyers who won't click Buy twice.
This guide covers the full chain: what GLTF 2.0 actually stores, how to shrink it aggressively with Draco and KTX2, the exact Blender export settings that produce clean files, and how to load them reliably in Unity, Unreal, and Three.js.
What Makes GLTF 2.0 the Universal 3D Format
GLTF (GL Transmission Format) was designed by the Khronos Group as a runtime-delivery format — not an authoring format like FBX or OBJ. That distinction matters enormously. Where FBX carries decades of compatibility baggage and OBJ discards materials entirely, GLTF 2.0 is built around what a GPU actually needs at draw time.
A GLTF file (or its binary sibling GLB) bundles:
- Meshes as typed binary arrays (float32 positions, uint16 indices) ready for direct GPU upload
- PBR materials via the `pbrMetallicRoughness` model, the same model Unity, Unreal, Godot, and WebGL all support natively
- Animations as keyframe tracks with cubic spline, linear, or step interpolation
- Scenes and node hierarchies as a JSON graph referencing binary buffers
- Extensions — officially registered extras like `KHR_draco_mesh_compression`, `KHR_texture_basisu`, `KHR_lights_punctual`, and dozens more
The binary GLB variant wraps the JSON header and all binary buffers into a single file, which is what you should ship in production. GLTF (the split variant) is useful during authoring when you want to inspect or diff the JSON separately.
PBR compatibility is the killer feature. A GLTF file authored in Blender will look identical in Three.js, Unity's URP, Unreal Engine 5, Godot 4, and Apple's RealityKit — provided you stay within the core spec and don't rely on engine-specific material hacks. That portability is why the BitSoul marketplace has standardized on GLB as the primary delivery format for 3D assets.
Draco Compression and KTX2 Textures: Shrinking File Size Without Sacrificing Quality
A raw GLB of a game-ready character can easily run 15–40 MB. With Draco geometry compression and KTX2 GPU-compressed textures, that same asset can drop to 3–8 MB with zero perceptible quality loss at runtime.
Draco Mesh Compression (`KHR_draco_mesh_compression`)
Draco is a Google-developed geometry codec that encodes vertex positions, normals, UVs, and indices using quantization and connectivity compression. It operates on the GLTF accessor level, so the mesh data in the buffer is replaced with Draco-encoded bytes, and the extension tag tells the loader to decode before uploading to the GPU.
Typical compression ratios: 8:1 to 16:1 on geometry buffers. A 2 MB vertex buffer becomes 150–250 KB.
Key Draco parameters:
| Parameter | Default | Aggressive | Description |
|-----------|---------|------------|-------------|
| `quantize_position` | 14 bits | 11–12 bits | Position precision |
| `quantize_normal` | 10 bits | 8 bits | Normal precision |
| `quantize_texcoord` | 12 bits | 10 bits | UV precision |
| `compression_level` | 7 | 10 | Encode speed vs ratio |
For game assets at normal play distances, 11-bit position quantization is visually lossless. Go lower only for background props.
KTX2 / Basis Universal Textures (`KHR_texture_basisu`)
KTX2 with Basis Universal transcoding is the complementary compression for textures. Unlike PNG or JPEG (which decompress to raw RGBA in CPU RAM before GPU upload), Basis textures transcode at load time into the GPU's native compressed format — ETC2 on mobile, BC7/BC5 on desktop, ASTC on Apple Silicon.
Result: textures stay compressed on the GPU, cutting VRAM usage by 4–8x. A 2048×2048 PBR texture set (albedo + normal + ORM) that takes ~48 MB of VRAM as PNG takes ~6 MB as KTX2.
Generate KTX2 textures with `toktx` (from the KTX-Software SDK) or use Blender's GLTF exporter with the `KHR_texture_basisu` option enabled (requires the `io_scene_gltf2` addon version 3.5+).
```bash
# Convert a PNG to KTX2 with ETC1S encoding (good for color maps)
toktx --encode etc1s --clevel 4 --qlevel 192 albedo.ktx2 albedo.png
# UASTC for normal maps (higher quality, larger file)
toktx --encode uastc --uastc_quality 3 normal.ktx2 normal.png
```
Use ETC1S for albedo and ORM maps where some chroma loss is acceptable; use UASTC for normal maps and metallic maps where precision matters.
Exporting GLTF from Blender: The Right Settings for Every Target
Blender's built-in GLTF exporter (`File → Export → glTF 2.0`) has improved dramatically through the 3.x and 4.x series. Here are the settings that matter, grouped by use case.
Essential Settings (All Targets)
```
Format: glTF Binary (.glb) # Single file, production-ready
Geometry → Apply Modifiers: ON # Bake subdivision, mirror, etc.
Geometry → UVs: ON
Geometry → Normals: ON
Geometry → Tangents: OFF # Let engine recompute (saves space)
Geometry → Vertex Colors: OFF # Unless used in shader
Mesh → Compression: ON # Enables KHR_draco_mesh_compression
Compression Level: 6 # Balance speed/ratio
Position Quantization: 12 bits
Normal Quantization: 8 bits
Texcoord Quantization: 10 bits
Materials → Export: ON
Materials → Image Format: Auto # PNG for transparency, JPEG for opaque
```
For Web (Three.js / Babylon.js / model-viewer)
```
Animation → Export: ON (if animated)
Animation → Optimize Animation: ON
Animation → Export Deformation Bones Only: ON
Skinning → Include All Bone Influences: OFF # Limit to 4 per vertex
```
Three.js requires the `DRACOLoader` to be initialized before loading Draco-compressed GLBs:
```javascript
import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js';
const dracoLoader = new DRACOLoader();
dracoLoader.setDecoderPath('/draco/');
const loader = new GLTFLoader();
loader.setDRACOLoader(dracoLoader);
loader.load('/assets/character.glb', (gltf) => {
scene.add(gltf.scene);
});
```
For Game Engines (Unity / Unreal / Godot)
Unity (via the GLTFast package) and Godot 4 (native import) both handle Draco-compressed GLBs out of the box. Unreal Engine 5 requires the Interchange plugin, which is enabled by default in UE 5.3+.
For Unity with GLTFast, ensure Draco support is installed:
```
Package Manager → Add by name: com.atteneder.draco
```
Loading GLTF in Unity, Unreal Engine 5, and Three.js
Each engine has quirks worth knowing before you waste time debugging a perfectly valid file.
Unity (GLTFast 6.x): The fastest runtime GLTF loader for Unity. Supports Draco, KTX2, animations, morph targets, and punctual lights. Set `ImportSettings.AnimationMethod = AnimationMethod.Mecanim` if you need Animator integration. URP and HDRP materials are auto-generated from the GLTF PBR parameters — but custom shader features (clearcoat, transmission) require GLTFast 6.4+.
Unreal Engine 5: Use the Interchange framework (`Edit → Project Settings → Interchange`). For runtime loading, the `glTFRuntime` plugin on the marketplace handles Draco and streaming. Static mesh LODs are not automatically generated — run the LOD tool after import or pre-generate LODs in Blender before export.
Three.js: The most complete implementation. `GLTFLoader` supports every major extension including `KHR_materials_transmission`, `KHR_materials_volume`, and `KHR_environment_map`. Use `gltf.scene.traverse()` to access individual meshes and attach physics colliders. For large scenes, enable `GLTFLoader`'s progressive loading with a `LoadingManager`.
Godot 4: Native import — drag the GLB into the FileSystem panel. Godot auto-generates a scene tree from the GLTF node hierarchy. Animations import as `AnimationPlayer` tracks. Gotcha: Godot uses Y-up, and Blender exports Z-up by default; enable `+Y Up` in the Blender GLTF export dialog to avoid a 90° rotation on import.
Marketplace-Ready GLTF: Checklist Before You Upload
Before you list a GLTF/GLB asset on BitSoul or any 3D marketplace, run through this checklist:
| Check | Tool | Pass Criteria |
|-------|------|---------------|
| File size | `ls -lh asset.glb` | < 10 MB for characters, < 5 MB for props |
| Draco encoded | `gltf-validator asset.glb` | `KHR_draco_mesh_compression` present |
| No broken UVs | Blender UV editor | No overlapping islands on primary UV set |
| Normal map Y-channel | Image viewer | Green channel dominant (OpenGL convention) |
| No loose geometry | Blender Select → Select All by Trait → Non-manifold | 0 results |
| Texture resolution | Image properties | Power of 2 (512, 1024, 2048, 4096) |
| Bone names | Outliner | Descriptive names, no Blender defaults like `Bone.001` |
| Origin at world center | Blender viewport | Object origin at 0,0,0 |
| License metadata | `glTF-Transform info asset.glb` | `copyright` field set |
Validate your file with the official Khronos GLTF validator before upload:
```bash
npx gltf-validator asset.glb --stdout | python3 -m json.tool | grep -E '(errorCount|warningCount|info)'
```
Zero errors is required. Warnings about accessor normalization or unused textures are acceptable but worth fixing.
Ship Smaller, Load Faster, Sell More
GLTF 2.0 is not just a file format — it is a delivery contract between your 3D tool and every runtime that matters. Draco and KTX2 compression can cut file sizes by 80–90% with no visible quality loss. Clean Blender export settings prevent the silent bugs that only appear in production engines. And a validated, well-structured GLB is what separates a professional marketplace listing from an asset buyers return.
Ready to put optimized assets in front of buyers? Browse the BitSoul 3D marketplace to see what well-prepared GLTF assets look like in practice — or list your own optimized work and reach thousands of game developers actively searching for quality assets.
---
*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.*