Find out what assemblies are being built and how long each takes.

Unity Assembly Definition Debugger.cs

using System;
using System.Collections.Generic;
using System.Text;
using UnityEditor;
using UnityEditor.Compilation;
using UnityEngine;

[InitializeOnLoad]
public class AsmdefDebug
{
    const string AssemblyReloadEventsEditorPref = "AssemblyReloadEventsTime";
    const string AssemblyCompilationEventsEditorPref = "AssemblyCompilationEvents";
    static readonly int ScriptAssembliesPathLen = "Library/ScriptAssemblies/".Length;

    static Dictionary<string, DateTime> s_StartTimes = new Dictionary<string, DateTime>();

    static StringBuilder s_BuildEvents = new StringBuilder();
    static double s_CompilationTotalTime;

    static AsmdefDebug()
    {
        CompilationPipeline.assemblyCompilationStarted += CompilationPipelineOnAssemblyCompilationStarted;
        CompilationPipeline.assemblyCompilationFinished += CompilationPipelineOnAssemblyCompilationFinished;
        AssemblyReloadEvents.beforeAssemblyReload += AssemblyReloadEventsOnBeforeAssemblyReload;
        AssemblyReloadEvents.afterAssemblyReload += AssemblyReloadEventsOnAfterAssemblyReload;
    }

    static void CompilationPipelineOnAssemblyCompilationStarted(string assembly)
    {
        s_StartTimes[assembly] = DateTime.UtcNow;
    }

    static void CompilationPipelineOnAssemblyCompilationFinished(string assembly, CompilerMessage[] arg2)
    {
        var time = s_StartTimes[assembly];
        var timeSpan = DateTime.UtcNow - s_StartTimes[assembly];
        s_CompilationTotalTime += timeSpan.TotalMilliseconds;
        s_BuildEvents.AppendFormat("{0:0.00}s {1}\n", timeSpan.TotalMilliseconds / 1000f, assembly.Substring(ScriptAssembliesPathLen, assembly.Length - ScriptAssembliesPathLen));
    }

    static void AssemblyReloadEventsOnBeforeAssemblyReload()
    {
        s_BuildEvents.AppendFormat("compilation total: {0:0.00}s\n", s_CompilationTotalTime / 1000f);
        EditorPrefs.SetString(AssemblyReloadEventsEditorPref, DateTime.UtcNow.ToBinary().ToString());
        EditorPrefs.SetString(AssemblyCompilationEventsEditorPref, s_BuildEvents.ToString());
    }

    static void AssemblyReloadEventsOnAfterAssemblyReload()
    {
        var binString = EditorPrefs.GetString(AssemblyReloadEventsEditorPref);

        long bin = 0;
        if (long.TryParse(binString, out bin))
        {
            var date = DateTime.FromBinary(bin);
            var time = DateTime.UtcNow - date;
            var compilationTimes = EditorPrefs.GetString(AssemblyCompilationEventsEditorPref);
            if (!string.IsNullOrEmpty(compilationTimes))
            {
                Debug.Log("Compilation Report\n" + compilationTimes + "Assembly Reload Time: " + time.TotalSeconds + "s\n");
            }
        }
    }
}

@karljj1 I don't understand why you complicated all of your code ? would you mind explaining ?

This, OTOH, is simple and effective:

using System.Collections.Generic;
using System.Diagnostics;
using UnityEditor;
using UnityEditor.Compilation;
using Debug = UnityEngine.Debug;

[InitializeOnLoad]
internal static class CompilationTime
{
    private static readonly Dictionary<string, Stopwatch> Dictionary;
    private static readonly Stopwatch                     Stopwatch;

    static CompilationTime()
    {
        CompilationPipeline.compilationStarted          += OnCompilationStarted;
        CompilationPipeline.compilationFinished         += OnCompilationFinished;
        CompilationPipeline.assemblyCompilationStarted  += OnAssemblyCompilationStarted;
        CompilationPipeline.assemblyCompilationFinished += OnAssemblyCompilationFinished;
        Dictionary                                      =  new Dictionary<string, Stopwatch>();
        Stopwatch                                       =  new Stopwatch();
    }

    private static void OnCompilationStarted(object context)
    {
        Dictionary.Clear();
        Stopwatch.Start();
    }

    private static void OnCompilationFinished(object context)
    {
        var elapsed = Stopwatch.Elapsed;

        Stopwatch.Stop();
        Stopwatch.Reset();

        foreach (var pair in Dictionary)
        {
            Debug.Log($"Assembly {pair.Key.Replace("Library/ScriptAssemblies/", string.Empty)} " +
                      $"built in {pair.Value.Elapsed.TotalSeconds:F} seconds.");
        }

        Debug.Log($"Total compilation time: {elapsed.TotalSeconds:F} seconds.");
    }

    private static void OnAssemblyCompilationStarted(string value)
    {
        Dictionary.Add(value, Stopwatch.StartNew());
    }

    private static void OnAssemblyCompilationFinished(string value, CompilerMessage[] messages)
    {
        Dictionary[value].Stop();
    }
}

@aybe
I'm sure there are parts that can be made simpler however compilationStarted and compilationFinished did not exist when I wrote this(I actually requested them when I was writing it).

okay I understand now, thanks 😃

I came across this and it kind of works well, but the one thing it fails on is reporting when the project is loaded. My project takes about 4 secs to load, and this as is reports that the reload of the assembly took 18mins!

The tool doesn't record the startup time. 18 mins will be the time you last did a compilation in editor and then restarted the Editor.
Try this tool, its much better https://github.com/needle-tools/compilation-visualizer

I am not talking about compilation, I was talking about the time it takes to reload / load the domain!

The profiler can help to tell you why it's taking a long time. Some scripts will execute during the reload and this can cause a significant delay. It may be a package or tool you are using causing the problems, the profiler can help to identify this.

Again, I said when the project is loaded, therefore the profiler can not be used. And as I said my project takes about 4secs to load and yet this code reports it takes anywhere between 8mins to 16 mins, it kind of looks like it is not clearing the times and just adding them to previous project loads.