Chunk

A chunk is a 256 block tall 16×16 segment of a Minecraft world. Chunks are the method used by the world generator to divide maps into manageable pieces.

Generation
Chunks are 16 blocks wide, 16 blocks long, and 256 blocks high, which is 65,536 blocks total. Chunks are generated around players when they first enter the world. As they wander around the world, new chunks are generated as needed.

Chunks are generated with the help of the map seed, which means that the chunks are always the same if you would use the same seed again, as long as the map generator and version number remain the same.

Chunk loading
Since Minecraft worlds are "infinite" and contain an extreme amount of chunks, the game only loads certain chunks in order to make the game playable.

Unloaded chunks are unprocessed by the game and do not process any of the game aspects.

Tickets
Loading starts when chunk receives ticket. All loaded chunks originate from ticket.

Each load ticket has 3 properties: Level, Ticket type and (optionally) Time to Live.

Level and load type
Levels are numbers that determine what load type the chunk is.

Load levels range from 22 to 44 in regular gameplay while only 22 to 33 are relevant. Technically, lower load levels than 22 are possible (but not without a modded game). Load levels above 44 are not possible.

For a given chunk, only its lowest-level ticket matters. (Lower levels = higher load type.)

Not all loaded chunks have the same properties and are divided into 4 load types. This excludes unloaded chunks.

Level propagation
Load levels "propagate" or flow from source chunk with ticket to neighboring chunks, but each time it increases its level by 1 until the maximum of 44 is reached.

The chunks that get load level from level expansion activate the assigned load type.

Ticket types
Different ticket types from different sources to activate chunks with different load levels.

Player ticket
Ticket created by player. It has a level of 31 so its propagation can be seen in the table above. And this ticket is given to each chunk that is in the player´s chunk loading distance.


 * Player's chunk loading distance:
 * Player's chunk loading distance is a square.
 * In single-player, "Render Distance" in options affects the side length of a square, side length = Render Distance × 2 + 1.
 * In multiplayer, "view-distance" in server.properties affects the side length of a square, side length = view-distance × 2 + 1.
 * For example, when "Render Distance" is 5 chunks, an area of 11 × 11 is Entity Ticking chunks, and the outskirts of 12 × 12 chunks are Ticking chunks, the outskirts of 13 × 13 chunks are Border chunks.

Forced ticket
Ticket created by using the forceload command. It has level of 31 so its propagation can be seen in the table above.

Chunks remain forceloaded even after closing and opening the game.

Start ticket
Ticket created by the world spawn for the chunk it located at (so called "spawn chunks"). Its position can be changed by a command. It has a level of 22, the lowest in the game. They are active whenever the player is in the overworld and are otherwise permanently active.

Portal ticket
Ticket created when an entity is teleported through nether portal, given to chunk at the other side of the portal. It has a level of 30, so it is stronger than player/forceloaded ticket.

It expires after 300 game ticks (without lag equivalent to 15 seconds). Because they are created each time an entity passes through the portal, it is possible to create "chunk loader" but it can create lag.

Dragon ticket
Ticket created at the start of the battle with ender dragon and is given to the 0,0 chunk (the one with exit portal). It has level of 24.

It expires after no more players participate in the battle or the dragon dies.

Post-teleport ticket
Ticket created when entity is teleported either by going through the end portal and using teleport or spreadplayers commands. For the teleport command, it has level of 32 whereas for the spreadplayers and end portal it has level of 33.

It expires after 5 game ticks.

Temporary ticket
Ticket created when an arbitrary piece of game code calls "getChunk". If the game code says the chunk should be loaded, it places this ticket on that chunk (after possibly creating it).

The load level depends on what kind of chunk the game attempts to load (a fully world-generated chunk or not). It will be at least 33 (border), but in many cases, it could beyond 33, which will involve world-generation in some way.

As an example, when generic mob wandering AI is executing, it asks if a certain block has a solid top surface. As part of that check, that chunk will have an "unknown" ticket with level 33 placed on it.

It expires after 1 game tick.

Light ticket
Unknown, possibly world-generation related.

