Multiworld randomizer

How Archipelago Works

A randomizer shuffles one game. Archipelago shuffles several games at once and hides each player's progression inside the others — so finishing depends on people, not just on your own map.

One seed, built from everyone's worlds

Every player writes a YAML file: which game they play, which options they want. The generator reads all of them, builds each game's world — its locations (every place an item can sit) and its items — then pools every item from every world and deals them back out across every location in the multiworld.

That single deal is the whole idea. Your Hookshot may be sitting in someone else's dungeon, and their sword may be behind your final boss.

player1.yaml Tears of the Kingdom player2.yaml A Link to the Past player3.yaml Hollow Knight Generator places items inside the logic multiworld: every location, filled World 1 2 1 3 1 2 3 World 2 1 3 2 1 3 2 World 3 3 1 2 3 1 2 each box is one location — the digit is the player it belongs to World 1 holds an item owned by player 3 seed + spoiler
Generation happens once, before anyone plays. The digit in each location says who owns the item found there — so most of what you find belongs to somebody else, and most of your own progression is out in other people's games.

Playing: checks go out, items come back

The seed is hosted as a room. Each player connects a client for their own game; the client watches the game for progress and talks to the server over a websocket. Nobody's game talks to anybody else's — everything crosses at the server.

When you clear a location, your client reports that check. The server looks up who owns the item that was placed there and pushes it to that player's client, which grants it inside their game. The server keeps the room's whole state, so anyone can disconnect and pick up later.

Player 2's game clears a location Client 2 watches the game Server holds the room Client 1 grants what arrives Player 1's game item appears flag flipped "location 482 checked" "you received Hookshot" put it in the inventory Room state checks done · items sent · hints chat · hints · DeathLink
The loop is one hop wide. A client only ever knows its own game and the server; the server is what turns your check into someone else's item. Its stored room state is why a seed survives a crash, a reconnect, or a player going to bed.

Why the seed is always finishable

Placement is not random — it is random within the logic. Each world declares how its regions connect and what each connection needs. The generator only ever places an item where the player could already have reached, given the items reachable before it. Items that open new ground are marked as progression; the rest is filler, and can go anywhere.

Great Sky Island reachable with nothing needs Ultrahand Surface shrines, caves, wells needs Paraglider Sky islands and the Depths below a progression item may only be placed behind doors it does not itself open Goal reachable by design
Logic is the contract. Because every placement respects reachability, no seed can lock its own progression behind itself — which is also why an option that changes what a region needs has to be declared to the generator, not just to the game.

What a client has to do for a real console game

The server speaks a game-agnostic protocol; all game-specific work lives in two places. An apworld describes the game at generation time — its items, locations, regions and rules. A client bridges the running game at play time: it must detect that a location was cleared and deliver items into a game that was never designed to receive them.

For Tears of the Kingdom that means a code mod inside the game, which the client drives over a socket: the mod reads the game's own save flags to spot checks, and writes flags or injects pouch items to hand over what the server sent.

Game on emulator save flags, pouch, live memory read / write In-game mod runs inside the game, serves one socket poll · give item Game client detects checks, delivers items websocket Server the other players are behind it the apworld ships both halves: the world definition for generation, the client for play
The bridge is where the work is. Generation only needs a description of the game; playing needs a way in and out of a running one — which is why a new game's port lives or dies on whether checks can be detected and items can be granted.

A detail worth knowing: the client is trusted. It reports its own checks and applies its own items, so a broken bridge does not look like an error — it looks like a game where nothing ever arrives.

The vocabulary

slot
One player's seat in the seed — a game, its options, and its own item and location lists.
location
A place an item can be placed: a chest, a shrine, a boss drop, a quest reward.
check
Clearing a location. It sends the item that was placed there to whoever owns it.
progression
An item the logic depends on. Filler and useful items never gate anything.
hint
Asking the server where an item is. Usually paid for with in-game currency or a budget.
release
Sending out everything left in your world once you finish, so nobody waits on you.
collect
Pulling in every item still owed to you — the other side of release.
DeathLink
Opt-in: when one participant dies, everyone who joined dies too.