Sculpt to Game Engine: Unity and Unreal

A sculpt and a game asset are not the same object, and the gap between them is where most first attempts fall apart. This is the handoff: what Unity and Unreal will actually accept, what each one does with a dense mesh, and which steps you can skip in 2026 that you couldn't skip five years ago. Disclosure up front: Re:Form is our browser sculpting tool and supplies the export side of the examples. Unity and Unreal are far more mature than we are, and the engine facts below were checked against Epic's and Unity's own documentation in August 2026.

Can you take a browser sculpt into Unity or Unreal?

Yes. Re:Form exports OBJ on every plan and adds STL, GLB, and FBX on Pro; Unity imports FBX, OBJ, DAE, and DXF out of the box, and Unreal Engine 5.8 imports FBX, OBJ, and glTF/GLB. The catch isn't the file — it's the triangle count. A 12-million-triangle sculpt is source art, not a shippable asset.

That distinction runs through the whole post. Getting the file in takes thirty seconds. Getting an asset that performs takes a decision about which of two paths you're on.

Why a raw sculpt is the wrong thing to ship

A finished sculpt is optimized for one thing: holding surface detail while you push it around. Nothing about it is optimized for a renderer running at 60 frames a second alongside a hundred other objects.

Four specific problems:

• Triangle density. Sculpts run into the millions by design. A traditional game character's in-engine mesh is measured in tens of thousands. That's two to three orders of magnitude.
• No UVs. Sculpting apps deform a dense surface; they don't generally lay out a texture map for it. Re:Form doesn't unwrap UVs, and without UVs you can't apply image textures in an engine.
• No LODs. Engines want progressively cheaper versions of a mesh for distant draws. A sculpt is a single density.
• Uneven topology. Sculpted triangles are placed for detail, not for deformation. If the asset needs to bend at an elbow, that matters. If it's a rock, it doesn't.

Which of these actually blocks you depends entirely on the engine and on whether the thing moves. A static prop in Unreal can ignore three of the four. A rigged character in Unity can ignore none of them.

Which format should you export for each engine?

Export GLB for Unreal and FBX for Unity. Unreal 5.8 imports .gltf and .glb through the same scene-import workflow it uses for FBX, and GLB is a single self-contained binary that carries Re:Form's vertex paint as the standard COLOR_0 attribute. Unity's manual recommends FBX as its native import chain and doesn't list glTF at all — that needs a package.

Here's the full picture:

Two footnotes on that table. First, Unity's glTF support is official but separate: the Unity glTFast package (com.unity.cloud.gltfast) implements the full glTF 2.0 spec, imports in the Editor and at runtime, and works with the Built-In, URP, and HDRP pipelines — you just install it from the Package Manager first. Second, Re:Form's FBX export is ASCII FBX 7.3, and some pipelines only accept binary FBX. If an importer refuses the file, GLB or OBJ will go through instead. STL is on the list only because Re:Form exports it; it's a 3D-printing format with no UVs, no color, and no units, and there is no reason to hand one to a game engine. The format breakdown covers what each one carries and silently drops.

What Unreal's Nanite changes

This is the part of the workflow that genuinely moved. Nanite is Unreal's virtualized geometry system, and Epic's 5.8 documentation is explicit about the intent: it makes it possible to directly import film-quality source art, such as ZBrush sculpts and photogrammetry scans, and to use high-poly detailing rather than baking detail into normal map textures.

In practice that means the dense mesh is the asset. You check Build Nanite in the import options — Epic's docs also suggest turning off Generate Lightmap UVs if you aren't using baked lighting, since it adds significant time to the import and build — and the engine constructs its own cluster hierarchy and level-of-detail structure from your geometry.

The requirements and limits, from the same documentation, as of August 2026:

• Nanite runs on current console and desktop platforms with graphics cards on recent drivers, using DirectX 12 with Shader Model 6.
• It supports static meshes, skeletal meshes, and geometry collections, and works with instanced static meshes, spline meshes, foliage, and landscape grass.
• Deformation via morph targets is not supported, and World Position Offset displacement is limited.

So: environment art, props, statues, rocks, hard-surface set dressing, and a lot of character work can go in dense. Anything driven by blend shapes — most facial animation — can't rely on Nanite for that part.

Do you still need retopology and normal-map baking?

For Unity, usually yes. For Unreal with Nanite, often no. Unity has no virtualized-geometry equivalent, so a multi-million-triangle sculpt has to become a low-poly mesh with a normal map baked from the high-poly original. Unreal's Nanite path lets the high-poly mesh render directly, which removes the bake for most static and non-morph-target assets.

That's the single biggest fork in this workflow, so it's worth being precise about what each path costs.

