3DAssets.dev

Unity guide

How to import free 3D models into Unity

Unity does not read glTF out of the box. Install glTFast, drop the file in, and you have a prefab. Here is the setup, the render pipeline trap, and the one conversion textured models need.

3DAssets.dev5 min read

Unity is the one engine here that needs a package installed before it will look at a glTF file. It reads FBX and OBJ natively; glTF and GLB it ignores until you add an importer. That importer is glTFast, it is a Unity-published package, and installing it takes about a minute.

Install glTFast

Open Window, then Package Manager, then the plus button, then Add package by name, and enter:

1com.unity.cloud.gltfast

From that point, dropping a .glb into your Assets folder produces an imported prefab exactly like an FBX would. Nothing else needs configuring for the common case.

If your project is on an older Unity version and that package name is not found, the same importer exists as com.atteneder.gltfast, which is where the project lived before Unity adopted it. Prefer the com.unity.cloud name on anything current.

Importing a model

Drag the file into the Project window, or copy it into the folder on disk and let Unity pick it up. You get a prefab with the meshes, materials and, where the model has them, an animation clip. Drag that into the scene.

Materials come in read-only, as they do with any imported model. To edit one, select the imported asset, open the Materials tab in the Inspector and extract the materials to your project, then edit the extracted copies. Editing the imported ones directly does not survive a reimport.

The pink material problem

If your model appears in the scene as a solid magenta silhouette, the geometry imported correctly and the shader did not compile for your render pipeline. glTFast ships shader variants for the built-in pipeline, URP and HDRP, and the mismatch usually comes from one of two things:

  • The model was imported before you switched pipeline. Right-click the asset and Reimport, which rebuilds its materials against the pipeline you are on now.
  • The shaders were stripped from a player build. They look fine in the editor and turn pink in the build. Add the glTFast shaders under Project Settings, then Graphics, then Always Included Shaders, and rebuild.

Neither is a problem with the model, which is worth knowing before you go looking for a different one.

Colliders

Imported meshes come with no collision. For a prop that only needs to be solid, add a Box Collider to the prefab and size it to the model; for anything a character stands on or walks through, a Mesh Collider set to convex is usually right.

Resist putting a non-convex Mesh Collider on every detailed prop. It works, and it is a large amount of physics cost for a crate that only ever needs to be a box.

Animations

Models with moving parts import their clips alongside the mesh, under the names the catalogue publishes, so a supply crate carries open and close and a fan carries spin. glTFast can bring them in as Legacy, Mecanim or Humanoid clips, and Legacy is the default. Legacy clips are played through an Animation component rather than an Animator:

1using UnityEngine;
2

3public class Crate : MonoBehaviour
4{
5    [SerializeField] Animation anim;
6

7    public void Open() => anim.Play("open");
8    public void Close() => anim.Play("close");
9}

Switch the import setting to Mecanim if you want an Animator and a state machine, which is the right call for anything beyond playing a named clip on cue. Note that Legacy clips cannot be swapped through an AnimatorOverrideController, so if that is in your plans, choose Mecanim at import rather than converting later.

Looping is a property of the clip in Unity rather than something carried in the file, so a spin you want running continuously needs Loop Time ticked on the imported clip.

Loading a model at runtime

This is where glTFast earns its place over converting everything to FBX up front. It parses glTF at runtime, so a model can come from a URL:

1// Unity: import model.glb with glTFast (Package Manager: com.unity.cloud.gltfast) and drag the prefab in,
2// or load it at runtime straight from the CDN:
3using GLTFast;
4

5var gltf = new GltfImport();
6if (await gltf.Load("https://cdn.3dassets.dev/assets/28312/v1/model.glb"))
7    await gltf.InstantiateMainSceneAsync(transform);

The URLs on cdn.3dassets.dev are immutable and CORS-enabled, so this works from a WebGL build as well as a desktop one, and a downloaded file can be cached indefinitely without any invalidation logic.

