Most tutorials about procedural textures in Blender end with a download link. This one does not. By the end of this article you will have built three complete shader node trees yourself: weathered rust, grained wood and cast concrete. Every node, every value and every connection is listed, so you can rebuild them from memory next week and bend them into anything else you need.
Everything here was tested in Blender 4.5 LTS and the 5.x series, using Cycles for the renders and EEVEE Next for the viewport checks. All three setups work in both engines.
What Procedural Textures Actually Are (30 Second Version)
A procedural texture is a mathematical pattern generated at render time instead of a pixel image loaded from disk. Blender evaluates a function at every shading point and returns a value. Because there is no image file involved, procedural materials are:
- Resolution independent: zoom in forever, no blur, no pixels.
- Seamless by nature: no UV seams, no tiling repetition.
- Infinitely tweakable: one slider changes rust coverage across a whole scene.
- Light on disk: a 40 node material weighs a few kilobytes.
The trade-off: they cost shader evaluation time, and some patterns (printed labels, photographic grime) are simply not worth faking with math. That is why the professional workflow is procedural base + baked result, covered at the end of this post.
The Three Nodes That Do 90% of the Work
| Node | What it generates | Use it for |
| Noise Texture | Smooth fractal clouds (Perlin based) | Dirt coverage, colour variation, bump break-up, coordinate distortion |
| Voronoi Texture | Cellular patterns from scattered points | Pits, pebbles, aggregate, cracks (Distance to Edge), scales |
| Wave Texture | Bands and rings, distortable | Wood grain, brushed metal, layered rock |
| Color Ramp | Remaps any value into a gradient or a hard mask | Turning soft noise into a crisp wear mask |
| Bump / Map Range / Mix | Plumbing | Driving roughness, surface relief and colour blends from one mask |
Important: Where Did the Musgrave Node Go?
If you are following an older tutorial that calls for a Musgrave Texture, stop looking for it in the Add menu. Musgrave was removed in Blender 4.1 and its functionality was folded directly into the Noise Texture node. Old files still open correctly: Blender converts the node automatically.
Here is how to reproduce the classic Musgrave looks with the modern Noise Texture:
| Old Musgrave type | Modern equivalent |
| fBM | Noise Texture with Normalize unchecked, tune Detail, Roughness and Lacunarity |
| Ridged Multifractal | Noise Texture (Normalize off) into a Math node set to Absolute, then a Math node set to Subtract from 1 |
| Hetero Terrain | Noise Texture multiplied by a second, larger scale Noise Texture used as a height mask |
| Hybrid Multifractal | Two Noise Textures mixed with a Color Ramp controlling the blend |
In the setups below, wherever a wear pattern needs that gritty, non-uniform Musgrave feel, we use Noise Texture with Normalize disabled. That single checkbox is the thing most people miss.

Before You Start: The Base Setup Used by All Three Materials
Every material in this article starts the same way. Build this once, then save it as a node group or an asset so you never type it again.
- Add a Cube or a UV Sphere, give it a new material, and open the Shader Editor (Shift + F3).
- Add a Texture Coordinate node (Add > Input > Texture Coordinate).
- Add a Mapping node (Add > Vector > Mapping).
- Connect Object output into the Mapping Vector input. Use Object, not Generated: Object coordinates stay consistent across different mesh sizes and give you a real world scale to think in.
- Plug the Mapping output into every texture node you add from now on.
Pro habit: press Ctrl + Shift + Click on any node to preview it directly in the viewport through a temporary Viewer. This is the single fastest way to learn what a node actually outputs. The piece Master Procedural Texturing makes a good next read.
Also install the Node Wrangler add-on (Edit > Preferences > Add-ons) if it is not already enabled. Ctrl + T on a texture node instantly adds Texture Coordinate and Mapping for you.