The classic path (Unity, and Unreal when Nanite doesn't fit): retopologize the sculpt into clean, low-density geometry, unwrap UVs on that new mesh, then bake the sculpt's surface detail into a normal map applied to it. This is real work — hours, not minutes — and Re:Form does none of it. Remeshing is not a substitute; it evens out triangle distribution but doesn't produce the deliberate, animation-ready topology a rigged character needs. We wrote up the difference in retopology vs remeshing because the two get used interchangeably and mean different things.

The Nanite path: export, import, tick the box. You still may want a decimated version for collision, and you still need materials, but the retopo-and-bake stage disappears.

Free tools cover the classic path. Blender does retopology, UV unwrapping, and normal-map baking, and it's the natural next stop after the sculpt — the browser-to-Blender handoff covers getting there cleanly.

Watch Unity's vertex ceiling

One hard number that catches people: a Unity mesh's index buffer is 16-bit by default, which tops out at 65,535 vertices. The 32-bit format goes up to about 4 billion, but Unity's own documentation warns that GPU support for 32-bit indices isn't guaranteed everywhere — Android devices with Mali-400 GPUs don't support them, and Unity logs a warning and refuses to render the mesh.

The practical reading: even where Unity technically accepts a dense mesh, mobile targets may not render it. If you're building for phones, the retopology-and-bake path isn't optional, and your budget lives in the tens of thousands of triangles, not the millions. Our polygon budget guide has the numbers by target.

Getting the scale right

Set the scale before you export, not after. Re:Form has a millimeters-per-world-unit setting that scales OBJ, STL, GLB, and FBX exports on the way out, and the two engines disagree about units in a way that guarantees a wrong number if you ignore it.

That's a factor of 100 between the two engines, before any millimeter-versus-meter confusion in your export. Decide the real-world size while you're still sculpting, dial the millimeters-per-unit value to match, and check the dimensions the moment the mesh lands. Unity's FBX importer has a Scale Factor field for correcting unit mismatches; Unreal's import options include an import-time uniform scale. Fixing it at import is repeatable. Scaling the object in the scene afterward looks identical and leaves a dirty transform that bites you later, when you attach a collider or re-export.

Orientation and axes

Re:Form's sculpting world is Z-up, matching Blender's convention, and interchange exports are converted on the way out so the mesh lands upright rather than face-down. Unity's world is Y-up; Unreal's is Z-up. Both engines apply their own conversion at import.

Check it anyway, on the first asset of any new project. Look at the mesh from the front view in the engine and confirm it faces the direction your engine considers forward. If it's rotated, fix it at import — both engines expose transform options in their import dialogs — rather than rotating the object in the scene. A character that arrives at a 90-degree rotation and gets "fixed" in the scene transform will fight every animation and every physics query afterward.

What travels, and what stays behind

Re:Form's vertex paint carries color, roughness, and metalness on the sculpt. Only some of that survives an export.

• GLB carries the color as a COLOR_0 vertex attribute. Any glTF-conformant importer reads it.
• Roughness and metalness stay behind. glTF's metallic-roughness model is material-level, not per-vertex, so there's no legal slot for them. Re:Form flags this at export rather than dropping it silently; you set those values in the engine's material, which is where you'd want them anyway.
• FBX and OBJ from Re:Form carry geometry, not paint. If the color matters, GLB is the export.
• Sculpt layers never survive. No interchange format has the concept. The layer stack lives in Re:Form's native .clay file — keep that as the master and treat every export as one-way.

Vertex color is also not the same thing as a texture. It's per-vertex, so its resolution is your mesh density, and an engine material has to be set up to read it. For a Nanite mesh at millions of triangles, vertex color is genuinely useful. For a retopologized 20,000-triangle character, it isn't — that asset wants real texture maps, made downstream.

The short version, as a workflow

1. Sculpt. Set millimeters-per-unit to your real-world target while you work.
2. Decide the path: Nanite (dense, Unreal, no morph targets) or classic (retopo + UVs + normal bake, required for Unity).
3. Export — GLB for Unreal, FBX for Unity — from Re:Form Pro. Keep the .clay as the master.
4. Classic path only: retopologize, unwrap, and bake in Blender or your DCC of choice.
5. Import. Tick Build Nanite if you're on that path. Check dimensions and orientation before anything else.
6. Build materials in the engine. Roughness, metalness, and image textures are engine-side work.

One licensing note, since this is a game pipeline: Re:Form's Free plan is for personal, non-commercial use. If the asset ships in something you sell, you need Pro — $9.99 a month or $99 a year, which also covers the STL, GLB, and FBX export you need to get out of the browser in the first place. Full terms are on the pricing page.

What Re:Form doesn't do

Being direct about the boundary: Re:Form is a sculpting front end, not a game-asset pipeline. It has no UV unwrapping, no texture baking, no retopology tools beyond remeshing, no rigging, and no LOD generation. It's in alpha, it runs only in desktop browsers with WebGPU, and it needs a free sign-in before you sculpt.

What it does do is get you from nothing to a dense, detailed mesh in a browser tab, with no install, on a machine that may not want a multi-gigabyte DCC package. For source art headed into Nanite, that's most of the job. For a Unity mobile character, it's the first of several steps. Either way, you can open the sculptor and find out where you land before spending anything.

FAQ

Can Unreal import a 12-million-triangle sculpt directly?

Yes, with Nanite. Epic's Unreal Engine 5.8 documentation describes directly importing film-quality source art such as ZBrush sculpts, and Nanite builds its own cluster and level-of-detail structure from that geometry. You enable it with the Build Nanite option at import. It requires DirectX 12 with Shader Model 6, and it doesn't support morph-target deformation.

Does Unity support glTF or GLB files?

Not in the base install. Unity's manual lists FBX, DAE, DXF, and OBJ as its imported standard formats and recommends FBX. Official glTF support comes from the separate Unity glTFast package (com.unity.cloud.gltfast), which implements the full glTF 2.0 spec, imports in the Editor and at runtime, and supports the Built-In, URP, and HDRP pipelines.

Do I need Re:Form Pro to send a sculpt to a game engine?

For anything commercial, yes. The Free plan covers personal, non-commercial work and exports OBJ only, which both engines read. Pro adds FBX and GLB export, raises the triangle budget from roughly 12.5 million to 50 million, and includes the commercial license you need if the asset ships in a game you sell. The FAQ has the plan details.