Generating meshes at runtime is common in procedural terrain, voxel engines, and dynamic environments. However, mesh generation can quickly become CPU intensive if not optimized.

Unity provides two powerful tools to solve this problem:

• Unity Job System
• Burst Compiler

Together they allow developers to generate meshes in parallel using multiple CPU cores with highly optimized native code.

Why Standard Mesh Generation Becomes Slow

Typical mesh generation code runs on the main thread.

for(int x = 0; x < size; x++)
{
    for(int z = 0; z < size; z++)
    {
        GenerateVertex(x, z);
    }
}

For large terrains or voxel worlds this becomes expensive because:

• Everything runs on a single CPU core
• The main thread gets blocked
• Frame rate drops during generation

The solution is to move heavy work off the main thread.

What Are Unity Jobs?

The Unity Job System allows code to run in parallel across multiple CPU cores.

Instead of one thread doing all the work, Unity splits the workload across many workers.

This makes procedural generation dramatically faster.

What Is Burst Compiler?

Burst is a compiler that converts C# jobs into highly optimized native code.

It uses SIMD instructions and CPU optimizations to make jobs significantly faster.

In many cases Burst can make code 10x faster.

Installing Jobs and Burst

Open the Unity Package Manager and install:

• Burst
• Mathematics
• Jobs

Basic Parallel Job Example

Here is a simple job that generates vertices for a terrain mesh.

using Unity.Jobs;
using Unity.Collections;
using Unity.Burst;
using Unity.Mathematics;

[BurstCompile]
public struct TerrainVertexJob : IJobParallelFor
{
    public int size;
    public float scale;

    public NativeArray<float3> vertices;

    public void Execute(int index)
    {
        int x = index % size;
        int z = index / size;

        float height = noise.cnoise(new float2(x, z) * scale);

        vertices[index] = new float3(x, height * 5f, z);
    }
}

Each vertex is calculated in parallel by different CPU threads.

Scheduling the Job

Now we schedule the job from a MonoBehaviour.

NativeArray<float3> vertices = new NativeArray<float3>(size * size, Allocator.TempJob);

TerrainVertexJob job = new TerrainVertexJob
{
    size = size,
    scale = 0.05f,
    vertices = vertices
};

JobHandle handle = job.Schedule(vertices.Length, 64);
handle.Complete();

The number 64 is the batch size used for distributing work between threads.

Applying Data to the Mesh

After the job finishes we apply the vertices to a mesh.

Vector3[] finalVertices = new Vector3[vertices.Length];

for(int i = 0; i < vertices.Length; i++)
{
    finalVertices[i] = vertices[i];
}

mesh.vertices = finalVertices;
mesh.RecalculateNormals();

vertices.Dispose();

The heavy computation happens in the job, while the mesh update stays on the main thread.

Why This Is Much Faster

• Work runs across multiple CPU cores
• Burst compiles code to optimized native instructions
• Main thread stays responsive

This is especially important for:

• Procedural terrain
• Voxel mesh generation
• Infinite worlds
• Runtime mesh deformation

Performance Tips

• Use NativeArray instead of List
• Avoid managed memory inside jobs
• Use Unity.Mathematics instead of Mathf
• Batch large jobs properly
• Reuse NativeArrays when possible

Combining Jobs with Chunk Systems

The most powerful approach is combining Jobs with chunk-based terrain generation.

Each chunk mesh can be generated in a separate job, allowing massive worlds to be built efficiently.

Modern procedural engines rely heavily on this technique.

Final Thoughts

Unity Jobs and Burst are essential tools for building high-performance procedural systems.

By moving mesh generation off the main thread and letting Burst optimize the code, developers can generate complex worlds without sacrificing frame rate.

If you are building voxel terrain, procedural environments, or runtime mesh systems, learning Jobs and Burst can dramatically improve performance.