Dimensions & structures · Java · Advanced

How to Find Exact Structure Bounding Boxes (Fortresses, Witch Huts, Monuments) in Chunk NBT

Building high-efficiency mob farms for Wither Skeletons, Witches, or Guardians requires knowing the exact coordinates of a structure's bounding box. Even if the physical blocks of a structure are destroyed or altered by terrain generation, the game uses invisible bounding boxes saved in the chunk data to dictate where structure-specific mobs can spawn. This guide teaches you how to inspect raw chunk NBT data using our browser-based tools to find those exact boundaries without your files ever leaving your computer.

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

What you need

  • A Java Edition world folder or .zip archive
  • The in-game block coordinates (X and Z) of the structure you want to inspect
  • Our browser-based NBT Editor tool
  • A backup copy of your world folder (always back up your world before inspecting or editing raw game files)

Step by step

  1. 1Calculate the Chunk and Region Coordinates

    Load your world in Minecraft, stand inside the structure you want to inspect, and press F3 to note your current block X and Z coordinates. Alternatively, note thechunk and region coordinates directly from the `Chunk:` and `Region:` lines on the F3 debug screen. If calculating manually, divide your block X and Z by 16 and round down (floor) to get the chunk coordinates, then divide the chunk coordinates by 32 and round down to find the region (`r.X.Z.mca`) coordinates.

    Tip: Remember that negative coordinates round down away from zero (for example, -15 divided by 16 is -0.93, which floors to chunk -1).

  2. 2Load the Region File in the NBT Editor

    Go to our site, select the NBT Editor tool, and choose Open world folder or .zip to load your save directly into your browser. For Overworld structures like Witch Huts (`minecraft:swamp_hut`) or Ocean Monuments (`minecraft:monument`), open the `region` folder. For Nether Fortresses (`minecraft:fortress`), open `DIM-1/region`, then locate and click the `r.X.Z.mca` file you identified in Step 1.

    Tip: Because all processing happens locally in your browser, even large region files will open instantly without waiting for an upload.

  3. 3Inspect the Structure References

    Expand the region file in the tree view, locate the specific chunk entry corresponding to your chunk coordinates, and open its NBT tree. Expand the `structures` compound tag (in versions prior to 1.18, this is located inside `Level` -> `Structures`), then open the `References` compound tag. Find the tag named after your target structure (such as `minecraft:fortress`), which contains a 64-bit long integer array pointing to the exact 'origin' chunk where the structure generation began.

    Tip: If the `starts` compound in your current chunk already contains full data for your structure instead of saying `INVALID`, you are already standing in the origin chunk and can skip the bit-unpacking in Step 4.

  4. 4Locate the Structure Origin Chunk

    If your current chunk only contains a value inside `References`, you must move to the structure's origin chunk to read the bounding box. That 64-bit integer packs both the X and Z chunk coordinates of the origin chunk: the lower 32 bits represent the signed chunk X coordinate, and the upper 32 bits represent the signed chunk Z coordinate. Once you decode those two numbers (or simply check the surrounding chunks near the geometric center of the structure), open that origin chunk inside the NBT Editor and expand `structures` -> `starts` -> `<structure_name>`.

    Tip: For small single-piece structures like a `minecraft:swamp_hut`, the origin chunk is almost always the exact chunk the cabin sits in.

  5. 5Read the Outer and Piece Bounding Boxes

    Inside the origin chunk's `starts` entry for your structure, look for the `BB` tag (an IntArray of 6 numbers) which represents the outer bounding box enclosing the entire structure. The six integers are always ordered as `[minX, minY, minZ, maxX, maxY, maxZ]`, defining the exact inclusive block coordinates of the opposite corners.Next, expand the `Children` list tag to see every individual room, corridor, or bridge piece that makes up the structure; each entry in `Children` has its own `BB` tag with the exact coordinates for that specific piece.

    Tip: Write down both the outer `BB` and the individual `Children` `BB` coordinates, as different mob spawning rules depend on whether the game checks the whole structure or specific pieces.

How it works

Minecraft separates structure data into two parts inside chunk NBT: `starts` and `References`. Because a large structure like a Nether Fortress can span across dozens of chunks, saving the entire blueprint in every single chunk would bloat the save file. Instead, the game saves the complete blueprint—including all bounding boxes (`BB`) and structural components (`Children`)—exclusively inside the `starts` tag of the single origin chunk where the structure began generating.

Every other chunk that the structure touches simply gets a lightweight pointer inside its `References` tag. When the game runs the mob spawning cycle in a chunk, it checks the `References` tag, follows the 64-bit coordinate pointer back to the origin chunk's `starts` tag, and checks if the prospective spawn block falls inside the `[minX, minY, minZ, maxX, maxY, maxZ]` values of the `BB` IntArrays.

