Quick answer: Open Jobs > Burst > Open Inspector to see every job’s compilation status. If a job shows “Not Compiled” or “Error,” Burst dropped to mono silently. Remove managed types, switch to native containers, and enable Synchronous Compilation to catch errors at compile time.

Here is how to fix Unity Burst compiler silently skipping job. You add [BurstCompile] to a job, expecting 10x speedup. Profiler shows no improvement. You try a more complex operation — still no speedup. Burst is supposed to print warnings when compilation fails, but when the failure happens during background compilation, they are easy to miss. The job runs unoptimized and you do not know.

The Symptom

A job marked [BurstCompile] does not show the expected performance improvement:

What Causes This

Managed type references. Burst only handles value types. Using string, List<T>, class instances, or any managed reference type inside a job prevents Burst compilation. The job falls back to C# mono execution.

Exceptions. try/catch blocks and throw statements are not supported. Remove them or use Burst-safe error signaling (return flags, NativeArray for error counts).

Static fields. Accessing non-readonly static fields from Burst jobs is not allowed. Use SharedStatic<T> or pass values in via job fields.

Generic method calls. Some generic method calls cannot be Burst-compiled. Specialize them or use explicit type parameters.

Async compilation dropping errors. Burst compiles in the background by default. If a job fails to compile while your game is running, Burst may not print a visible error until the next domain reload.

The Fix

Step 1: Open the Burst Inspector. Window > Jobs > Burst > Open Inspector. This window lists every Burst-eligible method in your project with its compilation status:

Click a method to see the generated assembly (or the error). Errors explain what is incompatible.

Step 2: Enable Synchronous Compilation during development. Jobs > Burst > Synchronous Compilation. Now errors surface at compile time, not on first run. Slows down iteration but catches issues immediately.

Also enable Safety Checks and Leak Detection for further error detection in editor. Disable for builds.

Step 3: Replace managed types with native.

// Bad: List<T> is managed, breaks Burst
[BurstCompile]
public struct BadJob : IJob
{
    public List<float> values; // ERROR
    public void Execute() { // ... */ }
}

// Good: NativeArray is value-type-like
[BurstCompile]
public struct GoodJob : IJob
{
    public NativeArray<float> values;
    public void Execute()
    {
        for (int i = 0; i < values.Length; i++)
            values[i] *= 2f;
    }
}

NativeArray, NativeList, NativeHashMap, NativeQueue are all Burst-compatible. Remember to Dispose them when the job completes.

Step 4: Avoid exceptions inside jobs. Burst allows throw new ArgumentException in some cases but the general rule is no exception handling. Use assertion-style checks that terminate the job gracefully:

[BurstCompile]
public struct SafeJob : IJob
{
    public NativeArray<int> data;
    public void Execute()
    {
        if (data.Length == 0)
            return; // early exit, no exception

        // ... work on data ...
    }
}

Testing Burst Speedup

Compare with and without Burst by temporarily disabling. Jobs > Burst > Enable Compilation toggle off runs everything without Burst. Profile your scene; toggle back on and profile again. Real Burst acceleration typically shows 3–10x speedup on math-heavy workloads.

“Burst is silent when it fails. The Inspector is the only ground truth. Check it before trusting your performance numbers.”

Related Issues

For managed code errors, see Burst Compile Error Managed Code. For DOTS query issues, DOTS Entity Query Missing Tag Component covers related ECS patterns.

Burst Inspector is the truth. Synchronous Compilation surfaces errors. Native types only.