Elden Ring for Archipelago

Elden Ring stays vanilla on disk. An apworld defines the randomizer, and an MIT-licensed Rust client runs it. Every meaningful pickup is a check: your finds go to the multiworld, and your items arrive in your inventory during play. Solo runs work the same way.

The pool is not a vanilla shuffle. By default a recipe called curated_filler reallocates every check that would have paid a Rune or junk consumable. Roughly two fifths of that space becomes real weapons, armor, spells, talismans, and Ashes of War. Vanilla items therefore will be missing from the seed by design. This recipe is already active; its weights control the result. See "What fills your junk checks" in Elden-Ring-Archipelago-Player-Guide.md for the full explanation.

Build your yaml at https://peliarch.ca/er/. There is nothing to install. The page explains every option and shows the seed size before generation.

Playing bingo? The bingo goal guide explains automatic tracking, manual objectives and how randomized items change acquisition goals.

Nothing gets patched. The game on disk stays completely vanilla: no edited game files, no regulation.bin changes, and nothing baked per seed. ModEngine3 loads the Rust client DLL. When you connect, it reads the seed layout from the Archipelago server and handles checks, item grants, graces, and region locks at runtime.

This tree ships no game assets and contains no code or data from any other randomizer project. The world is derived from scratch against vanilla game data. PROVENANCE.md has the derivation, the foreign-list rule, and credits.

---

Quick start: playing

The full walkthrough, with what each step should look like, is release/SETUP.md. The short version:

1. Install me3 (Mod Engine 3) with its Windows installer. Do not set anything up inside it.
2. Download the release zip from Releases: the file named ER-Archipelago-v<version>-<date>.zip, not "Source code". Use the same version the host generated with.
3. Extract it (right-click, Extract All..., then Browse...) to a folder of your own, such as C:\Games\ER-Archipelago. Not Program Files, not the game folder.
4. Double-click ap.me3 in the extracted me3\ folder. Windows shows it as just ap. That starts Elden Ring with Archipelago loaded; you will see an Archipelago menu bar over the game. A black me3 console window opens alongside the game; leave it open. 🛑 Launching from Steam, or from the "ELDEN RING (me3)" shortcut the me3 installer creates, starts the game without Archipelago. Always use ap.me3.
5. Connect from the Connection menu: the room's address and its port (shown on the room page), your slot name, and the password if any.
6. Make a new character and play. Your Archipelago saves are kept apart from your normal ones.

Hosting? You also install eldenring.apworld into Archipelago 0.6.7 and generate the seed: SETUP.md, Part 2. Something wrong? release/TROUBLESHOOTING.md is sorted by symptom.

---

How progression works

The world is carved into major regions, 17 in the base game and 28 with the DLC, and each one is sealed behind an Archipelago item called a Region Lock. Limgrave Lock, Caelid Lock, and so on. You start at Roundtable Hold with one region already open. When a region's Lock comes in from the multiworld that region opens, all its graces light up on your map, and you warp in. Walk into a region you don't hold the Lock for and the client warps you back to Roundtable.

The Lock is the only way into a region. Vanilla routes and vanilla key items gate nothing in Archipelago logic. You never need the Rold Medallion to reach the Mountaintops, you never fight Mohg to get into the Land of Shadow. The Lock arrives, the graces light, you warp in.

Two exceptions, and both sit on top of a region's Lock rather than replacing it:

• Raya Lucaria also needs the Academy Glintstone Key, which gets shuffled into the pool like anything else.
• Leyndell also needs Great Runes, 2 by default, echoing the vanilla capital gate. Auto-clamped to whatever's actually reachable that seed.

The options worth knowing about, all documented inline in the shipped release/EldenRing.yaml:

• num_regions: how many regions are in play. 0 is all of them, N > 0 seals the rest off for a shorter run. This is the mode that turns the open world into an actual progression graph.
• ending_condition: great_runes (the default: collect goal_great_runes of them; any distinct Great Runes count, default any four of the seven) or region_locks (no Great Rune requirement). Whether Region Locks are also required to finish is goal_region_unlock_policy (default: not required).
• enable_dlc / dlc_only: bring the 11 Shadow of the Erdtree regions in, or play only those.
• curated_filler: the recipe that spends the junk end of the pool. Ships pre-filled and active -- reweight it, or weight junk to keep whatever each check already paid.
• vanilla_pool: one switch for the whole vanilla item spread. Weighting junk above is only half the job -- it leaves the presence floor standing. This is the lever you want if you came for a vanilla-ish pool.

---

Playing it

Install with the quick start above, or the full release/SETUP.md. Then read the Player Guide for how a run plays. Every option has a comment in release/EldenRing.yaml, and release/KNOWN-ISSUES.md lists the rough edges. If a run is already stuck, release/GETTING-UNSTUCK.md explains the client's built-in rescue console.

