Normal Map vs Bump Map: The Honest Difference

By Voise · 3D artist since 2009Published May 20, 20268 min read

Split-screen 3D render — same brick wall lit with a grayscale bump map on the left and an RGB tangent-space normal map on the right — Same wall, same light, two maps. Bump on the left (a guess from brightness). Normal on the right (a direction at every pixel).

A bump map is a greyscale image where every pixel stores one number — how high or low that point should appear. A normal map is an RGB image where every pixel stores three numbers — a full 3D direction. Both fake surface detail without adding any geometry. Normal maps carry more information per pixel and look correct at every angle (which is why they won), but bump maps still pull their weight for fine grain and quick prototyping.

TL;DR

Bump map = one number per pixel (height). Normal map = three numbers per pixel (direction).
Normal maps are the modern PBR default. Bump maps are still handy for grain and prototypes.
Neither one changes the silhouette. Both are lighting lies.
You can stack a bump on top of a normal map for the finest detail.
Nine out of ten broken-looking normal maps are a wrong green channel, not a wrong map.

Right. A bump map walks into a bar. The bartender says "you look raised today." The bump map says "mate, that's just the lighting." (I'll see myself out. My wife's already rolling her eyes from another room.) I've been making PBR textures since 2009, and I get asked the bump-vs-normal question at least twice a week. Here's the honest answer, the one number that actually separates them, and the engine quirks that'll bite you if you don't know about them.

What a bump map actually is

A bump map is a greyscale image. One channel. Lighter pixels read as raised, darker pixels read as recessed. The renderer doesn't move any geometry — it looks at the slope of the brightness around each pixel and tilts the lighting calculation as if the surface were actually that bumpy.

Bump mapping is the original surface-detail trick. Jim Blinn invented it in 1978, well before PBR was a glint in anybody's eye. The clever bit: it's cheap. One channel, one slope, a small bit of maths per pixel. Half a megabyte gets you fine detail across an entire wall.

Grayscale bump map texture for a weathered wood plank — light wood grain on a mid-grey base, no colour information — A bump map. Greyscale. Lighter = raised, darker = recessed. One number per pixel.

Limits: because the renderer is inferring direction from brightness, it gets the direction slightly wrong at grazing angles and any time the slope changes sharply. The result still works for fine, low-contrast detail. It starts to look painted-on the moment you ask too much of it.

What a normal map actually is

A normal map is an RGB image. Three channels. But the colours aren't colours — they're direction vectors. Red is the X component, green is Y, blue is Z. Each value runs from -1 to 1, but image files only store 0 to 1, so the shader doubles it and subtracts one. The renderer reads the direction off the map and lights as if the surface really pointed that way at that pixel.

That's the whole leap. The renderer doesn't have to guess direction from brightness any more — it gets the direction directly. Three numbers instead of one. Hence the "tangent space normal map" you'll see in every PBR pipeline since about 2014, when the great handover from old shaders to PBR took place and everything started looking less like plastic.

Tangent-space normal map texture for the same wood plank — predominantly light purple with subtle red and green shifts along the grain — A tangent-space normal map of the same plank. The purple wash is "point straight out". The colour shifts are the grain.

For the deep dive on what those colours mean and why most of the map is purple, see my guide on what a normal map is. For this post, the one thing to take away: normal maps store directions, bump maps store heights. Three numbers vs one.

One number vs three: the difference in practice

Here's what the extra two channels actually buy you. A bump map can only describe how much higher or lower a pixel is than its neighbours. The renderer has to infer the direction by looking at the slope. That works fine for gentle, low-contrast detail.

A normal map skips the inference. It just tells the renderer exactly which way the surface points. So you get:

Sharper lighting on hard edges. A bump map can't represent a vertical face cleanly because there's no "straight up" in a height field. A normal map can.
Correct response at grazing angles. Bump maps flatten out when the camera is nearly parallel to the surface. Normal maps hold up.
Direction without ambiguity. Two pixels of the same brightness in a bump map look the same to the renderer. In a normal map they can point completely different ways.

3D render comparison of the same brick wall lit identically with a bump map versus a normal map — the bump version looks soft and painted on, the normal version has crisp shadows in the brick grooves — Same wall, same light. Bump version (left) goes soft on the brick edges. Normal version (right) keeps the shadow lines crisp.

