mc-locate exporter

A tiny client-side Fabric mod that collects the in-game observations mc-locate uses to recover a world's seed and coordinates — Nether bedrock, End pillar heights, and eye-of-ender bearings — and writes them to a JSON file the CLI can import.

It only reads blocks and entities the game has already sent to your own client because you are standing near them. It sends nothing, talks to no server, and never touches other players. See Scope & limits.

Requirements

• Fabric Loader ≥ 0.16
• Fabric API (any build matching your Minecraft version)
• One of the supported Minecraft versions below

Which jar do I download?

One jar is built per Minecraft version. Grab the one matching your game.

The full name is mc-locate-exporter-<mod version>+<mc version>.jar. Loader refuses to load a jar built for the wrong Minecraft version, so you cannot pick the wrong one by accident.

Install

1. Install Fabric Loader for your Minecraft version.
2. Drop Fabric API and the matching mc-locate exporter jar into your mods/ folder.
3. Launch the game.

Commands

All commands are client-side (/mclocate …) and run in single-player or on any server — they only read what your client can already see.

mark accepts: village, desert_pyramid, jungle_temple, swamp_hut, igloo, pillager_outpost, ocean_monument, woodland_mansion, ruined_portal, shipwreck, buried_treasure, fortress, bastion, end_city.

Passive mode — the intended workflow

Bedrock is a filter, not a search: on its own it can't find a seed, it can only strike candidates off a list. The list comes from the End pillars, which pin down 2³² structure seeds from a single reading. So the natural loop is:

1. Visit the End once → /mclocate pillars (or let auto-collect read them).
2. Turn on passive collection: /mclocate auto on.
3. Just play. Flying around the Nether accumulates bedrock as chunks load, quietly narrowing the candidate set. /mclocate status tells you when you likely have enough.
4. /mclocate export.

Passive collection also records eye-of-ender bearings the moment you throw one — taken from the eye entity itself, which is exact where an F3 reading is eyeballed. Those feed the CLI's stronghold triangulation.

Passive bedrock defaults to off (a mod shouldn't start logging your world uninvited); pillar and eye capture default to on. In singleplayer, passive mode also grabs the world seed automatically — the client owns it there.

Your session survives restarts

Everything collected is written continuously to .minecraft/mc-locate/session-current.json and flushed again when you leave the world, then reloaded on the next launch. A crash or a forgotten export no longer throws away an afternoon of collecting. /mclocate clear starts fresh.

About slime chunks

Slime chunks are marked by hand, and that's deliberate. A single slime spawn is not proof a chunk is a slime chunk — swamps spawn them too — and a wrong "yes" eliminates the true seed, the one failure this whole tool is built to avoid. So confirm it yourself (a slime spawning below y=40, away from a swamp) and then /mclocate slime. Use /mclocate slime not for a chunk you're sure is ordinary.

Multiplayer

It works on servers, with one exception. Every command is client-side — Fabric handles /mclocate ... locally and never sends it to the server — and every observation is a block or entity the server already sent your client because you are near it. So collecting bedrock, pillars, and eye bearings, and exporting them, all work on a normal (even vanilla) server. Nothing is sent to the server and no gameplay is changed.

The exception is /mclocate seed: it reads the integrated server's seed, which only exists in singleplayer. On a server there is no seed to read — that is the whole reason to crack one. So the multiplayer flow is: collect here, then crack in the CLI.

Seed cracking is against the rules on many servers (and hardened servers randomise the bits it relies on). Only use it where the server allows it.

Config

Settings live in .minecraft/mc-locate/config.properties, written on first run:

Getting the data into mc-locate

Export files land in .minecraft/mc-locate/observations-<timestamp>.json.

In the CLI:

1. Open mode 13 — Session & Observations.
2. Choose "Load / import observations from a file".
3. Point it at the exported JSON.

The observation file format is the contract between the two — the CLI doesn't care whether a mod, a script, or you by hand wrote it.

Scope & limits

• Client-side only. Reads your own loaded chunks and your own thrown eyes. No packets are forged; no other player is ever referenced.
• No structures via generation. It records structures you stand on with mark, but it does not compute structure positions — that needs the CLI's worldgen backend, which the mod deliberately doesn't ship.
• Server rules. Seed-cracking is against the rules on many servers, and hardened servers randomise the very bits this relies on (Paper's feature-seeds and friends). On those it simply won't converge — by design.
• Not yet tested in a live game. Every version compiles against the real Minecraft API and the JSON round-trips through the CLI's tests, but the in-game behaviour (chunk-load timing, the pillar scan) is unverified. If you hit something, please open an issue.

Building from source

The mod is a Stonecutter project — one codebase, many Minecraft versions.

# build every supported version at once
# (each jar lands in versions/<mc version>/build/libs/)
./gradlew build

# switch the checked-out source to one version, e.g. to work on it in an IDE
./gradlew "Set active project to 1.21.8"

# put the source back in its canonical form before committing
./gradlew "Reset active project"

Requires a JDK able to run Gradle (17+); the per-version compile toolchains (Java 21 for 1.21.x, Java 25 for 26.x) are provisioned automatically.