How We Reduced Unity Mobile Memory by 35% & Eliminated GC Spikes: An Addressables & ScriptableObject Architecture Guide

Managed Heap Expansion Behavior (Non-Compacting GC)
├── Initial Allocation: [ 24 MB Heap ]
├── Spike Frame (String concats, LINQ in Update): [ 140 MB Heap Expands! ]
└── After GC Sweep: Free memory is fragmented; heap remains at 140 MB!

using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class AddressableSpawner : MonoBehaviour
{
    [SerializeField] private AssetReferenceGameObject enemyPrefabReference;
    private AsyncOperationHandle<GameObject> loadHandle;
    private GameObject spawnedInstance;

    public async Task<GameObject> SpawnEnemyAsync(Vector3 spawnPosition, Quaternion spawnRotation)
    {
        // 1. Asynchronously load asset into memory only when required
        loadHandle = Addressables.LoadAssetAsync<GameObject>(enemyPrefabReference);
        await loadHandle.Task;

        if (loadHandle.Status == AsyncOperationStatus.Succeeded)
        {
            spawnedInstance = Instantiate(loadHandle.Result, spawnPosition, spawnRotation);
            return spawnedInstance;
        }

        Debug.LogError($"[Addressables] Failed to load prefab reference: {enemyPrefabReference}");
        return null;
    }

    public void UnloadAndCleanup()
    {
        // 2. Destroy instance and release memory handle
        if (spawnedInstance != null)
        {
            Destroy(spawnedInstance);
        }

        if (loadHandle.IsValid())
        {
            Addressables.Release(loadHandle);
        }
    }
}

// VoidEventChannelSO.cs - Asset stored in Project Window
using System;
using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName = "NewVoidEventChannel", menuName = "Events/Void Event Channel")]
public class VoidEventChannelSO : ScriptableObject
{
    private readonly List<Action> listeners = new List<Action>();

    public void RaiseEvent()
    {
        for (int i = listeners.Count - 1; i >= 0; i--)
        {
            listeners[i]?.Invoke();
        }
    }

    public void RegisterListener(Action listener)
    {
        if (!listeners.Contains(listener)) listeners.Add(listener);
    }

    public void UnregisterListener(Action listener)
    {
        if (listeners.Contains(listener)) listeners.Remove(listener);
    }
}

// PlayerDeathBroadcaster.cs - Zero GC Allocations
public class PlayerDeathBroadcaster : MonoBehaviour
{
    [SerializeField] private VoidEventChannelSO playerDeathChannel;

    public void KillPlayer()
    {
        // Broadcasts state changes with ZERO heap allocations
        playerDeathChannel.RaiseEvent();
    }
}

using UnityEngine;
using UnityEngine.Pool;

public class ProjectilePool : MonoBehaviour
{
    [SerializeField] private GameObject projectilePrefab;
    private IObjectPool<GameObject> pool;

    private void Awake()
    {
        pool = new ObjectPool<GameObject>(
            createFunc: () => Instantiate(projectilePrefab, transform),
            actionOnGet: (instance) => instance.SetActive(true),
            actionOnRelease: (instance) => instance.SetActive(false),
            actionOnDestroy: (instance) => Destroy(instance),
            collectionCheck: false,
            defaultCapacity: 50,
            maxSize: 200
        );
    }

    public GameObject Spawn(Vector3 position, Quaternion rotation)
    {
        GameObject projectile = pool.Get();
        projectile.transform.SetPositionAndRotation(position, rotation);
        return projectile;
    }

    public void Despawn(GameObject projectile) => pool.Release(projectile);
}