Maintainer 2

About Maintainer 2 – Unity Editor Tool & Plugin

Maintainer 2 Unity Asset Overview

desktop, and console, project bloat and broken references have consistently been the silent killers of development velocity. As teams scale and art pipelines iterate, assets get renamed, deleted, or duplicated, leaving behind missing script components, broken Unity Events, and unused duplicate textures that quietly inflate build sizes. Maintainer 2 by Code Stage addresses these production bottlenecks directly at the Editor level.

Architecturally, Maintainer 2 functions as a static analysis engine for Unity projects. Rather than running at runtime, it hooks into Unity's UnityEditor serialization APIs and reads project metadata (.meta files, YAML scene files, ScriptableObject binaries, and asset database maps). It parses object dependencies directly from serialized properties without needing to instantiate every asset into memory simultaneously, keeping memory overhead predictable even on multi-gigabyte repositories.

Core Technical Features & Highlights

When analyzing a maintenance utility, performance and accuracy are my main criteria. False positives can waste hours of developer time. Here is how Maintainer 2 breaks down technically across its primary modules:

1. Issues Finder

The Issues Finder scans scenes, prefabs, ScriptableObjects, and asset folders for missing scripts, broken property references, unassigned public fields, and empty array elements. It traverses serialized properties via SerializedProperty and identifies damaged object references (represented internally as `fileID: 0` or missing GUIDs).

2. Duplicates Finder

Instead of relying strictly on file names, the Duplicates Finder conducts deep content hashing (MD5/SHA) on raw binary asset data. This catches identical audio clips, textures, and 3D meshes saved under different names across multiple project directories.

3. References Finder

Understanding asset dependencies before refactoring legacy code is critical. Maintainer 2 indexes the entire project dependency graph, allowing you to right-click any asset in your Project view and trace every scene, prefab, or material referencing it.

• Zero Runtime Overhead: Operates entirely within Editor scripts under Editor/ directories; zero code footprint or extra memory usage in published release builds.
• Granular Filtering: Exclude specific paths, asset types, tag masks, or layer masks to prevent scanning third-party SDKs or legacy archives.
• Batch Auto-Fixing: Offers automatic garbage cleanup, missing reference removal, and safe reference re-assignment.
• Pipeline Native: Universal compatibility across URP, HDRP, and Built-In Render Pipelines since analysis runs above the rendering layer.

Ideal Use Cases & Game Genres

In my experience, this asset shines across specific production scenarios:

• Mobile Game Optimization: Essential for staying within strict APK/IPA installation size thresholds by locating hidden duplicate textures and unreferenced high-resolution audio files.
• Long-term Live-Ops Titles: Games updated over years accumulate dead code and orphaned prefabs. Maintainer 2 helps prune dead weight without breaking active scene references.
• Multi-Developer Indie Studios: When multiple artists and programmers push changes to version control, missing scripts frequently occur. Running automated scans keeps main branches clean.
• Large RPGs & Open-World Projects: Highly modular games with hundreds of ScriptableObjects benefits from automated integrity checks before generating production builds.

Quick-Start Unity Setup & Integration Guide

Setting up Maintainer 2 takes under five minutes. Follow these practical steps to configure it in your workspace:

Step 1: Launch and Configure Filters

Navigate to Tools > Code Stage > Maintainer in the Unity Editor menu bar. Before running a full project sweep, set up ignore rules to skip external plugins (e.g., Assets/Plugins/) to reduce scan noise and speed up analysis.

Step 2: Automate Build Pre-Processing

To ensure no broken references reach production, you can write a custom Editor script utilizing Unity's IPreprocessBuildWithReport interface to run checks automatically prior to building. Here is a custom implementation example:

using UnityEditor;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
using UnityEngine;
// Ensure you include the Maintainer namespace in Editor scripts
using CodeStage.Maintainer;

public class PreBuildMaintenanceCheck : IPreprocessBuildWithReport
{
    public int callbackOrder => 0;

    public void OnPreprocessBuild(BuildReport report)
    {
        Debug.Log("[Build Pipeline] Running project reference checks via Maintainer...");

        // Triggering an Editor-side scan programmatically
        // Ensures broken scenes or missing components halt automated build pipelines
        bool hasCriticalErrors = PerformSanityScan();

        if (hasCriticalErrors)
        {
            throw new BuildFailedException("[Build Pipeline] Build aborted: Missing script references or unassigned critical assets detected!");
        }
    }

    private bool PerformSanityScan()
    {
        // Custom logic to parse Maintainer scan status
        // In practice, check Maintainer's status or issue count before proceeding
        return false; 
    }
}

Pros & Cons Assessment

• Pro: Drastically reduces manual project auditing time before major milestones or console submission steps.
• Pro: Deep content-hash duplicate detection prevents redundant asset inclusion in AssetBundles and Addressables.
• Pro: Clean UI with intuitive contextual actions (Jump to Asset, Auto-Fix, Ignore List).
• Con: Initial deep scans on massive repositories (50GB+) can be time-intensive on traditional HDDs (SSDs recommended).
• Con: Auto-fixing missing references requires care; always commit project state to Git/Plastic SCM before batch-cleaning.

Developers Who Downloaded This Also Downloaded

Related Unity Tools Assets