Setup 1: Procedural Rust on Painted Metal
Real rust does not appear as a uniform orange coat. It appears where water sits, it eats through paint in patches, it pits the metal underneath, and it bleeds downwards in streaks. Our node tree fakes all four behaviours with two masks.
The Logic in Plain English
- A large Noise decides where rust lives (the macro patch mask).
- A Voronoi adds the crusty pitted texture inside those patches.
- A vertically squashed Noise creates drip streaks below the patches.
- The combined mask drives Base Color, Metallic, Roughness and Bump at the same time. This is the key principle: one mask, four outputs.
Step by Step
- Start from the base setup. On the Mapping node, leave Scale at 1 / 1 / 1 for now.
- Add Noise Texture (call it Rust Macro). Scale 3.5, Detail 8, Roughness 0.55, Distortion 0.4.
- Add a Color Ramp after it. Drag the black stop to 0.42 and the white stop to 0.58. This hardens the cloud into readable rust patches. Slide both stops together left or right to control total rust coverage: this is your main art director slider.
- Add a second Mapping node fed by Texture Coordinate > Object, with Scale 1 / 1 / 0.08. Feed it into a new Noise Texture (Drips), Scale 12, Detail 6, Roughness 0.7. The squashed Z axis stretches the noise into vertical runs.
- Add a Color Ramp on the drips, stops at 0.50 and 0.62.
- Add a Mix Color node set to Lighten, Factor 0.35. Plug the macro ramp into A and the drip ramp into B. You now have one rust mask with streaks. Call this output MASK.
- Add a Voronoi Texture (Crust): Feature F1, Distance Euclidean, Scale 60, Randomness 1.0. Follow it with a Color Ramp set to Ease interpolation, stops at 0.0 and 0.45.
- Base Color: add a Mix Color node. A = paint colour, a desaturated blue grey (Hex 3A4A52). B = rust, a dark burnt orange (Hex 6B3415). Factor = MASK. Then add one more Mix Color set to Multiply, Factor 0.4, using the Voronoi crust ramp to darken the rust pits.
- Metallic: add a Math node set to Subtract, 1.0 minus MASK, into the Metallic input. Clean paint over steel reads as metallic 1, rust reads as 0, because iron oxide is a dielectric.
- Roughness: add a Map Range node. From Min 0, From Max 1, To Min 0.28, To Max 0.88. Input = MASK. Paint stays glossy, rust goes chalky.
- Bump: add a Mix Color set to Add: MASK at 0.6 plus the Voronoi crust ramp at 0.4. Feed that into a Bump node, Strength 0.35, Distance 0.02. Bump output into the Principled Normal input.
Rust Node Values at a Glance
| Node | Settings | Drives |
| Noise (Rust Macro) | Scale 3.5, Detail 8, Roughness 0.55, Distortion 0.4 | Rust patch placement |
| Noise (Drips) | Mapping Scale Z 0.08, Noise Scale 12, Detail 6 | Vertical bleed streaks |
| Voronoi (Crust) | F1, Scale 60, Randomness 1.0 | Pitting and bump detail |
| Map Range | To Min 0.28, To Max 0.88 | Roughness split |
| Math (Subtract) | 1.0 minus mask | Metallic split |
Make It Yours
- For fresh surface rust, raise the Color Ramp stops to 0.60 / 0.70 and lower Bump strength to 0.15.
- For abandoned industrial, push the macro ramp stops to 0.25 / 0.40 and raise Voronoi scale to 110.
- Add a Geometry > Pointiness node into a Color Ramp and Mix it into MASK with Lighten to force rust onto exposed edges.
Setup 2: Procedural Wood With Grain, Rings and Pores
Wood is the classic test of a procedural artist. The trick is that the rings are not a clean Wave Texture. They are a Wave Texture whose coordinates have been distorted by noise, which is exactly what happens in a real trunk as it grows around knots. 3dart.it has a solid rundown on this.
The Logic in Plain English
- Stretch the coordinate space along the plank length.
- Distort those coordinates with a low frequency Noise so rings wobble.
- Run a Wave Texture through them to produce the rings.
- Layer a very stretched high frequency Noise on top for fibre.
- Add a stretched Voronoi for open pores (oak, ash) or skip it for a closed grain look (maple, beech).
Step by Step
- Base setup. Set the Mapping Scale to 1 / 1 / 0.25 so the pattern stretches along the Z axis of the plank. (Swap the axis if your plank runs along X.)
- Add a Noise Texture (Ring Warp): Scale 2.0, Detail 4, Roughness 0.5. Plug the Mapping Vector into it.
- Add a Wave Texture: Type Bands, Profile Sine, Direction X, Scale 2.5, Distortion 9, Detail 3, Detail Scale 1.5, Detail Roughness 0.5. Feed the Mapping Vector into its Vector input, and the Ring Warp Fac into a Math node set to Multiply (value 2.5), then into the Wave Distortion input if you want per area variation.
- Add a Color Ramp on the Wave output. Use B-Spline interpolation, black stop at 0.30, white stop at 0.70. Tight stops give hard tropical hardwood, wide stops give soft pine.
- Fibre pass: add a second Mapping node with Scale 35 / 35 / 1, into a new Noise Texture: Scale 8, Detail 10, Roughness 0.65. Follow with a Color Ramp, stops at 0.40 / 0.60.
- Pores pass (optional): use the same stretched Mapping into a Voronoi Texture: F1, Scale 45, Randomness 1.0. Color Ramp with Constant interpolation, single stop moved to 0.12, which isolates only the tiny cell centres as dots.
- Base Color: Mix Color node, A = light sapwood (Hex 9C6B3F), B = dark heartwood (Hex 4A2A14), Factor = the ring Color Ramp. Then a second Mix Color set to Multiply at Factor 0.25 using the fibre ramp, for subtle streaking.
- Roughness: Map Range on the ring ramp, To Min 0.30, To Max 0.48. Dark late growth rings are slightly rougher than light early growth. If you want a varnished look, add a Math Multiply node after it with a value of 0.4.
- Bump: Mix Color set to Add: ring ramp at 0.3 + fibre ramp at 0.5 + pores at 0.2 (chain two Mix nodes). Into a Bump node, Strength 0.2, Distance 0.01, then into Normal.
- Set Principled Specular IOR Level to around 0.4 for raw timber, or leave it at 0.5 and add a Clear Coat value of 0.3 for finished furniture.
Wood Species Cheat Sheet
| Look | Wave Scale | Distortion | Ramp stops | Colours |
| Pine / softwood | 2.0 | 12 | 0.25 / 0.80 | C9A06A to 7A5126 |
| Oak plank | 3.0 | 8 | 0.35 / 0.65 | 9C6B3F to 4A2A14 |
| Walnut | 2.2 | 6 | 0.40 / 0.60 | 5B3A22 to 241208 |
| Weathered barn wood | 3.5 | 14 | 0.20 / 0.85 | 8A8176 to 3E3730 |

