5 Unity Systems Built in an Afternoon

Speed is the indie developer's superpower. When you can build a system in an afternoon, you can prototype fearlessly — try ideas, throw them away, start over. When a system takes a week, every experiment feels like a commitment.

TL;DR: Five game systems that take hours in Unity but days in Unreal: (1) a 25-line JSON save/load system, (2) a generic object pool using Queue, (3) a ScriptableObject-based dialogue system, (4) a persistent singleton game manager, and (5) coroutine-powered screen fade transitions. Each includes full, copy-pasteable C# code. The compound time savings across all five can equal a month of development.

Here are five complete game systems, each buildable in Unity in a few hours, that would take significantly longer in Unreal Engine. Each one includes full, copy-pasteable C# code.

1. Save/Load System

Unity's C# makes JSON serialization trivially easy with JsonUtility. No custom serializers, no SaveGame subclasses, no binary formats. Just define your data, serialize it, write it to disk.

  
C# 
[System.Serializable]
public class SaveData
{
    public int level;
    public float health;
    public Vector3 position;
    public List<string> inventory;
}

public static class SaveSystem
{
    private static string Path => Application.persistentDataPath + "/save.json";

    public static void Save(SaveData data)
    {
        string json = JsonUtility.ToJson(data, true);
        System.IO.File.WriteAllText(Path, json);
    }

    public static SaveData Load()
    {
        if (!System.IO.File.Exists(Path)) return new SaveData();
        string json = System.IO.File.ReadAllText(Path);
        return JsonUtility.FromJson<SaveData>(json);
    }
}
 26 lines

That's it. A complete save/load system in 25 lines. In Unreal, you'd need a USaveGame subclass, UGameplayStatics::SaveGameToSlot, proper UPROPERTY serialization, and significantly more boilerplate. Our Save System bundle extends this with multiple slots and auto-save.

2. Object Pool

Object pooling prevents garbage collection spikes from constantly instantiating and destroying objects. Unity makes this clean with generics and queues.

  
C# 
public class ObjectPool : MonoBehaviour
{
    [SerializeField] private GameObject prefab;
    [SerializeField] private int initialSize = 10;
    private Queue<GameObject> pool = new();

    void Start()
    {
        for (int i = 0; i < initialSize; i++)
            AddToPool(Instantiate(prefab, transform));
    }

    public GameObject Get(Vector3 position, Quaternion rotation)
    {
        GameObject obj = pool.Count > 0 ? pool.Dequeue() : Instantiate(prefab, transform);
        obj.transform.SetPositionAndRotation(position, rotation);
        obj.SetActive(true);
        return obj;
    }

    public void Return(GameObject obj)
    {
        obj.SetActive(false);
        pool.Enqueue(obj);
    }

    private void AddToPool(GameObject obj)
    {
        obj.SetActive(false);
        pool.Enqueue(obj);
    }
}
 32 lines

In Unreal, object pooling requires subclassing AActor, managing activation states with SetActorHiddenInGame and SetActorEnableCollision, and dealing with the Actor lifecycle complexities. Grab our production-ready version from the Object Pool script page.

3. Dialogue System

ScriptableObjects make dialogue data trivially easy to author. Define your data, create assets in the editor, and wire them up with a simple UI.

  
C# 
[CreateAssetMenu(menuName = "Game/Dialogue")]
public class DialogueData : ScriptableObject
{
    public string speakerName;
    public Sprite portrait;
    [TextArea(3, 5)]
    public string[] lines;
    public DialogueData nextDialogue;
}

public class DialogueRunner : MonoBehaviour
{
    [SerializeField] private TMPro.TMP_Text nameText;
    [SerializeField] private TMPro.TMP_Text dialogueText;
    private DialogueData current;
    private int lineIndex;

    public void StartDialogue(DialogueData data)
    {
        current = data;
        lineIndex = 0;
        ShowCurrentLine();
    }

    public void Advance()
    {
        lineIndex++;
        if (lineIndex < current.lines.Length)
            ShowCurrentLine();
        else if (current.nextDialogue != null)
            StartDialogue(current.nextDialogue);
        else
            EndDialogue();
    }

    private void ShowCurrentLine()
    {
        nameText.text = current.speakerName;
        dialogueText.text = current.lines[lineIndex];
    }

    private void EndDialogue() => gameObject.SetActive(false);
}
 43 lines

A designer can create dialogue trees in the Unity Inspector without touching code. In Unreal, you'd either use an expensive Marketplace plugin or build a custom Blueprint-based editor — a multi-week effort. See our full Dialogue System with branching choices.

4. Singleton Game Manager

Every game needs a central manager that persists across scenes. Unity's DontDestroyOnLoad pattern makes this a one-time setup.

  
C# 
public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }
    
    public int Score { get; private set; }
    public int HighScore { get; private set; }

    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
        DontDestroyOnLoad(gameObject);
        HighScore = PlayerPrefs.GetInt("HighScore", 0);
    }

    public void AddScore(int points)
    {
        Score += points;
        if (Score > HighScore)
        {
            HighScore = Score;
            PlayerPrefs.SetInt("HighScore", HighScore);
        }
    }

    public void ResetScore() => Score = 0;
}
 31 lines

In Unreal, the equivalent involves UGameInstance subclasses, configuring the project settings to use your custom GameInstance, and working with Unreal's subsystem architecture. Not hard, but not 20 lines either. We have a generic Singleton base class that handles the boilerplate.

5. Screen Transitions

Smooth fade-to-black transitions between scenes are essential polish. Unity's Coroutine system makes this embarrassingly simple.

  
C# 
public class ScreenFader : MonoBehaviour
{
    [SerializeField] private CanvasGroup fadeCanvas;
    [SerializeField] private float fadeDuration = 0.5f;

    public IEnumerator FadeOut()
    {
        fadeCanvas.blocksRaycasts = true;
        float t = 0;
        while (t < fadeDuration)
        {
            t += Time.unscaledDeltaTime;
            fadeCanvas.alpha = t / fadeDuration;
            yield return null;
        }
        fadeCanvas.alpha = 1;
    }

    public IEnumerator FadeIn()
    {
        float t = 0;
        while (t < fadeDuration)
        {
            t += Time.unscaledDeltaTime;
            fadeCanvas.alpha = 1 - (t / fadeDuration);
            yield return null;
        }
        fadeCanvas.alpha = 0;
        fadeCanvas.blocksRaycasts = false;
    }

    public IEnumerator TransitionToScene(string sceneName)
    {
        yield return FadeOut();
        UnityEngine.SceneManagement.SceneManager.LoadScene(sceneName);
        yield return FadeIn();
    }
}
 38 lines

In Unreal, screen transitions involve Level Streaming, loading screens with ULoadingScreenManager, and custom widget animations. It's doable, but it's a full day's work minimum. Our Screen Fader script is ready to drop in.

The Compound Advantage

Each of these systems saved a few hours individually. But the compound effect is transformative. When your save system, pooling, dialogue, game manager, and transitions all take an afternoon total instead of a week each, you've saved a month of development time before you've even started on gameplay.

That's the real Unity advantage for indie devs — not any single feature, but the accumulation of small productivity wins that let you ship games instead of building infrastructure.

All five systems (and 45+ more scripts) are available in our free scripts library. Browse our Essential Utilities collection to see them organized into a starter kit.