Limitations

 * Idle timeout
 * Each dimension has its own idle timeout. If there are players or forceloaded chunks in the dimension, the timeout is disabled. When entity leaves or enters this dimension, the timeout is reset.
 * If the timeout reaches 300 game ticks, the dimension will stop processing certain actions. These include entity processing, ender dragon fight will stop and global entities (lightning and weather).


 * Some game aspects don't always get processed in loading chunks because there may be other conditions for their progress, which includes the following:
 * Chunk tick
 * Only chunks with centers within 128 blocks of a player are ticked on every game tick. See also Tick.
 * Entities
 * Hostile mobs instantly despawn if they spawn more than 128 blocks from any player.
 * This includes zombie pigmen at Nether portals and witches in witch huts.
 * Passive mobs do not spawn naturally outside a 240 block X 240 block area around a player.
 * The passive mob spawn cap is limited by the number of friendly mobs loaded into memory, which means that any passive mobs present in the spawn chunks count towards the mob cap and usually prevents friendly mobs from naturally spawning anywhere else in the world. The only exception is when passive mobs spawn as part of a newly generated chunk.
 * See also Spawn.

Exceptions
Events in a chunk may affect blocks in outside chunks. If the outside chunk is inactive the effects are suspended in most cases. Specifically,
 * Block changing on the edge of a ticking chunk can spread updates to blocks outside the ticking chunk and make them respond appropriately. The update may be propagated block by block until outside the border chunks, at which time it will create a temporary ticket to continue propagation.
 * Block in a chunk with a 33-level ticket can request a scheduled tick, but it does not be processed until the chunk gets a ticket on level 32 or below.
 * Flowing water or lava can spread to the first adjacent block outside a ticking chunk, but the flow becomes suspended there until the border chunk has a ticket on a greater level.
 * Fire can spread to the first adjacent flammable block outside the ticking chunk. Like water and lava, it becomes suspended there. It cannot spread further until the outside chunk gets a ticket with a level of 30 or below.
 * Grass and mycelium can spread to the first adjacent block outsider an entity ticking chunk.
 * Pumpkin and melon stems growing on the edge of an entity ticking chunk can place their fruits on an adjacent block outside an entity ticking chunk.
 * An entity (mob, minecart, arrow, etc.) that attempts to move into a ticking chunk from an entity ticking chunk becomes suspended as soon as it leaves the entity ticking chunk. When the ticking chunk gets a ticket on a greater level, the entity resumes moving.
 * Exploding TNT in entity ticking chunk can damage or destroy blocks in a non-entity-ticking chunk.

Bedrock Edition
All game aspects are active in loading chunks, including chunks within the simulation distance of a player and chunks loaded by Commands/tickingarea. Unloaded chunks are unprocessed by the game and do not process any of the game aspects.

Type

 * Player
 * A round-like shape.
 * Chunks within the simulation distance of a player are loading.


 * Command
 * Creats by a command.

Limit

 * Entities
 * Mob spawning is evaluated for every chunk within a 6 chunk cylindrical radius of the player that is loaded.

Exception
Events in a ticking area may affect blocks in outside chunks. If the outside chunk is inactive the effects are suspended in most cases. Specifically,
 * Block changing on the edge of a ticking area can spread updates to blocks outside ticking area and make them respond appropriately.
 * Flowing water or lava can spread to the first adjacent block in an outside chunk, but the flow becomes suspended there until the outside chunk becomes active.
 * Fire can spread to the first adjacent flammable block outside the ticking area. Like water and lava, it becomes suspended there; although visible, its animation does not run and it cannot spread further until the outside chunk becomes active.
 * Grass and mycelium can spread to the first adjacent block in an outside chunk, but the affected block does not actually change its appearance until its chunk becomes active; it then changes instantly. Grass and mycelium cannot spread beyond the first such block, nor from such a block into the ticking area until the outside chunk becomes active.
 * Pumpkin and melon stems growing on the edge of a ticking area can place their fruits on an adjacent block in an outside chunk.
 * An entity (mob, minecart, arrow, etc.) that attempts to move into an outside chunk becomes suspended as soon as it leaves the ticking area. It remains visible but motionless. When the outside block becomes active, the entity resumes moving.
 * Exploding TNT can damage or destroy blocks in an inactive chunk, and unlike other events, its effects are not limited to adjacent blocks. However, secondary effects in the outside chunk are suspended until the chunk becomes active. For instance, if an explosion destroys a block that supported sand or gravel, the sand or gravel does not fall immediately. The same thing happens with items that were attached to destroyed blocks, such as item frames and redstone torches; they do not drop until the chunk is activated.
 * Primed TNT that has been launched into an inactive chunk is suspended in mid-air within the first outside block it enters. It disappears until the outside chunk becomes active, at which time it resumes its flight and countdown.