Setup 3: Procedural Concrete With Pits, Aggregate and Cracks
Concrete looks boring until you break it into four separate frequencies. If you only use one Noise Texture, it will always read as grey plastic. The fix is layering, and the hero node here is Voronoi set to Distance to Edge, which produces crack lines for free.
The Four Layers
- Macro stains: very large noise, affects colour only.
- Mid surface: medium noise with Normalize off, affects bump and roughness.
- Air bubbles: tight Voronoi isolated into dots, carves small holes.
- Cracks: Voronoi Distance to Edge, distorted by noise so the lines are not geometric.
Step by Step
- Base setup. Mapping Scale 1 / 1 / 1.
- Macro stains: Noise Texture, Scale 1.5, Detail 6, Roughness 0.6. Into a Color Ramp with stops at 0.35 / 0.75 using soft grey values.
- Mid surface: Noise Texture, Scale 18, Detail 14, Roughness 0.65, Lacunarity 2.2, and uncheck Normalize. This is the Musgrave replacement and it gives the uneven, non-blobby grit that normalised noise cannot. Follow with a Map Range node set to Clamp, From Min -0.2, From Max 1.2.
- Air bubbles: Voronoi Texture, F1, Scale 55, Randomness 1.0. Color Ramp with Ease interpolation, black stop at 0.0, white stop at 0.10, then a Math node set to Subtract (1.0 minus value) so the dots become holes.
- Crack warp: Noise Texture, Scale 4, Detail 5, output into a Vector Math node set to Add, mixing with the Mapping Vector. Set the noise influence via a Math Multiply of 0.25 first.
- Cracks: Voronoi Texture fed by that warped vector, Feature Distance to Edge, Scale 5, Randomness 1.0. Color Ramp with Constant interpolation, single stop at 0.035. Lower the stop for hairline cracks, raise it for a broken slab.
- Base Color: Mix Color node, A = light concrete (Hex B6B4AE), B = damp grey (Hex 6E6C66), Factor = macro stain ramp. Then Mix with the crack mask set to Multiply, Factor 0.8, using a near black colour so cracks read dark.
- Roughness: Map Range on the mid surface output, To Min 0.72, To Max 0.95. Concrete is never glossy unless it is polished or wet.
- Bump chaining: this is the part that sells it. Create Bump node A with the crack mask, Strength 0.6, Distance 0.05. Plug its output into the Normal input of Bump node B, which uses the air bubble mask at Strength 0.3. Then plug B into the Normal input of Bump node C, which uses the mid surface noise at Strength 0.25. Bump C goes into the Principled Normal. Chaining bump nodes layers relief at different frequencies instead of averaging it away.
Concrete Variants
| Variant | Change these |
| Polished concrete floor | Roughness Map Range to 0.18 / 0.35, crack ramp stop down to 0.012, remove bubble bump |
| Exposed aggregate | Add Voronoi Smooth F1, Scale 25, Smoothness 0.35, mixed into Base Color at 0.4 |
| Brutalist board formed | Add a Wave Texture, Bands, Scale 8, Distortion 1, into bump at 0.15 |
| Wet pavement | Drop Roughness to 0.1 inside crack mask areas, raise Specular IOR Level to 0.6 |

