No description
Find a file
Andy Li 7f93b89a59 Add the League of Robot Runners' three large warehouse maps
- extended/2-extension-mapf/lorr/: sortation_large, warehouse_large and
  warehouse_long_corridor_large, from LoRR's Benchmark-Archive at 1adae00
  (src/bench/fetch_lorr.py).  Each holds a plain grid, map/<map>.map, and
  LoRR's own file, original_format.map, with its pickup (S) and delivery (E)
  points.  Each has 75 generated scenarios: 40,000 agents on
  sortation_large, 20,000 on the other two.  Their poi files draw on the
  maps' own points.  scen_selection.txt and scen_manifest.json list them.
- extended/3-practical-mapf/lorr/: their 2.5D sites (tier-3 source lorr,
  converted from LoRR's file), 75 scenarios each at 10,000 agents, with
  exports and pictures.
- core/: the three maps join the warehouse domain, as grids
  (core/grid/warehouse/) and as sites (core/sites/lorr/warehouse/), so core
  has 35 grid maps and 132 sites.
- Tier 2's manifest now records each map's POI count, and the LoRR maps'
  POI source.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Th5rxjKCh5uRe5JGqnZwdF
2026-11-10 23:31:02 +11:00
core
extended
.gitignore
README.md

Benchmark instances

Two folders:

folder holds use it for
core/ 32 MAPF Tracker maps and 3 League of Robot Runners maps with tier 2's scenarios, and 132 2.5D sites the benchmark to report on
extended/ all three tiers, whole scale studies, training data, other subsets

core/ is small enough to run in full, and it covers both halves of the benchmark:

  • core/grid/ holds the maps MAPF Tracker reports results on: tier 1's 33, the MovingAI MAPF benchmark. They come with tier 2's generated scenarios (ext-random, ext-even, ext-poi; 25 files each, up to 40,000 agents, with a solvability bound), not the published ones. That is 32 maps: maze-128-128-1 is a tree, where no multi-agent instance exists, so tier 2 generated none for it. Beside them are the League of Robot Runners' three large warehouse maps, with tier 2's scenarios for them and LoRR's own file.
  • core/sites/ holds 132 tier-3 sites: the same 36 maps as 2.5D sites, and 96 indoor sites, four from each of twelve layout groups. Each site has its 75 scenario files, the seven exported formats and a picture of every representation.

core/ is laid out to be read.

  • MovingAI maps keep their names and are grouped into the seven domains MAPF Tracker and the MAPF benchmark paper use:

    domain maps
    city Berlin_1_256, Boston_0_256, Paris_1_256
    empty empty-8-8, empty-16-16, empty-32-32, empty-48-48
    game Dragon Age: Origins brc202d, den312d, den520d, lak303d, orz900d, ost003d; Dragon Age 2 ht_chantry, ht_mansion_n, lt_gallowstemplar_n, w_woundedcoast
    maze maze-32-32-2, maze-32-32-4, maze-128-128-2, maze-128-128-10 (and, as a site only, maze-128-128-1)
    random random-32-32-10, random-32-32-20, random-64-64-10, random-64-64-20
    room room-32-32-4, room-64-64-8, room-64-64-16
    warehouse warehouse-10-20-10-2-1, warehouse-10-20-10-2-2, warehouse-20-40-10-2-1, warehouse-20-40-10-2-2; and the League of Robot Runners' sortation_large, warehouse_large, warehouse_long_corridor_large (their sites in core/sites/lorr/warehouse/)
  • Indoor sites are grouped by layout group and named <source>-<group>-<rank>, for example houseexpo-M-open-compact-1. Rank 1 is the pick whose cluster holds most of its group (the groups are under Tier 3).

  • Manifests: core/sites/'s manifests are keyed by these names. Each entry gives the site's site key in tier 3 and its group or domain. core/grid/scen_manifest.json gives each map's domain.

extended/ holds the three tiers as they are generated:

tier maps scenarios what it contributes
extended/1-existing-mapf/ 33 1,650 the published MovingAI benchmark (MAPF Tracker's), frozen
extended/2-extension-mapf/ 845 809 upstream + generated the other 809 MovingAI maps' scenarios, 3 League of Robot Runners maps, and every generated ext-* file
extended/3-practical-mapf/ 47,840 sites 75 per site, in its zip 2.5D raster sites

core/ is a copy, never edited. src/bench/tiers.py --sync in the main repository makes it from extended/, and --verify checks it byte for byte.

  • Plain copies: the grid files and the MovingAI sites' zips. Git stores a file and its copy as one object, so these cost nothing in the repository.
  • Renamed copies: an indoor site's zip is the tier-3 zip with its name in place of the source id. That covers the folder, the site file, the scenario, export and picture files, and the three export files that mention the id (export.json, the ROS .yaml, the DIMACS comments). Nothing else changes: the site's metadata and every scenario header still name its source id and hash. These 96 zips cost ~0.13 GB.

A checkout of core/ takes 2.4 GB. src/terrain/tier3.py states what is core and how it is named.

Within extended/, maps are duplicated across tiers; scenarios are not. Every tier carries every map it needs, so a solver pointed at one folder finds its maps there. But each tier holds only the scenarios it contributes. Tier 3's maps are its 2.5D sites, not grids.

Duplicating the maps costs about 250 MB per tier and buys a tree that works on its own. Duplicating the scenarios across tiers would buy nothing: a user who wants tier 1's scenarios has tier 1. So tier 2 does not re-ship tier 1's 1,650 files, and tier 3 does not re-ship tier 2's.

Tier 3 does not carry the grid .map files either. Its 842 MovingAI sites are converted from tier 2's copies, and until 2026-10-24 it kept byte-identical copies of all 842 beside its sites, which bought nothing.

Layout

benchmarks/
  core/
    grid/scen_manifest.json                        tier 2's manifest, for these 35 maps
    grid/<domain>/<map>/map/<map>.map              32 MAPF Tracker maps and 3 LoRR maps, e.g. grid/room/room-64-64-8/
    grid/warehouse/<lorr map>/original_format.map  LoRR's own file, with pickup and delivery points
    grid/<domain>/<map>/ext-random/<map>-ext-random-<i>.scen    25 each, copied from tier 2
    grid/<domain>/<map>/ext-even/  ext-poi/
    sites/site_manifest.json  scen_manifest.json  export_manifest.json    keyed by name
    sites/houseexpo/<group>/houseexpo-<group>-<rank>.zip    48, e.g. houseexpo/M-open-compact/houseexpo-M-open-compact-1.zip
    sites/procthor/<group>/procthor-<group>-<rank>.zip      48
    sites/movingai/<domain>/<map>.zip                       33
    sites/lorr/warehouse/<map>.zip                          3

  extended/
    1-existing-mapf/<map>/map/<map>.map
    1-existing-mapf/<map>/even/<map>-even-<i>.scen
    1-existing-mapf/<map>/random/<map>-random-<i>.scen

    2-extension-mapf/scen_selection.txt            the 60 maps that get generated scenarios
    2-extension-mapf/scen_manifest.json            what was generated for them
    2-extension-mapf/<collection>/<map>/map/
    2-extension-mapf/<collection>/<map>/even/      809 non-canonical maps only
    2-extension-mapf/<collection>/<map>/ext-random/    generated
    2-extension-mapf/<collection>/<map>/ext-even/      generated
    2-extension-mapf/<collection>/<map>/ext-poi/       generated
    2-extension-mapf/lorr/<map>/original_format.map    LoRR's own file (src/bench/fetch_lorr.py)

    3-practical-mapf/site_manifest.json            every site and its content hash
    3-practical-mapf/scen_manifest.json            every site's scenario files
    3-practical-mapf/export_manifest.json          the sites with exports: the 132 core sites
    3-practical-mapf/core_sites.json               the 96 core indoor sites, and why each
    3-practical-mapf/site_features.json            every indoor site's layout features and group
    3-practical-mapf/excluded_sites.json           scenes dropped, and why
    3-practical-mapf/houseexpo/<id>.zip            2.5D raster sites, one zip each
    3-practical-mapf/procthor/<split>-<i>.zip
    3-practical-mapf/movingai/<collection>/<map>.zip
    3-practical-mapf/lorr/<map>.zip

Tier 1 is flat, and core/ groups tier 1's maps by domain; tier 2 and tier 3's MovingAI sites are namespaced by collection. This is not inconsistency for its own sake. Tier 1's 33 map names are unique, and a flat tree is what the MAPF tooling and everyone's habits expect. MovingAI map names, though, collide across collections: AR0011SR is 224×216 in the Baldur's Gate originals and 512×512 in the scaled set. Flattening tiers 2 and 3 would silently drop one of every such pair.

Either way --bench takes a directory holding <map>/map/<map>.map, so --bench benchmarks/extended/1-existing-mapf and --bench benchmarks/extended/2-extension-mapf/dao both work.

Keeping the copies honest

Tier 2 is the tree that is edited, and core/ is rebuilt from extended/.

python3 src/bench/tiers.py --sync      # promote tier 1's scens out of tier 2; rebuild core/
python3 src/bench/tiers.py --verify    # check the invariants

fetch_movingai.py downloads everything into tier 2, including the canonical maps' upstream scenarios, which belong to tier 1. --sync moves those out, but only after confirming tier 1 already holds a byte-identical copy; if they disagree it stops rather than delete. It then rebuilds core/: it copies what is missing or different, and deletes what no longer belongs.

--verify checks:

  • the duplicated maps really are identical across tiers, comparing with line endings normalised, since the same map ships with CRLF in one archive and LF in another;
  • tier 1 holds nothing generated, and tier 2 has not picked tier 1's scenarios back up;
  • every tier-2 map has its tier-3 site;
  • core/ is exactly the copy --sync would make.

Tier 1 — existing MAPF

The published benchmark, frozen: 33 maps × (25 even + 25 random). Other people's results are already reported against these, so they are exactly as MovingAI ships them and nothing is added.

Tier 2 — MAPF extension

collection maps source
dao 156 Dragon Age: Origins
bgmaps 120 Baldur's Gate II, original size
street 90 city / street maps
bg512 75 Baldur's Gate II, scaled to 512×512
sc1 75 StarCraft
random 70 artificial
da2 67 Dragon Age 2
maze 60 artificial
room 40 artificial
wc3maps512 36 Warcraft III, scaled to 512×512
mapf 33 the tier 1 benchmark
weighted 20 weighted terrain
lorr 3 the League of Robot Runners' large warehouse maps, not MovingAI's

809 of the MovingAI maps were never part of the MAPF benchmark, and they ship with one scenario file each against tier 1's fifty. That is why the map count rises 33 → 842 while scenarios only go 1,650 → 2,459. The three lorr maps ship with none of their own; their scenarios are all generated.

Those single files are even scenarios by construction — 10 problems per bucket, bucket == floor(optimal_length / 4), verified — so they are filed under even/ and renamed to the numbering convention.

The League of Robot Runners maps

The lorr collection holds the League of Robot Runners' three large warehouse maps, grid maps that are not part of MovingAI. All are 500 × 140.

  • sortation_large: the sortation map of the 2023 and 2024 main rounds.
  • warehouse_large: their fulfillment-centre map.
  • warehouse_long_corridor_large: the 2026 main round's fulfillment map.

src/bench/fetch_lorr.py in the main repository downloads them from the competition's Benchmark-Archive repository at a pinned commit, and checks each file against its git blob hash.

LoRR's letters differ from MovingAI's: @ and T are obstacles; ., E (a delivery point) and S (a pickup point) are traversable. A MovingAI reader would take S for swamp and not know E, so each map is stored twice:

  • map/<map>.map is a standard grid with every traversable cell .;
  • original_format.map is LoRR's file, byte for byte.

The pickup and delivery points are the maps' points of interest: ext-poi draws on them instead of blobs. They cover 59–74% of the free space, against the 15% that blobs cover elsewhere. All three maps are covered by the solvability bound: N_TECC is their whole free space. sortation_large reaches 40,000 agents, and the two fulfillment maps 20,000.

The archive states no licence, so like the game-derived MovingAI collections their redistribution terms are unaudited.

Generated scenarios

src/gen/scen_gen.py adds three scenario types, 25 files each, to the maps listed in extended/2-extension-mapf/scen_selection.txt. They go in their own folders so nothing upstream is touched and tier 1 stays byte-identical to MovingAI:

2-extension-mapf/<collection>/<map>/even/                upstream, untouched
2-extension-mapf/<collection>/<map>/random/              upstream, untouched
2-extension-mapf/<collection>/<map>/ext-random/<map>-ext-random-<i>.scen
2-extension-mapf/<collection>/<map>/ext-even/  <map>-ext-even-<i>.scen
2-extension-mapf/<collection>/<map>/ext-poi/   <map>-ext-poi-<i>.scen
type how endpoints are chosen
ext-random uniform without replacement over the free space
ext-even an equal floor of agents in every bucket floor(len/4)
ext-poi 15% of the free space is marked as points of interest, and endpoints are drawn with POI weighted 25× — without replacement. On the lorr maps the POI are the maps' own pickup and delivery points instead

To run it, see Generating below.

Which maps, and how many agents

Sixty-three maps carry generated scenarios. Every other map in tier 2 keeps its .map and its upstream .scen; users generate for those with the same code and the same seed, so the result is byte-identical to what would have shipped.

Agent count comes from --agent-bands (default 10000,20000,40000): each map gets the largest band it can hold, and a map too small for the smallest band is generated to full occupancy. That puts 33 maps at 40k, six at 20k, four at 10k, and twenty at their own ceiling.

A map's ceiling is min(largest connected component, N_TECC − 1), where N_TECC counts free cells in a non-trivial 2-edge-connected component. By Theorem 15 of Yu & Rus (WAFR 2012), an instance with fewer agents than that is solvable whatever the start/goal assignment — and since every prefix of a feasible instance is feasible, every prefix of every generated file is provably solvable. It costs almost nothing: N_TECC runs 95–100% of the free space on most of these maps.

Where it does not, the bound is reported rather than applied (--bound-min-ratio, default 0.9), because Theorem 15 is sufficient and not necessary. On a corridor-width-1 maze every free cell is a bridge, so N_TECC is 0 and the bound would say "no agents" rather than "this map is hard". Those maps — maze512-1-0 and maze-128-128-1 — are excluded from the selection outright: they are trees, and not MAPF-able at these agent counts.

Why POI sampling is without replacement

A scenario file is a pool that users truncate to the first k rows, so the property has to hold at every k. Drawing without replacement gives exactly that: early agents come from a pool where POI dominate, and as the prefix grows the POI pool is drawn down, so the tail is whatever is left. Run the first 50 agents and you get heavy congestion around the interest points; run the file to full occupancy and it is a uniform random instance again. With two weight classes the sequential two-pool draw the script uses is exactly equivalent to Efraimidis–Spirakis weighted reservoir sampling, at O(agents) instead of O(free cells · log).

Measured on generated files: 80% of the first 50 agents' endpoints are POI against a 15% base rate, falling to 15% — the base rate exactly — over a file that runs to full occupancy. --verify reports this, so it is checked rather than claimed.

POI are grown as connected blobs around spread-out seeds, not scattered cells: an interest point is a place (a room, a depot, a junction), and scattering 15% of cells uniformly would be indistinguishable from random.

How even scales

MovingAI's even puts 10 agents in each bucket, which self-sizes to about 10 × diameter / 4 — a few thousand agents even on a 1024×1024 map, far short of a 40k band. --even-target band (the default) sets the floor to ceil(target / buckets) instead, keeping the definition while scaling the count. --even-target movingai keeps the upstream 10.

No map supplies that floor everywhere. Extreme buckets are rare by nature — a 256×256 map holds only so many pairs of cells 380 steps apart, and asking for 400 of them with distinct starts and distinct goals runs out. So the fill is two-stage: a flat floor in every bucket, then a top-up distributing the remainder over buckets that still have supply. Every bucket ends with at least the floor, the file reaches the target agent count, and the distribution is as flat as the map permits.

Generated even files are shuffled, not grouped by bucket — matching upstream, and necessary for the prefix-pool semantics, since ordering by distance would make every truncation a short-haul-only instance.

Excluded

The weighted collection (20 maps) is skipped. Its cells are terrain-cost letters A–P rather than free/blocked, so octile length is not its metric: Map1-even-1.scen and Map10-even-1.scen have identical endpoints and different stored lengths.

Terrain

Passable is ., G and S; @, O, T and W are blocked. Not a guess — across every shipped scenario, endpoints land only on those three, and swamp really is used (8,511 of 21,980 endpoints in wc3maps512).

Generating

Sixty-three maps × three types is 189 jobs of 25 files each, and scripts/generate_scenarios.py runs them as 4,725 one-file tasks, one subprocess each, --workers at a time. The first sixty maps' 4,500 took 54 h on 63 cores; the three LoRR maps' 225 took 36 min on 50.

python3 scripts/generate_scenarios.py --plan        # job list and memory, instant
python3 scripts/generate_scenarios.py --dry-run     # size it by generating one file per job
python3 scripts/generate_scenarios.py               # 50 workers, 25 files each
python3 scripts/generate_scenarios.py --workers 63
python3 scripts/generate_scenarios.py --extend 25   # add files 26-50 later
python3 scripts/generate_scenarios.py --verify      # check what was written
python3 src/bench/tiers.py --verify                 # tiers still consistent

Growing the set later. --count N is a target ("make sure N files exist"); --extend N is a delta ("add N more on top of what is there"). Files are independent — each carries its own seed blake2b(seed, map, type, index) — so generating 25 now and 25 more when disk allows produces byte-identical output to a single 50-file run. Verified by diffing the two trees.

Each task is a plain gen.scen_gen call restricted to one map, one type and a range of file numbers, so anything the runner produces can be reproduced by hand:

python3 src/gen/scen_gen.py --maps street/Paris_1_1024 --types poi --count 25
python3 src/gen/scen_gen.py --maps street/Paris_1_1024 --types poi --start-index 7 --count 7

Why one file per task. A job writes its 25 files one after another, so a run of whole jobs can finish no sooner than its slowest job — and a 512×512 maze job is 70–120 core-hours on its own, several times the length of the whole run spread over 64 cores. Splitting by file changes when a file is written, never what is in it (the seed is per file); verified by diffing a one-file-task tree against the single-call output. Per-task setup — loading the map, the N_TECC bound, the even scaffolding — is under ten seconds even on Paris_1_1024, against hours for the file. --files-per-task N groups files if you would rather have fewer processes.

Subprocesses rather than a pool inside one interpreter: a task that dies takes down only itself, the survivors keep going, and the failure is isolated in that task's own log under scen_gen_logs/. A long server run should not lose hours because one task crashed.

Resumable. A task whose output files all exist is skipped without starting a process, and each file is written under a temporary name and renamed into place, so an interrupt never leaves a half-written .scen.

Deterministic. Each file's seed is blake2b(--seed, map, type, index), so output does not depend on the worker count, on scheduling order, or on how many times the run was interrupted. A run on 64 workers produces the same bytes as one on 4.

Memory. Peak RSS per job is about 25 B × grid cells + 500 B × free cells (700 B for even, which also holds a per-cell eccentricity bound) plus the interpreter — measured against Paris_1_1024 at 570 MB, TheFrozenSea 534 MB, maze512-32-0 178 MB, Denver_2_256 52 MB. Agent count barely matters: 476 pairs to 40,008 moved the peak by 5 MB. The heaviest single task is under 600 MB. With one-file tasks the heaviest files can all run at once — the 63 heaviest are all Paris_1_1024, TheFrozenSea and Expedition — so the worst case is 35.5 GB at 63 workers (29.1 GB at 50). The runner prints this estimate for your chosen --workers before it starts.

Cost. About 1,092 core-hours for the full run on an Apple-silicon laptop, 88% of it computing the exact optimal path length behind each of the 110 million rows. That figure does not transfer between machines. On a 64-core AMD EPYC-Milan server the same A* runs about 2.2× slower on an idle machine (8room_000 56 ms/pair against 24, maze512-32-0 243, Paris_1_1024 128), and with 63 workers busy the mazes slow by another 2× (491 ms) while open maps lose only 10% — maze search is memory-bound. An even file also costs 2.6× a random one, measured on Expedition. Together that is about 5,600–5,900 core-hours, or ~90 hours on 63 workers, half of it the five 512×512 mazes. Measure on the target machine before planning around a number. Parallel efficiency is not linear either — 4.0× on 4 workers but 9.5× on 14 on the laptop.

--verify re-runs the exact octile search on a sample of rows in every file and checks distinct starts, distinct goals, start ≠ goal, bucket == floor(len/4), no empty bucket below the last full one, and POI concentration.

The search kernel in src/gen/octile.py is differentially tested against the obvious implementation in src/gen/core.py, and reproduces the optimal lengths stored in the shipped MovingAI files exactly — 60/60 rows on each of mapf, dao, street, sc1 and wc3maps512.

A note on map names

Map names are not unique across collections: 88 of 754 names appear in more than one, and 75 of those are genuinely different maps — every one a bg512 (512×512 rescale) against a bgmaps (original size) pair. AR0011SR is 512×512 in one and 224×216 in the other. The remaining 13 are byte-identical duplicates, the MAPF benchmark reusing maps from dao, da2 and street.

So scen_selection.txt addresses maps as collection/map, and a bare name matching more than one map is a hard error rather than an arbitrary pick.

Tier 3 — practical MAPF

47,840 2.5D raster sites in extended/3-practical-mapf/, in the ground-truth format described in the top-level README.md. 132 of them are also in core/sites/.

source sites core raster from
movingai 842 33 0.25 m (1 m grid cells, 4:1) tier 2's MovingAI maps
lorr 3 3 0.25 m (1 m grid cells, 4:1) tier 2's League of Robot Runners maps
houseexpo 35,107 48 0.05 m HouseExpo floor plans (MIT)
procthor 11,888 48 0.05 m ProcTHOR-10k houses (Apache-2.0)

Core sites. The 33 MovingAI ones are tier 1's maps, the ones MAPF Tracker reports results on, grouped in core/ by its seven domains, and the 3 lorr ones are the League of Robot Runners' warehouses. So core/ has all 36 maps both as grids, with tier 2's scenarios, and as metric sites, and the abstraction error can be measured on maps everyone knows.

A lorr site is converted from LoRR's own file, so its pickup and delivery points become the semantic classes terrain:Pickup and terrain:Delivery. Its poi scenarios draw on them, as tier 2's do for the same maps.

Most HouseExpo and ProcTHOR sites look alike, so core takes 48 from each source, four from each of twelve layout groups. Each group combines size with two axes that vary independently of it. Every feature is measured on the free space of the scenarios' 0.5 m robot.

axis HouseExpo (empty plans, never a loop) ProcTHOR (furnished)
size (free area) S < 50 m², M < 150, L ≥ 150 S < 20 m², M < 70, L ≥ 70
second open: at most one single-lane chokepoint; doors: more noloop; loops: robots can drive round an obstacle of ≥ 1 m²
third compact or elongated (geodesic diameter / √area at 2.0) sparse or cluttered (furniture on 20% of the floor)

Within a group, the four are its k-medoids, so they are typical of the group and spread across it. Each records how many of the group's sites its cluster holds. Each is named <source>-<group>-<rank>, rank 1 holding the most, and sits in core/sites/<source>/<group>/ under that name.

  • core_sites.json lists them, with their names and every parameter that chose them.
  • site_features.json gives every indoor site's features and group, so other subsets can be drawn from it.
  • The main repository's scripts/select_core_sites.py regenerates both byte for byte; src/terrain/site_features.py defines the features.

One folder per site, in one zip per site:

extended/3-practical-mapf/houseexpo/<id>/     (procthor/<split>-<i>/, movingai/<collection>/<map>/)
  <id>.site                     the 2.5D raster: three layers + metadata, one file
  original_format.<ext>         the scene it was converted from, byte for byte
  random/  even/  poi/          25 scenario files each, <id>-<type>-<n>.sscen
  exports/                      the seven derived formats              (core sites)
  viz/                          one picture per representation,
                                and <id>-overview.png of them all      (core sites)

original_format.<ext> is the source's own file, in the source's own format (the name says so: it is not the benchmark's raster): the HouseExpo plan (.json), the ProcTHOR house, i.e. its line of the split (.json), or the MovingAI grid (.map, the same file as tier 2's). It converts back to the site's content_sha256 with src/terrain/to_raster.py.

Every core site ships exports/, the seven abstraction formats, and viz/. viz/ holds a picture of the raster and of each export, plus the overview, a 2 × 4 figure of all eight. Other sites ship neither; the main repository's scripts/export_sites.py --all makes them, the same byte for byte.

<id>.site is a 64-byte header, the metadata as JSON, then the layers as raw little-endian arrays. The main repository's c/mapf_site.h reads it, and the scenario files, in C and C++ (c/README.md has the byte layout), and src/terrain/site_file.py reads it in Python.

Sites ship zipped. Each site's zip holds its whole folder:

tier 3, unpacked tier 3, zipped of which core sites, zipped
site files 76.5 GB 0.24 GB 0.001 GB
original files 0.79 GB 0.11 GB 0.0003 GB
scenario files (3,588,000) 53.1 GB 18.8 GB 0.27 GB
exports (132 core sites) 0.67 GB 0.076 GB 0.076 GB
pictures (132 core sites) 0.18 GB 0.17 GB 0.17 GB
total 131 GB 20.2 GB 0.52 GB (2.2 GB unpacked)

Most of the exports' size is one file: lorr/sortation_large's visibility graph, 4.9 M edges and 196 MB of text, because its floor is 15,620 one-cell pillars that see one another across the aisles.

The layers take 10 bytes per raster cell but are mostly constant planes, so they deflate ~300 to one; the scenarios are numbers in text, ~3 to one, and PNGs barely at all. Git holds only the zips; the unpacked sites are gitignored. After cloning, from the main repository:

python3 scripts/pack_sites.py --unpack --core        # core/sites/ only: seconds, 2.2 GB
python3 scripts/pack_sites.py --unpack               # all of tier 3: ~5 min, ~130 GB
python3 scripts/pack_sites.py --verify               # every zip reproduces its manifest hash

Each zip unpacks into a directory of the same name beside it, exactly the layout scripts/convert_sites.py writes. The zips are reproducible: fixed entry order, timestamps and permissions. So repacking an unchanged site leaves git with nothing to commit.

site_manifest.json lists every site with its content_sha256, so a site converted locally can be checked with to_raster.py --expect-sha256. scen_manifest.json lists each site's scenario files, and export_manifest.json each exported site. core/sites/ has the same three for its 132.

Dropped scenes. 131 scenes (112 ProcTHOR, 19 HouseExpo) were converted and then dropped because fewer than ten 0.5 m robots fit: single-robot search in a confined space rather than MAPF. excluded_sites.json lists each with its capacity and the parameters that decided it, and convert_sites.py skips them unless --include-excluded. The verdict depends on the robot; see scripts/sweep_sites.py.

Refetching

python3 src/bench/fetch_movingai.py --list
python3 src/bench/fetch_movingai.py --all     # downloads into tier 2
python3 src/bench/tiers.py --sync

Nothing is overwritten without --force, and a name collision whose content differs is reported rather than silently resolved.