unity-performance

Unity Performance Rules

Update/FixedUpdate/LateUpdate

Usage Rules

using UnityEngine;

public class PerformanceExample : MonoBehaviour
{
    private Rigidbody _rigidbody;
    
    // ✅ DO: Cache components in Awake/Start
    private void Awake()
    {
        _rigidbody = GetComponent<Rigidbody>();
    }
    
    // ❌ DON'T: Frequent GetComponent calls in Update
    /* 
    private void Update()
    {
        GetComponent<Rigidbody>().AddForce(Vector3.up); // Bad! Expensive call every frame.
    }
    */
    
    private void FixedUpdate()
    {
        // ✅ DO: Physics calculations in FixedUpdate
        _rigidbody.AddForce(Vector3.up);
    }
    
    private void Update()
    {
        // ✅ DO: Input processing and frame-logic in Update
        ProcessInput();
    }
    
    private void LateUpdate()
    {
        // ✅ DO: Camera following logic in LateUpdate (after player moves)
        UpdateCameraPosition();
    }
    
    private void ProcessInput() { /* ... */ }
    private void UpdateCameraPosition() { /* ... */ }
}

Object Pooling (UnityEngine.Pool)

Unity 6.2 Note: Do not write custom Queue-based pools. Use the native UnityEngine.Pool API.

using UnityEngine;
using UnityEngine.Pool;

public class BulletManager : MonoBehaviour
{
    [SerializeField] private Bullet _bulletPrefab;
    
    // Native Unity Pool interface
    private IObjectPool<Bullet> _bulletPool;
    
    private void Awake()
    {
        // Initialize the pool
        _bulletPool = new ObjectPool<Bullet>(
            createFunc: CreateBullet,
            actionOnGet: OnGetBullet,
            actionOnRelease: OnReleaseBullet,
            actionOnDestroy: OnDestroyBullet,
            collectionCheck: true, // Checks for double-return errors (debug only)
            defaultCapacity: 50,
            maxSize: 100
        );
    }

    private Bullet CreateBullet()
    {
        Bullet bullet = Instantiate(_bulletPrefab, transform);
        bullet.SetPool(_bulletPool); // Inject pool reference into the bullet
        return bullet;
    }

    private void OnGetBullet(Bullet bullet) => bullet.gameObject.SetActive(true);
    private void OnReleaseBullet(Bullet bullet) => bullet.gameObject.SetActive(false);
    private void OnDestroyBullet(Bullet bullet) => Destroy(bullet.gameObject);
    
    public void FireBullet(Vector3 position, Vector3 direction)
    {
        Bullet bullet = _bulletPool.Get();
        bullet.transform.position = position;
        bullet.Fire(direction);
    }
}

public class Bullet : MonoBehaviour
{
    private IObjectPool<Bullet> _pool;

    public void SetPool(IObjectPool<Bullet> pool) => _pool = pool;

    public void Fire(Vector3 direction) { /* Physics logic */ }

    private void DisableSelf()
    {
        // ✅ DO: Return to pool instead of Destroy()
        _pool.Release(this);
    }
}