# Who holds the world loaded

> /keystone loaded lists everything that keeps chunks in memory - players, /forceload, FTB Chunks force-loads, mods' chunk loaders, spawns, moving structures - with its owner, when they were last on, its chunks and its share of the tick, and draws it as a map. New in 0.4; it only reads.

Source: https://stygion.eu/docs/keystone/loaded
Updated: 2026-11-16

## Why

A modded server that holds 20 000 chunks with eight people online is not slow because of the eight people. Something else keeps the rest: a forgotten `/forceload`, a team's FTB Chunks force-loads from a base nobody has visited in a month, a chunk loader block, the spawn of every extra dimension, a moving ship. The game knows exactly why it keeps each chunk - it holds a **ticket** for it - but it never tells you. This module reads those tickets and says, for every source, whose it is and what it costs.

## What it shows

Every source that keeps chunks loaded, the heaviest first:

| Kind | What it is | Owner shown |
|---|---|---|
| Player | chunks around somebody online | the player |
| /forceload | vanilla `/forceload` | the claim the chunk stands in, if any |
| FTB force-load | FTB Chunks force-loaded claims | the team, its members, when one was last on, and whether its force-loads stay up offline |
| Chunk loader | any mod that loads chunks through NeoForge's ticket controllers (Create: Power Loader, Mekanism's anchor upgrade, AE2's spatial anchor, ...) | the mod, the block's position, and the claim it stands in |
| Spawn | a dimension's spawn chunks | - |
| Ticket | any other mod's ticket (for example a Sable sub-level while a ship moves) | its id when it has one |
| Short ticket | portals, teleports, ender pearls: gone within seconds or minutes | - |
| Unloading | chunks no ticket keeps any more, waiting to be written and dropped | - |

For each: **chunks** it keeps, how many of them **tick** (block entities and random ticks run there), the **block entities** in its ticking chunks, the owner's **last time online**, and a teleport to it.

**Every kept chunk is counted once.** A ticket keeps its own chunk and, ever weaker, the rings around it - one force-loaded chunk keeps a square of 27 x 27 in memory, 3 x 3 of it ticking. Keystone gives each chunk to the ticket that actually decides it (the strongest one reaching it), so the numbers add up to what the server holds. When a player and a chunk loader reach a chunk equally, it goes to the chunk loader: that is what stays loaded when everybody leaves.

## Commands

Looking needs `keystone.loaded`; letting go needs `keystone.loaded.release` as well.

| Command | What it does |
|---|---|
| `/keystone loaded` | the count and the heaviest sources (`list` in loaded.toml, 10) |
| `/keystone loaded measure [seconds]` | times the tick (default `measure.seconds`, 30) and adds each source's **ms a tick** |
| `/keystone loaded worlds` | chunks kept and ticking per world |
| `/keystone loaded idle` | which owners the idle rule finds |
| `/keystone loaded release <row>` | lets go of one source from the list you saw: only vanilla `/forceload` chunks and FTB Chunks force-loads (the claims stay); needs `keystone.loaded.release` |

**ms a tick** is shared out: the tick is timed per area of 16 x 16 chunks (the profiler's grid), and each area's time is split over the sources by how many of its ticking chunks each holds. Two bases in the same area share it. It is an estimate, as fine as that grid; for which mod's code it was, use [the profiler](/docs/keystone/profiler). A measured run cannot start while a profile or a benchmark is timing the tick.

## The editor

The *Loaded chunks* screen (under Running) has the same table, a **Measure** button and a **cost map**: every kept chunk of one world as a square in the colour of its source, bright where it ticks, with the areas that took the most of the tick framed in orange. Click a chunk or a row to show only that source.

## The idle rule (off by default)

Nothing changes unless you say so.

| Setting (loaded.toml) | Default | What it does |
|---|---|---|
| `idle.days` | 0 (off) | an owner not online for this many days counts as idle |
| `idle.action` | `report` | `report`: idle sources are only marked. `release`: Keystone lets go of their force-loads, once an hour at most, each logged |
| `idle.kinds` | `forceload`, `claims` | which kinds `release` may let go |
| `idle.keep-permission` | `keystone.loaded.keep` | somebody with this permission is never idle |
| `idle.discord-channel` | empty | a Discord channel told about every release |

**Mods' own chunk loaders are never let go**, only reported: the mod believes it holds the chunk, and taking it from under it is how machines break. Ask the owner, or remove the block. FTB Chunks has its own offline rules (`force_load_mode`, and a maximum of idle days before it unforces, in its world config); Keystone's rule works beside them and on vanilla force-loads too.

## The API

| Route | Scope | |
|---|---|---|
| `GET /v1/loaded` | `status.read` | the counts only: chunks kept and ticking, per world and per kind of source (`?fresh=true` for a new count) - no owners, no places |
| `GET /v1/loaded/sources` | `loaded.read` | every source with its owner, last seen, place and teleport (`?fresh=true`, `?limit=`), and the idle ones |
| `GET /v1/loaded/map?world=` | `loaded.read` | one world: x, z, source and level of every kept chunk, the legend, the measured areas |
| `POST /v1/loaded/measure` | `loaded.read` | starts a measured run (`seconds`) |
| `POST /v1/loaded/release` | `operations.run` | lets go of one source (`id` from `GET /v1/loaded/sources`), same limits as the command |

**`loaded.read` is the owner's scope**, like `homes.read`: who keeps chunks loaded and where is where their base is. A moderator's panel link and a narrow key see the counts; only keys issued to the owner see owners and places. In game, looking needs `keystone.loaded` and letting go needs `keystone.loaded.release` on its own.

For addons, `Game.chunkLoads()` in Keystone's API hands over the game's chunks and tickets as they stand.

## What it reads, and what it does not

It reads the game's own chunk holders and tickets in memory, on the server thread, only when asked (a command, the editor, the API, or the hourly idle check when `idle.days` is set). The people behind the sources - names and when they were last on - are read from Keystone's database afterwards, off the server thread, so a count never makes the tick wait on the disk. Nothing leaves the server. On a platform where a part of it cannot be read, it says so once in the log and shows what it can.