Two practical notes. Load returns false rather than throwing on a failed download, so check it. And instantiating on the main thread still costs a frame or two for a large model, so kick the load off before the player needs the object rather than at the moment they walk into it.

Scale and orientation

One glTF unit is one metre and one Unity unit is also one metre, so models arrive at their real size. Everything on 3DAssets.dev is authored in metres with +Y up and sits on the ground plane, so a five-metre tree is five units tall with its base at y = 0.

glTF is right-handed and Unity is left-handed, and glTFast handles that conversion on import. You do not need to do anything about it, and if a model appears mirrored the cause is almost always negative scale baked into the source rather than the handedness conversion.

Textured models need converting first

This is the one real friction point between this catalogue and Unity, and it is worth knowing before you spend an afternoon on it.

Textured models here store their images as WebP, through the EXT_texture_webp glTF extension, and they list it in extensionsRequired. glTFast does not support that extension and the maintainers have said it will not: the package prefers KTX2 and Basis Universal instead. Because the extension is required rather than optional, a conforming loader is not allowed to quietly skip it and carry on, so the model fails to load rather than arriving untextured.

Two things soften this. Most of the catalogue is untextured, using flat material colours rather than image maps, and those files carry no WebP at all and import normally. And converting a textured one takes a single command:

1npx @gltf-transform/cli png model.glb model-png.glb

That rewrites the images as PNG and drops the extension, leaving geometry, materials and animations untouched. Use jpeg in place of png for photographic textures. Drop the converted file into Assets and glTFast imports it with its textures.

Check extensionsUsed on the asset in the API, or the extensions list on the asset page, if you want to know which models need this before downloading them. KHR_mesh_quantization, which every model here uses for geometry, glTFast does support, so that half needs nothing.

Next

Importing the same models into Godot is a shorter process, since Godot reads glTF natively. For the browser rather than an engine, start with loading a GLB in three.js. If you would rather an agent did the importing and placing, Unity now has official plugins for Claude Code and Codex.

Common questions

Can Unity open GLB files?
Not with a stock install. Unity reads FBX and OBJ natively but has no built-in glTF importer, so a .glb dropped into a project is treated as an unknown file. Install the glTFast package (com.unity.cloud.gltfast) through the Package Manager and Unity imports GLB and glTF files as prefabs from then on.
Why won't my GLB model load in Unity at all?
If the file has image textures it almost certainly uses the EXT_texture_webp extension and lists it as required, and glTFast does not support that extension. A required extension cannot be skipped, so the load fails outright rather than producing an untextured model. Convert the file first with a single command, npx @gltf-transform/cli png model.glb model-png.glb, which rewrites the textures as PNG and leaves everything else alone.
Why are my imported models pink in Unity?
Pink means a material whose shader the current render pipeline cannot compile. glTFast ships shaders for the built-in pipeline, URP and HDRP, but the right variants have to be included in the build; the usual fixes are to reimport the model after switching pipeline, and to add the glTFast shaders to Always Included Shaders in Graphics settings so they survive a player build.
How do I load a 3D model from a URL at runtime in Unity?
Use glTFast's runtime API: create a GltfImport, await Load with the model URL, then await InstantiateMainSceneAsync with a parent transform. It downloads, parses and builds the GameObject hierarchy for you, which is how you would stream content into a released game rather than shipping every model in the build.
What scale do imported GLB models use in Unity?
One glTF unit is one metre and Unity's default unit is also one metre, so a correctly authored model arrives at its real size with no scale factor. Models on 3dassets.dev are authored in metres with +Y up and sit on the ground plane, so a five-metre tree is five units tall with its base at y=0.

Keep reading

Godot guide

How to import free 3D models into Godot

Godot 4 treats a GLB as a native scene, so importing one is a file copy. Here is the editor route, the runtime route, and how to set up collision and materials without fighting the reimporter.

AI setup

Give your AI assistant a 3D model library

An AI coding assistant can write a three.js scene in seconds and then fill it with grey cubes, because it has no models and no way to find any. Connecting it to a catalogue fixes that in one line.