Unity Devs: Stop Starving Your Frame Rate!

Sat, 13 Jun 2026 11:48:39 +0000

Unity Devs: Stop Starving Your Frame Rate! Embrace Modern Memory Discipline

It’s 2026, and I’m still seeing incredible Unity games marred by avoidable Garbage Collection (GC) spikes, inexplicably dragging frame rates down from silky smooth to stuttering messes. We’ve got powerful tools like Burst, DOTS, and advanced asynchronous patterns at our fingertips, yet many developers are missing the fundamental lesson: memory discipline. Every string concatenation, every List<T> resize without pre-allocation, every casual LINQ query hurts. These small, seemingly innocuous actions accumulate into significant performance bottlenecks as your game scales.

The good news is that modern C# offers powerful, accessible solutions. Span<T>, Memory<T>, and ArrayPool<T> aren’t just for optimization gurus anymore; they’re mandatory for any serious C# game developer aiming for consistent, high frame rates. It’s time to embrace a data-oriented mindset, even within your MonoBehaviour scripts, and stop treating memory as infinite. Your players (and their frame counters) will thank you.

Code Layout & Walkthrough: Taming Allocations

The core problem is the managed heap. When you new up an object or perform an operation that implicitly allocates memory, that memory needs to be tracked. Eventually, the Garbage Collector (GC) steps in to reclaim unused memory. This process, however, is not free; it causes CPU overhead and can pause your game thread, leading to those dreaded frame spikes. Our goal is to minimize these allocations, especially during hot code paths.

1. String Operations: Beyond Basic Concatenation

Strings are often the silent killers of frame rates because they are immutable. Every time you “modify” a string (e.g., concatenation with +), you’re actually creating an entirely new string in memory.

The Problematic Way:

void LogPlayerScore(int playerId, int score) {
    // Each '+' operator creates a new string intermediate
    string log = "Player " + playerId + " scored " + score + " points!"; 
    Debug.Log(log); 
}

The Optimized Way (using StringBuilder):

StringBuilder allows you to construct strings piece by piece without creating intermediate string objects for each part.

using System.Text;

// Use a static/reusable StringBuilder to avoid allocating it repeatedly
private static readonly StringBuilder s_stringBuilder = new StringBuilder();

void LogPlayerScoreOptimized(int playerId, int score) {
    s_stringBuilder.Clear(); // Clear for reuse
    s_stringBuilder.Append("Player ")
                   .Append(playerId)
                   .Append(" scored ")
                   .Append(score)
                   .Append(" points!");
    Debug.Log(s_stringBuilder.ToString()); // One allocation for the final string
}

For advanced scenarios involving parsing or formatting into fixed-size character buffers, Span<char> offers direct, allocation-free memory access.

2. Dynamic Collections & Array Pooling

List<T> is convenient, but frequent new List<T>() calls or implicit resizing (when Capacity is exceeded) are major allocation points. For temporary buffers, ArrayPool<T> is your best friend.

The Problematic Way:

List<Vector3> GetNearbyPositions(Vector3 center, float radius) {
    List<Vector3> positions = new List<Vector3>(); // Allocation
    // ... logic to populate 'positions' ...
    return positions; // Potentially triggers resize allocations during population
}

The Optimized Way (using ArrayPool<T> and Span<T>):

ArrayPool<T> provides a pool of reusable arrays, drastically reducing allocations for temporary collections. Span<T> then gives you a high-performance, allocation-free “view” into that raw array memory.

using System.Buffers;
using UnityEngine; // For Vector3

void ProcessTemporaryVectorData(int count) {
    // Rent a buffer from the shared pool. Avoids allocation if available.
    // 'count' should be the maximum expected size.
    Vector3[] buffer = ArrayPool<Vector3>.Shared.Rent(count); 
    
    // Create a Span<Vector3> as a view over the rented buffer
    Span<Vector3> data = buffer.AsSpan(0, count); 

    // Use 'data' (Span<Vector3>) here; operations are allocation-free
    for (int i = 0; i < data.Length; i++) {
        data[i] = new Vector3(Mathf.Sin(i), Mathf.Cos(i), 0);
    }
    Debug.Log($"Processed {data.Length} vectors. First: {data[0]}");

    // IMPORTANT: Return the buffer to the pool when you're done.
    ArrayPool<Vector3>.Shared.Return(buffer); 
}

The Span<T> allows direct manipulation of the array’s elements without any intermediate copies or allocations.

3. LINQ’s Hidden Costs

LINQ (Language Integrated Query) is expressive, but many extension methods (Where, Select, OrderBy, etc.) implicitly create enumerator objects or even new collections behind the scenes, leading to GC pressure.

The Problematic Way:

using System.Collections.Generic;
using System.Linq; // Requires System.Linq namespace

IEnumerable<GameObject> GetActiveEnemies(List<GameObject> allObjects) {
    // Creates an enumerator object for Where, potentially for ToList()
    return allObjects.Where(obj => obj != null && obj.activeSelf && obj.CompareTag("Enemy"))
                     .ToList(); // Explicitly allocates a new List
}

The Optimized Way (Manual Iteration & Reusable Collections):

For performance-critical code, a good old-fashioned loop is often superior. Even better, pass in a pre-allocated List<T> to store results, effectively eliminating repeat allocations.

using System.Collections.Generic;
using UnityEngine;

// Pass in a 'results' list to be cleared and reused
void GetActiveEnemiesNoAlloc(List<GameObject> allObjects, List<GameObject> results) {
    results.Clear(); // Clear the existing list for reuse

    foreach (var obj in allObjects) {
        if (obj != null && obj.activeSelf && obj.CompareTag("Enemy")) {
            results.Add(obj); // Add to the reusable list
        }
    }
}

Here, results is only allocated once (or whenever its capacity needs expansion), avoiding new List<GameObject>() every frame or every call.

Conclusion

GC spikes are not an inevitable evil; they are often a symptom of insufficient memory discipline. By consciously adopting tools like StringBuilder for string manipulation, leveraging ArrayPool<T> for temporary buffers, and embracing Span<T> and Memory<T> for high-performance memory access, you can drastically reduce your game’s allocation footprint. Combine this with the practice of reusing collections instead of constantly instantiating new ones, and you’ll see tangible improvements.

Embrace this data-oriented mindset. Understand where your memory is going. Stop treating memory as infinite. Your players will experience smoother, more consistent frame rates, and your game will feel significantly more polished. Start integrating these practices into your Unity projects today.

Coder Legion - Recent posts tagged frame

Unity Devs: Stop Starving Your Frame Rate!