Five Mistakes That Make Procedural Materials Look Fake
- Only one frequency. Real surfaces have detail at macro, mid and micro scale. If your material has one Noise node, it will look like a video game from 2004.
- Masks that drive only colour. Wear changes roughness and relief too. Always route your mask into at least three inputs.
- Bump strength set too high. Above roughly 0.5 the shading breaks and edges go plastic. Use multiple chained bumps at low strength instead.
- Using Generated coordinates on scaled objects. Texture scale changes with object size. Use Object coordinates, and apply scale with Ctrl + A.
- Forgetting Normalize. Leaving Normalize on in the Noise Texture clamps the output to 0 to 1 and flattens the fractal contrast that used to come from Musgrave.
Performance: When to Bake Your Procedural Textures
Procedural shaders are evaluated per sample. A 45 node concrete material on 200 objects will slow a Cycles render noticeably, and in real time engines like Unreal or Godot it will not export at all. Bake when:
- The same material is reused on many objects.
- You are exporting to a game engine or to glTF.
- You have finished art directing and the sliders will not change again.
Quick Baking Recipe
- UV unwrap the object (Smart UV Project is fine for props).
- Add an Image Texture node, create a new 2K or 4K image, and leave it selected but unconnected.
- Render Properties > Bake > set Bake Type to Diffuse with only the Color contribution enabled, then bake.
- Repeat for Roughness and Normal.
- Save the images, rebuild a simple Principled setup with them, and keep the procedural version in a spare material slot in case you need to re-bake.
A useful middle ground: keep the material procedural but reduce Detail values. Dropping Detail from 16 to 6 on three Noise nodes often cuts shader cost significantly with almost no visible change at normal viewing distance.

Save Your Work as Reusable Assets
Do not rebuild these from scratch every project:
- Select the core nodes and press Ctrl + G to make a node group. Expose Rust Amount, Grain Scale or Crack Width as group inputs.
- Right click the material in the Asset Browser workflow and choose Mark as Asset.
- Point your Asset Library path (Preferences > File Paths) at a dedicated folder so every new project has your shaders one drag away.
Three materials built by hand, with exposed sliders, will serve you better than a 150 material pack you did not author and cannot modify. otoy.com published something useful on the subject.
FAQ: Procedural Textures in Blender
Are procedural textures better than image textures in Blender?
Neither is better in absolute terms. Procedural textures win on resolution, seamlessness, file size and tweakability, which makes them ideal for surfaces like rust, wood, concrete, rock and fabric. Image textures win on photographic realism and render speed, and they are mandatory for specific details like printed logos or scanned skin. Most production materials mix both.
Does the Musgrave node still exist in Blender?
No. The Musgrave Texture node was removed in Blender 4.1 and merged into the Noise Texture node. To get the old behaviour, use a Noise Texture with Normalize disabled and adjust Detail, Roughness and Lacunarity. Files saved with older versions convert automatically when opened.
Do procedural textures need UV unwrapping?
No. Using Object or Generated coordinates from the Texture Coordinate node, procedural materials project onto the mesh without UVs and without seams. You only need UVs if you later want to bake the result into image maps.
Why does my procedural texture look blurry when I zoom in?
Usually because the Detail value is too low, or because the pattern scale is far too large for the camera distance. Raise Detail on the Noise Texture, add a second higher frequency texture layer for micro detail, and check that the object scale has been applied with Ctrl + A.
Do these node setups work in EEVEE as well as Cycles?
Yes. All the nodes used here (Noise, Voronoi, Wave, Color Ramp, Map Range, Mix, Bump) are supported in EEVEE Next and in Cycles. Displacement behaves differently between the two engines, which is why these setups rely on Bump rather than true displacement.
How many nodes is too many for one material?
There is no hard limit, but a good rule is to group anything beyond 25 to 30 nodes and expose only the handful of sliders you actually adjust. If a single material slows your viewport below interactive speed, reduce Detail values first and bake second.
Can I export procedural Blender materials to Unity or Unreal?
Not directly. Procedural nodes are evaluated by Blender’s shading system and have no equivalent in glTF, FBX or USD. Bake them to Base Color, Roughness, Metallic and Normal maps, then rebuild the material in the target engine.
Next Steps
You now have three complete node trees: a four input rust mask, a distorted wave wood grain, and a chained bump concrete. Rebuild each one once without looking at the values, and you will understand procedural textures in Blender better than any downloaded pack could teach you.
Try combining them next: rusted rebar poking through cracked concrete uses the crack mask from Setup 3 as the rust placement mask from Setup 1. That is the real power of working procedurally, every mask you build is reusable in every other material.
