How to Import GLB into Unity: Why It Is Not Supported Out of the Box and How to Install glTFast

Out of the box, Unity cannot import GLB (glTF) files. The 3D model formats that the official Unity Manual lists as natively supported are .fbx, .dae (Collada), .dxf, and .obj; glTF and GLB are not on that list (source: Unity Manual - Model file formats, as of July 2026). To work with GLB, you add Unity glTFast (com.unity.cloud.gltfast), a package officially provided by Unity, through the Package Manager. Once it is installed, simply copying a GLB into your Assets folder imports it just like any other 3D format.

This article focuses strictly on the technical steps of getting a GLB to load in Unity. For the bigger picture, from converting an illustration into a 3D model through to the realities of rigging and animation, see How to Turn a 2D Character Illustration into 3D for Unity: Conversion, Import, and What It Takes to Animate. If you want to understand the whole workflow, read that one first.

Note: Figmee currently lets you generate and download figurine-style images and 3D model data (GLB / 3MF) from drawings and illustrations you upload. Sales of physical 3D-printed items are in preparation (Coming Soon).

Why Unity cannot load GLB by default

Unity is designed to use FBX as its internal import path, and the official manual itself recommends using .fbx whenever possible as a best practice. glTF 2.0, on the other hand, is a format defined by the Khronos Group for fast display at runtime, and it is widely used on the web and in real-time rendering. Because the two serve different purposes, glTF simply is not part of Unity's core.

We cover the differences in character between formats in OBJ vs FBX vs STL vs GLB: How to Choose the Right 3D File Format. If the data you have is already GLB, the most straightforward route is to load it directly with glTFast rather than converting it first.

Installing Unity glTFast (about 3 minutes)

Unity glTFast is an official package provided by Unity, designed with a focus on speed, memory efficiency, and a small build footprint. It supports the glTF 2.0 specification and many extensions, and works on all platforms and with the Built-in, Universal (URP), and High Definition (HDRP) render pipelines (source: Unity glTFast Documentation, as of July 2026, version 6.17.0).

The installation steps described in the official documentation are as follows (source: Unity glTFast - Installation, as of July 2026).

1. Open your Unity project and select Window > Package Manager (20 seconds).
2. Click the add (+) button in the status bar (10 seconds).
3. Choose Add + package by name from the menu (10 seconds).
4. Type com.unity.cloud.gltfast into the Name field (20 seconds). Watch out for typos. This ID belongs to the official package, not to the name inherited from the older personal repository.
5. Click Add (1 minute). The latest version is fetched automatically. Depending on your network, this can take a few minutes.

Optional modules to add depending on your needs

glTFast covers more ground when combined with Unity's built-in packages and additional packages. The official documentation lists the following:

• Image Conversion: support for JPEG / PNG textures
• Unity Web Request Texture: loading images via URI
• Animation: animation playback
• Physics: collider generation
• Draco for Unity / KTX for Unity / meshoptimizer decompression for Unity: when you use the corresponding glTF extensions (mesh compression and texture compression)

There is no need to install everything from the start. It is perfectly fine to add the relevant module only when a symptom appears, such as textures not showing up or a compressed GLB refusing to open.

Importing a GLB (about 2 minutes)

Once installation is done, GLB is handled the same way as any other 3D format.

1. Move or copy the GLB file into your project's Assets folder (30 seconds). The official documentation explains that you can move or copy glTF files into your project's Assets folder just like other 3D formats, and that Unity glTFast imports them into native Unity prefabs and adds them to the asset database (source: Unity glTFast - Editor Import, as of July 2026).
2. For .gltf files, copy the accompanying files as well (30 seconds). The same documentation states clearly that you must not forget to copy the accompanying buffers (.bin) and image files, and that file names and relative paths cannot be changed, since doing so may break references. A .glb is packed into a single file, so this is not a concern. That is one of the reasons GLB is often chosen for handoffs.
3. Select the file in the Project view and check the Inspector (1 minute). The import settings, along with any warnings or errors, are shown here. Whenever something loads differently than you expected, look here first.
4. Expand the file in the Project view (30 seconds). The imported components are listed as Scenes / Meshes / Materials / AnimationClips / Textures. When you want to reuse an individual mesh or material on another object, take it from here.
5. Drag it into the scene to place it (10 seconds). This works exactly like a regular prefab.

About file extension association

When installed, glTFast registers itself as the default importer for .gltf and .glb. In other words, after installation these extensions are loaded through glTFast automatically, with no extra steps.

