If you have ever opened the Unity Profiler or the Stats window and saw a scary number of Draw Calls, don’t worry — you are not alone. Almost every Unity developer reaches that moment where the game runs fine on PC, but suddenly struggles on mobile or weaker devices.

One of the most common reasons is having too many draw calls. The good news? Reducing them is usually easier than you think once you understand how Unity renders objects.

In this guide, we will explain what draw calls are, why they matter, and most importantly how you can reduce them to improve your game’s performance.

What is a Draw Call in Unity?

A Draw Call happens when the CPU tells the GPU to render an object. Each time Unity sends a command like “draw this mesh with this material”, that counts as one draw call.

The problem is not the GPU drawing the object. GPUs are very good at that. The problem is the communication between CPU and GPU. Every draw call adds overhead.

So if your scene has:

• 100 objects
• Each with different materials
• No batching

You could easily end up with 100 draw calls or more. On mobile devices, that can hurt performance pretty quickly.

How to Check Draw Calls in Unity

Before optimizing, you should first measure your draw calls.

Open the Game view and click the Stats button. You will see something like:

• Batches
• SetPass Calls
• Triangles
• Vertices

The most important numbers for this topic are:

• Batches
• SetPass Calls

Generally speaking, fewer batches means fewer draw calls.

1. Use Static Batching

If objects in your scene never move, rotate, or scale during gameplay, you should mark them as Static. Unity can then combine them into fewer draw calls using Static Batching.

Examples of good static objects:

• Buildings
• Environment props
• Walls and floors

To enable it:

• Select the GameObject
• Check the Static checkbox in the Inspector

Unity will automatically batch them at build time.

2. Use the Same Materials

Unity can only batch objects if they share the same material. If every object has a different material, Unity must issue a separate draw call for each.

For example, this is bad:

• 10 cubes
• 10 slightly different materials

This is much better:

• 10 cubes
• 1 shared material

A common trick is to use texture atlases so many objects can share the same material.

3. Enable GPU Instancing

If you have many identical objects (trees, rocks, bullets, etc.), GPU instancing can render them with a single draw call.

To enable it:

• Select your material
• Enable GPU Instancing

If you are using scripts to spawn many objects, GPU instancing can make a huge difference.

Example spawning objects:

using UnityEngine;

public class SpawnExample : MonoBehaviour
{
    public GameObject prefab;
    public int count = 100;

    void Start()
    {
        for(int i = 0; i < count; i++)
        {
            Vector3 pos = new Vector3(Random.Range(-10,10),0,Random.Range(-10,10));
            Instantiate(prefab, pos, Quaternion.identity);
        }
    }
}

If the prefab shares the same material with GPU instancing enabled, Unity can render many of these objects efficiently.

4. Combine Meshes

Another technique is combining multiple meshes into one larger mesh. This reduces the number of renderers and draw calls.

Unity even provides a built‑in API for this.

using UnityEngine;

public class MeshCombiner : MonoBehaviour
{
    void Start()
    {
        MeshFilter[] meshFilters = GetComponentsInChildren<MeshFilter>();
        CombineInstance[] combine = new CombineInstance[meshFilters.Length];

        for (int i = 0; i < meshFilters.Length; i++)
        {
            combine[i].mesh = meshFilters[i].sharedMesh;
            combine[i].transform = meshFilters[i].transform.localToWorldMatrix;
        }

        Mesh mesh = new Mesh();
        mesh.CombineMeshes(combine);

        GetComponent<MeshFilter>().mesh = mesh;
    }
}

This approach is especially useful for static environment props.

5. Use LOD Groups

Sometimes the problem is not just draw calls but also too much geometry being rendered. LOD (Level of Detail) lets Unity render simpler versions of objects when they are far away.

This reduces:

• Triangles
• Vertices
• GPU workload

Which indirectly improves rendering performance.

Final Thoughts

Reducing draw calls is one of the most important optimization techniques in Unity, especially for mobile and VR games.

The main strategies are simple:

• Use static batching
• Share materials
• Enable GPU instancing
• Combine meshes
• Use LOD groups

The key is always the same rule of game optimization:

Measure first, optimize second.

Open the Unity Profiler, check your batches, and then apply the techniques above where they actually matter.

Your GPU (and your players) will thank you for it. 🚀