Optimizing Your Code

Practical tips for making Unity scripts run faster and stutter less. Each tip shows the slow version, the better version, and why it matters. For the overall process (budgets, profiling on devices, engine settings), see Optimization Best Practices.

Rule zero: measure first

Most code is fast enough. Before changing anything, find out what is actually slow using the Profiler (Window > Analysis > Profiler). Press Play, record a few seconds, click a spike in the CPU graph, and look at the Hierarchy view sorted by time. It tells you exactly which scripts and methods took the most time that frame.

The frame budget

At 60 FPS, everything (scripts, physics, animation, rendering) must fit in 16.6 ms per frame. At 30 FPS you have 33 ms. If a single frame takes 50 ms, the player sees a stutter. So both average cost and spikes matter.

1. Cache what you look up

GetComponent, GameObject.Find, FindObjectsByType and FindWithTag search for things. Searching every frame is wasted work because the answer is almost always the same.

// SLOW: searches every frame
void Update()
{
    GetComponent<Rigidbody>().AddForce(Vector3.up);
    GameObject.Find("Player").transform.position = Vector3.zero;
}

// BETTER: search once, remember the result
private Rigidbody rb;
[SerializeField] private Transform player; // or assign in the Inspector: no search at all

void Awake()
{
    rb = GetComponent<Rigidbody>();
}

void Update()
{
    rb.AddForce(Vector3.up);
}

2. Avoid creating garbage every frame

C# automatically frees memory you're no longer using. This is the garbage collector (GC). It's convenient, but when it runs, it can pause your game for a moment. The less garbage you create, the less often it runs.

Common sources of garbage in Update:

// BETTER: overlap check with no garbage
private readonly Collider[] hits = new Collider[32]; // max results we care about

void CheckNearby()
{
    int count = Physics.OverlapSphereNonAlloc(transform.position, 5f, hits);
    for (int i = 0; i < count; i++)
    {
        // use hits[i]
    }
}

To find garbage, select the GC Alloc column in the Profiler's CPU Hierarchy view and sort by it.

3. Pool objects you spawn a lot

Instantiate and Destroy are expensive when done dozens of times per second (bullets, particles, damage numbers). Reuse objects with an object pool instead. Unity includes UnityEngine.Pool.ObjectPool<T>; the Object Pooling guide covers it in depth.

4. Don't run code every frame if you don't have to

// WASTEFUL: checks a slow thing 60+ times per second
void Update()
{
    FindClosestEnemy();
}

// BETTER: check 5 times per second, still feels instant for AI
private float nextCheck;

void Update()
{
    if (Time.time < nextCheck) return;
    nextCheck = Time.time + 0.2f;
    FindClosestEnemy();
}

• React to events instead of checking every frame ("health changed" instead of reading health in Update). See UnityEvents.
• Use a coroutine with WaitForSeconds for slow-repeating work.
• Delete empty Update() methods. Unity still calls them.
• Disable scripts (enabled = false) on far-away or off-screen objects. OnBecameVisible/OnBecameInvisible can help.

5. Cheaper math and lookups

// Distance check without a square root
if ((a - b).sqrMagnitude < range * range) { }   // instead of Vector3.Distance(a, b) < range

// Animator parameters: hash once
private static readonly int SpeedId = Animator.StringToHash("Speed");
animator.SetFloat(SpeedId, speed);              // instead of SetFloat("Speed", speed)

// Shader/material properties: same idea
private static readonly int ColorId = Shader.PropertyToID("_BaseColor");
material.SetColor(ColorId, Color.red);

// Set position and rotation together
transform.SetPositionAndRotation(pos, rot);    // instead of setting each separately

These are small savings each, but they add up in code that runs on hundreds of objects every frame.

6. material vs. sharedMaterial

Reading renderer.material makes a copy of the material for that object the first time (so you can change its color without affecting others). Copies can't be batched together when drawing, and you must Destroy them yourself when you're done or they leak memory.

• Changing one object's look? material is fine, but for many objects, prefer a MaterialPropertyBlock.
• Changing all objects using that material? Use sharedMaterial. (In the Editor this changes the asset on disk.)

7. Physics tips

• Use primitive colliders (box, sphere, capsule) over Mesh Colliders whenever possible.
• Use the Layer Collision Matrix to turn off pairs that never need to collide (e.g. "Pickups" vs "Pickups").
• Pass a layer mask and max distance to raycasts so they check fewer colliders.
• Don't move static colliders (no Rigidbody) every frame. If it moves, give it a kinematic Rigidbody.
• Only raise the physics rate (Time.fixedDeltaTime) if you really need to; each step costs CPU.

8. UI tips

• When anything on a Canvas changes, Unity rebuilds that Canvas's mesh. Put frequently changing UI (timers, health bars) on a separate Canvas from static UI.
• Untick Raycast Target on images and text that don't need to be clicked.
• Hide UI by disabling the Canvas component or setting a CanvasGroup's alpha to 0, rather than repeatedly calling SetActive on many elements.

9. Logging

Debug.Log is slow and still runs in builds. Remove logs from Update when you're done debugging, or wrap them:

[System.Diagnostics.Conditional("UNITY_EDITOR")]
static void EditorLog(string msg) => Debug.Log(msg); // calls are removed from builds entirely

Quick checklist

1. Profile. Find the actual biggest cost.
2. No Find / GetComponent in Update.
3. No allocations per frame (check the GC Alloc column).
4. Pool anything spawned frequently.
5. Run slow checks on a timer or on events, not every frame.
6. Profile again to confirm it helped.

See also

• Optimization Best Practices (process, profiling, engine settings)
• GPU Instancing & Batching
• Object Pooling
• Better Ways to Do Things
• Debug

This page is a simplified, AI-assisted interpretation. For the complete and authoritative reference, see the official Unity documentation.