# Unity 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.

Source: https://skillsagentes.com/skills/wshobson/agents/unity-ecs-patterns
Repository: https://github.com/wshobson/agents
Author: wshobson
License: MIT
Updated: hace 2 meses
Context cost: 52 tok installed, 517 tok once triggered, 4.1k tok with every bundled file
Bundle: 2 files, 16 KB
Permissions requested: none declared

## Install

```bash
npx -y skills add wshobson/agents --skill unity-ecs-patterns --agent claude-code
```

## What it does

- Aplica patrones de Unity DOTS: Entity Component System, Job System y Burst Compiler
- Guía la conversión de código OOP a arquitectura ECS orientada a datos
- Aporta buenas prácticas de rendimiento: ISystem, ECB para cambios estructurales, gestión de chunks

## Use it when

- Construir juegos Unity de alto rendimiento
- Gestionar miles de entidades de forma eficiente
- Implementar sistemas de juego orientados a datos
- Optimizar lógica de juego limitada por CPU

## What triggers it

- "Ayúdame a convertir este código OOP de Unity a ECS"
- "¿Cómo uso Jobs y Burst para paralelizar mi sistema de movimiento?"
- "Necesito optimizar una simulación con miles de entidades en Unity DOTS"

## Before you install

- Requiere Unity con el paquete DOTS (ECS, Jobs, Burst) instalado.

## Files

- SKILL.md — 2 KB
- references/details.md — 14 KB

## SKILL.md

Reproduced verbatim from wshobson/agents under MIT. This section is the upstream document and is in English.

# Unity ECS Patterns

Production patterns for Unity's Data-Oriented Technology Stack (DOTS) including Entity Component System, Job System, and Burst Compiler.

## When to Use This Skill

- Building high-performance Unity games
- Managing thousands of entities efficiently
- Implementing data-oriented game systems
- Optimizing CPU-bound game logic
- Converting OOP game code to ECS
- Using Jobs and Burst for parallelization

## Core Concepts

### 1. ECS vs OOP

| Aspect      | Traditional OOP   | ECS/DOTS        |
| ----------- | ----------------- | --------------- |
| Data layout | Object-oriented   | Data-oriented   |
| Memory      | Scattered         | Contiguous      |
| Processing  | Per-object        | Batched         |
| Scaling     | Poor with count   | Linear scaling  |
| Best for    | Complex behaviors | Mass simulation |

### 2. DOTS Components

```
Entity: Lightweight ID (no data)
Component: Pure data (no behavior)
System: Logic that processes components
World: Container for entities
Archetype: Unique combination of components
Chunk: Memory block for same-archetype entities
```

## Detailed patterns and worked examples

Detailed pattern documentation lives in `references/details.md`. Read that file when the navigation tier above is insufficient.

## Best Practices

### Do's

- **Use ISystem over SystemBase** - Better performance
- **Burst compile everything** - Massive speedup
- **Batch structural changes** - Use ECB
- **Profile with Profiler** - Identify bottlenecks
- **Use Aspects** - Clean component grouping

### Don'ts

- **Don't use managed types** - Breaks Burst
- **Don't structural change in jobs** - Use ECB
- **Don't over-architect** - Start simple
- **Don't ignore chunk utilization** - Group similar entities
- **Don't forget disposal** - Native collections leak

---

Skills Agentes — https://skillsagentes.com/skills/wshobson/agents/unity-ecs-patterns