You need Elden Ring on PC (Steam). The DLC only matters if you turn on the DLC regions.

One thing worth repeating from the setup guide: the apworld and the client DLL are a hash-matched pair. The client checks a contract hash on connect and will loudly report a mismatched apworld in its log. Install both halves from the same release. release/DISTRIBUTION.md explains why.

---

What is in this repo

• greenfield/eldenring/ -- the apworld source: world logic, options, item/location data (generated from vanilla game data), features, tests. Packaged to eldenring.apworld by build.ps1 -Apworld.
• from-software-archipelago-clients/ -- the runtime client (Rust), the repo's one git submodule. Builds eldenring_archipelago.dll.
• tools/ -- datamining and generation tools, plus gf_test.py (the test harness).
• release/ -- everything player-facing: setup guide, shipped yaml, known issues, attribution, changelog.
• me3/ -- the local ModEngine3 staging dir build.ps1 -Me3Deploy writes.
• greenfield/ (above eldenring/) -- generation inputs, region curation tables, and gen_data.py, which derives the world's data.
• docs/HANDOFF-CHECK-ACCURACY.md -- the state of per-check accuracy, the bar it ships at (sweep-granted means reachable), and every open review queue with instructions for picking it up. Start there if you want to work on checks.

---

Contributor setup (Windows)

Prerequisites: Git, Python 3.12 (what CI runs), the Rust toolchain (the client is a cdylib), PowerShell. No .NET, no Visual Studio, no game unpacking -- the pure-runtime model removed all of that.

1. Clone

git clone --recurse-submodules https://git.peliarch.ca/alaric/er-archipelago-public.git er-archipelago
cd er-archipelago

One submodule: the Rust client. Everything else is this repo.

2. Bootstrap Archipelago

.\Archipelago is a stock upstream checkout you create, not something we version-control:

.\bootstrap-ap.ps1    # clones ArchipelagoMW/Archipelago into .\Archipelago

The version pin lives in .ap-version (currently 0.6.7) and is read by bootstrap-ap.ps1, by CI, and by the test harness, so the version you develop against and the version CI gates on cannot drift. The bootstrap refuses to run against any tree whose origin is not ArchipelagoMW. .\Archipelago is gitignored; the world is installed into it by build.ps1.

elden_ring_artifacts/ (game-derived data the generators read) is gitignored and never distributed. You do not need it to build or test: the committed generated data carries a freshness stamp (tools/gen_manifest.py) that CI and build.ps1 -Apworld verify.

3. Build and run seeds

build.ps1 is the whole pipeline:

.\build.ps1 -All          # the dev loop: -Greenfield + -Rust + -Me3Deploy + -Serve
.\build.ps1 -PureRuntime  # -Generate + -Rust + -Me3Deploy + -Serve (alias: -Mvp)

# individual stages
.\build.ps1 -Greenfield   # regenerate the data-derived apworld (needs elden_ring_artifacts\)
.\build.ps1 -Apworld      # package greenfield\eldenring -> eldenring.apworld (stamp-gated)
.\build.ps1 -Generate     # regenerate the multiworld from Archipelago\Players\*.yaml
.\build.ps1 -Rust         # cargo test + build the client DLL
.\build.ps1 -Me3Deploy    # stage DLL + apconfig + profile into me3\ (the primary loader)
.\build.ps1 -Serve        # launch the AP server on the newest output zip
.\build.ps1 -Preflight    # sanity-check a generated seed

Player yamls for local generation go in Archipelago\Players\; start from release/EldenRing.yaml.

4. Test

python tools/gf_test.py             # the apworld suite
python tools/gf_test.py -k shops    # extra args pass through to pytest

gf_test.py bootstraps its own pinned upstream Archipelago checkout into .ap-test/ (your working .\Archipelago is never touched or consulted), installs the world into it, and runs the suite. It refuses to run against a fork of Archipelago -- testing against the wrong tree produces answers to a different question.

run_ci.ps1 runs every automated gate from CONTRIBUTING.md in one command (unit suite, fill regression, region diversity, generated-data freshness, gen fuzz, the pure Rust crates). CI runs on every push and PR: the suite via gf_test.py, plus a job proving the committed generated data is not stale.

Read CONTRIBUTING.md before opening a PR -- it is the quality bar, and it does not accept "it looks right" as a pass.

---

Elden Ring and Shadow of the Erdtree are property of FromSoftware / Bandai Namco; this is a fan project, not affiliated with or endorsed by them. Code in this repository and the runtime client are MIT-licensed. This project ships no game assets and modifies no game files.