What is Unity DOTS?

Unity DOTS (Data-Oriented Technology Stack) is Unity’s high-performance framework designed to replace traditional object-oriented programming with a data-oriented approach. It allows games to run faster and scale efficiently by optimizing memory usage and leveraging multi-threading.

Why Use DOTS?

• Better Performance: Faster execution by optimizing memory layout.
• Multi-Threading Support: Uses multiple CPU cores effectively.
• Scalability: Handles thousands (or even millions) of entities efficiently.
• Reduced Garbage Collection: Minimizes memory leaks and lag spikes.

Now, let’s break down DOTS into its three core components: Entity Component System (ECS), Jobs System, and Burst Compiler.

Unity DOTS Stack Overview

DOTS consists of three primary components:

1. Entity Component System (ECS): A structured way to manage game objects efficiently.
2. Jobs System: Enables multi-threading to distribute workloads.
3. Burst Compiler: Optimizes performance by converting high-level C# code into highly efficient machine code.

Let’s go through each one in detail, with examples.

1. Entity Component System (ECS): A New Way to Think About Objects

What is ECS?

ECS is a replacement for the traditional GameObject/MonoBehaviour system. Instead of treating game objects as monolithic structures, ECS divides them into three parts:

• Entities: Unique identifiers for game objects (e.g., a player, an enemy, a tree).
• Components: Data that stores properties (e.g., position, health, velocity).
• Systems: Logic that processes entities with specific components (e.g., movement, AI behavior).

How ECS Improves Performance

• Optimized Memory Layout: Stores data in contiguous memory for faster access.
• Cache Efficiency: Allows efficient processing by minimizing CPU cache misses.
• Parallel Processing: Works well with multi-threading to update multiple entities simultaneously.

Example: Moving Entities with ECS

Here’s a basic example of how ECS updates an entity’s position in Unity DOTS:

using Unity.Entities;
using Unity.Mathematics;
using Unity.Transforms;

// Define a Position Component
public struct MoveSpeed : IComponentData
{
    public float Value;
}

// System to Update Entity Movement
public partial struct MoveSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        foreach (var (transform, speed) in SystemAPI.Query<RefRW<LocalTransform>, RefRO<MoveSpeed>>())
        {
            transform.ValueRW.Position += new float3(0, speed.Value * SystemAPI.Time.DeltaTime, 0);
        }
    }
}

Here, we:

1. Define a MoveSpeed component.
2. Create a MoveSystem that updates entity positions based on speed.

2. Jobs System: Unlocking Multi-Threading Without Complexity

What is the Jobs System?

The Jobs System allows you to execute tasks on multiple CPU cores, improving performance for tasks that would traditionally slow down the main thread.

How the Jobs System Works

• Breaks tasks into jobs that run in parallel.
• Reduces workload on the main thread.
• Increases efficiency for tasks like AI calculations, physics, and animation updates.

Example: Multi-Threaded Job for Calculations

using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using UnityEngine;

public class ExampleJobSystem : MonoBehaviour
{
    private void Start()
    {
        JobHandle jobHandle = new ExampleJob { multiplier = 2f }.Schedule();
        jobHandle.Complete();
    }
}

[BurstCompile]
struct ExampleJob : IJob
{
    public float multiplier;
    public void Execute()
    {
        Debug.Log("Job running in parallel with multiplier: " + multiplier);
    }
}

Here:

• We define an ExampleJob that runs on a worker thread.
• The Schedule() method executes the job in parallel.
• The Complete() method ensures the job finishes before continuing.

3. Burst Compiler: Squeezing Every Bit of Performance

What is the Burst Compiler?

The Burst Compiler converts high-level C# code into low-level machine code, making it run significantly faster.

Why is Burst Important?

• Auto-Vectorization: Optimizes CPU instructions for better efficiency.
• Performance Gains: Makes C# code almost as fast as native C++.
• Smaller Overhead: Reduces unnecessary computations.

Example: Optimized Vector Addition with Burst

using Unity.Burst;
using Unity.Collections;
using Unity.Jobs;
using UnityEngine;

public class BurstExample : MonoBehaviour
{
    private void Start()
    {
        NativeArray<float> values = new NativeArray<float>(1000, Allocator.TempJob);
        new MultiplyByTwoJob { Values = values }.Schedule(values.Length, 64).Complete();
        values.Dispose();
    }
}

[BurstCompile]
struct MultiplyByTwoJob : IJobParallelFor
{
    public NativeArray<float> Values;
    public void Execute(int index)
    {
        Values[index] *= 2;
    }
}

Here:

• BurstCompile speeds up execution.
• IJobParallelFor runs operations on multiple threads in parallel.

How DOTS Components Work Together

Imagine you’re making a space battle game where thousands of ships fly, shoot, and explode. DOTS helps:

1. ECS organizes ships efficiently, storing movement and health data optimally.
2. Jobs System parallelizes AI and physics, making sure calculations don’t bottleneck the main thread.
3. Burst Compiler accelerates complex math operations, ensuring smooth frame rates.

When to Use DOTS?

✅ Great for:

• Large-scale games (RTS, open-world, battle royale).
• High-performance simulations (physics-heavy or AI-driven games).
• Games that require extensive optimizations.

❌ Not ideal for:

• Small indie projects that don’t need advanced performance boosts.
• Simple 2D puzzle games or basic mechanics.

Final Thoughts: The Future of Unity DOTS

Unity DOTS is still evolving, but it’s a game-changer for developers looking to push performance boundaries. If you’re making a large-scale, high-performance game, DOTS is worth learning and experimenting with!

Ready to make your game run blazing fast? Start experimenting with Unity DOTS today!