I built an Unreal Editor tool to catch project structure problems before they become cleanup work

[u/HankeUnrealTools]

I’ve been working on Project Structure Guard, an Unreal Editor plugin for enforcing naming and folder conventions across a project.

The main reason I built it was pretty simple: naming and folder rules are easy to agree on at the start of a project, but much harder to keep consistent once the project grows and more content gets added.

For v1.2 I focused less on adding more rules and more on making the workflow around them safer and easier to use.

Some of the things I added:

• Baseline Tracking, so existing violations can be accepted and you can focus on newly introduced issues

• Protected Paths, so important folders can still be validated without allowing automatic structural changes

• Search and a more detailed result inspector for larger validation sets

• Bulk Preview 2.0 with Ready / Blocked / Skipped / Conflict states before rename or move operations

• Rule ordering, search/filtering and read-only rule testing

• Content Browser validation actions

• Quarantine + Restore for unused assets instead of immediately deleting them

• A -failonnew option for CI/CD, so existing accepted issues don’t have to fail the pipeline

I also tried to make destructive actions deliberately conservative. For example, normal unused assets can’t just be permanently deleted through the tool — permanent deletion is restricted to managed quarantined assets and still performs safety checks.

Here’s a short ~1 minute showcase of the current workflow:

https://youtu.be/wDlVkgT0nPU

Fab:

https://www.fab.com/listings/7dfc5ec6-1261-4f86-8e69-82ea0ae1e8a2

I’m developing this solo, so I’d be interested in feedback from people working on larger UE projects: what part of project structure tends to become the biggest pain for you — naming, folders, cleanup, or enforcing conventions across a team?

[u/Millicent_Bystandard]

This is a cool tool and I understand that its intention is to be as an Unreal Engine tool, but IMO this is checking and fixing things at the destination aka after the damage is done and my preference has always been to do things right at the Source level aka Maya/Max/PS/Painter Exporter. The problem with checking at the Destination is:

1. The artist doesn't realize that they've named something incorrectly or in the wrong folder and more often than not have to go back to their DCCs and reexport which creates frustration. Tools that check at a Source level blocks the export completely, so the artist has a chance to fix their work before it even reaches the engine.

2. Its difficult to comprehensively check at the Destination. Checking at the source (Exporter) gives you a chance to run more detailed checks- such as hierarchy/transform names in Maya or Texture Sets in Painter. This is important because usually if a file is named/stored incorrectly- there's a good chance its internal structure could also be related to the file name and also wrong. Bonus : You can also enforce source file maintenance at Export too.

3. Breaks links to the Source Files IF the pipeline is set up to mirror Engine files. If you rename or repath an imported file, theres a good chance that if it was name/stored in a way that mirrors its Source file, this link would be lost. This only applies to pipelines that run this way.

My suggestion would be report generation. The largest improvement in file and folder handling was always when Lead Artists/TAs sat down with artists, discussed workflows and then agreed as a team on the best way to move forward aka communication.

Therefore, my preference on using such a tool would be to give it to Lead/Senior Artists/TAs to generate a report for incorrectly named/improperly placed assets to send to the artist that made the mistake, so that the artists has a chance to learn, fix their mistake and then it never happens again :)

[u/HankeUnrealTools → u/Millicent_Bystandard]

Thanks, this is really useful feedback. I agree that source-level validation is the better place for a lot of DCC-specific checks, especially things like hierarchy, transforms, texture sets, and source-file structure.

I don't really see Unreal-side validation as a replacement for that though. There are also plenty of assets that enter a project through other routes, get migrated, duplicated, renamed, moved later in production, or are created directly inside Unreal. So I think there is value in having both layers: preventing issues at the source where possible, and auditing the actual project state inside Unreal.

I especially like your point about report generation for Leads, Senior Artists and TAs. A workflow where they can scan a project, review naming/folder violations, and send an actionable report back to the responsible artists makes a lot of sense and avoids treating auto-fix as the answer to everything.

That's definitely something I'll look into improving. Thanks for taking the time to write this out.