The thing neither one fixes: the silhouette. Both are lighting lies. Look down the length of a brick wall and the bricks flatten back into the flat polygon they always were. For that you need displacement or real geometry. Pick the cheap option whenever the cheap option works. (My wife says I overuse that line. She is wrong but I love her anyway.)

OpenGL vs DirectX: the channel flip everybody hits

Quick warning before you ship anything. Two of the major rendering conventions disagree on which way the Y axis points in a normal map. This is the bug that's eaten more of my career than I'd like to admit.

OpenGL convention — green channel up means the bump points up. Blender, Substance Painter, glTF, and Three.js default to this.
DirectX convention — green channel up means the bump points down. Unreal Engine and many older Unity setups expect this.

Plug an OpenGL-baked normal map into Unreal without flipping the green channel and every bump becomes a dent. The seam down a barrel suddenly looks lit from the inside — which is technically a feature if you were planning on being a lighthouse. Bump maps don't have this problem (they're just height; up is up). It's a normal-map exclusive.

Same brick wall normal map rendered under OpenGL convention with raised bricks and under DirectX convention with dented bricks — illustrating the green channel flip — Identical normal map, two conventions. Left: bricks raised correctly (OpenGL). Right: same map read as DirectX — bricks dented inward.

The fix is one tickbox. Either flip the green channel on export (Substance Painter has a preset for it, Photoshop is a single channel invert), or tell the engine to flip on import. Unity 6 has a checkbox. Unreal has a node. CraftPBR's normal map generator lets you pick OpenGL or DirectX up front so you never see the bug.

When to use a bump map

Bump maps are not dead. They're just a specialist tool now. Reach for one when:

You're prototyping. A greyscale doodle in Photoshop becomes a stand-in surface in 30 seconds. Replace it later.
You've already got a height map. No need to convert if the renderer can sample greyscale directly. Some engines (Unity, Unreal) will turn it into a normal under the hood anyway.
You want very fine grain on top of a normal map. Skin pores, hairline scratches, brushed-metal striations. Greyscale is easier to paint and edit than RGB.
You're on extremely tight memory. Old mobile, low-spec WebGL, Switch ports of indie titles. One channel beats three when every megabyte counts.

Outside those four cases, a normal map is the right tool.

When to use a normal map

Nearly always, in 2026. Specifically:

Anything PBR. The PBR pipeline expects a normal map. Unity HDRP, Unreal's Lumen, Blender's Principled BSDF, Godot's StandardMaterial3D, Three.js MeshStandardMaterial — all want one.
Anything you'll see at a glancing angle. Walls, floors, terrain, anything the camera skims along.
Anything with hard creases or panel lines. Mechanical surfaces, sci-fi hulls, brick mortar. Normal maps handle hard direction changes; bump maps soften them.
Anywhere you care about realistic specular response. Roughness and metalness only matter if the surface normal is right. Without a normal map, your roughness map is doing half its job.

Can you use both at once?

Yes. This is the dirty little secret that the "normal map vs bump map" framing hides — in a real production material you'll often use both, stacked.

The normal map carries the main surface direction. The bump map sits on top for very fine micro-detail. Pores on a leather couch. Hairline brushwork on a metal sheet. Tiny grain on a wood plank that's too small to bake into the normal cleanly.

In Blender, plug the normal map into a Normal Map node, feed that into the Normal input of a Bump node, and feed the bump greyscale into the Bump node's Height input. In Unreal, there's a BlendAngleCorrectedNormals material function that combines two normal maps cleanly — convert the bump to a normal first and blend. In Unity Shader Graph, Normal Blend handles it.

Rule of thumb: normal map for the structure, bump map for the texture. Bump is the micro-grain, normal is the macro shape. Like a fine sandpaper finish on a hand-carved piece of furniture.

Performance and file size: honest numbers

People will tell you bump maps are "faster". On a 2014 phone, maybe. On modern hardware the difference is rounding error. Here's what I actually see on the rig:

