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`).
- Author
- claude-dev-suite ↗
- Repository
- claude-dev-suite ↗
- Licence
- MIT
- Last repository change
- 21.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 21.10.2026, without references to retired models or APIs.
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
- When (and when not)
- Components
- Systems — ISystem (preferred over SystemBase for Burst)
- Querying
- Baking — GameObject → Entity
- Sub Scenes
- Anti-patterns
- Production checklist
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,…