Config Warden

An Unreal project's settings are not a file. They are a race.

Unreal applies config in layers, in a fixed order, and the value you get is whatever the last layer to mention a key said. After a couple of years your DefaultEngine.ini is full of lines that lost that race: an override a platform file overrides again, a value restated identically two lines apart, a setting someone added during a bug hunt in 2024. None of them do anything. All of them look load-bearing, which is exactly why nobody deletes them, and why every settings question on the team turns into ten minutes of grepping .ini files.

It reads the layers in the engine's own order and tells you who won

Config Warden walks Unreal's own GConfigLayers table rather than an order transcribed from documentation, so the apply order is the engine's data, not an assumption. Every plain assignment gets one of four verdicts:

• Live — this line wins for its section and key.
• Shadowed — a later layer assigns the same key. This line can never win. Dead.
• Redundant — this line restates the value already resolved. Removing it changes nothing. Dead.
• Unjudgeable — the key is touched somewhere by an array operator (+ - . !), so last-one-wins does not apply and no honest verdict is available. Reported, never removed.

Every dead line carries the file and line number of the winner, so you can check the verdict by hand in thirty seconds.

Then it deletes them, and proves the deletion changed nothing

This is the part that makes an automatic config cleaner safe to run on a studio project. The failure mode of a careless one is silent and delayed: it removes one line too many, nothing errors, and three weeks later a packaged build has the wrong shadow quality with no stack trace pointing back at the cleanup.

So Config Warden does not assert its edit was safe. It measures it:

1. Resolve every setting in the hierarchy and record what each one resolves to.
2. Delete only the dead lines, preserving every surviving byte including the original line endings, so a three-line change stays a three-line diff in source control.
3. Re-read every layer file from disk, as a fresh process would.
4. Re-resolve the whole hierarchy and compare every value against the pre-edit resolve.
5. If one value moved, restore every touched file to its original bytes and exit with a distinct failure code.

A successful apply reports the number it compared: Pruned 3 line(s) and verified 1174 resolved value(s) unchanged. A rollback names the exact key that moved. Both are real output from this build's verification runs.

Rules as data, and a build gate that means something

Point it at a JSON rule set and it enforces required, forbidden and expected settings with per-rule severity, then returns a CI exit code. Rules are data, so a technical artist adds one without a C++ build, and the file diffs in a pull request next to the settings it governs.

• 0 — clean.
• 1 — rule failures at or above your -FailOn threshold, or a rule set that would not parse.
• 2 — the scan examined nothing. Deliberately a failure, not a pass, because a gate that inspects zero settings and reports success is worse than no gate at all.
• 3 — a prune was attempted and did not verify. Everything was rolled back.

Three reports are written side by side: JSON for your dashboards, JUnit XML that your build server renders natively with one test per rule, and a self-contained HTML report with no external CSS, JS or fonts, so it survives being emailed or dropped into an artifact store.

Measured, not estimated

On the fixture project, one run read 3 layer files, examined 1,179 plain assignments and resolved 1,174 keys, in well under a second of commandlet time. On a stock UE 5.8 install it finds genuine dead lines in Epic's own BaseEngine.ini (RPCBlockAllowlist is assigned three times in the same section at lines 1930 to 1932, and only the last can ever win). Those are reported and never edited. Config Warden only ever writes to files under your project directory.

What ships

• Walks Unreal's own GConfigLayers hierarchy and reports what every setting resolves to and which layer won.
• Classifies every plain assignment as Live, Shadowed, Redundant or Unjudgeable, with the winning file and line number as evidence.
• Deletes dead lines from project config, then re-reads and re-resolves from disk and rolls back byte-for-byte if any resolved value moved.
• Preserves original line endings and every surviving byte, so the diff stays reviewable.
• -PruneRedundantOnly for teams that keep shadowed lines as a record of intent.
• Dry run by default. Nothing is written unless you pass -Apply.
• Rule sets as JSON data: required, forbidden and expected, with info / warning / error severity and a rationale printed on failure.
• A malformed rule set is refused with the index of the offending rule, never silently skipped.
• Four distinct CI exit codes, including a dedicated code for "the scan examined nothing".
• JSON, JUnit XML and self-contained HTML reports.
• Skipped layers are listed by name in every report rather than silently dropped.
• Headless commandlet. No editor UI is loaded, so it runs on a build machine.
• Editor-only module. Nothing is compiled into your packaged game.
• Full C++ source included, raw and readable.

What this is not — read this before you buy

Unreal already ships a config hierarchy viewer, and this listing does not pretend otherwise. FPropertyEditor::EditConfigHierarchy opens a first-party Config Editor tab showing the per-layer values for one property you right-click in the Details panel. If your question is "where is this one setting coming from", the engine answers it already. What Epic does not ship, and what this is: a project-wide audit of every key at once, dead-line detection with evidence, a pruner that removes them and verifies the removal, a platform-aware layer diff, and a headless CI mode with exit codes.

Only plain Key=Value assignments are judged. Any key touched anywhere in the chain by an array operator (+ - . !) is reported Unjudgeable and is never removed, under any switch. Those operators accumulate rather than override, so last-one-wins is false for them and no honest verdict exists.

Engine config is never edited. Dead lines in BaseEngine.ini are reported for information only. Only files under your project directory are ever modified.

Three layer categories are not modelled, because they are machine-local or require inventing a value: user settings, app settings and custom-config layers. They are listed by name in every report rather than silently dropped, so you always know what was not read.

There is no editor panel. Config Warden is a commandlet. Everything it does has to be reachable headlessly, which is what makes the CI mode possible, but if you want a UI this is not that product.

Unreal Engine 5.8 only. That is the only engine this build was compiled and run against, and the .uplugin declares it, which the engine enforces. It will not load on an older version.

Technical details

• Type — editor-only C++ plugin, one module.
• Interface — commandlet: UnrealEditor-Cmd.exe <Project>.uproject -run=ConfigWarden
• Switches — -ConfigType= -Platform= -Rules= -Out= -Apply -PruneRedundantOnly -FailOn=
• Platforms — the module declares Win64, Mac and Linux, but only Win64 has a verified build. That is the only platform this release was compiled and gate-tested on, so it is the only one claimed.
• Engine — Unreal Engine 5.8.
• Dependencies — none beyond the engine. No third-party libraries bundled.
• Source — full C++ source included, unminified.
• Network access — none.
• Runtime cost — none. Nothing is compiled into a packaged game.

AI disclosure

The source code in this plugin was written with AI assistance, and the store images for it were AI-generated. The measurements quoted in this listing come from real runs of the shipping build on Unreal Engine 5.8.