Why You Should Stop Baking Normal Maps (and Start Using Nanite)

Every game art tutorial I've read for the past decade opens with the same mantra: sculpt a high-poly, retopologize a low-poly, and bake those high-poly details onto a normal map. It's so ingrained that I've seen artists treat the bake as a rite of passage. But I'm here to tell you that for a growing category of real-time work, this pipeline is becoming a legacy skill. Nanite, Unreal Engine 5's virtualized geometry system, lets you import film-quality meshes with hundreds of millions or billions of polygons and stream them in real time, removing polygon budgets, draw count budgets, and the need to hand-author LODs or bake normal maps (Unreal Engine documentation, Epic Games). That's not a minor tweak to the pipeline—it's a fundamental shift in how we think about asset creation.

What Exactly Is the Traditional Pipeline, and Why Does It Hurt?

The modern game asset workflow is a high-poly-to-low-poly pipeline: you block out the shape, sculpt a dense high-poly mesh, retopologize a low-poly game mesh, unwrap UVs, bake detail onto the low-poly, then texture and integrate into the engine (Game art pipeline, Wikipedia). Retopology exists because real-time engines cannot afford millions of polygons per character (Game art pipeline, Wikipedia). So you spend hours—often days—manually creating a clean, low-poly cage with purposeful edge flow around joints and deformers, just so your character can bend without collapsing. Then you spend more time baking normal maps to fake the detail you just sculpted away.

Here's the dirty secret: that bake is a lie. You're capturing the high-poly's surface direction into an RGB texture and letting the low-poly pretend it's more detailed than it is. It works, sure. But it's a compromise. The normal map can't capture true displacement, only the illusion of it, and it breaks down at grazing angles and silhouette edges. And for hard-surface props, the retopology step is often pure drudgery—why rebuild a machine part's topology when the engine could just render the high-poly as-is? Nanite asks exactly that question.

The Nanite Argument: When You Can Skip the Bake

Unreal Engine 5's Nanite virtualized geometry imports film-quality meshes containing hundreds of millions or billions of polygons, streams and scales them in real time, and removes polygon budgets, draw count budgets and the need to hand-author LODs or bake normal maps (Unreal Engine documentation, Epic Games). I want to repeat that last clause: no hand-authoring LODs, no baking normal maps. For static assets—environment pieces, hard-surface props, architecture—you can sculpt your high-poly, do a quick UV unwrap for texturing, and drop it straight into the engine. The LODs are generated automatically, and the silhouette retains the full high-poly detail.

Let me give you a concrete scenario. Suppose you're building a rocky cliff for an open-world game. In the old pipeline, you'd sculpt a 2-million-poly rock in ZBrush, then spend an afternoon retopologizing it down to 10,000 triangles, unwrapping it, and baking a normal map to recover the cracks and crevices. With Nanite, you can import the 2-million-poly mesh directly. The engine handles the streaming and LODs in real time. The normal map becomes optional—you might still use it for micro-detail, but you're no longer dependent on it to convey the rock's form.

Nanite is not a magic wand, though. It's designed for static geometry, not for deformable characters. Skeletal animation still requires a skinned mesh with a controlled topology, because vertex weights and deformation need predictable edge flow (Skeletal animation, Wikipedia). So for characters and organic creatures, you'll still need to retopologize and bake. But for the vast majority of environment assets and props, the traditional bake can be bypassed entirely. That's a massive time save.

The Counter-Argument: Why I Still Teach Baking (and You Should Too)

Before you delete your Marmoset Toolbag, hear me out. Nanite is Unreal Engine 5–specific. It doesn't work in Unity or Godot, and it doesn't apply to mobile. Unity's optimization guidance still tells artists to spend the polygon budget on silhouette and large forms rather than small triangles, and to use textures and normal maps for fine detail (Unity mobile optimization guide). And technical artists still set asset budget spec sheets—like an LOD0 character at roughly 15,000 triangles with 2048x2048 textures and 2-3 draw calls, scaling down through LOD3 at 800 triangles (Technical artist roles, gamesindustry.biz). That's not going away for most of the industry.

So if you're a student or a junior artist, you need to know the traditional pipeline. It's the lingua franca of game art. When you apply for a job at a studio that works in Unity or on mobile, they will ask you to bake a normal map. And even in Unreal, you'll often need to export your assets to other tools or engines for a larger project. Baking is a fundamental skill that teaches you how geometry and texture interact, and that understanding is crucial even when you don't need to bake.

But here's my recommendation: learn both, and use the right tool for the job. For static assets destined for UE5, embrace Nanite and skip the bake. For characters, deformable props, and any cross-engine work, fall back on the traditional high-poly-to-low-poly pipeline. This hybrid approach gives you the best of both worlds: the speed and fidelity of Nanite for static scenes, and the control and compatibility of baked LODs for anything that moves.

Practical Advice for the Hybrid Pipeline

So how do you actually implement this in a real project? Here's a practical workflow that I use and recommend:

• Static environment assets: Sculpt in ZBrush, do a quick decimation or use ZRemesher to get a reasonable mesh, UV it in RizomUV or Maya, and import into UE5 as Nanite. Don't bake a normal map unless you need extra micro-detail that the sculpt can't capture.
• Characters and creatures: Retopologize manually with Quad Draw in Maya (or use ZRemesher with guide curves for a starting point) to get animation-friendly edge flow. Bake your normal maps as usual. This is non-negotiable for deformation.
• Props that appear in multiple engines: If you're shipping a prop for both UE5 and Unity, bake a full normal map set so you can use it in both engines. Nanite won't help you in Unity.

One caution: don't let Nanite become a crutch. The fact that you can import a 100-million-poly mesh doesn't mean you should. Even with Nanite, performance depends on how many pixels are on screen. And if you're making a mobile game, you won't have Nanite at all. So practice your retopology on every character, and only skip it for static assets when you're certain of the target engine.

The Bottom Line

Here's the single most important thing to remember: Nanite doesn't make the high-poly-to-low-poly pipeline obsolete—it makes it optional for static assets. The traditional bake is still essential for characters and for cross-engine work, but for UE5 environments, you can now spend your time sculpting instead of retopologizing. That's a massive win for art teams, and I expect the role of the technical artist to shift from enforcing polygon budgets to managing Nanite's virtualized geometry and LOD settings. But don't throw away your baking skills—you'll need them for the next project that isn't in UE5, and for the inevitable day when you have to animate a character.

Sources

• Game art pipeline - https://en.wikipedia.org/wiki/Video_game_art_design
• Unreal Engine documentation - https://dev.epicgames.com/documentation/en-us/unreal-engine/nanite-virtualized-geometry-in-unreal-engine
• Unity mobile optimization guide - https://unity.com/how-to/mobile-game-optimization-tips-part-1
• Technical artist roles - https://www.gamesindustry.biz/technical-art-roles-what-they-are-and-how-to-get-one