3D Model File Formats Explained: FBX vs OBJ vs glTF vs STL

How to Choose a 3D Model Format: A Format-by-Format Guide for Game and CGI Pipelines

3D model file formats decide what actually survives when you move an asset from Blender, Maya or 3ds Max into Unity, Unreal Engine, a web viewer or a 3D printing workflow. For example, imagine exporting the same chair from Blender in three different formats and opening them in Unreal Engine. The OBJ arrives gray and a hundred times smaller than it should be. The FBX is the right size, but its material is simplified, and some maps have to be connected manually. The GLB imports right away, with the material. There is nothing wrong with the model. Each format simply stores its own set of data, and applications read scale, axes, and materials differently.

Below is what lives inside the main formats, which ones are suitable for animation, the web, engines, and scans, and what to check if an asset does not look the same after import as it did in the source application. We cover in detail:

• FBX
• OBJ
• glTF and GLB
• USD and USDZ
• PLY
• BLEND

Briefly — Alembic, Collada, STL, 3MF, and STEP.

What Is a 3D Model Format and Why It Matters

A 3D model format is a way to write an asset into a file. That file may contain the mesh itself, UVs, materials and textures, a skeleton and animation, cameras, lights, scene hierarchy, units, and the axis that points upward. The important word is “may”: no format stores everything at once, because formats were created for different tasks. OBJ appeared in Wavefront software around 1990 for exchanging static geometry. glTF was designed to load quickly in a browser. STEP was made for engineers who need a circle to remain a circle, not become a 64-sided polygon.

That is why formats are compared by several properties:

Property	What question it answers
Geometry	Polygons, separate points, or precise CAD surfaces?
Animation	Can the format carry a skeleton, skinning weights, blend shapes, and keyframes?
Materials	A real PBR material, or just a color and a path to a texture?
Textures	Embedded in the file or stored next to it?
Units and axes	Does the file say what “1” means and where “up” is?
Open or closed	Is there a public specification that anyone can implement?

When import goes wrong, the cause is almost always in one of these rows.

Comparison Table: All Major Formats on One Page

Format	Extension	Used for	Geometry	Animation	PBR materials	Units in file	Open / closed	Typical size
FBX	.fbx	Game pipelines, animated assets	Polygonal mesh	Yes: skeleton, skinning, blend shapes	Not standardized	Yes	Closed (Autodesk)	Medium or large
OBJ	.obj + .mtl	Static geometry exchange	Polygonal mesh	No	No	No	Open de facto	Large (text)
glTF / GLB	.gltf, .glb	Web, AR, real-time delivery	Polygonal mesh	Yes: skinning, morph targets	Yes, in the core specification	Yes (meters)	Open (Khronos)	Small
USD / USDZ	.usd, .usda, .usdc, .usdz	VFX, large scenes, iOS AR	Mesh, subdivision surfaces	Yes	Yes, via UsdPreviewSurface and others; transfer is not always one-to-one	Can be specified; default is cm	Open (from Pixar)	Varies; binary is compact
BLEND	.blend	Blender working projects	Everything Blender has	Yes, inside Blender	Blender materials	Yes	Native to Blender, not for exchange	Large
PLY	.ply	Scans, point clouds, splats	Points or mesh	No	No standard PBR; vertex color and custom attributes	No	Open (Stanford)	Large for dense scans
Alembic	.abc	Baked VFX caches	Mesh per frame	Baked, no rig	No	Global units are not standardized	Open	Very large for long simulations
Collada	.dae	Older exchange between applications	Polygonal mesh	Yes	Pre-PBR only	Yes	Open (Khronos)	Large (XML)
STL	.stl	3D printing	Triangles only	No	No, not even color	No	Open de facto	Medium or large
3MF	.3mf	Modern 3D printing	Triangle mesh + print data	No	Color, basic materials	Yes (mm by default)	Open (ISO/IEC 25422)	Small (zip)
STEP	.step, .stp	CAD and engineering	Precise surfaces (B-rep, NURBS)	No	No	Yes	Open (ISO 10303)	Small or medium

When choosing a format, start with the “Used for” column: most problems are not caused by the format itself, but by using it for the wrong task.

The Main Formats Worth Knowing

FBX — The Workhorse of Animation and Game Pipelines

