Skip to content
Skills Library
Programming · Building & coding

unity-dots

/unity-dots

Unity DOTS — Entities 1.x, Burst-compiled jobs, IJobChunk / IJobEntity, NativeArray / NativeList, SystemBase vs ISystem, baking GameObject to entity, hybrid components. USE WHEN: massive entity counts (RTS, swarms, particles-as-entities), data-oriented refactor of hot simulations, deterministic netcode targets, Burst-friendly math. DO NOT USE FOR: regular GameObject gameplay (use `unity-core`); rendering (DOTS uses Entities Graphics — link from `unity-rendering`); networking with NGO (use `unity-netcode`).

Licence
MIT
Last repository change
21.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Unity DOTS — Entities 1.x, Burst-compiled jobs, IJobChunk / IJobEntity, NativeArray / NativeList, SystemBase vs ISystem, baking GameObject to entity, hybrid components. USE WHEN: massive entity counts (RTS, swarms, particles-as-entities), data-oriented refactor of hot simulations, deterministic netcode targets, Burst-friendly math. DO NOT USE FOR: regular GameObject gameplay (use `unity-core`); rendering (DOTS uses Entities Graphics — link from `unity-rendering`); networking with NGO (use `unity-netcode`).

Original author description

Unity DOTS — Entities 1.x, Burst-compiled jobs, IJobChunk / IJobEntity, NativeArray / NativeList, SystemBase vs ISystem, baking GameObject to entity, hybrid components. USE WHEN: massive entity counts (RTS, swarms, particles-as-entities), data-oriented refactor of hot simulations, deterministic netcode targets, Burst-friendly math. DO NOT USE FOR: regular GameObject gameplay (use `unity-core`); rendering (DOTS uses Entities Graphics — link from `unity-rendering`); networking with NGO (use `unity-netcode`).

How it works

  1. When (and when not)
  2. Components
  3. Systems — ISystem (preferred over SystemBase for Burst)
  4. Querying
  5. Baking — GameObject → Entity
  6. Sub Scenes
  7. Anti-patterns
  8. Production checklist
Original SKILL.md headings · 98 lines, 459 words
SKILL.md preview
---
name: unity-dots
description: |
  Unity DOTS — Entities 1.x, Burst-compiled jobs, IJobChunk / IJobEntity,
  NativeArray / NativeList, SystemBase vs ISystem, baking GameObject to
  entity, hybrid components.

  USE WHEN: massive entity counts (RTS, swarms, particles-as-entities),
  data-oriented refactor of hot simulations, deterministic netcode targets,
  Burst-friendly math.

  DO NOT USE FOR: regular GameObject gameplay (use `unity-core`); rendering
  (DOTS uses Entities Graphics — link from `unity-rendering`); networking
  with NGO (use `unity-netcode`).
allowed-tools: Read, Grep, Glob, Write, Edit
---

# Unity DOTS / ECS (Entities 1.x)

## When (and when not)

DOTS shines with **lots of similar things** doing **lots of similar work**: 10k+ units, particle-as-entity sim, deterministic physics for netcode. For typical character-based gameplay (a player, ~10 enemies, UI) classic GameObjects + MonoBehaviour are simpler and fast enough.

Mixing both: hybrid mode — GameObjects for hero/UI, ECS for swarms.

## Components

```csharp
public struct Position : IComponentData { public float3 Value; }
public struct Velocity : IComponentData { public float3 Value; }
public struct Health   : IComponentData { public float Value; }
public struct Enemy    : IComponentData {} // tag

public struct Inventory : IBufferElementData {     // dynamic buffer
    public Entity Item;
    public int    Count;
}
```

All `IComponentData` are blittable structs (no reference types directly).

## Systems — ISystem (preferred over SystemBase for Burst)

```csharp
[BurstCompile]
public partial struct MoveSystem : ISystem {
    public void OnUpdate(ref SystemState state) {
        float dt = SystemAPI.Time.DeltaTime;
        new MoveJob { DeltaTime = dt }.ScheduleParallel();
    }
}

[BurstCompile]
public partial struct MoveJob : IJobEntity {
    public float DeltaTime;
    void Execute(ref Position pos, in Velocity vel) {
        pos.Value += vel.Value * DeltaTime;
    }
}
```

