Performance & lag · Java · Intermediate

How to Find and Remove Forgotten Force-Loaded Chunks in chunks.dat

Force-loaded chunks stay active in memory even when no players are nearby, which is useful for farms and command setups. However, uninstalled datapacks or forgotten `/forceload` commands often leave hidden chunk tickets behind, causing severe server tick lag and unnecessary memory usage. This guide explains how to locate and remove these forgotten tickets inside your `chunks.dat` files using the browser-based NBT Editor.

Open the NBT EditorOpen and edit any NBT file: level.dat, player data, structures, schematics, Bedrock files.

What you need

  • A Minecraft Java Edition world folder or .zip archive
  • A full backup of your world before editing any files
  • Access to the NBT Editor on world.9minecraft.net

Step by step

  1. 1Back Up Your World and Close Minecraft

    Before modifying internal world data, completely close your Minecraft client or stop your dedicated server. Duplicate your world folder to a safe location on your computer. Because Minecraft caches world state in memory and writes to disk upon closing, editing a live world will result in your changes being overwritten or the file becoming corrupted.

    Tip: Make sure to check all dimensions if you used datapacks that operated in the Nether or the End.

  2. 2Open chunks.dat in the NBT Editor

    Launch the NBT Editor on our site and click to open your world folder or .zip file—everything runs locally in your browser so your files are never uploaded. For the Overworld, navigate to the `data` folder and select `chunks.dat`. If you need to check the Nether, look inside `DIM-1/data/chunks.dat`, or `DIM1/data/chunks.dat` for the End.

    Tip: If `chunks.dat` does not exist in a dimension's `data` folder, that dimension has never had any force-loaded chunks.

  3. 3Inspect the Forced Long Array

    Inside the NBT tree of `chunks.dat`, expand the root `data` compound tag. Look for a Long Array tag named `Forced` (shown with an `[L]` icon). Each entry inside this array represents a single force-loaded chunk, encoded as a 64-bit integer combining its X and Z coordinates.

    Tip: You may also see a `DataVersion` integer tag next to `Forced`; do not modify or delete the `DataVersion` tag.

  4. 4Clear the Forgotten Chunk Tickets

    To remove all force-loaded chunks in that dimension, select the `Forced` array and delete all the individual Long entries inside it, or leave it as an empty Long Array. Removing these entries deletes the persistent chunk tickets, meaning the game will no longer keep those chunks loaded when players leave the area. If you want to remove only specific chunks, you will need to decode the 64-bit integer first, though most administrators prefer to clear the entire list and re-add active farms in-game.

  5. 5Save and Replace the File

    Click the Save button in the NBT Editor to download your modified `chunks.dat` file. Move this downloaded file into your world's corresponding `data` directory, replacing the original `chunks.dat` file. Start your world or server, and run `/forceload query` in the chat to confirm that no unexpected chunks remain active.

How it works

In Minecraft Java Edition, chunks are kept active by a system of 'tickets'. When a player is nearby, the game issues player tickets; when you run `/forceload add`, the game issues a permanent `forced` ticket at ticket level 31 (full entity-processing ticks). To remember these tickets across server restarts, the game writes them to `chunks.dat` inside each dimension's `data` folder.

Instead of storing X and Z chunk coordinates as separate pairs of numbers, the `Forced` tag uses a Long Array (`TAG_Long_Array`) to save space. Each 64-bit Long integer packs two 32-bit signed integers together. The lower 32 bits store the chunk X coordinate, and the upper 32 bits store the chunk Z coordinate (mathematically represented as `(Z << 32) | (X & 0xFFFFFFFFL)`).

When a datapack uses `/forceload` to keep a hidden command block room or custom terrain processor loaded, it appends a Long value to this array. If you simply delete the datapack `.zip` from the `datapacks` folder without running its custom uninstall function, the entry in `chunks.dat` stays there forever, forcing the server to tick those chunks endlessly.

Common mistakes

  • Editing `chunks.dat` while the world is open in singleplayer or while the server is running, which causes Minecraft to overwrite your edited file upon saving.
  • Only checking the root `data/chunks.dat` folder and forgetting to check `DIM-1/data/chunks.dat` (Nether) and `DIM1/data/chunks.dat` (End) where datapacks often hide technical chunks.
  • Deleting the entire `data` compound or `DataVersion` tag inside `chunks.dat` instead of just emptying the `Forced` array, which can cause console errors when the world loads.
  • Placing the downloaded `chunks.dat` file into the world's root folder instead of inside the `data` subfolder.

FAQ

Will deleting entries from chunks.dat delete my builds in those chunks?

No. The `chunks.dat` file only stores the 'tickets' that tell the game to keep chunks active in RAM. Your actual blocks and entities are stored safely in the `region` and `entities` folders.

Why can't I just use `/forceload remove all` in-game?

You can, if the server can start and you know which dimension the chunks are in. However, `/forceload remove all` only clears the dimension you are currently standing in, cannot be run easily if a corrupted force-loaded chunk is crashing the server on startup, and does not work for custom dimensions whose command contexts have been removed.

How can I tell which exact coordinates a 64-bit Long in the Forced array points to?

Because the number is bit-packed, a value like `4294967297` means Chunk X=1, Z=1. To check exact coordinates without doing binary math, load a backup copy of the world and run `/forceload query` in each dimension before clearing the file.

By clearing the `Forced` Long Array inside each dimension's `data/chunks.dat` file using the NBT Editor, you can easily purge forgotten force-loaded chunk tickets and restore your world's performance.

More performance & lag guides

Performance & lagHow to Clean Up Thousands of Unused idcounts, map_X.dat, and raids.dat FilesOver years of gameplay, a Minecraft Java Edition world's data folder can accumulate thousands of orphaned map files and stuck raid trackers that noticeably slow down world saving and bloat backup sizes. Every time a player opens a shipwreck chest or talks to a cartographer, the game generates new map_X.dat files that stay on the disk even if the map item is thrown into lava. This guide shows you how to safely audit and purge unused map files, reset stuck raids.dat entries, and adjust idcounts.dat using our browser-based NBT Editor.JavaIntermediate6 steps
Performance & lagHow to Find Hidden Mob Build-Ups and Entity Hotspots in Your World SaveUnexplained severe lag in a Minecraft Java Edition world is often caused by hundreds of entities crammed into a single area, such as an unmonitored chicken farm or a dark cave where zombies keep picking up dropped items. Since Minecraft stores entity data separately from terrain blocks, you can pinpoint these lag hotspots by inspecting the size and contents of your world's entity files. This guide walks you through using our browser-based NBT Editor to locate and clean up runaway mob build-ups safely without ever uploading your save files.JavaIntermediate6 steps
Performance & lagHow to Locate Chunks With Excessive Hoppers, Chests, and Signs via Chunk NBTMassive storage systems filled with hundreds of hoppers, chests, and signs can easily cripple server TPS and tank client FPS when players wander nearby. By auditing the block_entities lists directly inside your region files, you can pinpoint the exact chunk coordinates of hidden lag machines or overgrown storage silos without ever loading the world in-game. This guide uses our browser-based NBT Editor to safely inspect and prune problematic chunk data entirely on your local device.JavaAdvanced5 steps