Parameter Identity Repair — Unreal 5 Material Parameter GUID Collisions, Found and Fixed

Drag Roughness Scale in a material instance and watch Metallic Scale move with it. That is not a UI bug. Those two parameters are sharing one hidden identity, and the engine cannot tell them apart.

Every material parameter carries an ExpressionGUID. You never see it, and material instances bind their overrides to it rather than to the parameter's name. Duplicate a material function and the copy keeps the original's GUIDs. That is the ordinary way anyone builds a family of materials, and it is the ordinary way this defect enters a project.

It is not an oversight either. UMaterialExpression::PostDuplicate says so in the engine source: "We do not force a guid regen here because this function is used when the Material Editor makes a copy of a material to edit. If we forced a GUID regen, it would cause all of the guids for a material to change everytime a material was edited."

Epic made a reasonable trade. Nothing in the editor cleans up after it. Across the whole engine the only places that mint a fresh parameter identity are node creation and paste: there is no command, no menu item and no scripting function that repairs a collision once it exists.

What goes wrong, in the order you notice it

• An instance override silently stops doing anything.
• Renaming a parameter moves a different parameter's overrides.
• Two sliders in the instance editor move as one.
• None of it is logged, warned about, or flagged by any validator.

What this plugin does

One command audits every Material and Material Function under the paths you name, reads the identity of every parameter expression, and grades each shared identity by what it is doing to you right now:

• Critical — different names, and at least one material reaches both. One is shadowing the other today, and overrides written against the shadowed one are going nowhere.
• Serious — different names, not yet used together. Breaks the day you combine them, and renames already migrate wrongly.
• Latent — same name everywhere. Harmless until somebody renames one.

Then it repairs, and the repair is built to be boring:

1. It keeps the identity on whichever parameter carries the most instance overrides, so the fewest overrides have to move at all.
2. It re-mints the others through the engine's own UpdateParameterGuid, which derives the new GUID from the expression's path, so your packages stay cook-deterministic. A randomly generated GUID would look identical in the editor and quietly break that.
3. It verifies every re-mint actually changed, and that the new identity is not already in use somewhere else. Either failure rolls the whole group back.
4. It re-binds instance overrides by name.
5. It writes a full undo journal to disk before the first package is saved.

The rule it will not break

It never guesses a binding. An override whose name matches no holder, or matches two, is reported and left exactly as it was, because a wrong re-bind is the same corruption this tool exists to cure arriving by a different route. A scan that examines zero parameters is reported as a failed scan, not as a clean project.

And it never reads or writes an override's value. The only field the repair assigns to is the GUID, which is why your authored values survive by construction rather than by a comparison that could itself be wrong.

The undo is tested, not just written

A journal you have never replayed is a promise, so this one is replayed on every build. The test project holds 113 parameter expressions across 113 material functions, 7 materials and 24 material instances, carrying 40 real identity collisions (12 Critical, 16 Serious, 12 Latent) produced the way you produce them: by duplicating a material function.

The check is a round trip, not an exit code. Audit it, repair it, revert it, then audit again and compare the two reports line by line: every GUID, asset path, grade, holder and override row comes back identical. 40 groups and 60 bound overrides, restored exactly.

That test is also how a reporting bug in -Revert was found and fixed before release: a fully successful undo was exiting 4 and naming six rows as missing when they were already correct. If you gate CI on exit codes, that one would have cost you an afternoon.

Nothing is written without -Apply

The default run is a preview that produces a designed HTML sheet and touches nothing. -Limit lets you repair ten groups and look at the diff before doing the rest. -Revert replays the journal.

Running it in CI

UnrealEditor-Cmd.exe YourProject.uproject -run=ParameterIdentityRepair -Paths=/Game

Exit 3 means collisions at or above your threshold. Exit 2 means nothing was scanned — a failure, not a pass, because an empty result is the one answer an audit tool must never report as good news.

Honest about speed

ExpressionGUID is not an Asset Registry tag in UE 5.8, so the identities cannot be read without opening the packages. The registry finds the candidates for free; the parameters themselves need a load. On a large project the audit takes minutes. Every report prints how many assets were offered against how many were actually opened, so you can see what the numbers rest on.

Compatibility

• Unreal Engine 5.8, Windows. That is the only configuration claimed, because it is the only one it was built and run on. Every image on this page came out of a real run on it.
• Editor-only plugin, C++, no runtime cost and nothing added to a packaged build.
• Works from the editor console or headless as a commandlet. -nullrhi is safe: it reads editor-only asset data and renders nothing.
• Full source included, raw and readable, plus the automation tests.

Known limit in 1.0.0: static switch and static component mask overrides are reported but not re-bound. In UE 5.8 those sit behind a different update path, and this plugin does not write through a path it has not proven.

Documentation

The full manual is public and readable before you buy: Parameter Identity Repair documentation.

More Unreal tools from CSAF

• Material Sprawl Collapser — finds materials that differ only by parameter values and collapses them into instances.
• Blueprint Default Surgeon — the Blueprint-side version of the same class of problem.
• Niagara Bounds Solver — simulates every Niagara system and writes the bounds it measures.

Core Systems Asset Factory. AI disclosure: code and graphics are AI-generated, and the plugin is shipped as readable source so you can check every line of it.