Performance Optimization Techniques in Unity

Performance optimization in games can sometimes be even more challenging and time-consuming than the actual development process. This is why both major game companies and independent developers invest heavily in optimization efforts.

I'll outline several optimization techniques for Unity. However, it's worth noting that I cannot list every possible optimization method—these are skills we develop over time through experience and continuous learning.

1. Resolution Management

Everything visible in your game is processed through the CPU and GPU before being displayed. Each object contributes to performance overhead on both components.

The simplest solution is to remove unnecessary objects, preventing them from creating load on the CPU and GPU. However, if an object is essential, you can reduce its resolution as a Plan B.

2. LOD (Level of Detail)

LOD systems reduce the detail of objects as they move further from the camera. This technique significantly reduces the load on both CPU and GPU.

Benefits of LOD:

• Reduced CPU/GPU load - Less detailed models require less processing
• Memory efficiency - Lower detail models consume less memory
• No perceived quality loss - Distant objects naturally draw less player attention
• Scalable performance - Automatically adjusts to viewing distance

3. Culling Techniques

Culling is based on removing objects that are outside the camera's view. This method is used not only by Unity but by many game engines. It prevents excessive load on both CPU and GPU and reduces unnecessary memory usage.

Types of Culling:

• View Frustum Culling - Hides objects outside camera's view cone
• Occlusion Culling - Hides objects blocked by other objects
• Portal Culling - Room-based visibility management for indoor scenes
• Distance Culling - Hides objects beyond a specified distance

4. Unity GPU Profiler

The Unity GPU Profiler displays your game's graphics processing data. This tool provides game developers with capabilities for identifying, debugging, and improving performance issues.

How to Use the Profiler:

1. Access it through Window → Analysis → Profiler
2. Enable Deep Profile for detailed function-level data
3. Focus on CPU and GPU timings in the hierarchy view
4. Identify bottlenecks in rendering, physics, and scripting
5. Use the GPU Profiler module to analyze draw calls and batching

5. Lighting Optimization

Lighting is personally one of the most challenging and complex elements in games. Well-executed lighting brings incredible visual quality and performance benefits to your game. However, if you lose control, your game's FPS will plummet.

Types of Lighting:

• Ambient Lighting - Base illumination for the entire scene
• Directional Lighting - Simulates sunlight with parallel rays
• Point Lighting - Localized light sources radiating in all directions
• Spot Lighting - Cone-shaped directional lights

Shadows are equally critical as lighting. As I mentioned, lighting and your game are separate worlds unto themselves—invest time in mastering this area.

6. Texture Compression

This method compresses visual data, reducing both file size and the load on CPU and GPU. It's actively used not only in the gaming industry but also in modeling programs.

Compression Formats:

• RLE (Run-Length Encoding) - Simple compression for patterns
• DXT (S3 Texture Compression) - Standard for PC platforms
• ETC (Ericsson Texture Compression) - Optimized for mobile devices
• ASTC (Adaptive Scalable Texture Compression) - Modern, flexible format

7. Asset Bundles

Asset Bundles are used to reduce game size, improve loading times, and make resource management more effective. This method compresses visuals, audio, text, and code to reasonable sizes.

Benefits:

• Reduced initial download size - Essential for mobile games
• Faster loading times - Load only necessary assets
• Easier updates - Update individual bundles without full reinstall
• Memory management - Load and unload assets dynamically

8. Shader Optimization

Simplifying complex shaders can lighten the load on both CPU and GPU. However, like some other methods, this may reduce visual quality, potentially making your game look worse aesthetically.

Shader Optimization Tips:

• Reduce the number of texture samples
• Minimize conditional statements (if/else)
• Use shader LOD to provide simpler variants for distant objects
• Avoid expensive operations like pow() and sin()
• Use mobile-optimized shaders for mobile platforms

9. Code Optimization

The code you write in your games can directly or indirectly affect performance. This is an endless topic, so I'll provide a few examples to give you an idea.

Avoiding Nested Conditionals

❌ Bad - Nested Conditions:

if (a == 1) {
    if (b == "Hello") {
        if (c != null) {
            Debug.Log("Success");
        }
    }
}

✅ Good - Combined Conditions:

if (a == 1 && b == "Hello" && c != null) {
    Debug.Log("Success");
}

This not only improves performance but also enhances code readability.

Efficient Object Finding

Better Alternative:

// ✅ Use tags for better performance
GameObject player = GameObject.FindWithTag("Player");

// ✅ Even better: Cache references
private GameObject player;

void Start() {
    player = GameObject.FindWithTag("Player");
}

Cache Component References

❌ Bad - Repeated GetComponent():

void Update() {
    GetComponent().velocity = Vector3.forward;
    GetComponent().angularVelocity = Vector3.zero;
}

✅ Good - Cached Reference:

private Rigidbody rb;

void Start() {
    rb = GetComponent();
}

void Update() {
    rb.velocity = Vector3.forward;
    rb.angularVelocity = Vector3.zero;
}

Raycast Optimization

Raycast is an element that strains Unity's physics engine. It's beneficial to use it sparingly when possible.

// ❌ Bad - Infinite raycast
if (Physics.Raycast(transform.position, transform.forward)) {
    // ...
}

// ✅ Good - Limited distance raycast
float maxDistance = 100f;
if (Physics.Raycast(transform.position, transform.forward, maxDistance)) {
    // ...
}

// ✅ Even better - Use layer masks
int layerMask = LayerMask.GetMask("Enemy");
if (Physics.Raycast(transform.position, transform.forward, maxDistance, layerMask)) {
    // ...
}

10. Set Priorities

During your game's development, identify the essential features your game needs and which features are extra. This way, you avoid adding unnecessary adjustments or content that strain device performance, and you'll also be more organized during the development process.

11. Collider Optimization

Colliders are components that help us control object collisions. However, unnecessary use of colliders negatively affects performance.

Collider Performance Comparison:

Conclusion

Beyond these techniques, there are many other optimization methods. You can discover them through trial and error or by researching resources on the internet.

Remember: Optimization is an ongoing process, not a one-time task. As you add features and content, continuously monitor and adjust your game's performance.