Understanding the difference between the main `BB` and the `Children` `BB` tags is the secret to advanced farm design. For a Witch Hut (`minecraft:swamp_hut`) or Ocean Monument (`minecraft:monument`), typically only one main bounding box matters. For a Nether Fortress (`minecraft:fortress`), however, Wither Skeletons and Blazes can spawn anywhere within the individual `Children` bounding boxes (such as a specific crossroad or bridge) on ANY valid solid block, OR anywhere inside the much larger outer structure `BB` provided the floor block is explicitly Nether Brick.

Common mistakes

  • Looking only inside the `starts` tag of a random corridor chunk and assuming the structure data is missing because it says `INVALID`; you must locate the origin chunk indicated by `References`.
  • Forgetting that in Minecraft 1.18 (world version 2844) and newer, the `Level` wrapper tag was removed and `Structures` was renamed to lowercase `structures` at the root of the chunk.
  • Confusing the outer structure `BB` with the `Children` piece `BB` when building a Nether Fortress farm, resulting in spawning platforms made of non-Nether-Brick blocks placed outside the `Children` boxes where nothing will spawn.
  • Misinterpreting the 6-number `BB` array order—it is always `[minX, minY, minZ, maxX, maxY, maxZ]`, and the coordinates are inclusive of the boundary blocks themselves.

FAQ

Why does the `starts` tag for my structure just say `id: INVALID`?

An `INVALID` tag inside `starts` simply means the structure did not originate in that specific chunk. Check the `References` tag in that same chunk to verify a structure overlaps it, and then inspect the origin chunk where the structure start actually lives.

How do I manually decode the 64-bit long integer inside the `References` tag?

The 64-bit integer is two signed 32-bit integers combined: `X = (int)(value & 0xFFFFFFFF)` and `Z = (int)(value >> 32)`. If you do not want to do bitwise math, you can look at the nearby chunks in the NBT Editor around the center of the structure until you find the one where `starts` contains the `Children` list.

If I destroy all the blocks of a Witch Hut or Fortress, does the bounding box disappear?

No. The `BB` coordinates are hardcoded into the chunk's NBT data upon world generation. As long as you do not delete or edit those NBT tags, structure mobs will continue to spawn inside those invisible coordinates regardless of what blocks are originally removed.

By inspecting the `structures/References` and `structures/starts` NBT tags of your region files in our NBT Editor, you can extract the exact `[minX, minY, minZ, maxX, maxY, maxZ]` bounding box coordinates for any structure to build pixel-perfect mob farms.

More dimensions & structures guides

Dimensions & structuresHow to View, Trim, or Remove Custom Datapack Dimensions in Your World SaveCustom datapacks and mods often generate their own dimensions, which can bloat your world save size or cause loading errors if the datapack is later removed. This guide shows you how to locate custom dimension namespaces in your Java Edition world folder, inspect their terrain using our browser-based World Map Viewer, and safely trim or delete their region data. Because our tools run locally in your browser, your world files are never uploaded to any server.JavaAdvanced5 steps
Dimensions & structuresHow to Plan Nether Hub Tunnels and Link Portals Using the World Map ViewerBuilding a Nether hub is the fastest way to travel long distances in Minecraft, because every block traveled in the Nether equals eight blocks in the Overworld. However, linking portals across dimensions often goes wrong when lava lakes, huge caverns, or math errors push portals out of alignment. By using our browser-based World Map Viewer, you can preview both dimensions, calculate exact 8:1 coordinates, and plan safe tunnel routes directly from your save files without uploading your world anywhere.Java & BedrockBeginner5 steps
Dimensions & structuresHow to Reset Outer End Cities for Fresh Elytras While Keeping Your Main End IslandOn long-running worlds or multiplayer servers, the End dimension quickly becomes picked clean of Elytras and Shulker shells as players raid every nearby End City. This guide shows you how to reset the outer End islands to regenerate brand-new cities while keeping your central dragon island, Endermen farms, and exit portal completely intact. You can do this safely in your browser using our Chunk Trimmer, which processes your files locally without ever uploading your world.Java & BedrockBeginner5 steps
Dimensions & structuresHow to Reset the Ender Dragon Fight and Regenerate End Exit Gateways in level.datSometimes the Ender Dragon fight in Minecraft Java Edition can glitch, leaving you without a dragon egg, a missing exit portal, or unable to generate the twenty outer End gateways. By editing the DragonFight compound inside your world's level.dat file, you can completely reset the battle state and replenish the gateway generation pool. This guide uses our browser-based level.dat Editor, which processes everything locally on your device so your files are never uploaded.JavaIntermediate5 steps
Dimensions & structuresHow to Reset Trial Chamber Vaults so Players Can Unlock Them AgainIn Minecraft Java Edition, Trial Chamber vaults are designed to only reward each player once by recording their unique ID inside the block itself. If you run a server or want to replay a Trial Chamber in single-player, you can reset these vaults without destroying or replacing the blocks. By using our browser-based NBT Editor, you can safely delete the player memory from specific vaults while keeping your world files completely private on your own computer.JavaAdvanced5 steps