2048×2048 uncompressed. Bump map: ~4 MB. Normal map: ~12 MB. Three times the memory, because three times the channels.
GPU-compressed. BC4 for the bump (single-channel format): ~2 MB. BC5 for the normal (two-channel, third reconstructed): ~4 MB. Gap closes to 2x.
Sample cost. Both are one texture lookup per pixel. The shader maths is a couple of extra MADs for the normal map. Sub-microsecond.
VRAM budget on a hero asset. For a typical PBR material set (albedo + normal + roughness + AO + metalness) at 2K, you're looking at around 30 MB after compression. A normal-vs-bump swap moves ~2 MB. Not the bottleneck.

Honest take: pick the map type for the look, not the budget. The only place memory still tips the scale is mobile, Switch, or web. Even then, channel-packing your roughness, AO, and metalness into a single RGB texture saves more than swapping normal for bump.

Generate a normal map in 30 seconds

Describe any surface. CraftPBR returns the full PBR set — albedo, normal, roughness, AO, metalness — with the right Y-axis convention for your engine. Free up to ten a day.

Try It Free

Converting one to the other

Two flows, both common.

Bump to normal is the easy direction. Any height-to-normal node works: Substance Designer's built-in node, Photoshop's 3D > Generate Normal Map command, Blender's Bump node (effectively converts live in the shader), or browser tools like NormalMap Online. The algorithm reads brightness slope and approximates direction. Works well on rough, matte surfaces; less well on anything shiny or with baked-in highlights.

Normal to bump is rarely worth it. You're throwing away two of three channels. The only time I've done it: stripping a normal map back to greyscale to feed into an older non-PBR shader on a legacy mobile port. Not a 2026 problem.

A note on AI tools: the better ones generate the whole PBR set in one go — albedo, normal, roughness, AO, metalness — designed together, so the normal map agrees with the albedo about where the bumps are. That's the bit photo-to-normal tools usually get wrong. The model does the heavy lifting; I do the cleanup.

Straight answers

The questions I get asked at the pub, with one-paragraph answers.

What is the difference between a normal map and a bump map?

One number vs three. A bump map stores a single height value per pixel in greyscale; a normal map stores a full RGB direction vector. Normal maps carry three times the information and look correct at every camera angle. Bump maps are simpler and cheaper but flatten out at grazing angles.

Is a normal map better than a bump map?

For PBR work, yes. Normal maps are the default in every modern engine and they hold up under every lighting condition. Bump maps are still useful as quick stand-ins, for micro-grain layered on top of a normal, and on extremely tight memory budgets. Outside those, reach for the normal map.

Can you use a bump map and a normal map at the same time?

Yes — the normal map carries the main surface direction and the bump map sits on top for fine grain. Blender's Bump node has a Normal input for exactly this. Unreal has BlendAngleCorrectedNormals. Unity Shader Graph has Normal Blend. Use both when the surface has detail at two scales.

Do bump maps work in Unity, Unreal, and Blender?

All three accept a greyscale bump or height map, but internally they convert it to a normal at shader time. The renderer always does the lighting maths on a normal. So "using a bump map" in a modern engine is really "letting the engine make a normal map from your bump map."

What is a tangent space normal map?

A normal map whose directions are stored relative to the surface, not the world. The renderer transforms each pixel's vector using the surface's tangent and bitangent at runtime. That's why one map works on any model and why most normal maps look mostly purple — (0.5, 0.5, 1.0) means "point straight out".

Does a normal map use more memory than a bump map?

About three times as much uncompressed (12 MB vs 4 MB at 2K), narrowing to roughly two times after GPU compression. On a modern card, not a bottleneck unless you're on mobile or Switch.

Can I convert a bump map to a normal map?

Yes. Substance Designer's height-to-normal node, Photoshop's Generate Normal Map command, Blender's Bump node, NormalMap Online — they all read the greyscale and approximate direction. Good for rough matte surfaces; weak on shiny ones.

When should I use a bump map instead of a normal map?

Prototyping, layering fine grain on top of a normal, working off an existing height map, or shipping to a memory-starved platform. Outside those cases, the normal map wins.

If you want the deeper story on how normal maps work, why they're purple, and how to bake one, my guide to normal maps goes channel by channel. For where these maps fit into a full material, the PBR overview covers all five maps that travel together. And if you just want to generate a normal map without sculpting anything, the normal map generator turns a photo or a prompt into one in a few seconds.