An FBX file is a proprietary 3D interchange format owned by Autodesk, used for moving 3D scenes between applications and, for roughly two decades, the standard way to move an animated character from Maya or 3ds Max into a game engine. It appeared in 1996 as the format for FiLMBOX, a motion-capture program by Kaydara. In 2004, Kaydara was acquired by Alias, and in 2006 Autodesk acquired Alias.

FBX stores almost everything that can exist in a scene: meshes, skeletons, skinning weights, blend shapes, animation, cameras, lights, hierarchy, plus unit scale and coordinate system. Almost every 3D application and engine understands it, and for rigged characters it is still the main route in most game pipelines.

The catch is that FBX has no public specification. Autodesk provides a closed SDK, but does not document the file format itself, so importers that do not use that SDK are written through reverse engineering — Blender developers even published their notes on the binary format. This leads to edge cases where two applications open the same FBX and disagree about pivots, scale, or smoothing. Godot, for example, first read FBX through the general-purpose Assimp library and later wrote a separate importer because transforms were coming in incorrectly. Add to that the fact that different SDK versions are not always compatible with one another, and that materials rarely arrive exactly as you set them up.

OBJ — Universal Static Geometry Exchange

The gray OBJ from the introduction is the most common surprise with this format. Where it comes from becomes clear once you know what an OBJ file is.

An OBJ file is a text file with a list of vertices, faces, normals, and UV coordinates — one of the oldest 3D formats still used every day. It came from Wavefront Technologies. The company is long gone, and the format has barely changed since the mid-1990s, which is why almost any program can open it. You can read it in a normal text editor, and that is unexpectedly useful when you need to understand what is actually inside the file.

There are no materials in the .obj itself. They live in a separate .mtl file and are described the way materials were described before PBR: ambient, diffuse, and specular colors, plus shininess. There is an unofficial extension with roughness and metallic, but support is so inconsistent that you should not rely on it. Textures are a third set of files, referenced by paths written in the .mtl. A gray model means one of the links has broken: the .mtl was not included, the textures were not copied, or the paths inside the .mtl point to folders that exist only on your computer. Send the .obj, .mtl, and textures together, and make sure the paths are relative.
OBJ has no animation and no units either, so scale is guessed by the importer every time. But for a static mesh and intermediate scan cleanup stages, that is often enough — and when nothing else opens, OBJ usually does.

glTF / GLB — The “JPEG for 3D” for Web, AR, and Real-Time

glTF is an open standard from the Khronos Group, the same consortium behind OpenGL and Vulkan. Khronos calls it the “JPEG for 3D,” and the comparison is fair: it was made for delivering ready-made content, not for editing. A .gltf file is JSON with references to separate binary files and images, while .glb packs the scene, binary data, and textures into a single file.

Inside are meshes, PBR materials, textures, skeletons, morph targets, animation, hierarchy, and cameras; lights and other features are added through extensions. For transfer between applications, two things matter here. First, a metallic-roughness PBR material is written directly into the core specification, so the importer does not have to guess which channel means what. Second, the specification fixes units and orientation: one unit is one meter, and the +Y axis points up. Most other formats leave this to the exporter author.

glTF is compact, loads quickly, is widely supported by web engines and viewers — Three.js, Babylon.js, model-viewer — and can compress geometry (Draco, meshopt) and textures (KTX2). The other side is that it is a delivery format: in round trips between applications, something may be lost; some features live in extensions that not everyone supports; and in some pipelines, for complex character animation, it is still less familiar than FBX.

USD / USDZ — A Scene Format for Large Pipelines

USD — Universal Scene Description — was created at Pixar so that hundreds of artists could work on the same shots without overwriting each other’s work. In 2016, Pixar open-sourced it, and since then the format has moved far beyond film.

The key difference in USD is composition. A scene is assembled from layers, references to other files, and variants: a layout artist, lighter, and animator can each own their own layer of the same shot, and USD composes the result. It stores geometry, including subdivision surfaces, materials, animation, cameras, and lights.

There is one caveat with materials. For exchange, they are usually described through UsdPreviewSurface, and the OpenUSD documentation itself calls it a limited set for transport, not a universal description of any material. That is why materials do not always transfer one-to-one between renderers. Units have a similar issue: they can be specified in the file, but if they are not, USD uses centimeters — which surprises people coming from glTF.