Finding chunk edges


X and Z coordinates that are divisible by 16 represent the boundaries between chunks. EG: (96, -32) is a corner where four chunks meet. One of those chunks is between X coordinates 80 to 96 and Z coordinates -48 to -32. Another one is between X coordinates 96 to 112 and Z coordinates -32 to -16, and so on. When either X or Z crosses a multiple of 16, the player is moving across chunks.

Essentially, the player is in the top-left corner (north-western) of a chunk when both x and z coordinates are divisible by 16.

Additionally, the player can know the chunk they are on by this formula: The X of a chunk is Floor ( X coordinate / 16 ) The Z of a chunk is Floor ( Z coordinate/ 16 ) Where Floor is the largest previous integer. E.g. Floor( 27.9561 ) is 27 In other words if X was 27, Z was -15 the chunk is chunk ( Floor( 27 / 16 ), Floor( -15 / 16 ) ), meaning that the player is on chunk (1, -1) Also, The player can know how far he is from the north-western corner by this formula: (X or Z coordinate) AND 15

$$, the key can be used to display chunk boundaries. Alternately, pressing the "F3" button opens the Debug screen that shows the player's X, Y, and Z coordinates, in addition to the "chunk" variable. These coordinates change as the player moves around. The player can know the chunk they are in by the variable "chunk".

$$, when toggling fancy graphics, the world renders again, loading only the chunk the player is in for a split second, briefly showing the chunk boundaries. When the player changes the render distance rapidly, chunk barriers appear as a blue line.

Java Edition
Slime chunks are specific chunks capable of spawning slimes below Y=40 regardless of Light. These chunks are otherwise same as all other chunks.

Slime chunks generate throughout the world (except in mushroom islands). 1 in 10 of all chunks is slime chunk. These slime chunks are determined pseudo-randomly by combining their chunk coordinates with the seed of the world: Random rnd = new Random(   seed +    (int) (xPosition * xPosition * 0x4c1906) +    (int) (xPosition * 0x5ac0db) +     (int) (zPosition * zPosition) * 0x4307a7L +    (int) (zPosition * 0x5f24f) ^ 0x3ad8025f ); return rnd.nextInt(10) == 0; That is, using the chunk coordinates to help generate a seed, a random number between 0 and 9 inclusive is generated, and if that number is 0, the chunk can spawn slimes. To convert world coordinates to chunk coordinates, divide by 16 and round down. Note that are 32-bit integers ( int s).

Bedrock Edition
The slime chunk algorithm $$ is different from $$. The algorithm doesn't depend on the world seed, thus the chunks that slimes can naturally spawn in are the same for every world.

Trivia

 * There are a possible fourteen trillion (14,062,500,000,000) real chunks that can be generated. There are 7.46&times;10244,700 possible chunks, excluding entities.
 * If a player stands in a chunk that has not generated yet, the world immediately becomes invisible until they are in a valid chunk. This does not happen if the Y coordinates are beyond the chunk boundaries.
 * $$, if one of the sixteen 16×16×16 sections of a chunk doesn't have any blocks in it, placing a block there shows the same animation as a chunk loading. This bug makes the block that the player placed turn to the same color of the sky in the direction the player is facing for about 1 second and starts fading away into the normal block texture. If the time is sunrise or sunset and the player places a block there, it actually changes colors constantly for 1 second if the player keeps bobbing their head up and down. The block also makes blocks behind it appear invisible.