Materials & Lighting · Beginner · 12 min
Material Instances: The Fast Way to Make Variations
Turn one material into a knob-board with parameters, then spin up dozens of colour and roughness variations as Material Instances that update live — no recompiling, no duplicate materials clogging your project.
Before this: What Is a Material? Make Your First One in UE5, PBR Basics: Base Color, Metallic, Roughness and Normal Explained
- Explain why Material Instances beat duplicating a material
- Convert constants in a material into named parameters
- Create a Material Instance and tweak its parameters live
- Spin up several variations from a single parent material
One material, a hundred looks
Say you've made a nice painted-metal material and now you want it in red, blue, green, and a scuffed-up rusty version. The tempting move is to duplicate the material five times and change the colour in each copy. Don't — that way lies a Content Browser full of near-identical materials and a project that recompiles shaders every time you nudge one.
There's a far better tool built for exactly this: the Material Instance. You take your original material, expose the few things you actually want to change — colour, roughness, a tiling number — as 'parameters' (think of them as labelled knobs). Then you create lightweight Instances that just dial those knobs to new values. One parent, endless children, and changes apply instantly with no recompile.
This is how real UE5 projects are built. Artists almost never edit a material's node graph day to day — they tweak Material Instances. By the end of this lesson you'll do the same.
Four terms to lock in first
Tap a card to flip it
Why an Instance beats a duplicate
When you edit a normal material, Unreal has to recompile its shader — the GPU program behind it. On a complex material that pause adds up fast, and every duplicate you make is another full shader to compile, store, and keep in memory.
A Material Instance shares its parent's compiled shader. Changing an Instance's colour or roughness is just swapping a number the shader already reads, so it updates the moment you let go of the slider. Make fifty Instances and you still only have one compiled shader behind them all. That's the whole trick: cheap variations, instant feedback, a tidy project.
Parameterise a material, then instance it
We'll start from a simple material that has at least a Base Color and a Roughness value (the one you built in the earlier materials lessons is perfect). Work top to bottom and tick each step.
- 1Open your material
In the Content Browser, double-click your material to open the Material Editor. You'll see the node graph in the middle and the big result node on the right with pins like Base Color, Metallic and Roughness.
TipIf you don't have a material yet, right-click in the Content Browser and choose Material, name it, and give it a Constant3Vector wired into Base Color so there's something to parameterise.
- 2Find a constant you'd like to vary
Look at what feeds Base Color. If it's a flat colour, that's a Constant3Vector node (a colour swatch). A single number like Roughness is a Constant (scalar) node. These fixed values are what we'll turn into knobs.
TipPick the things you'll genuinely want to change between variations — usually colour and roughness. You don't have to expose everything.
- 3Convert a constant to a parameter
Right-click the colour node and choose 'Convert to Parameter'. The node becomes a Parameter node with a name field.
Give it a clear name like 'BaseColor'. That name is the label you'll see on every Instance, so make it readable.
TipDo the same for your Roughness value: right-click it, Convert to Parameter, name it 'Roughness'. A scalar parameter shows up as a slider on Instances.
- 4Save the parent material
Click Save in the Material Editor toolbar. This recompiles the shader one last time — now with parameters baked in. Close the Material Editor.
This is the last recompile you'll trigger for these variations; everything from here is instant.
TipThe preview viewport in the Material Editor (a sphere by default) shows the current look, so you can confirm it before you save.
- 5Create a Material Instance
Back in the Content Browser, right-click your material and choose 'Create Material Instance'. A new asset appears, usually named after the parent with '_Inst' on the end.
Rename it to something meaningful for this variation, like 'M_PaintedMetal_Red_Inst'.
TipMaterial Instances use an 'MI_' or '_Inst' naming habit so you can tell parents from children at a glance in a busy project.
- 6Open the Instance and tick a parameter on
Double-click the Instance. The Material Instance Editor opens — no node graph, just a list of parameters from the parent, each with a checkbox.
Tick the checkbox next to 'BaseColor' to enable an override, then click the colour swatch and pick red. Tick 'Roughness' and drag its slider. The preview updates live as you drag.
TipOnly the parameters you tick are overridden; unticked ones quietly inherit from the parent, so you only manage what actually differs.
- 7Apply it and make more
Drag the Instance onto a mesh in your level (or assign it in the mesh's Details panel) to see it in context. Save the Instance.
Now repeat the 'Create Material Instance' step for blue, green and a rusty version — each is a few clicks and zero recompiles.
TipNeed ten quick colour swatches? Make one Instance, then duplicate it (right-click the asset and choose Duplicate, or press Ctrl+D) and just change the colour on each copy.
You change the Base Color on a Material Instance and there's no 'Compiling Shaders' pause — but editing the parent material does pause. Why the difference?
Editing the parent changes the shader's actual logic (its node graph), so Unreal must recompile the GPU program. That's the pause.
An Instance never touches the graph — it only feeds new values into parameters the compiled shader already reads. There's nothing to recompile, so the change is instant. This is exactly why you make variations as Instances, not as edited duplicates.
Material Instance vs. duplicating the material
One parent material, many lightweight children. Each child overrides only the parameters you tick.
All children share one compiled shader, so changes are instant and memory stays low.
Fix a bug or improve the parent once and every Instance inherits the fix automatically.
Every duplicate is a full, separate material with its own compiled shader to build and store.
Editing one means recompiling; ten variations is ten recompiles and ten shaders in memory.
Fix a bug and you have to fix it in every copy by hand — the classic 'I forgot one' source of inconsistency.
From your parameterised material, build a small 'paint set': four Material Instances in four different colours, two of them with noticeably different roughness (one glossy, one matte). Assign each to a separate mesh in your level so you can compare them side by side.
Hint 1
Make the first Instance with 'Create Material Instance', set its colour and roughness, then duplicate it (right-click the asset and choose Duplicate, or press Ctrl+D) three times.
Hint 2
On each duplicate, only the ticked parameters change — leave everything else inheriting from the parent.
Hint 3
Glossy means a low Roughness value (near 0); matte means a high one (near 1).
Right-click the parent → Create Material Instance → tick BaseColor (red), tick Roughness (drag low for glossy). Save. Duplicate it three times (right-click → Duplicate, or Ctrl+D). On each copy, change BaseColor to blue / green / grey and, on two of them, push Roughness high for a matte finish.
Drag each Instance onto a different mesh. You now have four variations sharing one shader, each editable in real time — and not a single recompile after the first save of the parent.
QuizCheck yourself
1What is the main advantage of a Material Instance over duplicating a material?
Instances share the parent's compiled shader and only swap parameter values, so variations are instant and the project stays tidy.
2Before you can change a material's colour from a Material Instance, what must you do in the parent material?
Only parameters are exposed to Instances. Right-click the constant and 'Convert to Parameter' so it shows up as an editable knob.
3In the Material Instance editor, what does the checkbox next to each parameter do?
Tick to override, leave unticked to inherit. You only manage the values that actually differ from the parent.
Handy shortcuts for this workflow
- Ctrl S Save the asset you're editing (parent material or Instance)
- Ctrl D Duplicate the selected Content Browser asset — fast way to spin off another Instance
- Right-click node In the Material Editor: 'Convert to Parameter' to expose a constant
- Right-click asset In the Content Browser: 'Create Material Instance' from the selected material
Mark this lesson complete
We'll remember it on your Academy page and unlock the next lesson below.
Questions beginners ask
Can a Material Instance have its own Material Instance (a child of a child)?
Yes. You can right-click an existing Instance and create a Material Instance from it, forming a chain. Each level overrides parameters and inherits the rest. It's handy for a 'master → family → specific variant' structure, though for most beginner work one level of Instances is plenty.
I converted a constant to a parameter but it doesn't appear on the Instance. What went wrong?
Make sure you saved the parent material after converting (that bakes the parameter in), and that the node is actually connected into the graph that reaches the result node. A parameter that isn't wired into anything used by the material may not be shown. Save the parent, then reopen the Instance.
Do Material Instances cost more performance than the original material?
No meaningful extra cost. They share the parent's compiled shader, so you're not adding new shaders — that's a big part of why they're recommended. Keeping variations as Instances is generally better for memory and load times than many duplicated materials.
What's the difference between a Material Instance Constant and a Dynamic one?
The asset you create in the Content Browser is a Material Instance Constant — its values are set in the editor and fixed at runtime. A Dynamic Material Instance is created in Blueprints or C++ at runtime so a parameter can change while the game runs (for example, a health bar shifting colour). This lesson covers the Constant kind; the dynamic version is a later topic.