USDZ is a packaged, read-only USD. This is what Apple uses for AR Quick Look on iPhone and iPad.
Today USD is used by film studios, game engines, NVIDIA Omniverse, robotics simulators, and Apple. For a single prop it is overkill, and engine support is newer and more version-dependent. But if a studio assembles large scenes, USD will appear there sooner or later.

PLY — Where Scans Usually Begin

PLY is a simple format from the Stanford computer graphics laboratory, published in 1994 for 3D scanner data. Thirty years later, that is still mostly what it is used for.

The important thing about PLY is that it does not have to be a mesh. The file may contain a point cloud without a single face — exactly what a laser scanner, LiDAR, or photogrammetry reconstruction produces before a surface has been built from it. Each point can carry any additional data: color, normal, confidence. The same flexibility has made PLY a common container for Gaussian splats — each point stores opacity, scale, rotation, and color coefficients in addition to position.

PLY has no PBR materials, no animation, and no units. Dense scans produce huge files, and custom attributes are understood only by software that knows to look for them.
This is the usual path of a scanned asset, including at ScanWOW: first a point cloud or dense mesh, then cleanup, a simplified mesh, and baked textures — and only then is the asset ready for an engine. PLY is the beginning of the process, not what ends up in your project.

BLEND — Blender’s Native Project Format

A .blend file is, strictly speaking, not a model but a saved Blender session: the entire project exactly as you left it. Objects, materials with nodes, live modifiers, rigs, animation, lights, cameras, physics, scripts, even the interface layout. Textures can be packed directly into the file.

For continuing work in Blender, this is the most complete option — as long as you remember to pack external textures and linked libraries, otherwise they will be lost when transferred. But it is not an exchange format. Most programs cannot read it, a file from a newer Blender version may open incorrectly in an older one, and Unity and Godot import .blend only by silently launching an installed Blender and exporting the file behind the scenes. On your machine it works; on a colleague’s machine without Blender, it does not. Anything you give to someone else should be exported as FBX or glTF.

Formats for More Specialized Tasks

A game asset is not usually delivered in these formats, but you will encounter them: Alembic comes from VFX, STL and 3MF from 3D printing, STEP from engineers, and Collada from old archives.

Alembic (.abc) — Baked Geometry for VFX

A cache format from Sony Pictures Imageworks and Industrial Light & Magic, standard in VFX for baked geometry: cloth, fluids, crowds. It stores the result already calculated for every frame, so playback is fast, but you cannot change the pose — there is no rig inside. It usually lives alongside USD rather than competing with it.

Collada (.dae) — Scene Exchange Before glTF and USD

An open XML format for scene exchange, also from Khronos. It used to be a neutral way to move scenes between applications before glTF and USD appeared. It still appears in old pipelines and asset archives, but it is rarely chosen for new projects.

STL — The 3D Printing Standard

An STL file (.stl) is a 3D printing format that describes a model as a set of triangles and nothing else: no color, no UVs, no materials, no units. 3D Systems created it in the late 1980s for the first stereolithography printers, and today every slicer for FDM, SLA, and SLS printing accepts it. Since the file has no units, slicers read the numbers as millimeters by convention, so a model built in meters in Blender may arrive a thousand times smaller. For printing, the mesh itself matters more than the format: it has to be watertight and manifold, with no holes or stray edges.

STL does not work for a game asset. Without UVs, there is nothing to map Base Color, roughness, or a normal map onto, and normals are stored only per face, so after import the model often looks faceted. A scan saved as STL loses exactly what it was captured for: the material. If you need color on the print as well, use 3MF.

3MF (.3mf) — 3D Printing with Color and Units

A modern replacement for STL from the 3MF Consortium and, since 2025, an ISO standard (ISO/IEC 25422). It is a zip package that can store color, multiple materials, units, and print settings — everything STL cannot do.

STEP (.step, .stp) — Precise Geometry for CAD

An engineering format standardized as ISO 10303. Instead of triangles, it stores precise surfaces and curves (B-rep and NURBS), so a drilled hole remains mathematically round. Turning STEP into a mesh for rendering is routine. The reverse path, from a mesh back into clean CAD surfaces, is not an export anymore but a model rebuild.

