# Archetypes & Chunks

As you look at your entities, you realise that many of them are similar. They even have an **identical structure**.

And this is exactly where **archetypes** come into play. An **archetype** is something **like a table** in a database; it c**ontains all** [**entities**](https://arch-ecs.gitbook.io/arch/documentation/entity) **with exactly the same component structure**. They are part of the [**World**](https://arch-ecs.gitbook.io/arch/documentation/world) and each new combination of entities is stored in a new archetype.

You don't need to worry about creating them, it all happens on its own under the bonnet.

## Archetype

So what have we learnt? **The structure** of an entity **determines** its **archetype**!

<pre class="language-csharp"><code class="lang-csharp"><a data-footnote-ref href="#user-content-fn-1">var dwarf = world.Create(new Dwarf(), new Position(), new Velocity());</a>
<a data-footnote-ref href="#user-content-fn-2">var elf = world.Create(new Elf(), new Position(), new Velocity());</a>
</code></pre>

{% hint style="info" %}
All elves with the same structure are therefore in one archetype. And all dwarves with the same structure in another.
{% endhint %}

Let's look at another example.

```csharp
var dwarf = world.Create(new Dwarf(), new Position(), new Velocity());
var miningDwarf = world.Create(new Dwarf(), new Position(), new Velocity(), new Pickaxe());
```

{% hint style="success" %}
Even though they are both dwarves, they are still in two different archetypes as their structure is different.
{% endhint %}

And now all entities with the same structure cuddle up very close to each other in their archetype, nice... right?

## Chunk

So now you've learnt what an **archetype** is. But what is this **chunk** that was mentioned earlier?

Well, while **archetypes do the grouping**, **chunks** are the place where the **entities** and their **components** are **stored in memory**. This also happens under the bonnet and you don't notice much of it.

Each chunk has exactly **16KB of memory** which is used entirely for entities and their components. This amount of data fits perfectly into an **L1 cache** and is therefore loaded incredibly quickly and efficiently when the entities and components are enumerated.

Another advantage is that **each archetype has N chunks**, so new chunks can be quickly **allocated** for more entities or existing chunks can be **trimmed** to free up memory. The best of the best to keep your world running!

{% hint style="info" %}
The size of the chunks adapts dynamically, the **default** base size is **16KB** but the archetype decides based on the composition of the entities whether larger chunks might make sense. **If too few entities fit into a chunk, all chunks are enlarged to the next largest multiple of the base size.** The base chunk size and the minimum number of entities that fit into each chunk can be adjusted when creating the [`World`](https://arch-ecs.gitbook.io/arch/documentation/world).
{% endhint %}

[^1]: Creates a dwarf entity which is in an archetype containing all entities with exactly the same components.

[^2]: Creates an elf entity which is in a different archetype where all entities have exactly the same components.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://arch-ecs.gitbook.io/arch/documentation/archetypes-and-chunks.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.