If you already use another glTF importer and the two conflict, you can disable glTFast's default importer registration by adding GLTFAST_FORCE_DEFAULT_IMPORTER_OFF to your project's scripting define symbols. In a project that combines several glTF-related assets, if the import result is not what you expected, the first thing to suspect is which importer is actually doing the work.

How to read the generated sub-assets

The five types that appear when you expand a GLB in the Project view each play a different role. Understanding them lets you respond quickly later when you need to reuse just one part or swap out only the materials.

If AnimationClips is empty, that does not mean the import failed; it means the original GLB simply contains no animation. A 3D model generated from a single drawing is a static mesh, so this entry is usually empty.

The materials listed under Materials follow the glTF core specification. glTF materials are made up of channels such as base color, metallic, roughness, ambient occlusion, normal map, and emissive, and on the Unity side these are mapped onto your project's shaders. When something looks more metallic than you expected or far too shiny, the two settings you usually need to adjust are metallic and roughness.

Know the other options too

glTFast is not the only way to work with glTF in Unity. UnityGLTF, published by the Khronos Group (as of July 2026), is a runtime glTF 2.0 loader and exporter for Unity, and it is also available as open source. It is a strong choice if you care about export features or if an existing project already uses it.

This is not about one being better than the other. In practice, you choose based on your project's requirements: the extensions you need, whether you need export, and your existing assets. If your new project only needs to import, glTFast is the easier one to set up, since it installs from the Package Manager as an official Unity package.

Three things to check after importing

Just because a model loads does not mean it is ready to use as is.

1. Materials and the render pipeline

This is the most common stumbling block. glTFast supports Built-in, URP, and HDRP alike, but if your project's pipeline and the material shaders do not match, the model will appear pure white, pure black, or magenta (pink). Magenta is Unity's default display when a shader cannot be found, so if you see that color, suspect a pipeline mismatch first. Also check that there is a light in the scene.

2. Scale and origin

Sometimes a character turns out to be enormous or extremely tiny the moment you place it. This happens when the source data was not built with real-world dimensions in mind, and it is not an error. Adjust it with the Scale value in the Transform, or decide the size relative to the ground or existing objects. Checking the origin (at the feet or at the center of the body) at this stage also makes later placement easier.

3. Face count and rendering load

AI-generated models and highly detailed models can have a high face count by real-time rendering standards. The more faces, the heavier the rendering and processing load, and the impact is greater the more you target mobile (What Is Polygon Count? What Happens When It Is High or Low, Targets by Use, and How to Count It). Use the number of characters you will display at once as your benchmark, and if needed, reduce the faces in a tool such as Blender before importing again.

Troubleshooting table

Frequently asked questions

Does Unity have built-in glTF / GLB import?

No. The formats listed as natively supported in the official Unity Manual are .fbx, .dae, .dxf, and .obj. To work with GLB, add the official Unity package glTFast (com.unity.cloud.gltfast) from the Package Manager. Once added, it registers as the default importer for those extensions, so from then on you can handle GLB just like any ordinary asset.

Is it better to convert to FBX before importing, or to import the GLB as is?

If you already have a GLB, loading it with glTFast without a conversion step means fewer steps and less risk of losing colors or textures along the way. On the other hand, if your whole team has standardized on FBX for handoffs, or you exchange data that includes animation, it is perfectly reasonable to go with FBX. We explain the character of the format in What Is a GLB File? How to Open, Use, and Convert It, Explained Simply.

Can GLB also be loaded at runtime (in-game)?

Yes. glTFast supports not only importing in the editor but also loading at runtime. This makes designs possible such as displaying models that users bring into your app. However, you need to build the asynchronous loading and error handling yourself, so the safe approach is to confirm the display with an editor import first and then move on to runtime support.

Summary

The process of working with GLB in Unity boils down to three steps: (1) add the official package com.unity.cloud.gltfast through the Package Manager, (2) copy the GLB into Assets, and (3) check the Inspector for warnings and place it in the scene. Unity's inability to load GLB natively is by design, and once you install a single package, everything from there on is standard work.

If you do run into trouble, it is almost always the fit between materials and the render pipeline. Magenta points to shaders, pure black to lighting, and missing textures to the accompanying files of a .gltf. Narrow it down that way and most problems are solved quickly. If you are planning to make the imported model move, you will also need bones and a rig, so check the full process in How to Turn a 2D Character Illustration into 3D for Unity: Conversion, Import, and What It Takes to Animate.

Related guides

• How to Import GLB into Godot: No Plugin Needed, Just Drop the File In