3D Model Formats for Unity and Unreal Engine

When people search for Unity 3D model formats, they usually want to know which file types import cleanly, which ones preserve animation, and which ones keep PBR materials close to the source. For animated assets in Unity, FBX is most often chosen, and for characters this is usually the right choice. But for a static prop with PBR materials, glTF is often cleaner.

Format	Unity	Unreal Engine	Blender	Maya / 3ds Max	Notes
FBX	Built-in import	Built-in import	Import and export	Built-in	Common route for animation
OBJ	Built-in import	Built-in import	Import and export	Built-in	Static assets, basic materials only
glTF / GLB	Via package (glTFast, UnityGLTF)	Built-in plugin or Interchange, depends on version	Import and export	Maya — third-party plugin; 3ds Max 2023+ — built-in export, without animation and skinning	Predictably transfers basic metallic-roughness PBR
USD	Via package	USD Importer plugin	Import and export	Maya — built-in plugin, 3ds Max — plugin	For complex scenes
BLEND	Only with Blender installed	No	Native format	No	Export for delivery
Alembic	Via package	Alembic Importer plugin	Import and export	Built-in plugin	Baked caches, not rigs

Support changes from version to version, so treat the table as a starting point and check the documentation for your version.

glTF in Unity is installed as a package — glTFast, which Unity itself maintains, or UnityGLTF. In Unreal, glTF used to work through a built-in plugin, and starting with version 5.1 — through Interchange. USD is moving there gradually as well: asset import through Interchange was announced as production-ready in 5.8, while level import is still experimental. Godot, in general, recommends glTF as its main 3D format. USD is needed when you are moving whole scenes, not a single prop.

Whatever the format, the engine builds its own material during import. Which one exactly depends on the import package and render pipeline, and the result is close to what you saw in Blender, but rarely identical: lighting, tone mapping, and how the engine reads maps all affect the result. For example, Unity’s Lit shader stores smoothness instead of roughness, so that channel needs to be inverted. A good importer will do this automatically; a manually assembled material will not.

Open vs Proprietary, Mesh vs CAD

3D model formats differ along two independent axes: who owns the specification and how the geometry is written.

Open vs Proprietary

Open formats — glTF, OBJ, STL, USD, PLY, 3MF, STEP — have a public specification that anyone can read and implement. Closed formats belong to one company, like FBX, or one application, like native Maya and 3ds Max scene files.
In practice, the difference becomes visible over the years. An open format can be supported by any application whose developers have read the specification, and no one can take that away. With a closed format, you depend on the owner’s SDK and their plans, even if the format itself is good, as FBX is. This is what people call vendor lock-in.

Mesh vs CAD

Mesh formats (OBJ, FBX, glTF, USD, PLY, STL, 3MF) store a surface as vertices and flat faces, so any curve in them is approximated by a polygon. CAD formats (STEP, IGES, and native SolidWorks, CATIA, or Fusion files) store exact math: planes, cylinders, and NURBS surfaces with the boundaries between them (B-rep). Games, the web, and rendering work with meshes; engineering and manufacturing work with CAD.

Going from CAD to mesh is called tessellation, and it is routine: export settings decide whether a circle becomes a 32-gon or a 256-gon. There is no export in the other direction, because a mesh stores only triangles, not the design intent: the software does not know that those 32 faces used to be a hole. A part is recovered from a scan through reverse engineering, which means modeling it again on top of the mesh.

CAD has its own open and proprietary formats:

	Open	Proprietary
Mesh	glTF, OBJ, USD, PLY, STL, 3MF	FBX, native Maya and 3ds Max scenes
CAD	STEP (ISO 10303), IGES	Native SolidWorks, CATIA, and Fusion files; DWG (AutoCAD)

Why Exports Break and How to Avoid It

Broken imports have only a few symptoms: the model is gray, lying on its side, the size of a house, or transparent from the wrong side. Each has its own cause, and the export format determines which of them can happen to you.

Missing Textures

A gray OBJ is the best-known case, but not the only one. FBX and .gltf can also reference textures that sit next to the file rather than inside it, and on another machine those paths may not exist, especially if the path is absolute (C:\Users\you\Documents\...). Use relative paths, keep textures in a folder next to the model, or embed them into the file: GLB always does this, while FBX can do it if texture embedding is enabled during export.