`partial struct` lets Unity generate the iteration boilerplate at compile time.

## Querying

```csharp
foreach (var (transform, velocity) in
         SystemAPI.Query<RefRW<Position>, RefRO<Velocity>>().WithAll<Enemy>()) {
    transform.ValueRW.Value += velocity.ValueRO.Value * dt;
}
```

`RefRW` = read/write, `RefRO` = read-only (better job scheduling).

## Baking — GameObject → Entity

```csharp
public class EnemyAuthoring : MonoBehaviour {
    public float Speed;
}
public class EnemyBaker : Baker<EnemyAuthoring> {
    public override void Bake(EnemyAuthoring authoring) {
        var e = GetEntity(TransformUsageFlags.Dynamic);
        AddComponent(e, new Velocity { Value = new float3(0, 0, authoring.Speed) });
        AddComponent<Enemy>(e);
    }
}
```

Designers tweak in Inspector; baking turns Authoring components into Entity components at subscene conversion time.

## Sub Scenes

Big static worlds → put in a SubScene asset, baked offline → loaded by streaming. Smaller content/dynamic spawning → spawn at runtime via `EntityManager.CreateEntity`.

## Anti-patterns

| Anti-pattern | Fix |
|---|---|
| Storing Entity references in `class` MonoBehaviour | Use bridge ScriptableObject + lookup, or hybrid component |
| `EntityManager.CreateEntity` per frame from main thread | Use `EntityCommandBuffer.ParallelWriter` from a job |
| Mixing managed types in IComponentData | Use `IComponentData` blittable + companion class component if absolutely needed |
| Forgetting Burst attribute | `[BurstCompile]` on systems & jobs — verify in Burst Inspector |
| Heavy `EntityQuery` per frame | Cache via `state.GetEntityQuery` in OnCreate |

## Production checklist

- [ ] DOTS used only where it beats GameObject perf measurably
- [ ] All hot systems Burst-compiled
- [ ] EntityCommandBuffer used for structural changes
- [ ] SubScenes for static content
- [ ] Authoring components reviewed by designers
- [ ] Determinism verified if ECS feeds netcode

Versions

The database has no other skills named unity-dots.

Database snapshot: 13.11.2026 · package version a27d8c597aee (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100unity-ecs-dots
    Unity 6 ECS/DOTS development guide. Use when working with Entity Component System, data-oriented design, Jobs system, or Burst Compiler. Covers Entities, IComponentData, ISystem, EntityManager, baking, Jobs, and Burst. Based on Unity 6.3 LTS documentation.
  • 100unity-csharp
    Use this skill when the user says 'unity dots', 'unity ecs', 'unity entities', 'ISystem', 'IJobEntity', 'burst compiler', 'unity job system', 'unity c# performance'. Covers Unity Entities (ECS), the C# Job System and Burst plus GC-free C# patterns for Unity gameplay code. Do NOT…
  • 100dots
    Unity DOTS and ECS — systems and jobs, Burst, structural change and EntityCommandBuffer, ComponentLookup aliasing, baking and authoring, and when ECS is the wrong answer. Use when the project has com.unity.entities and the work touches systems, components or jobs.
  • 100unity-ecs-patterns
    Master Unity ECS (Entity Component System) with DOTS, Jobs, and Burst for high-performance game development. Use when building data-oriented games, optimizing performance, or working with large entity counts.
  • 100unity-core
    Unity core scripting fundamentals — MonoBehaviour lifecycle, GameObject / Component model, ScriptableObjects, prefabs, serialization, coroutines, events, and execution order. USE WHEN: writing or refactoring core Unity scripts, designing data flow, setting up ScriptableObjects,…
  • 100unity
    Use this skill when the user says 'unity', 'unity 6', 'monobehaviour', 'URP', 'HDRP', 'addressables', 'unity performance', 'netcode for gameobjects'. Guides Unity projects: player loop, GameObject/component architecture, URP/HDRP, physics, animation, UI, Addressables,…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.