Build Report Tool

About Build Report Tool – Unity Editor Tool & Plugin

Build Report Tool Unity Asset Overview

The Build Report Tool serves as an essential editor extension designed to demystify Unity's compilation outputs. When building a target binary, Unity outputs a aggregated log containing asset overhead, serialized dependencies, and executable payload binaries. The engine's raw build log output, however, is unstructured and volatile. The Build Report Tool hooks into Unity's BuildPipeline via the IPostprocessBuildWithReport interface to capture raw build metrics instantly upon compilation completion.

At its architectural core, the utility decouples log parsing from data representation. The parser inspects the output of the native UnityEditor.Build.Reporting.BuildReport data structure along with the local Editor.log file, extracting precise byte allocations, compressed versus uncompressed size variances, and project asset relative paths. Captured data is mapped into persistent ScriptableObject data instances (or serialized XML containers), allowing developers to archive historical build profiles across different engine versions, targets, and optimization passes without mutating runtime assemblies.

Data Model & Memory Allocation During Parsing

Analyzing builds containing tens of thousands of individual assets can trigger significant Garbage Collection (GC) pressure inside the Unity Editor if handled carelessly. The architecture mitigates GC spikes during report generation through the following structural paradigms:

• String Interning & Cached Pathing: Reuses asset directory strings across serialized arrays to eliminate duplicate string allocations in memory during heavy log parsing.
• Lazy Loaded Visual Views: Asset file arrays (e.g., Textures, AudioClips, Meshes, and Managed Assemblies) are sorted and indexed in background worker threads where safe, instantiating UI elements only for currently visible scroll view rects.
• Data Granularity Segregation: Separates static scene references, Addressables/AssetBundles payloads, and compiled C# Mono/IL2CPP binary output into discrete data collections.

Inspector Configuration & Visualizing Asset Distribution

The editor interface operates via an advanced custom EditorWindow utilizing IMGUI/UI Toolkit rendering patterns designed to expose granular metrics without dragging down editor frame rates. The custom inspector splits build analysis into high-impact categories: Asset Breakdown, Unused Assets Scanner, Build Options Log, and File Dependency Treemaps.

Asset Categorization & Compression Profiling

The tool automatically aggregates individual files into dedicated type filters, helping developers pinpoint ballooning file sizes before deployment:

• Textures & Sprites: Displays uncompressed source sizes versus actual compressed build footprint (ASTC, ETC2, DXT, or BC7 allocations), identifying misconfigured Max Texture Size overrides.
• Audio Clips: Highlights sample rate overrides, forced Mono conversions, and compression formats (Vorbis, ADPCM, PCM) that exceed streaming threshold allocations.
• Meshes & Animations: Exposes vertex count overhead, skin weights, and unnecessary blend shape data embedded in FBX imports.
• Managed DLLs & Native Code: Breaks down compiled standard C# assemblies against IL2CPP metadata footprint, engine code stripping allocations, and third-party native plugin binaries.

The Unused Assets Engine compares project files present in the local Assets/ directory against the direct dependency graph generated by scenes included in the Build Settings panel. This allows technical directors to perform safe project cleanups without relying on brittle runtime missing-reference searches.

Quick-Start Unity Integration Guide

Integrating the Build Report Tool into an established Unity project requires zero modification of project runtime C# scripts or game logic. The asset resides strictly within an Editor assembly folder to guarantee zero runtime memory overhead or inclusion in final production binaries.

Automating Build Capture via C# Build Pipeline Hooks

To programmatically hook into the analysis pipeline or export build reports during continuous integration (CI/CD) automated builds, implement a custom editor script utilizing Unity's build interfaces:

using UnityEditor;
using UnityEditor.Build;
using UnityEditor.Build.Reporting;
using UnityEngine;
using BuildReport;

public class AutomatedBuildReporter : IPostprocessBuildWithReport
{
    // High callback order ensures the reporter runs after primary asset processors
    public int callbackOrder => 999;

    public void OnPostprocessBuild(BuildReport report)
    {
        Debug.Log($"[BuildReportTool] Processing build for target: {report.summary.platform}");

        // Trigger manual analysis generation via report object
        string reportSavePath = "BuildReports/LatestBuildReport.xml";
        
        // Pass Unity's native BuildReport object to the analyzer
        BuildReportTool.ReportData generatedData = BuildReportTool.ReportGenerator.CreateReport(report);

        if (generatedData != null)
        {
            BuildReportTool.ReportGenerator.SaveReport(generatedData, reportSavePath);
            Debug.Log($"[BuildReportTool] Successfully exported build analysis to: {reportSavePath}");
            
            // Check for critical size thresholds
            double totalSizeMb = report.summary.totalSize / (1024.0 * 1024.0);
            if (totalSizeMb > 150.0)
            {
                Debug.LogWarning($"[BuildReportTool] Warning: Target build size ({totalSizeMb:F2} MB) exceeds maximum cellular threshold.");
            }
        }
    }
}

Clean Setup Workflow

1. Import the package into your Unity Project (ensure files sit within an Editor/ folder structure).
2. Open the window via Window > Build Report in the top Unity menu bar.
3. Perform a standard build test via File > Build Settings > Build.
4. Once the build completes, the Build Report window automatically refreshes, parsing the build metrics into organized tabs.
5. Save the generated report file into your version control workspace to track build size progression over time.

Advanced Optimization Strategies & Profiling Insights

Deploying software across low-spec mobile devices, consoles, or WebGL environments demands strict size budgets. The Build Report Tool highlights actionable optimization targets that are frequently buried inside standard Unity logs.

Targeting Hidden Memory Overhead

When analyzing a report, look for common systemic asset bloated issues across the following areas:

• Shader Variant Inflation: Complex shader graphs can inadvertently compile thousands of unused variants. Look at the Shaders aggregate list to detect missing #pragma skip_variants directives or unstripped multi-compile keywords.
• Duplicate Asset Imports: Multiple prefabs dragging duplicate high-res textures into distinct scenes without proper Addressables grouping will display elevated total sizes despite identical asset names.
• Managed Code Stripping (Mono vs IL2CPP): Comparing builds generated with Managed Stripping Level set to Minimal versus Medium/High shows immediate size reductions in standard DLL assemblies.

Technical Evaluation: Strengths & Considerations

• Pros:
  • Eliminates manual, error-prone parsing of the raw native Unity Editor.log.
  • Identifies exact compressed file allocations per asset to fast-track optimization passes.
  • Saves offline serialized report files, enabling precise historical comparison across game updates.
  • Zero runtime footprint; completely stripped from target client builds.
• Cons:
  • Requires a complete build generation cycle to produce fresh analytical data.
  • Parsing extremely large projects (100,000+ individual assets) may induce a temporary Editor UI pause during initial log processing.

Developers Who Downloaded This Also Downloaded

Related Unity Tools Assets