Axis Mismatch

Applications disagree about where “up” is. Blender, 3ds Max, and Unreal Engine treat Z as up; Unity, Maya, and Three.js use Y up; and glTF fixes Y up directly in the specification. If the file does not store orientation or the importer ignores it, the model arrives lying on its side or rotated by 90 degrees. That is why most exporters have “forward” and “up” axis settings — set them for where the file is going, not where it came from.

Scale Mismatch

This is where units matter. glTF says that one unit is one meter. FBX stores unit scale in the file. USD can write units, and without them assumes centimeters. OBJ, STL, and PLY do not store units at all, so every application guesses.
That is where the tiny OBJ from the introduction comes from: in Blender one unit is a meter, in Unreal it is a centimeter, and OBJ does not say which one was intended. In the same way, a coffee mug may arrive the size of a house, and a building the size of a coin. Check units during export and scale factor during import, and model in real-world scale from the beginning. For scans, where real size is part of what you are paying for, it is worth checking twice.

Flipped Normals

Every face has a front side and a back side, and the normal tells which is which. If normals point inward, the renderer confuses inside and outside: faces disappear, lighting looks inverted, and the model seems turned inside out. The usual cause is a mirrored object with negative scale that was not applied before export, or dirty geometry in the source file. Recalculate normals and apply transforms before export.

Lost PBR Materials

OBJ’s .mtl format is older than PBR, so by the standard there is nowhere to put roughness, metallic, and ambient occlusion. FBX can carry them, but what arrives depends on the exporter and importer. If materials matter, use glTF or GLB, or carefully configure the FBX pipeline and reconnect maps inside the engine.

Normal Map Orientation

Normal maps come in two conventions, OpenGL and DirectX, and they differ in the direction of the green channel. Mix them up and raised details become dents, while the light seems to come from the wrong side. Unity and Blender expect OpenGL; Unreal expects DirectX.

Expert note from ScanWOW
One of the most common export mistakes is treating the model format as the whole pipeline. The mesh imports without problems, but the asset still looks wrong: the normal map is in the wrong convention, or roughness and metallic are packed into channels in a different order than the engine expects. Check the model format and texture export settings together, not one after another.

How to Choose the Right 3D Model Export Format

The right 3D model export format depends on the destination, not on the software where the asset was created. For asset libraries, 3D model export formats matter because the same scan may need to ship as FBX for a game engine, GLB for a web viewer or USD for a larger scene pipeline.

Ask five questions before choosing a format:
- Where will the asset be used?
- Does it need animation?
- Do PBR materials need to survive?
- Do you need a single self-contained file?
- Is this a source file or a delivery file?

Developer Cheat Sheet: 3D Model Formats by Use Case

Task	Recommended format	Fallback	Notes
Game asset for Unity	FBX / glTF	OBJ	FBX for animation, glTF for static PBR assets
Asset for Unreal Engine	FBX / glTF	OBJ	FBX is still the common route for animation
Godot	glTF / GLB	FBX	glTF is Godot’s recommended format
Web viewer	GLB	glTF	One file is easier to host and load
AR on Android	GLB	glTF	Read by Scene Viewer and model-viewer
AR on iOS	USDZ	glTF converted to USDZ	Required for AR Quick Look
Film / VFX	USD / FBX	Alembic for caches	USD for scenes, Alembic for baked simulations
Scanning or photogrammetry stage	PLY / OBJ	—	Intermediate; later cleaned and exported
3D printing	STL / 3MF	OBJ	3MF preserves units and color
CAD exchange	STEP	IGES	Precise engineering geometry
Source file that will still be edited	.blend or native scene file	USD	Keep it internally and export something else for delivery

The last row is more important than it looks. Keep the source file — .blend, a Maya scene, a USD layer — for yourself, and deliver FBX, glTF, or OBJ outside. One file should not do both jobs: .blend will not open for a client without Blender, and live modifiers cannot be recovered from FBX or GLB.

An asset from a library is always a delivery file, and what matters here is not only the export format but also the settings it arrives with: model detail, texture format and resolution, color space, normal map orientation, map packing, and naming. In ScanWOW, all of this is selected before download.

Format Is Not the Whole Export

