Clean Up Your UE5 Project with UnrealPilot

The Project Entropy Problem

Every project starts clean. Organized folders, meaningful names, no cruft. Six months later? A different story. Test assets never deleted. Duplicated materials. Blueprints from abandoned features. Actors placed for debugging left in production levels.

The mess has real costs:

• Build times: Cooking unused assets wastes minutes on every build
• Package size: Unused content ships to players
• Team confusion: Which asset is the real one?
• Performance: Unnecessary actors affect level load times

Cleaning up manually is tedious. You need to check references, verify nothing uses the asset, coordinate with team members. UnrealPilot handles this systematically.

Finding Unused Assets

The Reference Problem

Unreal's Reference Viewer shows what uses an asset. But checking every asset individually? With hundreds or thousands of assets, that's not practical.

UnrealPilot scans your entire project:

"Find all unused assets in the project"

It checks:

• Direct references (Blueprint uses Material)
• Indirect references (Material uses Texture used by Blueprint)
• Level references (actors placed in any map)
• Code references (C++ hard references)
• Data Table references (row references to assets)
• Soft references (TSoftObjectPtr, asset paths in properties)

Filtered Searches

Target specific asset types:

"Find unused textures over 1MB"

"Find materials not used in any level"

"Find Blueprint classes never spawned or placed"

"Find sound files not referenced by any cue"

Understanding Results

UnrealPilot doesn't just list unused assets—it explains why it thinks they're unused:

Potentially Unused Assets:

T_Character_OldDesign.uasset
  Status: No references found
  Last Modified: 4 months ago
  Size: 4.2 MB
  Recommendation: Safe to delete

M_Environment_Test.uasset
  Status: Referenced only by deleted level
  Note: Level L_TestMap was deleted but material remains
  Recommendation: Verify not needed, then delete

BP_Enemy_V2.uasset
  Status: No level placements, no spawn references
  Note: Similar to BP_Enemy which IS used
  Recommendation: May be deprecated version, verify before delete

Bulk Deletion

After reviewing the list:

"Delete all assets marked safe to delete"

UnrealPilot performs the deletion through proper editor APIs, handling:

• Source control integration (marks for delete)
• Redirector cleanup
• Reference verification before each delete
• Rollback capability if something goes wrong

Removing Redundant Actors

Level Cleanup

Levels accumulate actors that shouldn't be there:

"Find debug actors left in production levels"

UnrealPilot identifies:

• Actors with "Debug," "Test," or "Temp" in their names
• Print String nodes that fire in production
• Visualization actors (debug spheres, arrows)
• Disabled actors that serve no purpose

Duplicate Detection

"Find duplicate actors at the same location"

Common after copy-paste operations: two identical static meshes occupying the same space, causing z-fighting or double rendering.

UnrealPilot finds actors where:

• Same class and transform (exact duplicates)
• Same mesh at same location (duplicate placements)
• Overlapping collision without purpose

Hidden Actor Audit

"List all hidden actors and why they might be hidden"

Hidden actors often indicate unfinished work or debugging remnants. The audit categorizes them:

• Intentionally hidden (runtime visibility toggle)
• Hidden in editor only (development helpers)
• Hidden and probably forgotten

Content Organization

Folder Structure Analysis

"Analyze project folder structure and suggest improvements"

UnrealPilot evaluates against common UE5 conventions:

Content/
├── Characters/
│   ├── Player/
│   └── Enemies/
├── Environment/
│   ├── Meshes/
│   ├── Materials/
│   └── Textures/
├── UI/
├── Audio/
├── Effects/
└── Blueprints/

It identifies:

• Assets in wrong folders (textures in Blueprints folder)
• Inconsistent naming conventions
• Overly deep folder hierarchies
• Orphaned folders with few assets

Asset Relocation

"Move all textures to appropriate texture folders"

UnrealPilot moves assets and:

• Updates all references automatically
• Creates redirectors for external references
• Preserves source control history
• Reports any references that couldn't be updated

Naming Convention Enforcement

"Rename assets to follow Epic naming conventions"

Standard prefixes:

BP_ - Blueprint
M_ - Material
MI_ - Material Instance
T_ - Texture
S_ - Struct
E_ - Enum
WBP_ - Widget Blueprint
SK_ - Skeletal Mesh
SM_ - Static Mesh
A_ - Animation
ABP_ - Animation Blueprint

UnrealPilot renames assets, updates references, and logs all changes.

Blueprint Cleanup

Dead Code Detection

"Find Blueprint nodes that never execute"

Dead code in Blueprints:

• Disconnected node clusters
• Branches that always evaluate the same way
• Events that nothing calls
• Functions with no callers

Variable Cleanup

"Find unused variables in all Blueprints"

Variables that are declared but never read or written. Often remnants of refactored code.

Component Audit

"Find components that serve no purpose"

Components that:

• Have no connections to other nodes
• Are hidden and not used in code
• Duplicate functionality of other components

Material and Texture Optimization

Texture Analysis

"Find texture optimization opportunities"

UnrealPilot identifies:

• Oversized textures for their use case
• Textures without proper compression settings
• Duplicate textures with different names
• Unused mip levels that could be stripped

Material Instance Consolidation

"Find material instances that could share a parent"

Multiple similar materials often should be instances of a shared parent. Consolidation reduces shader compilation and improves batching.

Texture Size Report

"Generate texture memory report by folder"

See where texture memory goes:

Texture Memory Usage:

Characters/: 245 MB
  └── Player/: 120 MB
      └── T_Player_Albedo (4K): 85 MB ← Consider 2K
  └── Enemies/: 125 MB

Environment/: 890 MB
  └── Props/: 340 MB
      └── Many 4K textures for small objects

UI/: 45 MB

Level Organization

Actor Categorization

"Organize actors into folders by type"

Creates World Outliner folders:

Level
├── Lighting/
│   ├── DirectionalLight
│   └── PointLights (12)
├── Geometry/
│   ├── Floors (24)
│   └── Walls (67)
├── Gameplay/
│   ├── Spawners (4)
│   └── Triggers (8)
└── Environment/
    ├── Foliage (234)
    └── Props (89)

Layer Setup

"Create layers for different content types"

Useful for:

• Hiding categories while editing
• Selective cooking for different platforms
• Team workflow (environment vs gameplay)

Sublevel Organization

"Suggest sublevel breakdown for this level"

Large levels should use streaming sublevels. UnrealPilot analyzes actor distribution and suggests logical partitioning.

Source Control Integration

Safe Cleanup with Perforce/Git

UnrealPilot operations integrate with source control:

"Delete unused assets (check out and mark for delete)"

"Rename assets (check out, rename, update references)"

All changes are staged, not committed, letting you review before submitting.

Cleanup Changelists

"Create changelist for project cleanup"

Groups cleanup changes into a single, reviewable changelist with descriptive commit message.

Automated Cleanup Reports

Health Check

"Run project health check"

Comprehensive report covering:

• Unused asset count and size
• Naming convention violations
• Folder structure issues
• Blueprint warnings
• Material complexity outliers
• Texture memory distribution

Before-Release Audit

"Pre-release cleanup audit"

Focused on shipping concerns:

• Debug/test content that shouldn't ship
• Development-only assets
• Placeholder content
• Console commands exposed
• Print statements active

Incremental Cleanup

Big cleanup sessions are disruptive. Better: continuous maintenance.

Weekly Checks

"Find assets added this week that violate naming conventions"

"Find new unused assets from recent imports"

Catch problems when they're small, not after they've multiplied.

Pre-Commit Validation

"Validate these assets before I commit"

Check specific assets against project standards before they enter source control.

Real Cleanup Example

Here's a typical cleanup session:

User: "Run full project cleanup analysis"

UnrealPilot:
Project Analysis Complete

Unused Assets: 47 (312 MB)
  - 23 textures (245 MB)
  - 12 materials
  - 8 meshes
  - 4 blueprints

Naming Issues: 34 assets
  - Missing prefix: 28
  - Wrong prefix: 6

Folder Issues: 12
  - Textures in wrong folder: 8
  - Empty folders: 4

Blueprint Issues: 7
  - Unused variables: 15 across 5 BPs
  - Dead code: 2 BPs

Recommendations:
  1. Delete 47 unused assets (saves 312 MB build size)
  2. Rename 34 assets to match conventions
  3. Relocate 8 textures to proper folders
  4. Clean up Blueprint dead code

Shall I proceed with any of these?

User: "Delete unused assets and rename to match conventions"

UnrealPilot:
Executing cleanup...
  - Deleted 47 assets
  - Renamed 34 assets
  - Updated 89 references
  - Created cleanup changelist CL#12847

Changes staged for review. No files committed.

Summary

Project cleanup is necessary but tedious. The manual process—checking references, verifying safety, updating names—takes hours and is easy to skip. So projects get messier over time.

UnrealPilot makes cleanup practical. Describe what you want cleaned, review the changes, approve. The AI handles the tedious reference checking and bulk operations. You keep your project healthy without losing development time.

Get early access to UnrealPilot →