A 3D model format determines what can even reach the engine, but it does not promise that it will. A typical case is a material assembled in Blender from procedural nodes. glTF stores maps and numbers, not a node graph, so only image textures and Principled BSDF values will make it into the file, while procedural noise and layer blending stay in Blender. The format is not the issue here: everything that is not an image should have been baked into textures beforehand.

With scans, the situation is the opposite: everything is already baked, and what breaks is not the material but how the textures are named and packed for a specific engine. You can see which texture formats and settings are available for scans in the ScanWOW library →

Conclusion: There Is No Single Best 3D Model Format

There is no universal winner among 3D model formats. FBX is still common for animation and game-engine pipelines. OBJ is useful for simple static geometry exchange. glTF and GLB are strong choices for web, AR and real-time PBR delivery. STL and 3MF belong to 3D printing. STEP is for CAD and engineering. USD is becoming important for large scene pipelines, while BLEND is best kept as a Blender source file.

The right choice depends on the destination, the data you need to preserve and the export settings around the model: textures, normal-map orientation, scale, axes and map packing. Choosing between 3D model formats is really choosing what data must survive the trip.

Read Also

• What Is PBR

FAQ

Which Is Better, STL or OBJ?

STL is for 3D printing; every slicer expects it. OBJ is for cases where you need UV coordinates and a basic material. Neither is ideal for game assets with PBR materials.

OBJ or FBX?

OBJ is for simply moving static geometry between applications. FBX is for anything rigged and animated. If PBR materials or the web matter, start with glTF.

What Is an FBX File and What Is It Used For?

An FBX file is a proprietary 3D interchange file format owned by Autodesk. It is mainly used for animated 3D assets, including characters, rigs, skeletal animation, cameras, and scene hierarchy. It is common in Maya, 3ds Max, Unity, and Unreal Engine pipelines.

What Is an OBJ File?

An OBJ file is a plain-text 3D geometry file format that stores static mesh data such as vertices, faces, normals, and UV coordinates. It is often paired with an MTL file for basic materials, but it does not store animation or reliable modern PBR materials.

What Does OBJ Mean in 3D?

In 3D workflows, OBJ usually refers to the Wavefront Object file format. It is a simple static mesh format that stores geometry in a human-readable text file, often paired with an MTL file for basic materials.

Is glTF Better Than OBJ?

For the web, AR, and PBR — usually yes: it is generally more compact and carries real PBR materials. If you only need bare geometry, OBJ is enough.

Which 3D Formats Does Unity Support?

Out of the box — FBX, OBJ, Collada, and DXF, as well as native files from some 3D applications if those applications are installed. glTF and GLB work through packages such as glTFast or UnityGLTF. The exact list depends on the version.

Which 3D Formats Does Unreal Engine Support?

FBX and OBJ are imported with built-in tools; glTF, USD, and Alembic work through built-in plugins or Interchange, depending on the engine version and enabled plugins.

Can I Use a Downloaded Model in a Commercial Game?

That depends on the license, not on the file format. Check the terms for the asset and your plan: the format says nothing about what you are allowed to do with the file.

Why Does My OBJ Look Wrong in Another Program?

Most often, the .mtl is missing, texture paths do not exist on another computer, scale or axes differ, or normals are flipped. And standard OBJ/MTL does not reliably carry modern PBR.

Sources

• Khronos Group. glTF and glTF 2.0 Specification.
• Alliance for OpenUSD / Pixar. OpenUSD; UsdPreviewSurface Specification; Linear units in UsdGeom.
• Autodesk. FBX.
• Blender developers. FBX binary file format specification. 2013.
• Godot Engine. FBX importer rewritten for Godot 3.2.4.
• Blender Foundation. Blender Manual.
• Library of Congress. PLY, Polygon File Format.
• Library of Congress. Wavefront OBJ.
• Library of Congress. STL, Stereolithography.
• Alembic.
• 3MF Consortium. 3MF Specification.
• ISO. ISO 10303 (STEP).
• Unity. Unity Documentation.
• Autodesk. 3ds Max 2023: glTF export.
• Epic Games. Unreal Engine 5.1 Release Notes; Unreal Engine 5.8 Release Notes; Importing Assets Using Interchange; glTF File Format Support in Unreal Engine; Unreal Engine Documentation.