Loot tables from horizon-data.bin, parsed on first use (#4267)

horizon-prepare writes the prepared folder's data file with the loot
tables as their exported bytes, after parsing each one, and
--verify-data parses every table and compares it with its file. The game
maps it and parses a table when it is first read; a data pack's or
content mod's table still replaces the file's. A missing or stale file
(keyed by each source file's id, size and time) is rebuilt with the same
writer; a folder it can't write parses every table at load as before.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

.github/pull_request_template.md

@@ -4,6 +4,18 @@
 
 <!-- What this changes, and why. Link the issue it fixes ("Fixes #123"). -->
 
+## Kind
+
+<!-- Tick one: it sets the pull request's label (CONTRIBUTING.md "Pull requests"). -->
+
+- [ ] parity: Horizon now does what vanilla 26.3 does
+- [ ] bug: a crash or a breakage
+- [ ] perf: faster, or less memory
+- [ ] feature: something new for players (listed under New in the release notes)
+- [ ] extra: Horizon-only, off by default
+- [ ] tooling: tools, CI, tests, harnesses
+- [ ] docs
+
 ## Vanilla reference
 
 <!-- The vanilla classes and methods this follows (tools/rea_vanilla.py), and the harness that checks it.

.github/workflows/ci.yml

@@ -51,7 +51,7 @@ jobs:
         if: steps.rust.outputs.required != 'false'
         run: |
           sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
-          rustup toolchain install stable --profile minimal --component rustfmt --component clippy --target wasm32-unknown-unknown
+          rustup toolchain install stable --profile minimal --component rustfmt --component clippy
       # Dependencies and the workspace's own build, saved from main's runs (pull requests read main's cache).
       - uses: Swatinem/rust-cache@v2
         if: steps.rust.outputs.required != 'false'
@@ -62,7 +62,6 @@ jobs:
         if: steps.rust.outputs.required != 'false'
         run: |
           cargo +stable fmt --all -- --check
-          # With the game's code mods (on in every release build, off by default).
           cargo +stable clippy --workspace --all-targets -- -D warnings
           # The server build (released as horizon-engine): the game without sound or controllers.
           cargo +stable clippy -p horizon-client --all-targets --no-default-features -- -D warnings
@@ -71,11 +70,11 @@ jobs:
       - name: Test Rust core and voxel kernel correctness
         if: steps.rust.outputs.required != 'false'
         run: |
-          cargo +stable test --workspace --lib --bins --tests --features horizon-mods/pack
+          cargo +stable test --workspace --lib --bins --tests
           # The full content-root tests (#[ignore]d: minutes each on a laptop). The same build as above; they need the
           # prepared vanilla data, so without it they pass at once.
-          cargo +stable test --workspace --lib --features horizon-mods/pack mod_content::tests:: -- --ignored
-          cargo +stable test --workspace --doc --features horizon-mods/pack
+          cargo +stable test --workspace --lib mod_content::tests:: -- --ignored
+          cargo +stable test --workspace --doc
   # The launcher is its own workspace (launcher/Cargo.toml), so verify's cargo runs never build it. A pull request that
   # changes it or a crate it builds is checked here, and so is every push to main: two pull requests can each pass
   # alone and break it together (#2059 and the registry ratings did, 2026-10-26).

.github/workflows/claim-command.yml

@@ -0,0 +1,76 @@
+name: claim command
+# `/claim` and `/unclaim` comments: anyone takes an issue before working on it, and a daily run releases the claims
+# older than 5 days that no open pull request links (CONTRIBUTING.md "Claim before you start",
+# tools/ci/claim_command.py).
+#
+# Why no pull request's code runs here, though the token can write:
+# - `issue_comment` and `schedule` always run this file from main, whoever comments and wherever.
+# - It checks out main's script and list only, never a pull request; it reads threads through the API.
+# - The comment's text and author reach the script as env vars, never in a shell line. The token stays in the step
+#   and can only write issues (assignees, comments, reactions).
+on:
+  issue_comment:
+    types: [created]
+  schedule:
+    - cron: "23 5 * * *"
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  command:
+    # Every other comment skips here, before a runner starts. Pull requests are answered by the script.
+    if: >-
+      github.event_name == 'issue_comment' && github.event.comment.user.type != 'Bot' && (
+      startsWith(github.event.comment.body, '/claim') ||
+      startsWith(github.event.comment.body, '/unclaim') ||
+      startsWith(github.event.comment.body, '🤖 Agent: /claim') ||
+      startsWith(github.event.comment.body, '🤖 Agent: /unclaim'))
+    # One command per issue at a time, so two `/claim`s can't both find it free. On the job, not the workflow:
+    # the skipped runs of ordinary comments must not cancel a waiting one.
+    concurrency:
+      group: claim-${{ github.event.issue.number }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+          persist-credentials: false
+          sparse-checkout: |
+            .github/trusted-reviewers.txt
+            tools/ci/nightly_set.py
+            tools/ci/claim_command.py
+          sparse-checkout-cone-mode: false
+      - name: Run the command
+        env:
+          GH_TOKEN: ${{ github.token }}
+          BODY: ${{ github.event.comment.body }}
+          AUTHOR: ${{ github.event.comment.user.login }}
+          ISSUE: ${{ github.event.issue.number }}
+          COMMENT_ID: ${{ github.event.comment.id }}
+          REPO: ${{ github.repository }}
+        run: python3 tools/ci/claim_command.py command
+  release:
+    if: github.event_name != 'issue_comment' && github.repository == 'horizon-rust/horizon'
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+          persist-credentials: false
+          sparse-checkout: |
+            tools/ci/nightly_set.py
+            tools/ci/claim_command.py
+          sparse-checkout-cone-mode: false
+      - name: Release stale claims
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+        run: python3 tools/ci/claim_command.py release

.github/workflows/overlap-note.yml

@@ -0,0 +1,41 @@
+name: overlap note
+# One comment on a pull request naming the other open pull requests that close the same issue or change the same
+# functions, edited on every push (tools/ci/overlap_note.py, issue #3859).
+#
+# Why no pull request's code runs here, though `pull_request_target` gives a token that can write:
+# - `pull_request_target` runs this file and the script from main, never the pull request's copy.
+# - The checkout is main's (`ref: main`), blobless, with the script alone on disk. The pull requests' heads are fetched
+#   as git objects and only diffed, never checked out; git runs with hooks, fsmonitor, external diff and textconv off.
+# - The rest comes from the API. The token writes the comment only.
+on:
+  pull_request_target:
+    types: [opened, reopened, synchronize, ready_for_review]
+permissions:
+  contents: read
+jobs:
+  note:
+    if: github.event.pull_request.base.ref == 'main'
+    # A newer push replaces the note being computed.
+    concurrency:
+      group: overlap-note-${{ github.event.pull_request.number }}
+      cancel-in-progress: true
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+          fetch-depth: 0
+          filter: blob:none
+          persist-credentials: false
+          sparse-checkout: |
+            tools/ci/overlap_note.py
+          sparse-checkout-cone-mode: false
+      - name: Note
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+        run: python3 tools/ci/overlap_note.py event

.github/workflows/pr-labels.yml

@@ -0,0 +1,36 @@
+name: pr labels
+# A pull request's kind label (the box ticked in the template) and area labels (the paths it changes):
+# tools/ci/pr_labels.py, CONTRIBUTING.md "Pull requests".
+#
+# Why no pull request's code runs here, though `pull_request_target` gives a token that can write to fork PRs:
+# - `pull_request_target` runs this file and the script from main, never the pull request's copy.
+# - It checks out main's script only (`ref: main`), never the pull request's head or merge commit.
+# - The script reads the event file (the description is data in JSON, never in a shell line) and the API's list of
+#   changed file names; it runs, builds and imports nothing of theirs. The token writes labels only.
+on:
+  pull_request_target:
+    types: [opened, reopened, synchronize, edited, ready_for_review]
+permissions:
+  contents: read
+jobs:
+  label:
+    # Title-only edits change nothing: skip them before a runner starts.
+    if: github.event.action != 'edited' || github.event.changes.body != null
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+          persist-credentials: false
+          sparse-checkout: |
+            tools/ci/pr_labels.py
+          sparse-checkout-cone-mode: false
+      - name: Label
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+        run: python3 tools/ci/pr_labels.py event

AGENTS.md

@@ -30,6 +30,8 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
   change), none for a fix. Agents never add `release-now`: the maintainer decides it. Merges ship in batches of 5, or after
   6 hours ([docs/release-flow.md](docs/release-flow.md)).
 - Contributors first: `gh pr list --state open --search <area>` before you start; never duplicate theirs.
+- **Claim before you start**: comment `/claim` on the issue (no issue yet: open one, then claim it). An assigned
+  issue is taken: pick another. `/unclaim` when you stop; a claim with no open PR linking it is released after 5 days.
 
 ## Crates
 
@@ -51,7 +53,7 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 | `horizon-server` | `horizon-server`: `server.toml`, CLI, supervisor of the headless game ([docs/hosting.md](docs/hosting.md)) |
 | `horizon-server-files` | `server.properties`, eula, ops/whitelist/bans, usercache |
 | `horizon-friends`, `horizon-relay` | Play with Friends: invite codes, encrypted tunnel, the relay ([docs/play-with-friends.md](docs/play-with-friends.md)) |
-| `horizon-mods`, `horizon-mod-sdk`, `cargo-horizon-mod` | Sandboxed WebAssembly mods: runtime, SDK + WIT, `cargo horizon-mod` ([docs/mods.md](docs/mods.md)) |
+| `horizon-mods`, `cargo-horizon-mod` | Content mods (`.hmod`: manifest, content fence, no code), the registry index and `.hpack`, and `cargo horizon-mod` (`new`, `build`, `run`, `check`, `registry`) ([docs/mods.md](docs/mods.md)). Code mods are native, built by the launcher ([docs/native-mods.md](docs/native-mods.md)) |
 | `horizon-port-pack` | Porting Java modpacks ([docs/modpacks.md](docs/modpacks.md)) |
 | `horizon-shader-api` | Horizon's own WGSL shader packs ([docs/api/shaders.md](docs/api/shaders.md)): `horizon-shaders.toml`, the `.hshader` package; shared by the game, the launcher and the registry |
 | `horizon-shaders` | Shader packs (the `shaders/` folder format), rebuilt clean-room from a written spec of the format; no wgpu |
@@ -71,7 +73,7 @@ reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` an
 python3 tools/pr_ready.py                  # the self-check: fmt, clippy -D warnings, touched crates' tests, harnesses; paste its block in the PR
 python3 tools/pr_ready.py --quick          # same without harnesses
 cargo test -p horizon-client --lib --bins --tests   # skips the 104 examples (pr_ready does this); `--doc` separately
-cargo test -p horizon-client --features horizon-client/mods --lib mod_content::tests:: -- --ignored   # the 5 slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
+cargo test -p horizon-client --lib mod_content::tests:: -- --ignored   # the 5 slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
 cargo build --profile fast -p horizon-client        # optimized, quick to link: use it to play or run lan_e2e
 python3 tools/parity.py --changed origin/main       # the harnesses your branch can affect (CI's parity job)
 python3 tools/parity.py --changed-files paths.txt --list   # which harnesses cover these files, without running them
@@ -91,9 +93,6 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 - What a change reruns (of 329 harnesses, measured 2026-10-23): a file of the game binary (`game.rs`, `game/`)
   ~25, a file of the client lib ~103, of `horizon-world` ~103–109, of `horizon-core` ~119. Plan for it.
 - Rust integration tests: `crates/horizon-client/tests/` (`lan_bot.rs`, `generation_saves.rs`, `streaming_meshes.rs`).
-- **macOS:** `cargo build/test --workspace` may fail to link the two wasm guest cdylibs (undefined
-  `horizon:mods/events` symbols) until #1446 lands: add `--exclude coords-hud --exclude predator-missile --exclude horizon-mods-test-guest --exclude horizon-mods-test-ui-guest`.
-  Their real check is `cargo test -p horizon-mods` (builds them for `wasm32-unknown-unknown`).
 - Linux needs `libasound2-dev libudev-dev`; `--no-default-features` drops audio and controllers (the server build).
 - Run and drive the game (starts the `horizon-client` beside `horizon-ctl`; other arguments go to the game):
   `target/fast/horizon-ctl --socket $PWD/ctl.sock launch --world W --creative --offscreen --wait --resources $PWD/.local/horizon-client/26.3`,

CONTRIBUTING.md

@@ -74,6 +74,19 @@ including examples. The dependency scope includes optional, platform, build and
 Tests run library, binary, integration and doc tests without building unrelated example executables. Shared Cargo
 configuration and toolchain changes select the whole workspace; CI also keeps its workspace-wide checks.
 
+## Claim before you start
+
+Work is tracked in GitHub issues, and an issue that is assigned is taken (so is one with the `in progress` label:
+claimed on Discord with Kira's `/claim`): pick another, or ask its holder in the thread. Before you start, comment
+**`/claim`** on the issue; you are assigned at once, no role needed. No issue for your work yet? Open one (a line is
+enough), then claim it. `/unclaim` gives it back.
+
+A claim with no open pull request linking the issue (`Fixes #123` in the description, or a draft) is released after
+5 days, with a comment: open a draft early. You can hold 5 open issues at a time. Agents claim the same way.
+
+When your pull request changes the same functions as another open one, or closes the same issue, a bot comment names
+it (edited on every push, never repeated): talk to its author in the thread before you both finish the same work.
+
 ## Pull requests
 
 - **Small.** One change per pull request, under about 500 lines of code where you can; split bigger work into
@@ -82,8 +95,12 @@ configuration and toolchain changes select the whole workspace; CI also keeps it
   can see.
 - **Tick "Allow edits by maintainers".** When something small is left (a lint, a rebase, a nit) we push the fixup
   ourselves instead of sending it back to you; only design questions come back.
-- **Labels** (we set them if you can't): `feature` when players get something new (it appears under "New" in the
-  release notes), `skip-release` when players see no change (tooling, docs, tests), nothing for a fix.
+- **Tick its kind** in the template: `parity` (Horizon now does what vanilla does), `bug` (a crash or breakage),
+  `perf`, `feature` (new for players), `extra` (Horizon-only, off by default), `tooling` or `docs`. A workflow sets
+  that label, and area labels (`launcher`, `mobs`, `worldgen`, `rendering`...) from the paths you change.
+  `label:parity` is the list of real progress toward vanilla.
+- **Release labels** (we set them if you can't): `feature` also puts it under "New" in the release notes,
+  `skip-release` when players see no change (tooling, docs, tests), nothing for a fix.
   `release-now` is for crash fixes that shouldn't wait. pr_ready suggests one.
 
 Who reviews and merges: the Horizon Team, on CI for ordinary pull requests; risky ones (saves, network, world
@@ -102,4 +119,4 @@ new pushes, we add it again.
 ## Talk to us
 
 [Discord](https://discord.gg/HcTeMZxe5E) for questions and ideas, [issues](https://github.com/horizon-rust/horizon/issues)
-for bugs. If you want to take something on, say so in its issue so nobody else starts the same work.
+for bugs. To take something on, `/claim` its issue ([above](#claim-before-you-start)).

Cargo.toml

@@ -23,26 +23,14 @@ members = [
     "crates/horizon-bench",
     "crates/horizon-friends",
     "crates/horizon-relay",
-    "crates/horizon-mod-sdk",
     "crates/horizon-mods",
-    "crates/horizon-mods/tests/guest",
-    "crates/horizon-mods/tests/ui_guest",
     "crates/cargo-horizon-mod",
     "crates/horizon-port-pack",
     "crates/horizon-shaders",
     "crates/horizon-shader-api",
     "crates/horizon-release-sign",
-    "crates/horizon-mod-sdk/examples/coords-hud",
-    "crates/horizon-mod-sdk/examples/predator-missile",
-    "crates/horizon-mod-sdk/examples/welcome",
-    "crates/horizon-mod-sdk/examples/beacons",
-    "mods/official/fps-overlay",
-    "mods/official/keystrokes",
-    "mods/official/far-view",
-    "mods/official/minimap",
-    "mods/official/zoom",
+    "crates/horizon-data-file",
     "xtask",
-    "mods/official/recipes",
 ]
 resolver = "2"
 

README.md

@@ -7,6 +7,7 @@
   <img src="https://img.shields.io/badge/Minecraft-Java%2026.3-5D9C3F" alt="Minecraft Java 26.3">
   <img src="https://img.shields.io/badge/Rust-stable-B7410E?logo=rust&logoColor=white" alt="Rust">
   <img src="https://img.shields.io/badge/vanilla%20parity-100%25-F0795A" alt="Vanilla parity 100%">
+  <a href="#project-status"><img src="https://img.shields.io/badge/player--visible%20gaps-833%20open-F0795A" alt="Player-visible gaps open"></a>
   <img src="https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Windows-2A2470" alt="Linux, macOS and Windows">
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-3B2F7E" alt="MIT license"></a>
 </p>
@@ -48,7 +49,7 @@ The [documentation](https://playhorizon.dev/docs/) covers each of these.
 - **Horizon's own extras:** new menus (vanilla's are one setting away), graphics presets, distant terrain up to 1024 chunks, controller support, optional zoom, minimap and more, all off by default where they would change the vanilla look. See [Settings](https://playhorizon.dev/docs/settings).
 - **Resource packs and data packs:** resource packs work, and data packs load functions, predicates, item modifiers and world generation (vanilla's heights and biomes for now).
 - **Playing with others:** invite friends from the pause menu's Friends button with a code, Open to LAN, and joining servers, online-mode ones with the Microsoft account the launcher signs in with. See [Multiplayer](https://playhorizon.dev/docs/multiplayer).
-- **Mods:** Horizon has its own mods, installed from the launcher. The official ones (Zoom, FPS Counter, Keystrokes and Minimap) are native Rust that the launcher builds into your game, with no Rust to install; older WebAssembly mods still run while they move. Java mod jars do not run in Horizon. See [Mods and data packs](https://playhorizon.dev/docs/mods).
+- **Mods:** content mods add blocks, items and data, and native mods change the game's own Rust code, built by the launcher on your copy, with no Rust to install. Horizon's own (Zoom, FPS Counter, Keystrokes, Minimap, Recipes and Coordinates HUD) are native mods. Java mod jars do not run in Horizon. See [Mods and data packs](https://playhorizon.dev/docs/mods).
 
 Screenshots, captured in the Rust client itself with vanilla assets and no mods or shaders:
 
@@ -127,6 +128,8 @@ It runs rustfmt, clippy with warnings denied, the tests of the crates you touche
 
 ## Project status
 
+**Player-visible gaps: 833 open** of the 833 the [port ledger](tools/port_ledger.py) found, reading every vanilla 26.3 method against Horizon's code: vanilla behaviour a player would notice that Horizon doesn't have yet. By area: Screens, HUD and client packets [197](https://github.com/horizon-rust/horizon/issues/3518); Entity and block rendering, models [129](https://github.com/horizon-rust/horizon/issues/3519); Animals [110](https://github.com/horizon-rust/horizon/issues/3512); Server and players on the server [106](https://github.com/horizon-rust/horizon/issues/3520); Blocks, redstone and fluids [86](https://github.com/horizon-rust/horizon/issues/3516); Entities, projectiles, vehicles and decorations [64](https://github.com/horizon-rust/horizon/issues/3514); Monsters and bosses [53](https://github.com/horizon-rust/horizon/issues/3513); Mob AI, villagers and raids [35](https://github.com/horizon-rust/horizon/issues/3521); World, world generation and saves [32](https://github.com/horizon-rust/horizon/issues/3517); Items, enchantments and inventories [21](https://github.com/horizon-rust/horizon/issues/3515). This number goes down as gaps close (`tools/parity_gaps.py`); the harness results below say that what is tested matches.
+
 The table below is the project's own audit of each subsystem. Every subsystem now matches vanilla in every harness that compares it. 100% means 100% of what the harnesses compare, not proof that nothing else differs. The remaining known differences are listed below.
 
 ### Java parity: 100%

benchmarks/perf/horizon-win-9800x3d-5080-rd16.json

@@ -0,0 +1,773 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-10-29T01:13:01Z",
+ "app": {
+  "name": "horizon-client",
+  "version": "v0.2.97",
+  "commit": null
+ },
+ "hardware": {
+  "os": "windows",
+  "arch": "x86_64",
+  "cpu_threads": 16,
+  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
+  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
+  "ram_mb": 95943,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 5080",
+   "vendor": "nvidia",
+   "driver": "NVIDIA 617.42",
+   "backend": "vulkan",
+   "kind": "discrete"
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 16,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 3158.208,
+   "stdev": 215.77,
+   "min": 3023.046,
+   "max": 3407.049,
+   "ci95": 536.046
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 7170.164,
+   "stdev": 557.958,
+   "min": 6703.242,
+   "max": 7788.08,
+   "ci95": 1386.157
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 1694.647,
+   "stdev": 41.285,
+   "min": 1653.122,
+   "max": 1735.687,
+   "ci95": 102.566
+  },
+  "chunks.village.meshed_count": {
+   "n": 3,
+   "mean": 23544.0,
+   "stdev": 47.127,
+   "min": 23495.0,
+   "max": 23589.0,
+   "ci95": 117.081
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 1711.652,
+   "stdev": 77.412,
+   "min": 1623.403,
+   "max": 1768.093,
+   "ci95": 192.317
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 593.407,
+   "stdev": 32.279,
+   "min": 571.485,
+   "max": 630.473,
+   "ci95": 80.191
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 358.473,
+   "stdev": 27.832,
+   "min": 326.35,
+   "max": 375.353,
+   "ci95": 69.143
+  },
+  "memory.village.gpu_mb": {
+   "n": 3,
+   "mean": 631.813,
+   "stdev": 8.381,
+   "min": 626.803,
+   "max": 641.489,
+   "ci95": 20.822
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 2521.363,
+   "stdev": 291.624,
+   "min": 2336.881,
+   "max": 2857.57,
+   "ci95": 724.493
+  },
+  "chunks.forest.meshed_count": {
+   "n": 3,
+   "mean": 27346.667,
+   "stdev": 57.934,
+   "min": 27306.0,
+   "max": 27413.0,
+   "ci95": 143.927
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 2423.783,
+   "stdev": 55.746,
+   "min": 2386.353,
+   "max": 2487.851,
+   "ci95": 138.493
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 709.165,
+   "stdev": 66.309,
+   "min": 638.666,
+   "max": 770.286,
+   "ci95": 164.734
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 401.039,
+   "stdev": 40.413,
+   "min": 354.472,
+   "max": 426.929,
+   "ci95": 100.399
+  },
+  "memory.forest.gpu_mb": {
+   "n": 3,
+   "mean": 705.008,
+   "stdev": 6.062,
+   "min": 698.466,
+   "max": 710.435,
+   "ci95": 15.06
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 2094.909,
+   "stdev": 521.225,
+   "min": 1758.024,
+   "max": 2695.274,
+   "ci95": 1294.9
+  },
+  "chunks.ocean.meshed_count": {
+   "n": 3,
+   "mean": 24312.667,
+   "stdev": 261.934,
+   "min": 24116.0,
+   "max": 24610.0,
+   "ci95": 650.732
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 2201.125,
+   "stdev": 73.595,
+   "min": 2153.6,
+   "max": 2285.897,
+   "ci95": 182.834
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 553.968,
+   "stdev": 100.955,
+   "min": 445.599,
+   "max": 645.355,
+   "ci95": 250.806
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 325.078,
+   "stdev": 131.154,
+   "min": 177.4,
+   "max": 427.981,
+   "ci95": 325.831
+  },
+  "memory.ocean.gpu_mb": {
+   "n": 3,
+   "mean": 652.944,
+   "stdev": 5.177,
+   "min": 647.51,
+   "max": 657.818,
+   "ci95": 12.862
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 3304.58,
+   "stdev": 134.041,
+   "min": 3155.996,
+   "max": 3416.409,
+   "ci95": 333.003
+  },
+  "chunks.mountain.meshed_count": {
+   "n": 3,
+   "mean": 26591.0,
+   "stdev": 57.472,
+   "min": 26525.0,
+   "max": 26630.0,
+   "ci95": 142.779
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 1961.086,
+   "stdev": 39.725,
+   "min": 1921.241,
+   "max": 2000.69,
+   "ci95": 98.69
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 536.973,
+   "stdev": 38.828,
+   "min": 495.61,
+   "max": 572.635,
+   "ci95": 96.461
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 296.586,
+   "stdev": 30.236,
+   "min": 275.859,
+   "max": 331.281,
+   "ci95": 75.118
+  },
+  "memory.mountain.gpu_mb": {
+   "n": 3,
+   "mean": 896.941,
+   "stdev": 5.177,
+   "min": 891.506,
+   "max": 901.814,
+   "ci95": 12.862
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 1458.578,
+   "stdev": 3.229,
+   "min": 1455.32,
+   "max": 1461.777,
+   "ci95": 8.022
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 1236.28,
+   "stdev": 4.869,
+   "min": 1230.701,
+   "max": 1239.672,
+   "ci95": 12.096
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 21218,
+   "seconds": 12.0,
+   "avg_fps": 1768.093,
+   "low_1pct_fps": 630.473,
+   "low_01pct_fps": 375.353,
+   "p50_ms": 0.537,
+   "p95_ms": 0.846,
+   "p99_ms": 1.222,
+   "p999_ms": 2.081,
+   "max_ms": 6.256,
+   "cpu_p50_ms": 0.38,
+   "gpu_p50_ms": 0.104,
+   "histogram": [
+    20695,
+    499,
+    22,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 19482,
+   "seconds": 12.001,
+   "avg_fps": 1623.403,
+   "low_1pct_fps": 578.262,
+   "low_01pct_fps": 373.717,
+   "p50_ms": 0.586,
+   "p95_ms": 0.95,
+   "p99_ms": 1.357,
+   "p999_ms": 2.158,
+   "max_ms": 7.35,
+   "cpu_p50_ms": 0.445,
+   "gpu_p50_ms": 0.104,
+   "histogram": [
+    18729,
+    713,
+    38,
+    1,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 20922,
+   "seconds": 12.0,
+   "avg_fps": 1743.46,
+   "low_1pct_fps": 571.485,
+   "low_01pct_fps": 326.35,
+   "p50_ms": 0.526,
+   "p95_ms": 0.883,
+   "p99_ms": 1.313,
+   "p999_ms": 2.14,
+   "max_ms": 12.027,
+   "cpu_p50_ms": 0.379,
+   "gpu_p50_ms": 0.104,
+   "histogram": [
+    20308,
+    582,
+    28,
+    2,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 29855,
+   "seconds": 12.0,
+   "avg_fps": 2487.851,
+   "low_1pct_fps": 770.286,
+   "low_01pct_fps": 421.717,
+   "p50_ms": 0.365,
+   "p95_ms": 0.619,
+   "p99_ms": 0.948,
+   "p999_ms": 1.717,
+   "max_ms": 9.446,
+   "cpu_p50_ms": 0.232,
+   "gpu_p50_ms": 0.157,
+   "histogram": [
+    29607,
+    233,
+    13,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 28766,
+   "seconds": 12.0,
+   "avg_fps": 2397.145,
+   "low_1pct_fps": 718.542,
+   "low_01pct_fps": 426.929,
+   "p50_ms": 0.374,
+   "p95_ms": 0.662,
+   "p99_ms": 1.016,
+   "p999_ms": 1.858,
+   "max_ms": 6.379,
+   "cpu_p50_ms": 0.239,
+   "gpu_p50_ms": 0.157,
+   "histogram": [
+    28457,
+    293,
+    14,
+    0,
+    0,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 28637,
+   "seconds": 12.0,
+   "avg_fps": 2386.353,
+   "low_1pct_fps": 638.666,
+   "low_01pct_fps": 354.472,
+   "p50_ms": 0.373,
+   "p95_ms": 0.704,
+   "p99_ms": 1.159,
+   "p999_ms": 1.952,
+   "max_ms": 14.388,
+   "cpu_p50_ms": 0.233,
+   "gpu_p50_ms": 0.157,
+   "histogram": [
+    28198,
+    415,
+    18,
+    5,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 25968,
+   "seconds": 12.001,
+   "avg_fps": 2163.877,
+   "low_1pct_fps": 570.949,
+   "low_01pct_fps": 369.854,
+   "p50_ms": 0.408,
+   "p95_ms": 0.767,
+   "p99_ms": 1.339,
+   "p999_ms": 2.38,
+   "max_ms": 3.329,
+   "cpu_p50_ms": 0.271,
+   "gpu_p50_ms": 0.141,
+   "histogram": [
+    25383,
+    534,
+    47,
+    4,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 25843,
+   "seconds": 12.0,
+   "avg_fps": 2153.6,
+   "low_1pct_fps": 445.599,
+   "low_01pct_fps": 177.4,
+   "p50_ms": 0.413,
+   "p95_ms": 0.725,
+   "p99_ms": 1.309,
+   "p999_ms": 3.451,
+   "max_ms": 12.071,
+   "cpu_p50_ms": 0.275,
+   "gpu_p50_ms": 0.142,
+   "histogram": [
+    25375,
+    373,
+    56,
+    22,
+    1,
+    7,
+    3,
+    5,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 27431,
+   "seconds": 12.0,
+   "avg_fps": 2285.897,
+   "low_1pct_fps": 645.355,
+   "low_01pct_fps": 427.981,
+   "p50_ms": 0.388,
+   "p95_ms": 0.693,
+   "p99_ms": 1.163,
+   "p999_ms": 2.041,
+   "max_ms": 3.068,
+   "cpu_p50_ms": 0.254,
+   "gpu_p50_ms": 0.141,
+   "histogram": [
+    27036,
+    363,
+    31,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 23536,
+   "seconds": 12.0,
+   "avg_fps": 1961.326,
+   "low_1pct_fps": 542.675,
+   "low_01pct_fps": 331.281,
+   "p50_ms": 0.436,
+   "p95_ms": 0.856,
+   "p99_ms": 1.425,
+   "p999_ms": 2.22,
+   "max_ms": 9.458,
+   "cpu_p50_ms": 0.296,
+   "gpu_p50_ms": 0.14,
+   "histogram": [
+    22819,
+    671,
+    40,
+    5,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 23056,
+   "seconds": 12.001,
+   "avg_fps": 1921.241,
+   "low_1pct_fps": 495.61,
+   "low_01pct_fps": 282.617,
+   "p50_ms": 0.44,
+   "p95_ms": 0.911,
+   "p99_ms": 1.516,
+   "p999_ms": 2.543,
+   "max_ms": 14.342,
+   "cpu_p50_ms": 0.299,
+   "gpu_p50_ms": 0.141,
+   "histogram": [
+    22198,
+    783,
+    65,
+    7,
+    0,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 24009,
+   "seconds": 12.0,
+   "avg_fps": 2000.69,
+   "low_1pct_fps": 572.635,
+   "low_01pct_fps": 275.859,
+   "p50_ms": 0.436,
+   "p95_ms": 0.819,
+   "p99_ms": 1.274,
+   "p999_ms": 2.085,
+   "max_ms": 14.003,
+   "cpu_p50_ms": 0.297,
+   "gpu_p50_ms": 0.14,
+   "histogram": [
+    23421,
+    560,
+    22,
+    0,
+    1,
+    0,
+    2,
+    2,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "horizon-win-9800x3d-5080"
+}

benchmarks/perf/horizon-win-9800x3d-5080-rd32.json

@@ -0,0 +1,773 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-10-29T18:55:59Z",
+ "app": {
+  "name": "horizon-client",
+  "version": "v0.2.97",
+  "commit": null
+ },
+ "hardware": {
+  "os": "windows",
+  "arch": "x86_64",
+  "cpu_threads": 16,
+  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
+  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
+  "ram_mb": 95943,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 5080",
+   "vendor": "nvidia",
+   "driver": "NVIDIA 617.42",
+   "backend": "vulkan",
+   "kind": "discrete"
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 32,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 2897.812,
+   "stdev": 82.455,
+   "min": 2844.677,
+   "max": 2992.8,
+   "ci95": 204.846
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 10503.454,
+   "stdev": 493.592,
+   "min": 9934.491,
+   "max": 10816.992,
+   "ci95": 1226.251
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 3717.47,
+   "stdev": 1330.649,
+   "min": 2942.872,
+   "max": 5253.954,
+   "ci95": 3305.783
+  },
+  "chunks.village.meshed_count": {
+   "n": 3,
+   "mean": 47525.333,
+   "stdev": 1369.122,
+   "min": 46133.0,
+   "max": 48870.0,
+   "ci95": 3401.363
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 1163.541,
+   "stdev": 3.485,
+   "min": 1159.52,
+   "max": 1165.693,
+   "ci95": 8.658
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 415.992,
+   "stdev": 15.742,
+   "min": 399.062,
+   "max": 430.188,
+   "ci95": 39.108
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 215.549,
+   "stdev": 34.678,
+   "min": 177.857,
+   "max": 246.101,
+   "ci95": 86.151
+  },
+  "memory.village.gpu_mb": {
+   "n": 3,
+   "mean": 1833.432,
+   "stdev": 4.415,
+   "min": 1828.334,
+   "max": 1835.997,
+   "ci95": 10.969
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 5455.049,
+   "stdev": 593.897,
+   "min": 4973.659,
+   "max": 6118.723,
+   "ci95": 1475.44
+  },
+  "chunks.forest.meshed_count": {
+   "n": 3,
+   "mean": 82758.0,
+   "stdev": 413.547,
+   "min": 82487.0,
+   "max": 83234.0,
+   "ci95": 1027.39
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 1389.46,
+   "stdev": 28.128,
+   "min": 1371.096,
+   "max": 1421.843,
+   "ci95": 69.88
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 504.377,
+   "stdev": 13.251,
+   "min": 492.444,
+   "max": 518.637,
+   "ci95": 32.919
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 329.682,
+   "stdev": 47.451,
+   "min": 294.872,
+   "max": 383.732,
+   "ci95": 117.885
+  },
+  "memory.forest.gpu_mb": {
+   "n": 3,
+   "mean": 1985.175,
+   "stdev": 6.354,
+   "min": 1978.907,
+   "max": 1991.612,
+   "ci95": 15.786
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 4504.145,
+   "stdev": 745.393,
+   "min": 3650.589,
+   "max": 5026.8,
+   "ci95": 1851.809
+  },
+  "chunks.ocean.meshed_count": {
+   "n": 3,
+   "mean": 74927.333,
+   "stdev": 399.375,
+   "min": 74476.0,
+   "max": 75235.0,
+   "ci95": 992.182
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 1188.639,
+   "stdev": 10.807,
+   "min": 1177.005,
+   "max": 1198.365,
+   "ci95": 26.849
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 154.773,
+   "stdev": 3.712,
+   "min": 151.38,
+   "max": 158.738,
+   "ci95": 9.223
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 67.809,
+   "stdev": 3.032,
+   "min": 65.903,
+   "max": 71.305,
+   "ci95": 7.532
+  },
+  "memory.ocean.gpu_mb": {
+   "n": 3,
+   "mean": 2084.845,
+   "stdev": 9.674,
+   "min": 2074.009,
+   "max": 2092.615,
+   "ci95": 24.034
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 9048.431,
+   "stdev": 344.33,
+   "min": 8821.41,
+   "max": 9444.624,
+   "ci95": 855.432
+  },
+  "chunks.mountain.meshed_count": {
+   "n": 3,
+   "mean": 89659.667,
+   "stdev": 87.123,
+   "min": 89561.0,
+   "max": 89726.0,
+   "ci95": 216.442
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 1085.847,
+   "stdev": 13.819,
+   "min": 1070.378,
+   "max": 1096.974,
+   "ci95": 34.332
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 257.7,
+   "stdev": 31.437,
+   "min": 224.366,
+   "max": 286.814,
+   "ci95": 78.101
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 107.783,
+   "stdev": 14.883,
+   "min": 91.541,
+   "max": 120.768,
+   "ci95": 36.975
+  },
+  "memory.mountain.gpu_mb": {
+   "n": 3,
+   "mean": 2708.833,
+   "stdev": 9.674,
+   "min": 2697.997,
+   "max": 2716.603,
+   "ci95": 24.034
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 2044.895,
+   "stdev": 10.562,
+   "min": 2032.875,
+   "max": 2052.691,
+   "ci95": 26.238
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 1730.107,
+   "stdev": 14.764,
+   "min": 1717.52,
+   "max": 1746.357,
+   "ci95": 36.678
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 13986,
+   "seconds": 12.001,
+   "avg_fps": 1165.41,
+   "low_1pct_fps": 399.062,
+   "low_01pct_fps": 177.857,
+   "p50_ms": 0.822,
+   "p95_ms": 1.21,
+   "p99_ms": 1.691,
+   "p999_ms": 3.499,
+   "max_ms": 13.089,
+   "cpu_p50_ms": 0.665,
+   "gpu_p50_ms": 0.193,
+   "histogram": [
+    12380,
+    1527,
+    58,
+    13,
+    2,
+    2,
+    1,
+    2,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 13915,
+   "seconds": 12.001,
+   "avg_fps": 1159.52,
+   "low_1pct_fps": 430.188,
+   "low_01pct_fps": 246.101,
+   "p50_ms": 0.809,
+   "p95_ms": 1.212,
+   "p99_ms": 1.702,
+   "p999_ms": 3.291,
+   "max_ms": 6.894,
+   "cpu_p50_ms": 0.648,
+   "gpu_p50_ms": 0.192,
+   "histogram": [
+    11996,
+    1839,
+    59,
+    17,
+    2,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 13989,
+   "seconds": 12.001,
+   "avg_fps": 1165.693,
+   "low_1pct_fps": 418.725,
+   "low_01pct_fps": 222.688,
+   "p50_ms": 0.816,
+   "p95_ms": 1.22,
+   "p99_ms": 1.692,
+   "p999_ms": 3.264,
+   "max_ms": 7.781,
+   "cpu_p50_ms": 0.669,
+   "gpu_p50_ms": 0.193,
+   "histogram": [
+    12321,
+    1578,
+    72,
+    11,
+    2,
+    4,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 17063,
+   "seconds": 12.001,
+   "avg_fps": 1421.843,
+   "low_1pct_fps": 502.049,
+   "low_01pct_fps": 294.872,
+   "p50_ms": 0.666,
+   "p95_ms": 0.935,
+   "p99_ms": 1.549,
+   "p999_ms": 2.692,
+   "max_ms": 6.831,
+   "cpu_p50_ms": 0.533,
+   "gpu_p50_ms": 0.362,
+   "histogram": [
+    16417,
+    596,
+    40,
+    7,
+    2,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 16454,
+   "seconds": 12.001,
+   "avg_fps": 1371.096,
+   "low_1pct_fps": 492.444,
+   "low_01pct_fps": 310.443,
+   "p50_ms": 0.688,
+   "p95_ms": 0.979,
+   "p99_ms": 1.556,
+   "p999_ms": 2.693,
+   "max_ms": 4.596,
+   "cpu_p50_ms": 0.553,
+   "gpu_p50_ms": 0.36,
+   "histogram": [
+    15692,
+    697,
+    57,
+    7,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 16506,
+   "seconds": 12.001,
+   "avg_fps": 1375.442,
+   "low_1pct_fps": 518.637,
+   "low_01pct_fps": 383.732,
+   "p50_ms": 0.675,
+   "p95_ms": 1.017,
+   "p99_ms": 1.605,
+   "p999_ms": 2.369,
+   "max_ms": 3.201,
+   "cpu_p50_ms": 0.54,
+   "gpu_p50_ms": 0.364,
+   "histogram": [
+    15628,
+    833,
+    44,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 14381,
+   "seconds": 12.001,
+   "avg_fps": 1198.365,
+   "low_1pct_fps": 154.2,
+   "low_01pct_fps": 66.219,
+   "p50_ms": 0.731,
+   "p95_ms": 1.023,
+   "p99_ms": 3.003,
+   "p999_ms": 12.478,
+   "max_ms": 18.863,
+   "cpu_p50_ms": 0.596,
+   "gpu_p50_ms": 0.315,
+   "histogram": [
+    13586,
+    546,
+    105,
+    60,
+    13,
+    13,
+    8,
+    16,
+    8,
+    11,
+    5,
+    7,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 14287,
+   "seconds": 12.0,
+   "avg_fps": 1190.548,
+   "low_1pct_fps": 158.738,
+   "low_01pct_fps": 71.305,
+   "p50_ms": 0.741,
+   "p95_ms": 1.041,
+   "p99_ms": 2.9,
+   "p999_ms": 12.0,
+   "max_ms": 17.23,
+   "cpu_p50_ms": 0.602,
+   "gpu_p50_ms": 0.315,
+   "histogram": [
+    13450,
+    591,
+    109,
+    57,
+    13,
+    8,
+    10,
+    11,
+    14,
+    10,
+    7,
+    6,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 14124,
+   "seconds": 12.0,
+   "avg_fps": 1177.005,
+   "low_1pct_fps": 151.38,
+   "low_01pct_fps": 65.903,
+   "p50_ms": 0.739,
+   "p95_ms": 1.096,
+   "p99_ms": 2.928,
+   "p999_ms": 11.884,
+   "max_ms": 19.375,
+   "cpu_p50_ms": 0.604,
+   "gpu_p50_ms": 0.314,
+   "histogram": [
+    13052,
+    822,
+    114,
+    54,
+    16,
+    8,
+    4,
+    14,
+    11,
+    15,
+    3,
+    8,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 12845,
+   "seconds": 12.0,
+   "avg_fps": 1070.378,
+   "low_1pct_fps": 224.366,
+   "low_01pct_fps": 91.541,
+   "p50_ms": 0.825,
+   "p95_ms": 1.362,
+   "p99_ms": 2.325,
+   "p999_ms": 9.621,
+   "max_ms": 13.309,
+   "cpu_p50_ms": 0.689,
+   "gpu_p50_ms": 0.307,
+   "histogram": [
+    10937,
+    1699,
+    143,
+    25,
+    5,
+    6,
+    4,
+    8,
+    8,
+    8,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 13083,
+   "seconds": 12.001,
+   "avg_fps": 1090.188,
+   "low_1pct_fps": 261.921,
+   "low_01pct_fps": 111.039,
+   "p50_ms": 0.816,
+   "p95_ms": 1.335,
+   "p99_ms": 2.14,
+   "p999_ms": 8.222,
+   "max_ms": 11.95,
+   "cpu_p50_ms": 0.681,
+   "gpu_p50_ms": 0.306,
+   "histogram": [
+    11105,
+    1812,
+    112,
+    21,
+    5,
+    5,
+    5,
+    6,
+    11,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 13164,
+   "seconds": 12.0,
+   "avg_fps": 1096.974,
+   "low_1pct_fps": 286.814,
+   "low_01pct_fps": 120.768,
+   "p50_ms": 0.822,
+   "p95_ms": 1.307,
+   "p99_ms": 1.989,
+   "p999_ms": 7.701,
+   "max_ms": 9.429,
+   "cpu_p50_ms": 0.687,
+   "gpu_p50_ms": 0.307,
+   "histogram": [
+    11280,
+    1758,
+    82,
+    13,
+    5,
+    5,
+    6,
+    8,
+    7,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "horizon-win-9800x3d-5080"
+}

benchmarks/perf/horizon-win-9800x3d-5080-rd8.json

@@ -0,0 +1,773 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-10-29T18:37:03Z",
+ "app": {
+  "name": "horizon-client",
+  "version": "v0.2.97",
+  "commit": null
+ },
+ "hardware": {
+  "os": "windows",
+  "arch": "x86_64",
+  "cpu_threads": 16,
+  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
+  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
+  "ram_mb": 95943,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 5080",
+   "vendor": "nvidia",
+   "driver": "NVIDIA 617.42",
+   "backend": "vulkan",
+   "kind": "discrete"
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 8,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 2950.343,
+   "stdev": 162.732,
+   "min": 2822.925,
+   "max": 3133.657,
+   "ci95": 404.282
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 6135.1,
+   "stdev": 863.831,
+   "min": 5547.861,
+   "max": 7126.98,
+   "ci95": 2146.05
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 985.519,
+   "stdev": 28.184,
+   "min": 956.244,
+   "max": 1012.469,
+   "ci95": 70.019
+  },
+  "chunks.village.meshed_count": {
+   "n": 3,
+   "mean": 6908.0,
+   "stdev": 9.849,
+   "min": 6897.0,
+   "max": 6916.0,
+   "ci95": 24.468
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 2941.608,
+   "stdev": 79.283,
+   "min": 2850.416,
+   "max": 2994.188,
+   "ci95": 196.965
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 1271.318,
+   "stdev": 58.797,
+   "min": 1203.758,
+   "max": 1310.917,
+   "ci95": 146.072
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 839.261,
+   "stdev": 37.982,
+   "min": 795.415,
+   "max": 862.067,
+   "ci95": 94.36
+  },
+  "memory.village.gpu_mb": {
+   "n": 3,
+   "mean": 363.984,
+   "stdev": 0.926,
+   "min": 363.449,
+   "max": 365.053,
+   "ci95": 2.299
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 1350.752,
+   "stdev": 293.128,
+   "min": 1106.764,
+   "max": 1675.913,
+   "ci95": 728.23
+  },
+  "chunks.forest.meshed_count": {
+   "n": 3,
+   "mean": 8066.0,
+   "stdev": 108.885,
+   "min": 7986.0,
+   "max": 8190.0,
+   "ci95": 270.508
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 3494.693,
+   "stdev": 110.997,
+   "min": 3389.894,
+   "max": 3610.993,
+   "ci95": 275.755
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 1295.14,
+   "stdev": 159.638,
+   "min": 1148.468,
+   "max": 1465.171,
+   "ci95": 396.596
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 859.326,
+   "stdev": 119.845,
+   "min": 721.994,
+   "max": 942.743,
+   "ci95": 297.734
+  },
+  "memory.forest.gpu_mb": {
+   "n": 3,
+   "mean": 381.189,
+   "stdev": 5.222,
+   "min": 376.423,
+   "max": 386.77,
+   "ci95": 12.972
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 1123.386,
+   "stdev": 604.175,
+   "min": 734.302,
+   "max": 1819.414,
+   "ci95": 1500.976
+  },
+  "chunks.ocean.meshed_count": {
+   "n": 3,
+   "mean": 6613.0,
+   "stdev": 135.632,
+   "min": 6523.0,
+   "max": 6769.0,
+   "ci95": 336.955
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 3346.003,
+   "stdev": 59.312,
+   "min": 3303.535,
+   "max": 3413.77,
+   "ci95": 147.352
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 1357.991,
+   "stdev": 95.364,
+   "min": 1248.887,
+   "max": 1425.451,
+   "ci95": 236.917
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 911.822,
+   "stdev": 94.717,
+   "min": 802.528,
+   "max": 969.989,
+   "ci95": 235.308
+  },
+  "memory.ocean.gpu_mb": {
+   "n": 3,
+   "mean": 391.636,
+   "stdev": 5.435,
+   "min": 387.424,
+   "max": 397.771,
+   "ci95": 13.502
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 1588.954,
+   "stdev": 458.924,
+   "min": 1309.548,
+   "max": 2118.606,
+   "ci95": 1140.123
+  },
+  "chunks.mountain.meshed_count": {
+   "n": 3,
+   "mean": 7887.667,
+   "stdev": 41.041,
+   "min": 7862.0,
+   "max": 7935.0,
+   "ci95": 101.959
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 3375.623,
+   "stdev": 26.82,
+   "min": 3352.309,
+   "max": 3404.933,
+   "ci95": 66.629
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 1383.745,
+   "stdev": 67.628,
+   "min": 1324.071,
+   "max": 1457.203,
+   "ci95": 168.01
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 850.213,
+   "stdev": 103.149,
+   "min": 790.305,
+   "max": 969.318,
+   "ci95": 256.256
+  },
+  "memory.mountain.gpu_mb": {
+   "n": 3,
+   "mean": 448.64,
+   "stdev": 5.435,
+   "min": 444.428,
+   "max": 454.775,
+   "ci95": 13.502
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 1171.629,
+   "stdev": 0.337,
+   "min": 1171.398,
+   "max": 1172.016,
+   "ci95": 0.837
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 1082.078,
+   "stdev": 12.494,
+   "min": 1069.117,
+   "max": 1094.047,
+   "ci95": 31.04
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 35764,
+   "seconds": 12.0,
+   "avg_fps": 2980.22,
+   "low_1pct_fps": 1310.917,
+   "low_01pct_fps": 860.301,
+   "p50_ms": 0.317,
+   "p95_ms": 0.433,
+   "p99_ms": 0.633,
+   "p999_ms": 0.937,
+   "max_ms": 2.807,
+   "cpu_p50_ms": 0.192,
+   "gpu_p50_ms": 0.063,
+   "histogram": [
+    35741,
+    22,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 35931,
+   "seconds": 12.0,
+   "avg_fps": 2994.188,
+   "low_1pct_fps": 1299.278,
+   "low_01pct_fps": 795.415,
+   "p50_ms": 0.318,
+   "p95_ms": 0.428,
+   "p99_ms": 0.62,
+   "p999_ms": 0.943,
+   "max_ms": 5.797,
+   "cpu_p50_ms": 0.191,
+   "gpu_p50_ms": 0.063,
+   "histogram": [
+    35906,
+    23,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 34206,
+   "seconds": 12.0,
+   "avg_fps": 2850.416,
+   "low_1pct_fps": 1203.758,
+   "low_01pct_fps": 862.067,
+   "p50_ms": 0.326,
+   "p95_ms": 0.508,
+   "p99_ms": 0.705,
+   "p999_ms": 1.025,
+   "max_ms": 1.398,
+   "cpu_p50_ms": 0.196,
+   "gpu_p50_ms": 0.063,
+   "histogram": [
+    34167,
+    39,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 41800,
+   "seconds": 12.0,
+   "avg_fps": 3483.193,
+   "low_1pct_fps": 1271.782,
+   "low_01pct_fps": 913.242,
+   "p50_ms": 0.264,
+   "p95_ms": 0.415,
+   "p99_ms": 0.657,
+   "p999_ms": 0.935,
+   "max_ms": 1.482,
+   "cpu_p50_ms": 0.144,
+   "gpu_p50_ms": 0.075,
+   "histogram": [
+    41768,
+    32,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 43333,
+   "seconds": 12.0,
+   "avg_fps": 3610.993,
+   "low_1pct_fps": 1465.171,
+   "low_01pct_fps": 942.743,
+   "p50_ms": 0.263,
+   "p95_ms": 0.355,
+   "p99_ms": 0.561,
+   "p999_ms": 0.859,
+   "max_ms": 1.694,
+   "cpu_p50_ms": 0.143,
+   "gpu_p50_ms": 0.074,
+   "histogram": [
+    43310,
+    23,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 40679,
+   "seconds": 12.0,
+   "avg_fps": 3389.894,
+   "low_1pct_fps": 1148.468,
+   "low_01pct_fps": 721.994,
+   "p50_ms": 0.267,
+   "p95_ms": 0.446,
+   "p99_ms": 0.67,
+   "p999_ms": 1.183,
+   "max_ms": 2.434,
+   "cpu_p50_ms": 0.146,
+   "gpu_p50_ms": 0.076,
+   "histogram": [
+    40590,
+    87,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 39849,
+   "seconds": 12.0,
+   "avg_fps": 3320.704,
+   "low_1pct_fps": 1399.634,
+   "low_01pct_fps": 969.989,
+   "p50_ms": 0.281,
+   "p95_ms": 0.404,
+   "p99_ms": 0.601,
+   "p999_ms": 0.875,
+   "max_ms": 1.494,
+   "cpu_p50_ms": 0.159,
+   "gpu_p50_ms": 0.069,
+   "histogram": [
+    39831,
+    18,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 40966,
+   "seconds": 12.0,
+   "avg_fps": 3413.77,
+   "low_1pct_fps": 1425.451,
+   "low_01pct_fps": 962.948,
+   "p50_ms": 0.278,
+   "p95_ms": 0.372,
+   "p99_ms": 0.581,
+   "p999_ms": 0.857,
+   "max_ms": 1.576,
+   "cpu_p50_ms": 0.157,
+   "gpu_p50_ms": 0.069,
+   "histogram": [
+    40947,
+    19,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 39643,
+   "seconds": 12.0,
+   "avg_fps": 3303.535,
+   "low_1pct_fps": 1248.887,
+   "low_01pct_fps": 802.528,
+   "p50_ms": 0.28,
+   "p95_ms": 0.413,
+   "p99_ms": 0.642,
+   "p999_ms": 1.087,
+   "max_ms": 2.215,
+   "cpu_p50_ms": 0.158,
+   "gpu_p50_ms": 0.069,
+   "histogram": [
+    39582,
+    60,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 40436,
+   "seconds": 12.0,
+   "avg_fps": 3369.626,
+   "low_1pct_fps": 1369.962,
+   "low_01pct_fps": 790.305,
+   "p50_ms": 0.279,
+   "p95_ms": 0.403,
+   "p99_ms": 0.604,
+   "p999_ms": 0.812,
+   "max_ms": 10.313,
+   "cpu_p50_ms": 0.159,
+   "gpu_p50_ms": 0.069,
+   "histogram": [
+    40425,
+    8,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 40860,
+   "seconds": 12.0,
+   "avg_fps": 3404.933,
+   "low_1pct_fps": 1457.203,
+   "low_01pct_fps": 969.318,
+   "p50_ms": 0.278,
+   "p95_ms": 0.389,
+   "p99_ms": 0.574,
+   "p999_ms": 0.814,
+   "max_ms": 2.714,
+   "cpu_p50_ms": 0.158,
+   "gpu_p50_ms": 0.069,
+   "histogram": [
+    40847,
+    11,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 40229,
+   "seconds": 12.0,
+   "avg_fps": 3352.309,
+   "low_1pct_fps": 1324.071,
+   "low_01pct_fps": 791.016,
+   "p50_ms": 0.28,
+   "p95_ms": 0.402,
+   "p99_ms": 0.617,
+   "p999_ms": 0.968,
+   "max_ms": 3.746,
+   "cpu_p50_ms": 0.159,
+   "gpu_p50_ms": 0.069,
+   "histogram": [
+    40192,
+    35,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "horizon-win-9800x3d-5080"
+}

benchmarks/perf/vanilla-mods-win-9800x3d-5080-rd16.json

@@ -0,0 +1,706 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-10-29T01:25:53Z",
+ "app": {
+  "name": "minecraft",
+  "version": "26.3",
+  "mods": [
+   {
+    "name": "fabric-loader",
+    "version": "0.19.5"
+   },
+   {
+    "name": "sodium",
+    "version": "mc26.3-0.9.2-fabric"
+   },
+   {
+    "name": "lithium",
+    "version": "mc26.3-0.26.2-fabric"
+   },
+   {
+    "name": "ferrite-core",
+    "version": "9.0.0-fabric"
+   },
+   {
+    "name": "immediatelyfast",
+    "version": "1.17.1+26.3-fabric"
+   }
+  ]
+ },
+ "hardware": {
+  "os": "windows",
+  "arch": "x86_64",
+  "cpu_threads": 16,
+  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
+  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
+  "ram_mb": 95943,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
+   "vendor": "NVIDIA Corporation",
+   "driver": "3.3.0 NVIDIA 617.42",
+   "backend": "opengl",
+   "kind": ""
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 16,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 10777.756,
+   "stdev": 129.67,
+   "min": 10636.92,
+   "max": 10892.2,
+   "ci95": 322.144
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 23477.423,
+   "stdev": 346.614,
+   "min": 23130.92,
+   "max": 23824.148,
+   "ci95": 861.106
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 6007.033,
+   "stdev": 104.227,
+   "min": 5891.431,
+   "max": 6093.825,
+   "ci95": 258.936
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 1282.11,
+   "stdev": 65.207,
+   "min": 1228.13,
+   "max": 1354.56,
+   "ci95": 161.997
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 343.465,
+   "stdev": 9.96,
+   "min": 335.223,
+   "max": 354.532,
+   "ci95": 24.744
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 131.669,
+   "stdev": 4.692,
+   "min": 126.427,
+   "max": 135.476,
+   "ci95": 11.656
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 8669.311,
+   "stdev": 434.39,
+   "min": 8280.854,
+   "max": 9138.35,
+   "ci95": 1079.173
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 1745.757,
+   "stdev": 13.014,
+   "min": 1734.41,
+   "max": 1759.963,
+   "ci95": 32.332
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 460.958,
+   "stdev": 10.859,
+   "min": 449.051,
+   "max": 470.316,
+   "ci95": 26.978
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 178.955,
+   "stdev": 3.777,
+   "min": 175.213,
+   "max": 182.766,
+   "ci95": 9.383
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 7056.368,
+   "stdev": 117.329,
+   "min": 6986.912,
+   "max": 7191.833,
+   "ci95": 291.485
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 1815.056,
+   "stdev": 47.875,
+   "min": 1759.788,
+   "max": 1843.745,
+   "ci95": 118.937
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 514.215,
+   "stdev": 57.205,
+   "min": 452.445,
+   "max": 565.368,
+   "ci95": 142.117
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 191.842,
+   "stdev": 23.217,
+   "min": 175.546,
+   "max": 218.426,
+   "ci95": 57.68
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 14094.582,
+   "stdev": 399.624,
+   "min": 13641.534,
+   "max": 14397.0,
+   "ci95": 992.801
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 1499.768,
+   "stdev": 22.197,
+   "min": 1477.269,
+   "max": 1521.651,
+   "ci95": 55.146
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 408.466,
+   "stdev": 16.114,
+   "min": 395.097,
+   "max": 426.358,
+   "ci95": 40.032
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 139.743,
+   "stdev": 3.969,
+   "min": 136.465,
+   "max": 144.156,
+   "ci95": 9.86
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 2495.607,
+   "stdev": 75.339,
+   "min": 2412.738,
+   "max": 2559.965,
+   "ci95": 187.166
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 2326.611,
+   "stdev": 15.702,
+   "min": 2314.98,
+   "max": 2344.473,
+   "ci95": 39.01
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 14738,
+   "seconds": 12.0,
+   "avg_fps": 1228.13,
+   "low_1pct_fps": 335.223,
+   "low_01pct_fps": 133.103,
+   "p50_ms": 0.722,
+   "p95_ms": 1.384,
+   "p99_ms": 2.043,
+   "p999_ms": 5.224,
+   "max_ms": 11.459,
+   "histogram": [
+    12159,
+    2421,
+    128,
+    14,
+    1,
+    5,
+    2,
+    3,
+    4,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 16255,
+   "seconds": 12.0,
+   "avg_fps": 1354.56,
+   "low_1pct_fps": 354.532,
+   "low_01pct_fps": 135.476,
+   "p50_ms": 0.672,
+   "p95_ms": 1.136,
+   "p99_ms": 1.841,
+   "p999_ms": 4.913,
+   "max_ms": 16.94,
+   "histogram": [
+    14841,
+    1298,
+    86,
+    13,
+    2,
+    5,
+    4,
+    1,
+    3,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 15164,
+   "seconds": 12.0,
+   "avg_fps": 1263.64,
+   "low_1pct_fps": 340.639,
+   "low_01pct_fps": 126.427,
+   "p50_ms": 0.708,
+   "p95_ms": 1.299,
+   "p99_ms": 1.895,
+   "p999_ms": 5.173,
+   "max_ms": 16.748,
+   "histogram": [
+    13026,
+    2014,
+    94,
+    13,
+    1,
+    3,
+    3,
+    6,
+    2,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 20915,
+   "seconds": 12.0,
+   "avg_fps": 1742.897,
+   "low_1pct_fps": 470.316,
+   "low_01pct_fps": 182.766,
+   "p50_ms": 0.5,
+   "p95_ms": 0.936,
+   "p99_ms": 1.437,
+   "p999_ms": 2.77,
+   "max_ms": 13.414,
+   "histogram": [
+    20067,
+    788,
+    44,
+    4,
+    0,
+    4,
+    3,
+    3,
+    1,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 21120,
+   "seconds": 12.0,
+   "avg_fps": 1759.963,
+   "low_1pct_fps": 449.051,
+   "low_01pct_fps": 178.887,
+   "p50_ms": 0.49,
+   "p95_ms": 0.901,
+   "p99_ms": 1.531,
+   "p999_ms": 3.005,
+   "max_ms": 12.907,
+   "histogram": [
+    20414,
+    644,
+    40,
+    10,
+    1,
+    3,
+    2,
+    2,
+    2,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 20813,
+   "seconds": 12.0,
+   "avg_fps": 1734.41,
+   "low_1pct_fps": 463.506,
+   "low_01pct_fps": 175.213,
+   "p50_ms": 0.496,
+   "p95_ms": 0.924,
+   "p99_ms": 1.414,
+   "p999_ms": 2.733,
+   "max_ms": 16.832,
+   "histogram": [
+    20049,
+    707,
+    41,
+    5,
+    0,
+    1,
+    5,
+    2,
+    2,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 22100,
+   "seconds": 12.0,
+   "avg_fps": 1841.634,
+   "low_1pct_fps": 565.368,
+   "low_01pct_fps": 218.426,
+   "p50_ms": 0.483,
+   "p95_ms": 0.835,
+   "p99_ms": 1.209,
+   "p999_ms": 2.082,
+   "max_ms": 14.627,
+   "histogram": [
+    21540,
+    532,
+    18,
+    1,
+    1,
+    1,
+    2,
+    2,
+    1,
+    1,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 21118,
+   "seconds": 12.0,
+   "avg_fps": 1759.788,
+   "low_1pct_fps": 452.445,
+   "low_01pct_fps": 175.546,
+   "p50_ms": 0.489,
+   "p95_ms": 0.915,
+   "p99_ms": 1.532,
+   "p999_ms": 2.811,
+   "max_ms": 11.846,
+   "histogram": [
+    20308,
+    755,
+    36,
+    9,
+    0,
+    2,
+    0,
+    3,
+    2,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 22125,
+   "seconds": 12.0,
+   "avg_fps": 1843.745,
+   "low_1pct_fps": 524.832,
+   "low_01pct_fps": 181.555,
+   "p50_ms": 0.477,
+   "p95_ms": 0.855,
+   "p99_ms": 1.241,
+   "p999_ms": 2.236,
+   "max_ms": 12.478,
+   "histogram": [
+    21487,
+    608,
+    18,
+    1,
+    1,
+    1,
+    2,
+    2,
+    1,
+    2,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 18005,
+   "seconds": 12.0,
+   "avg_fps": 1500.383,
+   "low_1pct_fps": 403.944,
+   "low_01pct_fps": 136.465,
+   "p50_ms": 0.591,
+   "p95_ms": 1.058,
+   "p99_ms": 1.592,
+   "p999_ms": 3.186,
+   "max_ms": 12.608,
+   "histogram": [
+    16864,
+    1084,
+    32,
+    8,
+    0,
+    5,
+    3,
+    5,
+    1,
+    2,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 17728,
+   "seconds": 12.001,
+   "avg_fps": 1477.269,
+   "low_1pct_fps": 395.097,
+   "low_01pct_fps": 138.609,
+   "p50_ms": 0.598,
+   "p95_ms": 1.042,
+   "p99_ms": 1.561,
+   "p999_ms": 5.033,
+   "max_ms": 11.462,
+   "histogram": [
+    16612,
+    1051,
+    39,
+    7,
+    1,
+    6,
+    5,
+    3,
+    1,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 18260,
+   "seconds": 12.0,
+   "avg_fps": 1521.651,
+   "low_1pct_fps": 426.358,
+   "low_01pct_fps": 144.156,
+   "p50_ms": 0.585,
+   "p95_ms": 1.015,
+   "p99_ms": 1.458,
+   "p999_ms": 3.609,
+   "max_ms": 11.945,
+   "histogram": [
+    17267,
+    943,
+    26,
+    6,
+    5,
+    2,
+    3,
+    3,
+    2,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "vanilla-mods-win-9800x3d-5080"
+}

benchmarks/perf/vanilla-mods-win-9800x3d-5080-rd32.json

@@ -0,0 +1,706 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-10-29T19:27:56Z",
+ "app": {
+  "name": "minecraft",
+  "version": "26.3",
+  "mods": [
+   {
+    "name": "fabric-loader",
+    "version": "0.19.5"
+   },
+   {
+    "name": "sodium",
+    "version": "mc26.3-0.9.2-fabric"
+   },
+   {
+    "name": "lithium",
+    "version": "mc26.3-0.26.2-fabric"
+   },
+   {
+    "name": "ferrite-core",
+    "version": "9.0.0-fabric"
+   },
+   {
+    "name": "immediatelyfast",
+    "version": "1.17.1+26.3-fabric"
+   }
+  ]
+ },
+ "hardware": {
+  "os": "windows",
+  "arch": "x86_64",
+  "cpu_threads": 16,
+  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
+  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
+  "ram_mb": 95943,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
+   "vendor": "NVIDIA Corporation",
+   "driver": "3.3.0 NVIDIA 617.42",
+   "backend": "opengl",
+   "kind": ""
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 32,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 11038.922,
+   "stdev": 118.058,
+   "min": 10935.424,
+   "max": 11167.506,
+   "ci95": 293.295
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 39248.588,
+   "stdev": 479.755,
+   "min": 38964.834,
+   "max": 39802.506,
+   "ci95": 1191.875
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 11176.953,
+   "stdev": 356.144,
+   "min": 10836.65,
+   "max": 11547.064,
+   "ci95": 884.781
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 925.977,
+   "stdev": 6.727,
+   "min": 918.832,
+   "max": 932.189,
+   "ci95": 16.713
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 250.092,
+   "stdev": 1.868,
+   "min": 248.431,
+   "max": 252.114,
+   "ci95": 4.64
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 92.692,
+   "stdev": 4.466,
+   "min": 88.423,
+   "max": 97.332,
+   "ci95": 11.095
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 17335.638,
+   "stdev": 687.588,
+   "min": 16544.168,
+   "max": 17785.772,
+   "ci95": 1708.201
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 929.034,
+   "stdev": 3.11,
+   "min": 926.32,
+   "max": 932.428,
+   "ci95": 7.727
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 312.69,
+   "stdev": 16.386,
+   "min": 297.667,
+   "max": 330.163,
+   "ci95": 40.708
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 129.331,
+   "stdev": 12.786,
+   "min": 115.486,
+   "max": 140.694,
+   "ci95": 31.765
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 12601.063,
+   "stdev": 148.042,
+   "min": 12430.182,
+   "max": 12690.506,
+   "ci95": 367.785
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 1016.598,
+   "stdev": 5.481,
+   "min": 1010.482,
+   "max": 1021.068,
+   "ci95": 13.618
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 325.361,
+   "stdev": 15.112,
+   "min": 315.682,
+   "max": 342.774,
+   "ci95": 37.543
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 117.042,
+   "stdev": 11.095,
+   "min": 107.807,
+   "max": 129.349,
+   "ci95": 27.563
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 38513.008,
+   "stdev": 958.119,
+   "min": 37447.333,
+   "max": 39303.226,
+   "ci95": 2380.292
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 644.782,
+   "stdev": 3.94,
+   "min": 640.866,
+   "max": 648.745,
+   "ci95": 9.788
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 166.029,
+   "stdev": 4.758,
+   "min": 162.326,
+   "max": 171.395,
+   "ci95": 11.819
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 86.231,
+   "stdev": 8.587,
+   "min": 76.632,
+   "max": 93.184,
+   "ci95": 21.334
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 2964.911,
+   "stdev": 8.27,
+   "min": 2959.813,
+   "max": 2974.453,
+   "ci95": 20.545
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 2894.541,
+   "stdev": 12.847,
+   "min": 2879.928,
+   "max": 2904.059,
+   "ci95": 31.917
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 11123,
+   "seconds": 12.0,
+   "avg_fps": 926.911,
+   "low_1pct_fps": 249.732,
+   "low_01pct_fps": 92.322,
+   "p50_ms": 0.989,
+   "p95_ms": 1.492,
+   "p99_ms": 2.33,
+   "p999_ms": 7.409,
+   "max_ms": 15.258,
+   "histogram": [
+    6224,
+    4701,
+    147,
+    28,
+    3,
+    2,
+    5,
+    3,
+    3,
+    3,
+    1,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 11187,
+   "seconds": 12.001,
+   "avg_fps": 932.189,
+   "low_1pct_fps": 252.114,
+   "low_01pct_fps": 88.423,
+   "p50_ms": 0.984,
+   "p95_ms": 1.496,
+   "p99_ms": 2.328,
+   "p999_ms": 7.858,
+   "max_ms": 16.843,
+   "histogram": [
+    6518,
+    4486,
+    138,
+    20,
+    9,
+    1,
+    1,
+    6,
+    1,
+    2,
+    3,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 11026,
+   "seconds": 12.0,
+   "avg_fps": 918.832,
+   "low_1pct_fps": 248.431,
+   "low_01pct_fps": 97.332,
+   "p50_ms": 0.989,
+   "p95_ms": 1.524,
+   "p99_ms": 2.37,
+   "p999_ms": 7.446,
+   "max_ms": 16.573,
+   "histogram": [
+    6075,
+    4740,
+    162,
+    23,
+    5,
+    2,
+    4,
+    7,
+    4,
+    1,
+    1,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 11117,
+   "seconds": 12.001,
+   "avg_fps": 926.32,
+   "low_1pct_fps": 310.239,
+   "low_01pct_fps": 131.814,
+   "p50_ms": 1.011,
+   "p95_ms": 1.34,
+   "p99_ms": 2.045,
+   "p999_ms": 4.711,
+   "max_ms": 14.077,
+   "histogram": [
+    3849,
+    7150,
+    78,
+    26,
+    5,
+    1,
+    3,
+    2,
+    1,
+    0,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 11190,
+   "seconds": 12.001,
+   "avg_fps": 932.428,
+   "low_1pct_fps": 330.163,
+   "low_01pct_fps": 140.694,
+   "p50_ms": 1.008,
+   "p95_ms": 1.307,
+   "p99_ms": 1.869,
+   "p999_ms": 4.341,
+   "max_ms": 13.489,
+   "histogram": [
+    4273,
+    6822,
+    60,
+    20,
+    7,
+    0,
+    3,
+    3,
+    0,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 11141,
+   "seconds": 12.001,
+   "avg_fps": 928.354,
+   "low_1pct_fps": 297.667,
+   "low_01pct_fps": 115.486,
+   "p50_ms": 1.005,
+   "p95_ms": 1.352,
+   "p99_ms": 2.054,
+   "p999_ms": 5.292,
+   "max_ms": 14.339,
+   "histogram": [
+    4901,
+    6118,
+    83,
+    23,
+    3,
+    2,
+    4,
+    3,
+    0,
+    1,
+    2,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 12126,
+   "seconds": 12.0,
+   "avg_fps": 1010.482,
+   "low_1pct_fps": 317.626,
+   "low_01pct_fps": 113.971,
+   "p50_ms": 0.933,
+   "p95_ms": 1.23,
+   "p99_ms": 1.935,
+   "p999_ms": 4.393,
+   "max_ms": 14.824,
+   "histogram": [
+    9183,
+    2830,
+    82,
+    17,
+    3,
+    1,
+    2,
+    3,
+    0,
+    1,
+    3,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 12219,
+   "seconds": 12.0,
+   "avg_fps": 1018.243,
+   "low_1pct_fps": 342.774,
+   "low_01pct_fps": 129.349,
+   "p50_ms": 0.929,
+   "p95_ms": 1.222,
+   "p99_ms": 1.867,
+   "p999_ms": 4.329,
+   "max_ms": 10.33,
+   "histogram": [
+    9421,
+    2710,
+    60,
+    15,
+    3,
+    0,
+    0,
+    5,
+    3,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 12253,
+   "seconds": 12.0,
+   "avg_fps": 1021.068,
+   "low_1pct_fps": 315.682,
+   "low_01pct_fps": 107.807,
+   "p50_ms": 0.923,
+   "p95_ms": 1.225,
+   "p99_ms": 1.969,
+   "p999_ms": 5.235,
+   "max_ms": 19.524,
+   "histogram": [
+    9231,
+    2904,
+    92,
+    10,
+    2,
+    5,
+    0,
+    4,
+    1,
+    2,
+    0,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 7691,
+   "seconds": 12.001,
+   "avg_fps": 640.866,
+   "low_1pct_fps": 164.367,
+   "low_01pct_fps": 93.184,
+   "p50_ms": 1.454,
+   "p95_ms": 1.95,
+   "p99_ms": 3.4,
+   "p999_ms": 9.754,
+   "max_ms": 14.995,
+   "histogram": [
+    36,
+    7331,
+    233,
+    26,
+    17,
+    13,
+    20,
+    3,
+    6,
+    5,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 7737,
+   "seconds": 12.0,
+   "avg_fps": 644.736,
+   "low_1pct_fps": 162.326,
+   "low_01pct_fps": 76.632,
+   "p50_ms": 1.454,
+   "p95_ms": 1.905,
+   "p99_ms": 3.676,
+   "p999_ms": 9.926,
+   "max_ms": 18.459,
+   "histogram": [
+    46,
+    7399,
+    199,
+    24,
+    21,
+    24,
+    10,
+    6,
+    1,
+    1,
+    4,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 7785,
+   "seconds": 12.0,
+   "avg_fps": 648.745,
+   "low_1pct_fps": 171.395,
+   "low_01pct_fps": 88.876,
+   "p50_ms": 1.439,
+   "p95_ms": 1.886,
+   "p99_ms": 3.562,
+   "p999_ms": 10.342,
+   "max_ms": 12.927,
+   "histogram": [
+    57,
+    7432,
+    186,
+    44,
+    23,
+    20,
+    9,
+    3,
+    3,
+    7,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "vanilla-mods-win-9800x3d-5080"
+}

benchmarks/perf/vanilla-mods-win-9800x3d-5080-rd8.json

@@ -0,0 +1,706 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-10-29T18:49:40Z",
+ "app": {
+  "name": "minecraft",
+  "version": "26.3",
+  "mods": [
+   {
+    "name": "fabric-loader",
+    "version": "0.19.5"
+   },
+   {
+    "name": "sodium",
+    "version": "mc26.3-0.9.2-fabric"
+   },
+   {
+    "name": "lithium",
+    "version": "mc26.3-0.26.2-fabric"
+   },
+   {
+    "name": "ferrite-core",
+    "version": "9.0.0-fabric"
+   },
+   {
+    "name": "immediatelyfast",
+    "version": "1.17.1+26.3-fabric"
+   }
+  ]
+ },
+ "hardware": {
+  "os": "windows",
+  "arch": "x86_64",
+  "cpu_threads": 16,
+  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
+  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
+  "ram_mb": 95943,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
+   "vendor": "NVIDIA Corporation",
+   "driver": "3.3.0 NVIDIA 617.42",
+   "backend": "opengl",
+   "kind": ""
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 8,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 11089.831,
+   "stdev": 46.336,
+   "min": 11036.36,
+   "max": 11118.192,
+   "ci95": 115.114
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 17643.831,
+   "stdev": 47.672,
+   "min": 17589.192,
+   "max": 17676.942,
+   "ci95": 118.433
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 3603.773,
+   "stdev": 161.342,
+   "min": 3488.106,
+   "max": 3788.086,
+   "ci95": 400.828
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 2103.54,
+   "stdev": 40.465,
+   "min": 2078.464,
+   "max": 2150.222,
+   "ci95": 100.529
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 577.326,
+   "stdev": 33.693,
+   "min": 557.613,
+   "max": 616.23,
+   "ci95": 83.704
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 195.53,
+   "stdev": 18.899,
+   "min": 181.495,
+   "max": 217.019,
+   "ci95": 46.951
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 3282.612,
+   "stdev": 48.569,
+   "min": 3233.16,
+   "max": 3330.246,
+   "ci95": 120.661
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 2424.739,
+   "stdev": 26.074,
+   "min": 2394.789,
+   "max": 2442.383,
+   "ci95": 64.777
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 732.987,
+   "stdev": 11.926,
+   "min": 724.144,
+   "max": 746.55,
+   "ci95": 29.627
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 249.926,
+   "stdev": 8.826,
+   "min": 241.293,
+   "max": 258.934,
+   "ci95": 21.928
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 2705.954,
+   "stdev": 173.487,
+   "min": 2538.486,
+   "max": 2884.891,
+   "ci95": 431.0
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 2431.99,
+   "stdev": 33.071,
+   "min": 2394.02,
+   "max": 2454.493,
+   "ci95": 82.159
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 764.065,
+   "stdev": 14.782,
+   "min": 747.287,
+   "max": 775.168,
+   "ci95": 36.723
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 261.954,
+   "stdev": 14.724,
+   "min": 252.457,
+   "max": 278.916,
+   "ci95": 36.58
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 4982.865,
+   "stdev": 115.523,
+   "min": 4849.837,
+   "max": 5057.932,
+   "ci95": 286.997
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 2538.05,
+   "stdev": 67.405,
+   "min": 2462.815,
+   "max": 2592.938,
+   "ci95": 167.458
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 760.16,
+   "stdev": 13.503,
+   "min": 746.001,
+   "max": 772.895,
+   "ci95": 33.547
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 240.897,
+   "stdev": 17.872,
+   "min": 224.391,
+   "max": 259.878,
+   "ci95": 44.401
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 2052.982,
+   "stdev": 57.756,
+   "min": 1992.574,
+   "max": 2107.66,
+   "ci95": 143.487
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 1903.921,
+   "stdev": 62.254,
+   "min": 1838.307,
+   "max": 1962.156,
+   "ci95": 154.659
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 25803,
+   "seconds": 12.0,
+   "avg_fps": 2150.222,
+   "low_1pct_fps": 616.23,
+   "low_01pct_fps": 217.019,
+   "p50_ms": 0.433,
+   "p95_ms": 0.642,
+   "p99_ms": 1.04,
+   "p999_ms": 2.307,
+   "max_ms": 7.466,
+   "histogram": [
+    25503,
+    269,
+    8,
+    6,
+    7,
+    6,
+    2,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 24942,
+   "seconds": 12.0,
+   "avg_fps": 2078.464,
+   "low_1pct_fps": 557.613,
+   "low_01pct_fps": 181.495,
+   "p50_ms": 0.45,
+   "p95_ms": 0.665,
+   "p99_ms": 1.1,
+   "p999_ms": 2.305,
+   "max_ms": 9.819,
+   "histogram": [
+    24615,
+    288,
+    17,
+    2,
+    4,
+    9,
+    2,
+    3,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 24984,
+   "seconds": 12.0,
+   "avg_fps": 2081.934,
+   "low_1pct_fps": 558.135,
+   "low_01pct_fps": 188.076,
+   "p50_ms": 0.444,
+   "p95_ms": 0.682,
+   "p99_ms": 1.101,
+   "p999_ms": 2.412,
+   "max_ms": 11.567,
+   "histogram": [
+    24645,
+    308,
+    9,
+    3,
+    5,
+    5,
+    7,
+    1,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 29245,
+   "seconds": 12.0,
+   "avg_fps": 2437.044,
+   "low_1pct_fps": 728.266,
+   "low_01pct_fps": 249.55,
+   "p50_ms": 0.38,
+   "p95_ms": 0.555,
+   "p99_ms": 0.892,
+   "p999_ms": 1.851,
+   "max_ms": 6.973,
+   "histogram": [
+    29066,
+    154,
+    4,
+    6,
+    7,
+    6,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 28738,
+   "seconds": 12.0,
+   "avg_fps": 2394.789,
+   "low_1pct_fps": 724.144,
+   "low_01pct_fps": 241.293,
+   "p50_ms": 0.384,
+   "p95_ms": 0.571,
+   "p99_ms": 0.907,
+   "p999_ms": 1.833,
+   "max_ms": 8.35,
+   "histogram": [
+    28573,
+    140,
+    6,
+    3,
+    6,
+    5,
+    3,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 29309,
+   "seconds": 12.0,
+   "avg_fps": 2442.383,
+   "low_1pct_fps": 746.55,
+   "low_01pct_fps": 258.934,
+   "p50_ms": 0.378,
+   "p95_ms": 0.566,
+   "p99_ms": 0.876,
+   "p999_ms": 1.744,
+   "max_ms": 10.291,
+   "histogram": [
+    29138,
+    148,
+    5,
+    6,
+    5,
+    2,
+    4,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 29454,
+   "seconds": 12.0,
+   "avg_fps": 2454.493,
+   "low_1pct_fps": 769.741,
+   "low_01pct_fps": 252.457,
+   "p50_ms": 0.378,
+   "p95_ms": 0.55,
+   "p99_ms": 0.853,
+   "p999_ms": 1.471,
+   "max_ms": 6.629,
+   "histogram": [
+    29323,
+    110,
+    2,
+    2,
+    7,
+    7,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 28729,
+   "seconds": 12.0,
+   "avg_fps": 2394.02,
+   "low_1pct_fps": 747.287,
+   "low_01pct_fps": 254.49,
+   "p50_ms": 0.383,
+   "p95_ms": 0.579,
+   "p99_ms": 0.896,
+   "p999_ms": 1.56,
+   "max_ms": 7.367,
+   "histogram": [
+    28567,
+    141,
+    3,
+    5,
+    4,
+    4,
+    4,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 29370,
+   "seconds": 12.0,
+   "avg_fps": 2447.458,
+   "low_1pct_fps": 775.168,
+   "low_01pct_fps": 278.916,
+   "p50_ms": 0.376,
+   "p95_ms": 0.559,
+   "p99_ms": 0.887,
+   "p999_ms": 1.567,
+   "max_ms": 9.65,
+   "histogram": [
+    29209,
+    141,
+    3,
+    9,
+    0,
+    5,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 31116,
+   "seconds": 12.0,
+   "avg_fps": 2592.938,
+   "low_1pct_fps": 761.584,
+   "low_01pct_fps": 224.391,
+   "p50_ms": 0.356,
+   "p95_ms": 0.511,
+   "p99_ms": 0.767,
+   "p999_ms": 1.843,
+   "max_ms": 8.478,
+   "histogram": [
+    31011,
+    76,
+    4,
+    3,
+    13,
+    4,
+    3,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 29554,
+   "seconds": 12.0,
+   "avg_fps": 2462.815,
+   "low_1pct_fps": 746.001,
+   "low_01pct_fps": 238.423,
+   "p50_ms": 0.366,
+   "p95_ms": 0.579,
+   "p99_ms": 0.849,
+   "p999_ms": 1.75,
+   "max_ms": 7.607,
+   "histogram": [
+    29430,
+    101,
+    2,
+    3,
+    9,
+    4,
+    3,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 30701,
+   "seconds": 12.0,
+   "avg_fps": 2558.396,
+   "low_1pct_fps": 772.895,
+   "low_01pct_fps": 259.878,
+   "p50_ms": 0.357,
+   "p95_ms": 0.537,
+   "p99_ms": 0.81,
+   "p999_ms": 1.702,
+   "max_ms": 6.682,
+   "histogram": [
+    30568,
+    112,
+    1,
+    6,
+    5,
+    3,
+    6,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "vanilla-mods-win-9800x3d-5080"
+}

benchmarks/perf/vanilla-win-9800x3d-5080-rd16.json

@@ -0,0 +1,690 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-10-29T01:19:23Z",
+ "app": {
+  "name": "minecraft",
+  "version": "26.3",
+  "mods": [
+   {
+    "name": "fabric-loader",
+    "version": "0.19.5"
+   }
+  ]
+ },
+ "hardware": {
+  "os": "windows",
+  "arch": "x86_64",
+  "cpu_threads": 16,
+  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
+  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
+  "ram_mb": 95943,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
+   "vendor": "NVIDIA Corporation",
+   "driver": "3.3.0 NVIDIA 617.42",
+   "backend": "opengl",
+   "kind": ""
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 16,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 7681.834,
+   "stdev": 189.48,
+   "min": 7538.777,
+   "max": 7896.728,
+   "ci95": 470.732
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 19898.834,
+   "stdev": 192.981,
+   "min": 19695.728,
+   "max": 20079.777,
+   "ci95": 479.431
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 6127.947,
+   "stdev": 26.756,
+   "min": 6097.19,
+   "max": 6145.854,
+   "ci95": 66.471
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 1218.486,
+   "stdev": 26.337,
+   "min": 1188.13,
+   "max": 1235.248,
+   "ci95": 65.43
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 318.468,
+   "stdev": 6.292,
+   "min": 313.2,
+   "max": 325.435,
+   "ci95": 15.632
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 126.59,
+   "stdev": 1.844,
+   "min": 124.744,
+   "max": 128.431,
+   "ci95": 4.58
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 8548.814,
+   "stdev": 152.302,
+   "min": 8380.912,
+   "max": 8678.071,
+   "ci95": 378.37
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 1912.359,
+   "stdev": 130.238,
+   "min": 1791.386,
+   "max": 2050.215,
+   "ci95": 323.555
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 401.907,
+   "stdev": 35.911,
+   "min": 379.849,
+   "max": 443.345,
+   "ci95": 89.216
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 149.26,
+   "stdev": 9.983,
+   "min": 139.809,
+   "max": 159.701,
+   "ci95": 24.801
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 6953.478,
+   "stdev": 276.636,
+   "min": 6635.649,
+   "max": 7140.072,
+   "ci95": 687.258
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 1860.512,
+   "stdev": 116.512,
+   "min": 1726.149,
+   "max": 1933.597,
+   "ci95": 289.454
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 446.336,
+   "stdev": 56.993,
+   "min": 382.26,
+   "max": 491.369,
+   "ci95": 141.589
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 164.934,
+   "stdev": 11.839,
+   "min": 152.493,
+   "max": 176.062,
+   "ci95": 29.413
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 15211.386,
+   "stdev": 256.348,
+   "min": 14938.008,
+   "max": 15446.375,
+   "ci95": 636.856
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 1653.223,
+   "stdev": 61.705,
+   "min": 1584.652,
+   "max": 1704.273,
+   "ci95": 153.297
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 331.929,
+   "stdev": 10.858,
+   "min": 319.394,
+   "max": 338.396,
+   "ci95": 26.974
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 113.436,
+   "stdev": 3.255,
+   "min": 110.869,
+   "max": 117.097,
+   "ci95": 8.086
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 2540.129,
+   "stdev": 152.057,
+   "min": 2373.152,
+   "max": 2670.633,
+   "ci95": 377.761
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 2299.514,
+   "stdev": 81.451,
+   "min": 2207.129,
+   "max": 2360.973,
+   "ci95": 202.352
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 14785,
+   "seconds": 12.0,
+   "avg_fps": 1232.081,
+   "low_1pct_fps": 325.435,
+   "low_01pct_fps": 128.431,
+   "p50_ms": 0.742,
+   "p95_ms": 1.265,
+   "p99_ms": 2.032,
+   "p999_ms": 5.653,
+   "max_ms": 12.791,
+   "histogram": [
+    12845,
+    1784,
+    127,
+    7,
+    1,
+    8,
+    4,
+    3,
+    5,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 14258,
+   "seconds": 12.0,
+   "avg_fps": 1188.13,
+   "low_1pct_fps": 313.2,
+   "low_01pct_fps": 126.595,
+   "p50_ms": 0.757,
+   "p95_ms": 1.349,
+   "p99_ms": 2.12,
+   "p999_ms": 5.541,
+   "max_ms": 13.998,
+   "histogram": [
+    11994,
+    2076,
+    157,
+    9,
+    2,
+    8,
+    2,
+    4,
+    5,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 14823,
+   "seconds": 12.0,
+   "avg_fps": 1235.248,
+   "low_1pct_fps": 316.768,
+   "low_01pct_fps": 124.744,
+   "p50_ms": 0.744,
+   "p95_ms": 1.199,
+   "p99_ms": 2.047,
+   "p999_ms": 5.628,
+   "max_ms": 15.519,
+   "histogram": [
+    13214,
+    1453,
+    118,
+    16,
+    2,
+    8,
+    6,
+    3,
+    0,
+    1,
+    0,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 21497,
+   "seconds": 12.0,
+   "avg_fps": 1791.386,
+   "low_1pct_fps": 382.527,
+   "low_01pct_fps": 139.809,
+   "p50_ms": 0.474,
+   "p95_ms": 0.931,
+   "p99_ms": 1.646,
+   "p999_ms": 5.274,
+   "max_ms": 13.459,
+   "histogram": [
+    20598,
+    799,
+    66,
+    9,
+    3,
+    8,
+    8,
+    2,
+    2,
+    0,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 24603,
+   "seconds": 12.0,
+   "avg_fps": 2050.215,
+   "low_1pct_fps": 443.345,
+   "low_01pct_fps": 159.701,
+   "p50_ms": 0.426,
+   "p95_ms": 0.752,
+   "p99_ms": 1.442,
+   "p999_ms": 3.134,
+   "max_ms": 13.282,
+   "histogram": [
+    24041,
+    487,
+    48,
+    6,
+    5,
+    6,
+    2,
+    3,
+    3,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 22746,
+   "seconds": 12.0,
+   "avg_fps": 1895.476,
+   "low_1pct_fps": 379.849,
+   "low_01pct_fps": 148.269,
+   "p50_ms": 0.456,
+   "p95_ms": 0.829,
+   "p99_ms": 1.561,
+   "p999_ms": 4.176,
+   "max_ms": 10.671,
+   "histogram": [
+    22092,
+    523,
+    91,
+    17,
+    4,
+    7,
+    3,
+    4,
+    4,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 23062,
+   "seconds": 12.0,
+   "avg_fps": 1921.791,
+   "low_1pct_fps": 465.379,
+   "low_01pct_fps": 166.247,
+   "p50_ms": 0.463,
+   "p95_ms": 0.809,
+   "p99_ms": 1.45,
+   "p999_ms": 2.398,
+   "max_ms": 11.808,
+   "histogram": [
+    22454,
+    561,
+    27,
+    3,
+    2,
+    6,
+    0,
+    4,
+    3,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 23204,
+   "seconds": 12.0,
+   "avg_fps": 1933.597,
+   "low_1pct_fps": 491.369,
+   "low_01pct_fps": 176.062,
+   "p50_ms": 0.466,
+   "p95_ms": 0.766,
+   "p99_ms": 1.406,
+   "p999_ms": 2.229,
+   "max_ms": 15.102,
+   "histogram": [
+    22699,
+    469,
+    19,
+    4,
+    1,
+    1,
+    4,
+    2,
+    2,
+    2,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 20714,
+   "seconds": 12.0,
+   "avg_fps": 1726.149,
+   "low_1pct_fps": 382.26,
+   "low_01pct_fps": 152.493,
+   "p50_ms": 0.5,
+   "p95_ms": 0.956,
+   "p99_ms": 1.742,
+   "p999_ms": 3.852,
+   "max_ms": 12.888,
+   "histogram": [
+    19814,
+    787,
+    83,
+    11,
+    2,
+    7,
+    3,
+    5,
+    0,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 20049,
+   "seconds": 12.0,
+   "avg_fps": 1670.745,
+   "low_1pct_fps": 338.396,
+   "low_01pct_fps": 117.097,
+   "p50_ms": 0.502,
+   "p95_ms": 0.949,
+   "p99_ms": 1.673,
+   "p999_ms": 6.456,
+   "max_ms": 16.791,
+   "histogram": [
+    19187,
+    753,
+    70,
+    8,
+    1,
+    6,
+    12,
+    4,
+    3,
+    4,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 19016,
+   "seconds": 12.0,
+   "avg_fps": 1584.652,
+   "low_1pct_fps": 337.998,
+   "low_01pct_fps": 112.343,
+   "p50_ms": 0.531,
+   "p95_ms": 1.082,
+   "p99_ms": 1.717,
+   "p999_ms": 5.939,
+   "max_ms": 12.958,
+   "histogram": [
+    17849,
+    1069,
+    63,
+    7,
+    3,
+    6,
+    2,
+    7,
+    4,
+    5,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 20452,
+   "seconds": 12.0,
+   "avg_fps": 1704.273,
+   "low_1pct_fps": 319.394,
+   "low_01pct_fps": 110.869,
+   "p50_ms": 0.496,
+   "p95_ms": 0.911,
+   "p99_ms": 1.706,
+   "p999_ms": 5.938,
+   "max_ms": 24.863,
+   "histogram": [
+    19694,
+    626,
+    82,
+    14,
+    3,
+    14,
+    5,
+    4,
+    5,
+    3,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "vanilla-win-9800x3d-5080"
+}

benchmarks/perf/vanilla-win-9800x3d-5080-rd32.json

@@ -0,0 +1,690 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-10-29T19:06:49Z",
+ "app": {
+  "name": "minecraft",
+  "version": "26.3",
+  "mods": [
+   {
+    "name": "fabric-loader",
+    "version": "0.19.5"
+   }
+  ]
+ },
+ "hardware": {
+  "os": "windows",
+  "arch": "x86_64",
+  "cpu_threads": 16,
+  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
+  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
+  "ram_mb": 95943,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
+   "vendor": "NVIDIA Corporation",
+   "driver": "3.3.0 NVIDIA 617.42",
+   "backend": "opengl",
+   "kind": ""
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 32,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 7518.874,
+   "stdev": 42.968,
+   "min": 7469.532,
+   "max": 7548.049,
+   "ci95": 106.748
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 35424.207,
+   "stdev": 144.711,
+   "min": 35318.049,
+   "max": 35589.041,
+   "ci95": 359.511
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 11146.828,
+   "stdev": 49.683,
+   "min": 11094.798,
+   "max": 11193.773,
+   "ci95": 123.43
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 882.053,
+   "stdev": 19.433,
+   "min": 866.126,
+   "max": 903.706,
+   "ci95": 48.279
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 183.995,
+   "stdev": 4.924,
+   "min": 178.512,
+   "max": 188.041,
+   "ci95": 12.234
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 83.193,
+   "stdev": 6.797,
+   "min": 77.734,
+   "max": 90.806,
+   "ci95": 16.886
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 18184.002,
+   "stdev": 266.879,
+   "min": 17880.667,
+   "max": 18382.735,
+   "ci95": 663.017
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 1202.907,
+   "stdev": 20.426,
+   "min": 1179.9,
+   "max": 1218.906,
+   "ci95": 50.744
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 228.139,
+   "stdev": 5.166,
+   "min": 222.394,
+   "max": 232.401,
+   "ci95": 12.833
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 107.956,
+   "stdev": 4.675,
+   "min": 105.185,
+   "max": 113.354,
+   "ci95": 11.614
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 13146.632,
+   "stdev": 507.943,
+   "min": 12572.118,
+   "max": 13536.145,
+   "ci95": 1261.902
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 1223.169,
+   "stdev": 13.11,
+   "min": 1208.837,
+   "max": 1234.556,
+   "ci95": 32.569
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 236.27,
+   "stdev": 6.77,
+   "min": 228.686,
+   "max": 241.702,
+   "ci95": 16.818
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 99.089,
+   "stdev": 8.354,
+   "min": 91.897,
+   "max": 108.253,
+   "ci95": 20.755
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 41846.641,
+   "stdev": 661.649,
+   "min": 41435.666,
+   "max": 42609.895,
+   "ci95": 1643.76
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 815.008,
+   "stdev": 24.644,
+   "min": 797.565,
+   "max": 843.201,
+   "ci95": 61.224
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 55.371,
+   "stdev": 5.128,
+   "min": 50.389,
+   "max": 60.633,
+   "ci95": 12.739
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 7.966,
+   "stdev": 1.103,
+   "min": 6.848,
+   "max": 9.053,
+   "ci95": 2.74
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 2892.492,
+   "stdev": 29.54,
+   "min": 2859.574,
+   "max": 2916.691,
+   "ci95": 73.387
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 2799.159,
+   "stdev": 12.256,
+   "min": 2786.234,
+   "max": 2810.613,
+   "ci95": 30.447
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 10845,
+   "seconds": 12.001,
+   "avg_fps": 903.706,
+   "low_1pct_fps": 185.432,
+   "low_01pct_fps": 81.039,
+   "p50_ms": 0.98,
+   "p95_ms": 1.708,
+   "p99_ms": 3.082,
+   "p999_ms": 9.304,
+   "max_ms": 15.487,
+   "histogram": [
+    6030,
+    4403,
+    297,
+    49,
+    25,
+    16,
+    8,
+    2,
+    6,
+    2,
+    4,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 10516,
+   "seconds": 12.0,
+   "avg_fps": 876.328,
+   "low_1pct_fps": 188.041,
+   "low_01pct_fps": 90.806,
+   "p50_ms": 1.012,
+   "p95_ms": 1.806,
+   "p99_ms": 3.354,
+   "p999_ms": 8.714,
+   "max_ms": 14.39,
+   "histogram": [
+    4927,
+    5158,
+    292,
+    70,
+    33,
+    13,
+    6,
+    5,
+    6,
+    2,
+    3,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 10394,
+   "seconds": 12.001,
+   "avg_fps": 866.126,
+   "low_1pct_fps": 178.512,
+   "low_01pct_fps": 77.734,
+   "p50_ms": 1.026,
+   "p95_ms": 1.789,
+   "p99_ms": 3.399,
+   "p999_ms": 10.6,
+   "max_ms": 15.389,
+   "histogram": [
+    4437,
+    5552,
+    273,
+    65,
+    18,
+    28,
+    8,
+    1,
+    1,
+    3,
+    5,
+    3,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 14519,
+   "seconds": 12.0,
+   "avg_fps": 1209.916,
+   "low_1pct_fps": 232.401,
+   "low_01pct_fps": 105.185,
+   "p50_ms": 0.726,
+   "p95_ms": 1.306,
+   "p99_ms": 2.25,
+   "p999_ms": 7.033,
+   "max_ms": 13.303,
+   "histogram": [
+    13121,
+    1197,
+    103,
+    36,
+    24,
+    19,
+    4,
+    3,
+    8,
+    2,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 14159,
+   "seconds": 12.0,
+   "avg_fps": 1179.9,
+   "low_1pct_fps": 222.394,
+   "low_01pct_fps": 105.33,
+   "p50_ms": 0.732,
+   "p95_ms": 1.366,
+   "p99_ms": 2.499,
+   "p999_ms": 8.061,
+   "max_ms": 11.797,
+   "histogram": [
+    12501,
+    1356,
+    195,
+    45,
+    25,
+    14,
+    6,
+    3,
+    9,
+    5,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 14627,
+   "seconds": 12.0,
+   "avg_fps": 1218.906,
+   "low_1pct_fps": 229.622,
+   "low_01pct_fps": 113.354,
+   "p50_ms": 0.713,
+   "p95_ms": 1.292,
+   "p99_ms": 2.317,
+   "p999_ms": 7.136,
+   "max_ms": 12.041,
+   "histogram": [
+    13194,
+    1224,
+    97,
+    47,
+    27,
+    21,
+    2,
+    6,
+    6,
+    2,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 14714,
+   "seconds": 12.001,
+   "avg_fps": 1226.113,
+   "low_1pct_fps": 238.423,
+   "low_01pct_fps": 97.117,
+   "p50_ms": 0.722,
+   "p95_ms": 1.223,
+   "p99_ms": 2.243,
+   "p999_ms": 7.032,
+   "max_ms": 13.21,
+   "histogram": [
+    13490,
+    1027,
+    115,
+    29,
+    18,
+    13,
+    7,
+    3,
+    3,
+    5,
+    4,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 14507,
+   "seconds": 12.001,
+   "avg_fps": 1208.837,
+   "low_1pct_fps": 228.686,
+   "low_01pct_fps": 91.897,
+   "p50_ms": 0.719,
+   "p95_ms": 1.256,
+   "p99_ms": 2.354,
+   "p999_ms": 7.473,
+   "max_ms": 15.432,
+   "histogram": [
+    13124,
+    1112,
+    180,
+    35,
+    23,
+    9,
+    8,
+    4,
+    2,
+    6,
+    2,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 14815,
+   "seconds": 12.0,
+   "avg_fps": 1234.556,
+   "low_1pct_fps": 241.702,
+   "low_01pct_fps": 108.253,
+   "p50_ms": 0.721,
+   "p95_ms": 1.2,
+   "p99_ms": 2.197,
+   "p999_ms": 6.689,
+   "max_ms": 12.791,
+   "histogram": [
+    13565,
+    1055,
+    107,
+    29,
+    23,
+    15,
+    8,
+    3,
+    4,
+    5,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 10119,
+   "seconds": 12.001,
+   "avg_fps": 843.201,
+   "low_1pct_fps": 60.633,
+   "low_01pct_fps": 9.053,
+   "p50_ms": 0.891,
+   "p95_ms": 1.845,
+   "p99_ms": 3.91,
+   "p999_ms": 8.209,
+   "max_ms": 316.409,
+   "histogram": [
+    6956,
+    2747,
+    240,
+    83,
+    45,
+    22,
+    8,
+    8,
+    5,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    4,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 9693,
+   "seconds": 12.052,
+   "avg_fps": 804.258,
+   "low_1pct_fps": 50.389,
+   "low_01pct_fps": 6.848,
+   "p50_ms": 0.906,
+   "p95_ms": 1.924,
+   "p99_ms": 4.157,
+   "p999_ms": 8.578,
+   "max_ms": 297.695,
+   "histogram": [
+    6578,
+    2678,
+    248,
+    94,
+    45,
+    18,
+    16,
+    5,
+    4,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    5,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 9571,
+   "seconds": 12.0,
+   "avg_fps": 797.565,
+   "low_1pct_fps": 55.09,
+   "low_01pct_fps": 7.997,
+   "p50_ms": 0.929,
+   "p95_ms": 1.944,
+   "p99_ms": 4.495,
+   "p999_ms": 7.764,
+   "max_ms": 321.994,
+   "histogram": [
+    5954,
+    3172,
+    230,
+    103,
+    39,
+    34,
+    19,
+    11,
+    4,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    4,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "vanilla-win-9800x3d-5080"
+}

benchmarks/perf/vanilla-win-9800x3d-5080-rd8.json

@@ -0,0 +1,690 @@
+{
+ "format": "horizon-benchmark-report",
+ "version": 1,
+ "kind": "game",
+ "created": "2026-10-29T18:43:17Z",
+ "app": {
+  "name": "minecraft",
+  "version": "26.3",
+  "mods": [
+   {
+    "name": "fabric-loader",
+    "version": "0.19.5"
+   }
+  ]
+ },
+ "hardware": {
+  "os": "windows",
+  "arch": "x86_64",
+  "cpu_threads": 16,
+  "os_version": "Microsoft Windows [Version 10.0.26200.8037]",
+  "cpu": "AMD Ryzen 7 9800X3D 8-Core Processor",
+  "ram_mb": 95943,
+  "gpu": {
+   "name": "NVIDIA GeForce RTX 5080/PCIe/SSE2",
+   "vendor": "NVIDIA Corporation",
+   "driver": "3.3.0 NVIDIA 617.42",
+   "backend": "opengl",
+   "kind": ""
+  }
+ },
+ "conditions": {
+  "scenario": "perf_bench:village,forest,ocean,mountain",
+  "seed": "1234",
+  "render_distance": 8,
+  "simulation_distance": 12,
+  "vsync": false,
+  "offscreen": false,
+  "repeats": 3,
+  "warmup_s": 2.0,
+  "window": [
+   1280,
+   720
+  ]
+ },
+ "metrics": {
+  "startup.title_ms": {
+   "n": 3,
+   "mean": 7676.526,
+   "stdev": 305.763,
+   "min": 7426.024,
+   "max": 8017.247,
+   "ci95": 759.617
+  },
+  "startup.world_ms": {
+   "n": 3,
+   "mean": 13862.526,
+   "stdev": 284.577,
+   "min": 13569.024,
+   "max": 14137.247,
+   "ci95": 706.985
+  },
+  "chunks.village.load_ms": {
+   "n": 3,
+   "mean": 3808.014,
+   "stdev": 61.275,
+   "min": 3737.989,
+   "max": 3851.799,
+   "ci95": 152.227
+  },
+  "fps.village.avg_fps": {
+   "n": 3,
+   "mean": 2216.576,
+   "stdev": 45.247,
+   "min": 2166.285,
+   "max": 2253.985,
+   "ci95": 112.409
+  },
+  "fps.village.low_1pct_fps": {
+   "n": 3,
+   "mean": 545.307,
+   "stdev": 14.876,
+   "min": 528.15,
+   "max": 554.607,
+   "ci95": 36.957
+  },
+  "fps.village.low_01pct_fps": {
+   "n": 3,
+   "mean": 215.412,
+   "stdev": 5.692,
+   "min": 209.522,
+   "max": 220.882,
+   "ci95": 14.14
+  },
+  "chunks.forest.load_ms": {
+   "n": 3,
+   "mean": 3212.958,
+   "stdev": 151.722,
+   "min": 3076.655,
+   "max": 3376.428,
+   "ci95": 376.928
+  },
+  "fps.forest.avg_fps": {
+   "n": 3,
+   "mean": 2456.542,
+   "stdev": 336.369,
+   "min": 2068.162,
+   "max": 2654.549,
+   "ci95": 835.654
+  },
+  "fps.forest.low_1pct_fps": {
+   "n": 3,
+   "mean": 624.759,
+   "stdev": 90.0,
+   "min": 521.303,
+   "max": 685.008,
+   "ci95": 223.59
+  },
+  "fps.forest.low_01pct_fps": {
+   "n": 3,
+   "mean": 252.469,
+   "stdev": 21.044,
+   "min": 229.228,
+   "max": 270.233,
+   "ci95": 52.28
+  },
+  "chunks.ocean.load_ms": {
+   "n": 3,
+   "mean": 2983.236,
+   "stdev": 168.416,
+   "min": 2788.777,
+   "max": 3082.249,
+   "ci95": 418.403
+  },
+  "fps.ocean.avg_fps": {
+   "n": 3,
+   "mean": 2469.831,
+   "stdev": 333.258,
+   "min": 2085.121,
+   "max": 2669.9,
+   "ci95": 827.925
+  },
+  "fps.ocean.low_1pct_fps": {
+   "n": 3,
+   "mean": 688.684,
+   "stdev": 96.943,
+   "min": 576.803,
+   "max": 747.759,
+   "ci95": 240.839
+  },
+  "fps.ocean.low_01pct_fps": {
+   "n": 3,
+   "mean": 286.444,
+   "stdev": 21.36,
+   "min": 262.183,
+   "max": 302.422,
+   "ci95": 53.066
+  },
+  "chunks.mountain.load_ms": {
+   "n": 3,
+   "mean": 6079.869,
+   "stdev": 719.864,
+   "min": 5542.196,
+   "max": 6897.69,
+   "ci95": 1788.385
+  },
+  "fps.mountain.avg_fps": {
+   "n": 3,
+   "mean": 2605.12,
+   "stdev": 326.424,
+   "min": 2228.824,
+   "max": 2812.075,
+   "ci95": 810.948
+  },
+  "fps.mountain.low_1pct_fps": {
+   "n": 3,
+   "mean": 699.63,
+   "stdev": 87.846,
+   "min": 599.44,
+   "max": 763.45,
+   "ci95": 218.239
+  },
+  "fps.mountain.low_01pct_fps": {
+   "n": 3,
+   "mean": 264.461,
+   "stdev": 28.459,
+   "min": 239.602,
+   "max": 295.503,
+   "ci95": 70.701
+  },
+  "memory.rss_peak_mb": {
+   "n": 3,
+   "mean": 2120.426,
+   "stdev": 116.406,
+   "min": 2046.93,
+   "max": 2254.637,
+   "ci95": 289.191
+  },
+  "memory.rss_steady_mb": {
+   "n": 3,
+   "mean": 1912.642,
+   "stdev": 38.925,
+   "min": 1889.766,
+   "max": 1957.586,
+   "ci95": 96.702
+  }
+ },
+ "frames": [
+  {
+   "phase": "village",
+   "repeat": 0,
+   "frames": 27048,
+   "seconds": 12.0,
+   "avg_fps": 2253.985,
+   "low_1pct_fps": 553.164,
+   "low_01pct_fps": 215.833,
+   "p50_ms": 0.412,
+   "p95_ms": 0.617,
+   "p99_ms": 1.187,
+   "p999_ms": 2.238,
+   "max_ms": 9.792,
+   "histogram": [
+    26716,
+    296,
+    15,
+    4,
+    7,
+    5,
+    2,
+    2,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 1,
+   "frames": 26754,
+   "seconds": 12.0,
+   "avg_fps": 2229.458,
+   "low_1pct_fps": 554.607,
+   "low_01pct_fps": 220.882,
+   "p50_ms": 0.417,
+   "p95_ms": 0.626,
+   "p99_ms": 1.212,
+   "p999_ms": 2.448,
+   "max_ms": 8.388,
+   "histogram": [
+    26423,
+    293,
+    16,
+    9,
+    4,
+    5,
+    1,
+    1,
+    2,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "village",
+   "repeat": 2,
+   "frames": 25996,
+   "seconds": 12.0,
+   "avg_fps": 2166.285,
+   "low_1pct_fps": 528.15,
+   "low_01pct_fps": 209.522,
+   "p50_ms": 0.43,
+   "p95_ms": 0.662,
+   "p99_ms": 1.308,
+   "p999_ms": 2.477,
+   "max_ms": 11.033,
+   "histogram": [
+    25615,
+    338,
+    23,
+    5,
+    5,
+    5,
+    2,
+    2,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 0,
+   "frames": 31855,
+   "seconds": 12.0,
+   "avg_fps": 2654.549,
+   "low_1pct_fps": 667.966,
+   "low_01pct_fps": 257.945,
+   "p50_ms": 0.341,
+   "p95_ms": 0.519,
+   "p99_ms": 0.932,
+   "p999_ms": 1.761,
+   "max_ms": 10.944,
+   "histogram": [
+    31558,
+    275,
+    6,
+    2,
+    7,
+    0,
+    4,
+    2,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 1,
+   "frames": 31763,
+   "seconds": 12.0,
+   "avg_fps": 2646.916,
+   "low_1pct_fps": 685.008,
+   "low_01pct_fps": 270.233,
+   "p50_ms": 0.344,
+   "p95_ms": 0.52,
+   "p99_ms": 0.94,
+   "p999_ms": 1.685,
+   "max_ms": 11.406,
+   "histogram": [
+    31474,
+    272,
+    3,
+    4,
+    2,
+    2,
+    1,
+    3,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "forest",
+   "repeat": 2,
+   "frames": 24818,
+   "seconds": 12.0,
+   "avg_fps": 2068.162,
+   "low_1pct_fps": 521.303,
+   "low_01pct_fps": 229.228,
+   "p50_ms": 0.439,
+   "p95_ms": 0.767,
+   "p99_ms": 1.284,
+   "p999_ms": 2.351,
+   "max_ms": 11.468,
+   "histogram": [
+    24356,
+    410,
+    36,
+    4,
+    4,
+    3,
+    2,
+    2,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 0,
+   "frames": 32039,
+   "seconds": 12.0,
+   "avg_fps": 2669.9,
+   "low_1pct_fps": 741.491,
+   "low_01pct_fps": 294.727,
+   "p50_ms": 0.345,
+   "p95_ms": 0.501,
+   "p99_ms": 0.86,
+   "p999_ms": 1.431,
+   "max_ms": 9.257,
+   "histogram": [
+    31771,
+    250,
+    3,
+    2,
+    4,
+    6,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 1,
+   "frames": 31854,
+   "seconds": 12.0,
+   "avg_fps": 2654.471,
+   "low_1pct_fps": 747.759,
+   "low_01pct_fps": 302.422,
+   "p50_ms": 0.347,
+   "p95_ms": 0.503,
+   "p99_ms": 0.853,
+   "p999_ms": 1.404,
+   "max_ms": 13.925,
+   "histogram": [
+    31580,
+    261,
+    3,
+    2,
+    0,
+    1,
+    3,
+    3,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "ocean",
+   "repeat": 2,
+   "frames": 25022,
+   "seconds": 12.0,
+   "avg_fps": 2085.121,
+   "low_1pct_fps": 576.803,
+   "low_01pct_fps": 262.183,
+   "p50_ms": 0.428,
+   "p95_ms": 0.758,
+   "p99_ms": 1.214,
+   "p999_ms": 2.109,
+   "max_ms": 9.206,
+   "histogram": [
+    24600,
+    390,
+    20,
+    3,
+    2,
+    3,
+    2,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 0,
+   "frames": 33745,
+   "seconds": 12.0,
+   "avg_fps": 2812.075,
+   "low_1pct_fps": 736.0,
+   "low_01pct_fps": 258.279,
+   "p50_ms": 0.327,
+   "p95_ms": 0.471,
+   "p99_ms": 0.808,
+   "p999_ms": 1.689,
+   "max_ms": 10.07,
+   "histogram": [
+    33516,
+    205,
+    7,
+    0,
+    7,
+    4,
+    3,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 1,
+   "frames": 33294,
+   "seconds": 12.0,
+   "avg_fps": 2774.461,
+   "low_1pct_fps": 763.45,
+   "low_01pct_fps": 295.503,
+   "p50_ms": 0.334,
+   "p95_ms": 0.471,
+   "p99_ms": 0.813,
+   "p999_ms": 1.63,
+   "max_ms": 8.512,
+   "histogram": [
+    33056,
+    221,
+    3,
+    5,
+    1,
+    2,
+    3,
+    2,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  },
+  {
+   "phase": "mountain",
+   "repeat": 2,
+   "frames": 26747,
+   "seconds": 12.0,
+   "avg_fps": 2228.824,
+   "low_1pct_fps": 599.44,
+   "low_01pct_fps": 239.602,
+   "p50_ms": 0.403,
+   "p95_ms": 0.678,
+   "p99_ms": 1.107,
+   "p999_ms": 2.054,
+   "max_ms": 9.178,
+   "histogram": [
+    26418,
+    298,
+    13,
+    6,
+    2,
+    8,
+    0,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0
+   ]
+  }
+ ],
+ "label": "vanilla-win-9800x3d-5080"
+}

benchmarks/perf/windows-9800x3d-5080-2026-10-29.md

@@ -0,0 +1,106 @@
+# Horizon v0.2.97 vs vanilla 26.3 on Windows 11: Ryzen 7 9800X3D + RTX 5080 (2026-10-29, RD 8 and 32 rerun 2026-10-30)
+
+The first `tools/perf_bench.py` run on Windows ([docs/benchmark.md](../../docs/benchmark.md)): Horizon, vanilla 26.3 and
+vanilla with performance mods, render distances 8, 16 and 32, 1280x720, three games each, every game from a fresh
+world. The reports are the `*-win-9800x3d-5080-rd*.json` files next to this page.
+
+```sh
+python tools/perf_bench.py --table horizon-win-9800x3d-5080 vanilla-win-9800x3d-5080 vanilla-mods-win-9800x3d-5080
+```
+
+## Setup
+
+- **Machine:** AMD Ryzen 7 9800X3D (8 cores, 16 threads), 94 GB RAM (DDR5, EXPO off), NVIDIA GeForce RTX 5080
+  (driver 617.42), Windows 11 Pro 26200, Balanced power plan, desktop. One 1920x1080 120 Hz display. The game windows
+  were on the desktop of an unlocked session.
+- **Horizon:** release v0.2.97 as the launcher installs it (`--build %APPDATA%\horizon-launcher\versions\v0.2.97`,
+  `--resources` its `.local\horizon-client\26.3`), Vulkan.
+- **Vanilla:** the 26.3 client jar with Fabric Loader 0.19.5 and the driver mod, Java 25.0.5 (Temurin), `-Xmx2G`
+  with the launcher's G1 flags and the manifest's `-XX:StackShadowPages=32`, OpenGL 3.3.
+- **Vanilla + mods:** the same with Sodium mc26.3-0.9.2, Lithium mc26.3-0.26.2, FerriteCore 9.0.0 and
+  ImmediatelyFast 1.17.1 (`tools/benchmark-deps/mods.lock.json`).
+- **Commands:** `python tools/perf_bench.py --game <game> --label <game>-win-9800x3d-5080 --distances <d>
+  --sizes 1280x720 --repeats 3` (plus `--build` and `--resources` for Horizon), with the games taking turns at
+  each distance.
+- **Memory** is the working set on Windows (what Task Manager shows), sampled from outside the process. Horizon's
+  GPU figure is its own Vulkan allocator total. `nvidia-smi` gives no per-process figure under WDDM, so vanilla has
+  none.
+
+## Load
+
+Windows has no load average, so the reports have no `load_avg_1m`. Every game ran on an otherwise idle machine:
+
+- **RD 8 and RD 32** (rerun on 2026-10-30, after the first pass had builds running alongside): a script started each
+  game only once no `rustc`, `cargo`, `link` (or other compiler) process and no other game (`horizon-client`, `java`,
+  `javaw`, Minecraft) was running, and the machine's CPU load had stayed under 15 % in every 5-second sample for
+  30 seconds. During each game it sampled every 2 seconds the machine's CPU load and the CPU of everything outside the
+  benchmark's own processes. A game during which a compiler or another game ran, or other processes used over 15 % of
+  the machine for 10 seconds, was discarded and run again: two of the 20 games were (vanilla + mods at RD 32, a
+  build started during one, background processes during the other).
+- **RD 16** (2026-10-29): no `rustc`, `cargo` or `link` process at any point, the load logged every 5 seconds.
+
+| Game | RD | Mean / max CPU load (machine, the game included) | Other processes' CPU, mean / max | Compiler processes |
+|---|---|---|---|---|
+| Horizon | 8 | 18 % / 49 % | 6 % / 12 % | 0 |
+| Vanilla | 8 | 28 % / 75 % | 7 % / 20 % | 0 |
+| Vanilla + mods | 8 | 30 % / 81 % | 7 % / 20 % | 0 |
+| Horizon | 16 | 29 % / 80 % | – | 0 |
+| Vanilla | 16 | 41 % / 91 % | – | 0 |
+| Vanilla + mods | 16 | 51 % / 90 % | – | 0 |
+| Horizon | 32 | 36 % / 100 % | 5 % / 15 % | 0 |
+| Vanilla | 32 | 39 % / 73 % | 6 % / 18 % | 0 |
+| Vanilla + mods | 32 | 42 % / 88 % | 6 % / 21 % | 0 |
+
+"Other processes" is the machine's load minus the benchmark's own processes (the game and `perf_bench.py`), in
+2-second samples. Most of it is the system's share of the game's own drawing (the graphics driver and the
+compositor), which no process of the benchmark is charged for; the desktop apps left open (a browser, chat apps)
+briefly reached 5 % at most. RD 16's load was logged from outside every 5 seconds, so it has no such split, and its mean includes the time between
+games. Compared with the first pass, the idle RD 8 runs give Horizon about 10 % higher averages and about 50 % higher
+1% lows, and vanilla up to 10 % higher averages.
+
+## Results
+
+Mean of 3 games ± 95% confidence interval. FPS over the 12-second flight at 16 blocks/s (average / 1% low /
+0.1% low):
+
+| RD | scene | Horizon v0.2.97 | Vanilla 26.3 | Vanilla + mods |
+| --- | --- | --- | --- | --- |
+| 8 | forest | 3495 ±276 / 1295 ±397 / 859 ±298 | 2457 ±836 / 625 ±224 / 252 ±52 | 2425 ±65 / 733 ±30 / 250 ±22 |
+| 8 | mountain | 3376 ±67 / 1384 ±168 / 850 ±256 | 2605 ±811 / 700 ±218 / 264 ±71 | 2538 ±167 / 760 ±34 / 241 ±44 |
+| 8 | ocean | 3346 ±147 / 1358 ±237 / 912 ±235 | 2470 ±828 / 689 ±241 / 286 ±53 | 2432 ±82 / 764 ±37 / 262 ±37 |
+| 8 | village | 2942 ±197 / 1271 ±146 / 839 ±94 | 2217 ±112 / 545 ±37 / 215 ±14 | 2104 ±101 / 577 ±84 / 196 ±47 |
+| 16 | forest | 2424 ±138 / 709 ±165 / 401 ±100 | 1912 ±324 / 402 ±89 / 149 ±25 | 1746 ±32 / 461 ±27 / 179 ±9 |
+| 16 | mountain | 1961 ±99 / 537 ±96 / 297 ±75 | 1653 ±153 / 332 ±27 / 113 ±8 | 1500 ±55 / 408 ±40 / 140 ±10 |
+| 16 | ocean | 2201 ±183 / 554 ±251 / 325 ±326 | 1861 ±289 / 446 ±142 / 165 ±29 | 1815 ±119 / 514 ±142 / 192 ±58 |
+| 16 | village | 1712 ±192 / 593 ±80 / 358 ±69 | 1218 ±65 / 318 ±16 / 127 ±5 | 1282 ±162 / 343 ±25 / 132 ±12 |
+| 32 | forest | 1389 ±70 / 504 ±33 / 330 ±118 | 1203 ±51 / 228 ±13 / 108 ±12 | 929 ±8 / 313 ±41 / 129 ±32 |
+| 32 | mountain | 1086 ±34 / 258 ±78 / 108 ±37 | 815 ±61 / 55 ±13 / 8 ±3 | 645 ±10 / 166 ±12 / 86 ±21 |
+| 32 | ocean | 1189 ±27 / 155 ±9 / 68 ±8 | 1223 ±33 / 236 ±17 / 99 ±21 | 1017 ±14 / 325 ±38 / 117 ±28 |
+| 32 | village | 1164 ±9 / 416 ±39 / 216 ±86 | 882 ±48 / 184 ±12 / 83 ±17 | 926 ±17 / 250 ±5 / 93 ±11 |
+
+Startup, loading and memory (means of 3 games):
+
+| RD | | Horizon v0.2.97 | Vanilla 26.3 | Vanilla + mods |
+| --- | --- | --- | --- | --- |
+| 8 | start to title / in-world | 3.0 s / 6.1 s | 7.7 s / 13.9 s | 11.1 s / 17.6 s |
+| 8 | mean scene load | 1.3 s | 4.0 s | 3.6 s |
+| 8 | working set, steady / peak | 1082 / 1172 MB | 1913 / 2120 MB | 1904 / 2053 MB |
+| 16 | start to title / in-world | 3.2 s / 7.2 s | 7.7 s / 19.9 s | 10.8 s / 23.5 s |
+| 16 | mean scene load | 2.4 s | 9.2 s | 9.0 s |
+| 16 | working set, steady / peak | 1236 / 1459 MB | 2300 / 2540 MB | 2327 / 2496 MB |
+| 32 | start to title / in-world | 2.9 s / 10.5 s | 7.5 s / 35.4 s | 11.0 s / 39.2 s |
+| 32 | mean scene load | 5.7 s | 21.1 s | 19.9 s |
+| 32 | working set, steady / peak | 1730 / 2045 MB | 2799 / 2892 MB | 2895 / 2965 MB |
+
+## What it shows
+
+- At RD 8 and 16, Horizon's average FPS is 18–42 % above vanilla's in every scene. Its 1% lows are 1.2–2.3 times
+  vanilla's and its 0.1% lows 2.0–3.9 times. On this CPU and GPU the performance mods leave vanilla's averages
+  level or slightly lower, and raise its 1% lows by 6–23 %.
+- At RD 32, Horizon's average is 15–33 % above vanilla's over the forest, the mountain and the village, with 1% lows
+  2.2–4.7 times vanilla's. Over the ocean its average is level with vanilla's, but its lows are lower than vanilla's
+  and the modded client's (155 vs 236 and 325 FPS 1% low, 68 vs 99 and 117 FPS 0.1% low), on an idle machine too.
+  That scene is worth a closer look.
+- Horizon reaches the title screen 2.4–2.6 times faster than vanilla (3.4–3.8 times faster than the modded client)
+  and loads a scene's chunks 3–4 times faster. Its steady working set is 38–46 % smaller.
+- Each game uses its own graphics API: Horizon Vulkan, vanilla OpenGL. That difference is part of what's compared.

crates/cargo-horizon-mod/Cargo.toml

@@ -4,10 +4,10 @@ version = "0.1.0"
 edition.workspace = true
 license.workspace = true
 rust-version = "1.86"
-description = "cargo horizon-mod new/build/run/check: make Horizon mods in Rust (docs/mods.md)"
+description = "cargo horizon-mod new/build/run/check: make Horizon content mods (docs/mods.md)"
 
 [dependencies]
-horizon-mods = { path = "../horizon-mods", default-features = false, features = ["pack", "runtime", "index"] }
+horizon-mods = { path = "../horizon-mods", default-features = false, features = ["index"] }
 serde_json = "1.0.151"
 
 [lints]

crates/cargo-horizon-mod/src/check.rs

@@ -1,35 +1,19 @@
 //! `cargo horizon-mod check <file>`: what the registry checks of a submission,
 //! run anywhere: its kind's own checks (docs/api/mod-index.md), its signature
-//! when given a key, and for a mod a trial run in the sandbox: it must start,
-//! survive ticks, frames, a chat line and each of its commands (a server mod:
-//! a player joining, chatting, typing them and leaving), and import no more
-//! than its capabilities.
+//! when given a key, and for a `.hmod` that it is content only.
 use horizon_mods::{
-    Clock, GameMode, Mods, Output, Package, Player, ServerPlayer, Snapshot, Status,
+    Package,
     index::{self, Facts, Kind},
-    manifest::component_imports,
 };
 use serde_json::{Value, json};
 use std::path::Path;
 
-/// How long the trial run plays: two seconds of game.
-const TICKS: u64 = 40;
-const FRAMES_PER_TICK: u64 = 3;
-
 pub struct Report {
     pub kind: Kind,
     pub facts: Facts,
     pub sha256: String,
     pub size: u64,
     pub signed: bool,
-    /// A mod has code to run (a content mod may have none).
-    pub code: bool,
-    /// A mod's component imports.
-    pub imports: Vec<String>,
-    /// A mod's commands, each run once.
-    pub commands: Vec<String>,
-    /// What the mod showed during the trial run.
-    pub output: Vec<String>,
 }
 
 impl Report {
@@ -53,10 +37,6 @@ impl Report {
             "sha256": self.sha256,
             "size": self.size,
             "signed": self.signed,
-            "code": self.code,
-            "imports": self.imports,
-            "commands": self.commands,
-            "output": self.output,
         })
     }
 
@@ -100,18 +80,8 @@ impl Report {
         if self.kind == Kind::NativeMod {
             out += "  native source: unsandboxed; not executed by the registry check. Compile and test against the exact pinned Horizon and Mixins revisions before review.\n";
         }
-        if self.kind == Kind::Mod && !self.code {
+        if self.kind == Kind::Mod {
             out += "  no code: content only, nothing to run\n";
-        } else if self.kind == Kind::Mod {
-            let commands = if self.commands.is_empty() {
-                String::new()
-            } else {
-                format!(", /{}", self.commands.join(", /"))
-            };
-            out += &format!(
-                "  trial run: started, {TICKS} ticks, {} frames, a chat line{commands}: ok\n",
-                TICKS * FRAMES_PER_TICK
-            );
         }
         out
     }
@@ -153,145 +123,26 @@ pub fn check(
         (None, None) => false,
         _ => return Err("--key and --signature go together".into()),
     };
-    let mut report = Report {
+    if kind == Kind::Mod {
+        content_only(path)?;
+    }
+    Ok(Report {
         kind,
         facts,
         sha256: index::sha256_file(path)?,
         size,
         signed,
-        code: false,
-        imports: Vec::new(),
-        commands: Vec::new(),
-        output: Vec::new(),
-    };
-    if report.kind == Kind::Mod {
-        trial_run(path, &mut report)?;
-    }
-    Ok(report)
+    })
 }
 
-/// Runs a mod in the sandbox, as the game does, from a scratch copy so its
-/// storage lands in a folder removed afterwards. A content mod has no code to
-/// run: `inspect` already read its content as the game does.
-fn trial_run(path: &Path, report: &mut Report) -> Result<(), String> {
-    let package = Package::read(path)?;
-    let Some(wasm) = package.wasm.as_deref() else {
-        return Ok(());
-    };
-    report.code = true;
-    report.imports = component_imports(wasm)?;
-    package
-        .manifest
-        .check_imports(report.imports.iter().map(String::as_str))?;
-    let dir = std::env::temp_dir().join(format!("horizon-mod-check-{}", std::process::id()));
-    let _ = std::fs::remove_dir_all(&dir);
-    std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
-    let copy = dir.join("mod.hmod");
-    let result = std::fs::copy(path, &copy)
-        .map_err(|e| e.to_string())
-        .and_then(|_| play(&copy, report));
-    let _ = std::fs::remove_dir_all(&dir);
-    result
-}
-
-fn play(path: &Path, report: &mut Report) -> Result<(), String> {
-    let mut mods = Mods::load(&[path.to_path_buf()], |_| true, |_| false);
-    let failed = |mods: &Mods| match &mods.entries()[0].status {
-        Status::Failed(reason) => Some(reason.clone()),
-        _ => None,
-    };
-    if let Some(reason) = failed(&mods) {
-        return Err(format!("it didn't start: {reason}"));
-    }
-    let client: Vec<String> = mods.commands().map(str::to_owned).collect();
-    let server: Vec<String> = mods.server_commands().map(|c| c.name.clone()).collect();
-    report.commands = [client.clone(), server.clone()].concat();
-    // A server mod plays with one player on, who joins, chats and leaves.
-    let steve = ServerPlayer {
-        id: "00000000-0000-4000-8000-000000000001".into(),
-        name: "Steve".into(),
-        x: 0.5,
-        y: 64.0,
-        z: 0.5,
-        dimension: "minecraft:overworld".into(),
-        game_mode: GameMode::Survival,
-        health: 20.0,
-    };
-    let snapshot = |t: u64| Snapshot {
-        player: Some(Player {
-            x: 0.5 + t as f64 * 0.1,
-            y: 64.0,
-            z: 0.5,
-            yaw: 90.0,
-            pitch: 0.0,
-            health: 20.0,
-            food: 20,
-            dimension: "minecraft:overworld".into(),
-        }),
-        clock: Some(Clock {
-            game_time: t,
-            day_time: 1000 + t,
-        }),
-        players: vec![steve.clone()],
-        // The GUI of a 1280 x 720 window at scale 3.
-        gui_size: (427.0, 240.0),
-        ..Snapshot::default()
-    };
-    mods.set_snapshot(snapshot(0));
-    mods.player_joined(&steve);
-    for t in 0..TICKS {
-        mods.set_snapshot(snapshot(t));
-        mods.tick(t);
-        mods.server_tick(t);
-        for _ in 0..FRAMES_PER_TICK {
-            mods.frame(1.0 / 60.0);
-        }
-    }
-    mods.chat("<Steve> hello");
-    mods.player_chat(&steve, "hello");
-    for name in &client {
-        mods.command(name);
-    }
-    for name in &server {
-        mods.server_command(&steve, name);
-    }
-    mods.set_snapshot(Snapshot::default());
-    mods.player_left(&steve);
-    for out in mods.drain() {
-        report.output.push(match out {
-            Output::Chat { text, .. } => format!("chat: {text}"),
-            Output::Tell { text, .. } => format!("tell: {text}"),
-            Output::Broadcast { text, .. } => format!("broadcast: {text}"),
-            Output::Feedback { text, error } | Output::Reply { text, error, .. } => {
-                format!("{}: {text}", if error { "error" } else { "feedback" })
-            }
-            Output::Command { line } => format!("command: /{line}"),
-            Output::QuietCommands { lines, .. } => {
-                format!("{} quiet command(s)", lines.len())
-            }
-            Output::Stopped { reason, .. } => return Err(format!("it stopped: {reason}")),
-            Output::SetBlocks {
-                dimension, blocks, ..
-            } => {
-                format!("set {} block(s) in {dimension}", blocks.len())
-            }
-            Output::OpenScreen { .. } => "opened a screen".to_string(),
-            Output::CloseScreen { .. } => "closed its screen".to_string(),
-            Output::PlaceRecipe { book_id, all } => {
-                format!("placed recipe {book_id}{}", if all { " (all)" } else { "" })
-            }
-            Output::Give { item, count, .. } => format!("gave {count} {item}"),
-            Output::Shake { strength, seconds } => {
-                format!("shook the camera: {strength:.2} for {seconds:.1} s")
-            }
-        });
-    }
-    let shapes = mods.hud_shapes().count();
-    if shapes > 0 {
-        report.output.push(format!("drew {shapes} HUD shape(s)"));
-    }
-    match failed(&mods) {
-        Some(reason) => Err(format!("it stopped: {reason}")),
+/// A mod is content only: WebAssembly code mods don't run any more, code mods are native
+/// (`.hnmod`, docs/native-mods.md). `inspect` already read its content as the game does.
+fn content_only(path: &Path) -> Result<(), String> {
+    match Package::read(path)?.wasm {
+        Some(_) => Err(
+            "it has WebAssembly code, which Horizon doesn't run any more: make it a native mod (docs/native-mods.md)"
+                .into(),
+        ),
         None => Ok(()),
     }
 }
@@ -316,7 +167,7 @@ mod tests {
                 .text()
                 .contains("cozy 1.0.0 (modpack, format 1, for 26.3)")
         );
-        // The fixture mod's code is a stand-in: its manifest reads, its run fails.
+        // A mod with WebAssembly code is refused: code mods are native.
         let hmod = fixture("coords_hud-0.1.0.hmod");
         let key = std::fs::read_to_string(fixture("test.pub")).unwrap();
         let sig = std::fs::read_to_string(fixture("coords_hud-0.1.0.hmod.minisig")).unwrap();
@@ -324,7 +175,7 @@ mod tests {
         let e = check(&hmod, Kind::Mod, Some(key), Some(&sig))
             .err()
             .unwrap();
-        assert!(e.contains("didn't start"), "{e}");
+        assert!(e.contains("native mod"), "{e}");
         let e = check(
             &hmod,
             Kind::Mod,

crates/cargo-horizon-mod/src/main.rs

@@ -1,32 +1,23 @@
-//! `cargo horizon-mod`: make Horizon mods in Rust (`docs/mods.md`).
+//! `cargo horizon-mod`: make Horizon content mods (`docs/modpacks.md`): blocks,
+//! items, data and assets, no code. Code mods are native (docs/native-mods.md).
 //!
-//! - `new <path> [--template code|content] [--name "Name"] [--sdk-path <dir>]`:
-//!   a mod from a template: a Rust crate, or a content mod (no code).
-//! - `build [--debug]`: the `.hmod` in `target/horizon-mod/`, with the mod's
-//!   `assets/` and `data/`; a folder without `Cargo.toml` is content only.
+//! - `new <path> [--name "Name"]`: a content mod from the template.
+//! - `build`: the `.hmod` in `target/horizon-mod/`, with the mod's `assets/`
+//!   and `data/`.
 //! - `run [--game <horizon-client>] [-- <game args>]`: build, then play with
-//!   the mod; run `build` again and the game reloads it.
-//! - `test [--debug] [--hmod <file>] [<name>]`: build, then run the mod's
-//!   `tests/*.toml` scripts in the sandbox, with no game.
+//!   the mod.
 //! - `check <file> [--json]`: what the registry checks of a submission
-//!   (`.hmod`, `.hpack`, resource pack `.zip`), with a trial run for a mod.
+//!   (`.hmod`, `.hnmod`, `.hpack`, resource pack `.zip`, `.hshader`).
 //! - `registry build|review|check|list`: the registry repository's CI.
-use horizon_mods::{
-    Capability, Content, Manifest, Package,
-    manifest::{MANIFEST, component_imports, componentize},
-    testing::{Script, TestGame},
-};
+use horizon_mods::{Capability, Content, Manifest, Package, manifest::MANIFEST};
 mod check;
 mod registry;
 
 use std::{
     path::{Path, PathBuf},
-    process::{Command, ExitCode, Stdio},
+    process::{Command, ExitCode},
 };
 
-const TARGET: &str = "wasm32-unknown-unknown";
-const SDK_GIT: &str = "{ git = \"https://github.com/horizon-rust/horizon\" }";
-
 fn main() -> ExitCode {
     // Cargo runs `cargo-horizon-mod horizon-mod <args>`.
     let mut args: Vec<String> = std::env::args().skip(1).collect();
@@ -35,14 +26,13 @@ fn main() -> ExitCode {
     }
     let result = match args.first().map(String::as_str) {
         Some("new") => new(&args[1..]),
-        Some("build") => build(!args.iter().any(|a| a == "--debug")).map(|p| {
+        Some("build") => build().map(|p| {
             println!("Built {}", p.display());
         }),
         Some("run") => run(&args[1..]),
-        Some("test") => test(&args[1..]),
         Some("check") => check(&args[1..]),
         Some("registry") => registry::main(&args[1..]),
-        _ => Err("usage: cargo horizon-mod new <path> [--template code|content] | build [--debug] | run [--game <horizon-client>] [-- <game args>] | test [--debug] [--hmod <file>] [<name>] | check <file> [--kind <kind>] [--key <public key> --signature <file.minisig>] [--json] | registry build|review|check|list".into()),
+        _ => Err("usage: cargo horizon-mod new <path> [--name \"Name\"] | build | run [--game <horizon-client>] [-- <game args>] | check <file> [--kind <kind>] [--key <public key> --signature <file.minisig>] [--json] | registry build|review|check|list".into()),
     };
     match result {
         Ok(()) => ExitCode::SUCCESS,
@@ -83,31 +73,9 @@ fn new(args: &[String]) -> Result<(), String> {
         })
         .collect();
     let name = flag(args, "--name").map_or_else(|| base.replace(['-', '_'], " "), str::to_string);
-    let sdk = match flag(args, "--sdk-path") {
-        Some(p) => {
-            let p = std::fs::canonicalize(p).map_err(|e| format!("--sdk-path {p}: {e}"))?;
-            format!("{{ path = {:?} }}", p.display().to_string())
-        }
-        None => SDK_GIT.to_string(),
-    };
-    let fill = |t: &str| {
-        t.replace("{crate}", &id.replace('_', "-"))
-            .replace("{id}", &id)
-            .replace("{name}", &name)
-            .replace("{sdk}", &sdk)
-    };
-    let code = [
-        ("Cargo.toml", include_str!("../template/Cargo.toml.in")),
-        (MANIFEST, include_str!("../template/horizon-mod.toml")),
-        ("src/lib.rs", include_str!("../template/src/lib.rs")),
-        (".gitignore", include_str!("../template/gitignore")),
-        (
-            "tests/hello.toml",
-            include_str!("../template/tests/hello.toml"),
-        ),
-    ];
+    let fill = |t: &str| t.replace("{id}", &id).replace("{name}", &name);
     // A block copying a vanilla one, with its model, name, loot, recipe and tag.
-    let content = [
+    let files = [
         (
             MANIFEST,
             include_str!("../template/content/horizon-mod.toml"),
@@ -146,12 +114,12 @@ fn new(args: &[String]) -> Result<(), String> {
         ),
         (".gitignore", include_str!("../template/gitignore")),
     ];
-    let files: &[(&str, &str)] = match flag(args, "--template").unwrap_or("code") {
-        "code" => &code,
-        "content" => &content,
-        other => return Err(format!("no template {other}: code or content")),
-    };
-    for &(file, text) in files {
+    if flag(args, "--template").is_some_and(|t| t != "content") {
+        return Err(
+            "only content mods are made here: code mods are native (docs/native-mods.md)".into(),
+        );
+    }
+    for (file, text) in files {
         let file = fill(file);
         let file = file.as_str();
         let to = dir.join(file);
@@ -169,29 +137,24 @@ fn new(args: &[String]) -> Result<(), String> {
     Ok(())
 }
 
-/// Builds the mod in the current folder and packs `target/horizon-mod/<id>.hmod`:
-/// the manifest, the crate's component (none without a `Cargo.toml`: a
-/// content mod) and the files in `assets/` and `data/`.
-fn build(release: bool) -> Result<PathBuf, String> {
-    build_in(Path::new("."), release)
+/// Packs the content mod in the current folder into `target/horizon-mod/<id>.hmod`: the
+/// manifest and the files in `assets/` and `data/`.
+fn build() -> Result<PathBuf, String> {
+    build_in(Path::new("."))
 }
 
-fn build_in(root: &Path, release: bool) -> Result<PathBuf, String> {
+fn build_in(root: &Path) -> Result<PathBuf, String> {
     let manifest_text = std::fs::read_to_string(root.join(MANIFEST))
         .map_err(|e| format!("{MANIFEST}: {e} (run this in a mod's folder)"))?;
     let manifest = Manifest::parse(&manifest_text)?;
-    let (wasm, target_dir) = if root.join("Cargo.toml").exists() {
-        let (wasm, target) = compile(root, release)?;
-        // The game refuses a component importing capabilities the manifest lacks.
-        manifest.check_imports(component_imports(&wasm)?.iter().map(String::as_str))?;
-        (Some(wasm), target)
-    } else if manifest.capabilities.contains(&Capability::Registries) {
-        (None, root.join("target"))
-    } else {
+    if root.join("Cargo.toml").exists() {
+        return Err("a Cargo.toml: code mods are native now (docs/native-mods.md)".into());
+    }
+    if !manifest.capabilities.contains(&Capability::Registries) {
         return Err(format!(
-            "no Cargo.toml: only a content mod (capability registries in {MANIFEST}) has no code"
+            "a content mod has capability registries in {MANIFEST}"
         ));
-    };
+    }
     // The same checks as the game's, and the files in the order it lists them.
     let content = Content::read(root, &manifest)?;
     let mut reader = content.reader()?;
@@ -200,53 +163,17 @@ fn build_in(root: &Path, release: bool) -> Result<PathBuf, String> {
         files.push((name.as_str(), reader.read(name)?));
     }
     let files: Vec<(&str, &[u8])> = files.iter().map(|(n, b)| (*n, b.as_slice())).collect();
-    let dir = target_dir.join("horizon-mod");
+    let dir = root.join("target/horizon-mod");
     std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
     let path = dir.join(format!("{}.hmod", manifest.id));
     // Write then rename, so a running game never reads half a file.
     let partial = path.with_extension("hmod.partial");
-    let bytes = Package::write_files(&manifest_text, wasm.as_deref(), &files)?;
+    let bytes = Package::write_files(&manifest_text, None, &files)?;
     std::fs::write(&partial, bytes).map_err(|e| e.to_string())?;
     std::fs::rename(&partial, &path).map_err(|e| e.to_string())?;
     Ok(path)
 }
 
-/// Builds the crate for WebAssembly: its component, and Cargo's target folder.
-fn compile(root: &Path, release: bool) -> Result<(Vec<u8>, PathBuf), String> {
-    let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
-    let mut cmd = Command::new(cargo);
-    cmd.current_dir(root).args([
-        "build",
-        "--lib",
-        "--target",
-        TARGET,
-        "--message-format=json-render-diagnostics",
-    ]);
-    if release {
-        cmd.arg("--release");
-    }
-    let out = cmd
-        .stderr(Stdio::inherit())
-        .output()
-        .map_err(|e| e.to_string())?;
-    if !out.status.success() {
-        return Err(format!(
-            "cargo build failed (is the target installed? rustup target add {TARGET})"
-        ));
-    }
-    let core = String::from_utf8_lossy(&out.stdout)
-        .lines()
-        .filter_map(|l| serde_json::from_str::<serde_json::Value>(l).ok())
-        .filter(|m| m["reason"] == "compiler-artifact")
-        .flat_map(|m| m["filenames"].as_array().cloned().unwrap_or_default())
-        .filter_map(|f| f.as_str().map(PathBuf::from))
-        .rfind(|f| f.extension().is_some_and(|e| e == "wasm"))
-        .ok_or("the build made no .wasm: is the crate a cdylib?")?;
-    let wasm = componentize(&std::fs::read(&core).map_err(|e| e.to_string())?)?;
-    let target = core.ancestors().nth(3).ok_or("unexpected target folder")?;
-    Ok((wasm, target.to_path_buf()))
-}
-
 /// `check <file>`: the registry's checks of a submission, printed; fails
 /// when one does.
 fn check(args: &[String]) -> Result<(), String> {
@@ -278,74 +205,14 @@ fn check(args: &[String]) -> Result<(), String> {
     Ok(())
 }
 
-/// `test`: every `tests/*.toml` script (those whose name holds `<name>`)
-/// against the built mod, or the `.hmod` given with `--hmod`.
-fn test(args: &[String]) -> Result<(), String> {
-    let hmod = match flag(args, "--hmod") {
-        Some(p) => PathBuf::from(p),
-        None => build(!args.iter().any(|a| a == "--debug"))?,
-    };
-    let filter = args
-        .iter()
-        .enumerate()
-        .find(|(i, a)| !a.starts_with("--") && (*i == 0 || args[i - 1] != "--hmod"))
-        .map(|(_, a)| a.as_str());
-    let mut scripts: Vec<PathBuf> = std::fs::read_dir("tests")
-        .map_err(|e| {
-            format!(
-                "tests/: {e} (a mod's tests are tests/<name>.toml: docs/mods.md, \"Testing a mod\")"
-            )
-        })?
-        .filter_map(|e| Some(e.ok()?.path()))
-        .filter(|p| p.extension().is_some_and(|e| e == "toml"))
-        .filter(|p| filter.is_none_or(|f| p.to_string_lossy().contains(f)))
-        .collect();
-    scripts.sort();
-    if scripts.is_empty() {
-        return Err("no tests/*.toml to run".into());
-    }
-    println!(
-        "running {} scripts against {}",
-        scripts.len(),
-        hmod.display()
-    );
-    let mut failed = 0;
-    for path in &scripts {
-        let result = std::fs::read_to_string(path)
-            .map_err(|e| e.to_string())
-            .and_then(|text| Script::parse(&text))
-            .and_then(|script| {
-                let mut game = TestGame::load(&hmod)?;
-                script.run(&mut game)?;
-                Ok(script.steps.len())
-            });
-        match result {
-            Ok(steps) => println!("test {} ... ok ({steps} steps)", path.display()),
-            Err(e) => {
-                failed += 1;
-                println!("test {} ... FAILED\n  {e}", path.display());
-            }
-        }
-    }
-    let passed = scripts.len() - failed;
-    if failed > 0 {
-        return Err(format!("{failed} failed, {passed} passed"));
-    }
-    println!("test result: ok. {passed} passed");
-    Ok(())
-}
-
 fn run(args: &[String]) -> Result<(), String> {
-    let path = build(true)?;
+    let path = build()?;
     let game = flag(args, "--game")
         .map(str::to_string)
         .or_else(|| std::env::var("HORIZON_CLIENT").ok())
         .unwrap_or_else(|| "horizon-client".into());
     let extra = args.iter().skip_while(|a| *a != "--").skip(1);
-    println!(
-        "Starting {game} with {} (rebuild with `cargo horizon-mod build` to reload it)",
-        path.display()
-    );
+    println!("Starting {game} with {}", path.display());
     let status = Command::new(&game)
         .arg("--dev-mod")
         .arg(&path)
@@ -364,28 +231,6 @@ fn run(args: &[String]) -> Result<(), String> {
 mod tests {
     use super::*;
 
-    #[test]
-    fn the_template_is_a_valid_mod() {
-        let dir = std::env::temp_dir().join(format!("horizon-mod-new-{}", std::process::id()));
-        let path = dir.join("My-Mod");
-        new(&[path.display().to_string(), "--name".into(), "My Mod".into()]).unwrap();
-        let manifest =
-            Manifest::parse(&std::fs::read_to_string(path.join(MANIFEST)).unwrap()).unwrap();
-        assert_eq!(
-            (manifest.id.as_str(), manifest.name.as_str()),
-            ("my_mod", "My Mod")
-        );
-        let cargo = std::fs::read_to_string(path.join("Cargo.toml")).unwrap();
-        assert!(cargo.contains("name = \"my-mod\"") && cargo.contains(SDK_GIT));
-        let script = std::fs::read_to_string(path.join("tests/hello.toml")).unwrap();
-        assert_eq!(Script::parse(&script).unwrap().steps.len(), 3);
-        assert!(
-            new(&[path.display().to_string()]).is_err(),
-            "never overwrites"
-        );
-        std::fs::remove_dir_all(&dir).unwrap();
-    }
-
     #[test]
     fn the_content_template_builds_and_checks_with_no_code() {
         let dir = std::env::temp_dir().join(format!("horizon-mod-content-{}", std::process::id()));
@@ -397,7 +242,7 @@ mod tests {
         ];
         new(&new_args).unwrap();
         assert!(!path.join("Cargo.toml").exists());
-        let hmod = build_in(&path, true).unwrap();
+        let hmod = build_in(&path).unwrap();
         assert_eq!(hmod, path.join("target/horizon-mod/gems.hmod"));
         let package = Package::read(&hmod).unwrap();
         assert!(package.wasm.is_none());
@@ -409,17 +254,14 @@ mod tests {
         );
         assert_eq!(content.files.len(), 8, "{:?}", content.files);
         let report = check::check(&hmod, check::kind_of(&hmod).unwrap(), None, None).unwrap();
-        assert!(!report.code);
         assert!(
             report.text().contains("no code: content only"),
             "{}",
             report.text()
         );
-        // Without registries, a mod needs code.
-        let manifest = std::fs::read_to_string(path.join(MANIFEST)).unwrap();
-        let manifest = manifest.replace("[\"registries\"]", "[]");
-        std::fs::write(path.join(MANIFEST), manifest).unwrap();
-        assert!(build_in(&path, true).unwrap_err().contains("no Cargo.toml"));
+        // Code is native now.
+        std::fs::write(path.join("Cargo.toml"), "").unwrap();
+        assert!(build_in(&path).unwrap_err().contains("native"));
         assert!(
             new(&[
                 dir.join("x").display().to_string(),

crates/cargo-horizon-mod/template/Cargo.toml.in

@@ -1,14 +0,0 @@
-[package]
-name = "{crate}"
-version = "0.1.0"
-edition = "2024"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-horizon-mod-sdk = {sdk}
-
-[profile.release]
-opt-level = "s"
-lto = true

crates/cargo-horizon-mod/template/horizon-mod.toml

@@ -1,12 +0,0 @@
-id = "{id}"
-name = "{name}"
-version = "0.1.0"
-description = ""
-authors = []
-# The Horizon mod API the SDK targets.
-api = "0.1"
-# client: runs in the player's game.
-side = "client"
-# What the mod may do, shown to players before they turn it on:
-# game-read (position, health, time), chat (show messages), hud (draw text).
-capabilities = ["chat"]

crates/cargo-horizon-mod/template/src/lib.rs

@@ -1,19 +0,0 @@
-use horizon_mod_sdk::{Mod, Registration, chat};
-
-struct MyMod {
-    greeted: u32,
-}
-
-impl Mod for MyMod {
-    fn init() -> Result<(Self, Registration), String> {
-        Ok((MyMod { greeted: 0 }, Registration::new().command("hello")))
-    }
-
-    fn command(&mut self, _name: &str, args: &str) -> Result<Option<String>, String> {
-        self.greeted += 1;
-        chat::show(&format!("Hello {args}! ({} so far)", self.greeted));
-        Ok(None)
-    }
-}
-
-horizon_mod_sdk::export_mod!(MyMod);

crates/cargo-horizon-mod/template/tests/hello.toml

@@ -1,14 +0,0 @@
-# `cargo horizon-mod test` runs every tests/*.toml against the built mod, with no game:
-# steps happen in order, and `expect` checks what the mod showed during the step.
-# Every key: docs/mods.md, "Testing a mod".
-
-[[step]]
-expect.commands = ["hello"]
-
-[[step]]
-command = "hello world"
-expect.chat = ["Hello world! (1 so far)"]
-
-[[step]]
-command = "hello again"
-expect.chat = ["Hello again! (2 so far)"]

crates/horizon-bots/src/main.rs

@@ -21,18 +21,19 @@ use horizon_protocol::{
     connection::{ConnWriter, Connection},
     crypto::offline_uuid,
     ids,
+    item::Stack,
     packets::{
         Empty, configuration,
         handshake::{self, Intention},
         login::{self, ServerHello},
-        play,
+        play, recipes,
     },
 };
 use serde_json::json;
 use std::{
     collections::HashSet,
     sync::{
-        Arc, Mutex,
+        Arc, LazyLock, Mutex,
         atomic::{AtomicBool, AtomicU64, Ordering},
     },
     thread,
@@ -44,7 +45,22 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
 
   --server HOST:PORT     default 127.0.0.1:25565
   --bots N               default 10
-  --behaviour B          idle, walk, explore or mixed (60 % walk, 20 % explore, 20 % idle); default mixed
+  --behaviour B          idle, walk, explore or mixed (60 % walk, 20 % explore, 20 % idle); default mixed.
+                         One abusive client, to test a server's limits (run it beside a normal crowd):
+                         flood-move (--flood moves a tick, each 64 to 256 blocks away, ignoring chunks),
+                         flood-acks (--flood chunk batch acks asking for 64 chunks a tick, while exploring),
+                         flood-packets (--flood rotations a tick),
+                         flood-chunks (one move a tick, 9.9 blocks straight ahead: as fast as the
+                         moved-too-quickly check allows, never waiting for chunks),
+                         and --flood a tick of packets that cost the server work:
+                         flood-use (place and break stone around itself), flood-click (inventory
+                         clicks with a stale state), flood-suggest (command suggestions, every
+                         other one 30 000 characters long), flood-book (100 pages of 1024 characters
+                         into a writable book), flood-sign (four 384-character lines on the block
+                         below), flood-recipe (recipe book placements)
+  --flood N              packets a tick for the flood behaviours; default 100
+  --no-read              stop reading from the server once spawned (a client that lets the
+                         server's replies pile up)
   --join-every SECONDS   default 1
   --seconds N            how long to run after the first bot joins; default 60
   --view-distance N      what the bots ask for; default 10
@@ -59,6 +75,16 @@ enum Behaviour {
     Idle,
     Walk,
     Explore,
+    FloodMove,
+    FloodAcks,
+    FloodPackets,
+    FloodChunks,
+    FloodUse,
+    FloodClick,
+    FloodSuggest,
+    FloodBook,
+    FloodSign,
+    FloodRecipe,
 }
 
 impl Behaviour {
@@ -67,6 +93,16 @@ impl Behaviour {
             Self::Idle => "idle",
             Self::Walk => "walk",
             Self::Explore => "explore",
+            Self::FloodMove => "flood-move",
+            Self::FloodAcks => "flood-acks",
+            Self::FloodPackets => "flood-packets",
+            Self::FloodChunks => "flood-chunks",
+            Self::FloodUse => "flood-use",
+            Self::FloodClick => "flood-click",
+            Self::FloodSuggest => "flood-suggest",
+            Self::FloodBook => "flood-book",
+            Self::FloodSign => "flood-sign",
+            Self::FloodRecipe => "flood-recipe",
         }
     }
 }
@@ -81,6 +117,8 @@ struct Options {
     view_distance: i8,
     seed: u64,
     explore_speed: f64,
+    flood: usize,
+    no_read: bool,
     name: String,
     report: Option<String>,
 }
@@ -96,6 +134,8 @@ fn options() -> Result<Options, String> {
         view_distance: 10,
         seed: 12345,
         explore_speed: 22.0,
+        flood: 100,
+        no_read: false,
         name: "Bot".into(),
         report: None,
     };
@@ -105,6 +145,10 @@ fn options() -> Result<Options, String> {
             print!("{HELP}");
             std::process::exit(0);
         }
+        if arg == "--no-read" {
+            o.no_read = true;
+            continue;
+        }
         let value = args.next().ok_or(format!("{arg} needs a value"))?;
         let number = |what: &str| format!("{arg} needs {what}, not {value:?}");
         match arg.as_str() {
@@ -122,14 +166,31 @@ fn options() -> Result<Options, String> {
             "--explore-speed" => {
                 o.explore_speed = value.parse().map_err(|_| number("blocks a second"))?;
             }
+            "--flood" => o.flood = value.parse().map_err(|_| number("packets a tick"))?,
             "--name" => o.name = value,
             "--report" => o.report = Some(value),
             _ => return Err(format!("unknown option {arg}; --help lists them")),
         }
     }
-    if !["idle", "walk", "explore", "mixed"].contains(&o.behaviour.as_str()) {
+    const BEHAVIOURS: [&str; 14] = [
+        "idle",
+        "walk",
+        "explore",
+        "mixed",
+        "flood-move",
+        "flood-acks",
+        "flood-packets",
+        "flood-chunks",
+        "flood-use",
+        "flood-click",
+        "flood-suggest",
+        "flood-book",
+        "flood-sign",
+        "flood-recipe",
+    ];
+    if !BEHAVIOURS.contains(&o.behaviour.as_str()) {
         return Err(format!(
-            "--behaviour {}: use idle, walk, explore or mixed",
+            "--behaviour {}: use idle, walk, explore, mixed or a flood behaviour (--help lists them)",
             o.behaviour
         ));
     }
@@ -156,6 +217,8 @@ struct Bot {
     teleport: Mutex<Option<[f64; 3]>>,
     error: Mutex<Option<String>>,
     joined_after_ms: AtomicU64,
+    /// The bot stopped reading (--no-read).
+    deaf: AtomicBool,
 }
 
 /// A small deterministic generator (SplitMix64), so every run moves the bots the same way.
@@ -185,6 +248,89 @@ fn raw(id: i32, write: impl FnOnce(&mut Writer)) -> Vec<u8> {
     w.data
 }
 
+/// Item ids of the pinned version (26.3's item registry).
+const STONE: i32 = 1;
+const WRITABLE_BOOK: i32 = 1371;
+
+/// The `i`th packet of a costly flood this tick, the bot at `pos`; none for other behaviours.
+fn costly(
+    behaviour: Behaviour,
+    i: usize,
+    sequence: i32,
+    pos: [f64; 3],
+    random: &mut Random,
+) -> Option<Vec<u8>> {
+    use ids::play::serverbound as sb;
+    static LONG_COMMAND: LazyLock<String> =
+        LazyLock::new(|| format!("/msg {}", "x".repeat(30_000)));
+    static BOOK: LazyLock<Vec<u8>> = LazyLock::new(|| {
+        play::Serverbound::EditBook(play::EditBook {
+            slot: 0,
+            pages: vec!["a".repeat(1024); 100],
+            title: None,
+        })
+        .encode()
+    });
+    let block = pos.map(|v| v.floor() as i32);
+    let packet = match behaviour {
+        Behaviour::FloodUse => {
+            // A block within reach: place stone there, or break what is there.
+            let at = [0, 1, 2].map(|k| block[k] + (random.unit() * 7.0) as i32 - 3);
+            if i % 2 == 0 {
+                play::Serverbound::UseItemOn(play::UseItemOn {
+                    hand: 0,
+                    pos: at,
+                    face: 1,
+                    cursor: [0.5, 1.0, 0.5],
+                    inside: false,
+                    world_border: false,
+                    sequence,
+                })
+            } else {
+                play::Serverbound::PlayerAction(play::PlayerAction {
+                    action: 0,
+                    pos: at,
+                    direction: 1,
+                    sequence,
+                })
+            }
+        }
+        Behaviour::FloodClick => play::Serverbound::ContainerClick(play::ContainerClick {
+            container: 0,
+            state: 0,
+            slot: 36 + (i % 9) as i16,
+            button: 0,
+            input: 0,
+            changed: Vec::new(),
+            carried: None,
+        }),
+        Behaviour::FloodSuggest => {
+            let text = if i % 2 == 0 {
+                "/"
+            } else {
+                LONG_COMMAND.as_str()
+            };
+            return Some(raw(sb::COMMAND_SUGGESTION, |w| {
+                w.varint(sequence);
+                w.string(text);
+            }));
+        }
+        Behaviour::FloodBook => return Some(BOOK.clone()),
+        Behaviour::FloodSign => play::Serverbound::SignUpdate(play::SignUpdate {
+            pos: [block[0], block[1] - 1, block[2]],
+            lines: std::array::from_fn(|_| "a".repeat(384)),
+            front: true,
+        }),
+        Behaviour::FloodRecipe => play::Serverbound::PlaceRecipe(recipes::PlaceRecipe {
+            container: 0,
+            recipe: (i % 2042) as i32,
+            use_max: true,
+        }),
+        _ => return None,
+    };
+    Some(packet.encode())
+}
+
 fn err(e: impl std::fmt::Display) -> String {
     e.to_string()
 }
@@ -339,6 +485,12 @@ fn read(
     let mut batch = BatchSize::new();
     let mut teleports = 0u64;
     loop {
+        if bot.deaf.load(Ordering::Relaxed) {
+            while bot.online.load(Ordering::SeqCst) {
+                thread::sleep(Duration::from_millis(100));
+            }
+            return;
+        }
         let (id, body) = match reader.recv() {
             Ok(packet) => packet,
             Err(e) => {
@@ -489,6 +641,24 @@ fn run_bot(
         .store(asked.elapsed().as_millis() as u64, Ordering::SeqCst);
     let send = |body: Vec<u8>| lock(&writer).send(&body).is_ok();
     send(raw(sb::PLAYER_LOADED, |_| {}));
+    bot.deaf.store(o.no_read, Ordering::Relaxed);
+    // What the costly floods need in hand (creative: the server takes the bot's word for it).
+    let tool = match behaviour {
+        Behaviour::FloodUse => Some(Stack::new(STONE, 64)),
+        Behaviour::FloodBook => Some(Stack::new(WRITABLE_BOOK, 1)),
+        _ => None,
+    };
+    if tool.is_some() {
+        send(
+            play::Serverbound::SetCreativeModeSlot(play::SetCreativeModeSlot {
+                slot: 36,
+                item: tool,
+            })
+            .encode(),
+        );
+        send(play::Serverbound::SetCarriedItem(play::SetCarriedItem { slot: 0 }).encode());
+    }
+    let mut sequence = 0;
     let mut random = Random(o.seed ^ (index as u64).wrapping_mul(0x2545_F491_4F6C_DD1D));
     let mut pos = spawn;
     let cruise = spawn[1] + 24.0;
@@ -504,7 +674,38 @@ fn run_bot(
             pos = at;
         }
         let here = ((pos[0].floor() as i32) >> 4, (pos[2].floor() as i32) >> 4);
-        if !lock(&bot.held).contains(&here) {
+        // The abusive client doesn't wait for its chunk, as a real client must.
+        if behaviour == Behaviour::FloodMove {
+            // The last of these moves goes out below, with the tick's end.
+            pos[1] = cruise;
+            for _ in 1..o.flood.max(1) {
+                let angle = random.unit() * std::f64::consts::TAU;
+                let reach = 64.0 + random.unit() * 192.0;
+                pos[0] += angle.cos() * reach;
+                pos[2] += angle.sin() * reach;
+                send(
+                    play::Serverbound::MovePlayerPos(play::MovePlayerPos {
+                        x: pos[0],
+                        y: pos[1],
+                        z: pos[2],
+                        flags: 0,
+                    })
+                    .encode(),
+                );
+            }
+            let angle = random.unit() * std::f64::consts::TAU;
+            pos[0] += angle.cos() * 128.0;
+            pos[2] += angle.sin() * 128.0;
+        } else if behaviour == Behaviour::FloodChunks {
+            // Up to cruising height first, then just under the server's 10 blocks a tick:
+            // every tick asks for new chunks.
+            if pos[1] < cruise {
+                pos[1] = (pos[1] + 0.5).min(cruise);
+            } else {
+                pos[0] += heading.cos() * 9.9;
+                pos[2] += heading.sin() * 9.9;
+            }
+        } else if !lock(&bot.held).contains(&here) {
             bot.waited.fetch_add(1, Ordering::Relaxed);
         } else if pos[1] < cruise {
             pos[1] = (pos[1] + 0.5).min(cruise);
@@ -529,7 +730,37 @@ fn run_bot(
                         pos[2] += dz / distance * step;
                     }
                 }
-                Behaviour::Explore => {
+                Behaviour::FloodMove
+                | Behaviour::FloodChunks
+                | Behaviour::FloodUse
+                | Behaviour::FloodClick
+                | Behaviour::FloodSuggest
+                | Behaviour::FloodBook
+                | Behaviour::FloodSign
+                | Behaviour::FloodRecipe => {}
+                Behaviour::FloodPackets => {
+                    for i in 0..o.flood {
+                        send(
+                            play::Serverbound::MovePlayerRot(play::MovePlayerRot {
+                                yaw: (i % 360) as f32,
+                                pitch: 0.0,
+                                flags: 0,
+                            })
+                            .encode(),
+                        );
+                    }
+                }
+                Behaviour::FloodAcks | Behaviour::Explore => {
+                    if behaviour == Behaviour::FloodAcks {
+                        for _ in 0..o.flood {
+                            send(
+                                play::Serverbound::ChunkBatchReceived(play::ChunkBatchReceived {
+                                    chunks_per_tick: 64.0,
+                                })
+                                .encode(),
+                            );
+                        }
+                    }
                     // Flying in creative, by default about 22 blocks a second, which keeps new
                     // chunks coming as fast as the server sends them.
                     let step = o.explore_speed / 20.0;
@@ -538,6 +769,13 @@ fn run_bot(
                 }
             }
         }
+        // The costly floods go out wherever the bot is, chunks or not (--no-read gets none).
+        for i in 0..o.flood {
+            sequence += 1;
+            if let Some(body) = costly(behaviour, i, sequence, pos, &mut random) {
+                send(body);
+            }
+        }
         let ok = send(
             play::Serverbound::MovePlayerPos(play::MovePlayerPos {
                 x: pos[0],
@@ -569,6 +807,16 @@ fn behaviour_of(mode: &str, index: usize) -> Behaviour {
         "idle" => Behaviour::Idle,
         "walk" => Behaviour::Walk,
         "explore" => Behaviour::Explore,
+        "flood-move" => Behaviour::FloodMove,
+        "flood-acks" => Behaviour::FloodAcks,
+        "flood-packets" => Behaviour::FloodPackets,
+        "flood-chunks" => Behaviour::FloodChunks,
+        "flood-use" => Behaviour::FloodUse,
+        "flood-click" => Behaviour::FloodClick,
+        "flood-suggest" => Behaviour::FloodSuggest,
+        "flood-book" => Behaviour::FloodBook,
+        "flood-sign" => Behaviour::FloodSign,
+        "flood-recipe" => Behaviour::FloodRecipe,
         // mixed: of every five bots, three walk, one explores, one stands.
         _ => match index % 5 {
             0 | 2 | 4 => Behaviour::Walk,

crates/horizon-client-core/src/block_entity_nbt.rs

@@ -494,7 +494,11 @@ pub fn canonical(tag: &Tag) -> Option<Tag> {
                     _ => string("minecraft:air"),
                 },
             );
-            f.put("facing", Tag::Int(int(tag.get("facing")).unwrap_or(0)));
+            // Direction.LEGACY_ID_CODEC: the 3D data value as a byte.
+            f.put(
+                "facing",
+                Tag::Byte(int(tag.get("facing")).unwrap_or(0) as i8),
+            );
             f.float("progress", 0.0);
             f.flag("extending", false);
             f.flag("source", false);
@@ -873,6 +877,23 @@ mod tests {
         );
     }
 
+    /// `PistonMovingBlockEntity.saveAdditional`: `facing` through
+    /// `Direction.LEGACY_ID_CODEC` (a byte), `progress` a float.
+    #[test]
+    fn moving_piston_fields_match_vanilla() {
+        let out = canon(
+            "{id:\"minecraft:piston\",x:1,y:2,z:3,blockState:{Name:\"minecraft:stone\"},\
+             facing:5,progress:0.5f,extending:1b,source:0b}",
+        );
+        assert_eq!(out.get("facing"), Some(&Tag::Byte(5)));
+        assert_eq!(out.get("progress"), Some(&f32_tag(0.5)));
+        assert_eq!(out.get("extending"), Some(&Tag::Byte(1)));
+        assert_eq!(out.get("source"), Some(&Tag::Byte(0)));
+        let fresh = canon("{id:\"minecraft:piston\",x:1,y:2,z:3}");
+        assert_eq!(fresh.get("facing"), Some(&Tag::Byte(0)));
+        assert_eq!(fresh.get("blockState"), Some(&string("minecraft:air")));
+    }
+
     #[test]
     fn loot_table_replaces_items_and_zero_seed_is_omitted() {
         let out = canon(

crates/horizon-client-core/src/component.rs

@@ -195,6 +195,7 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
                 .and_then(|h| u32::from_str_radix(h, 16).ok())
         });
     }
+    style.shadow_color = o.get("shadow_color").and_then(shadow_color);
     let flag = |k: &str| o.get(k).and_then(Value::as_bool);
     style.bold = flag("bold");
     style.italic = flag("italic");
@@ -256,6 +257,28 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
         .map(str::to_owned);
     style
 }
+
+/// `Style.shadow_color`: a packed ARGB int or normalized RGBA array.
+pub(crate) fn shadow_color(value: &Value) -> Option<u32> {
+    if let Some(packed) = value.as_i64() {
+        return i32::try_from(packed).ok().map(|n| n as u32);
+    }
+    let rgba = value.as_array()?;
+    if rgba.len() != 4 {
+        return None;
+    }
+    let channels = rgba
+        .iter()
+        .map(|channel| {
+            // ExtraCodecs.ARGB_COLOR_CODEC reads floats; ARGB.as8BitChannel
+            // floors each normalized channel multiplied by 255.
+            let value = channel.as_f64()? as f32;
+            (value.is_finite() && (0.0..=1.0).contains(&value))
+                .then_some((value * 255.0_f32).floor() as u32)
+        })
+        .collect::<Option<Vec<_>>>()?;
+    Some(channels[3] << 24 | channels[0] << 16 | channels[1] << 8 | channels[2])
+}
 /// `ComponentSerialization.CODEC` decoding into text. `selector` components
 /// are resolved by `resolve` (ComponentUtils.updateForEntity).
 pub fn to_text(v: &Value, resolve: &mut dyn FnMut(&str) -> Text) -> Text {
@@ -417,6 +440,23 @@ pub fn name_text(tag: &Tag) -> Text {
 mod tests {
     use super::*;
 
+    #[test]
+    fn shadow_color_accepts_packed_and_rgba_styles() {
+        let packed = serde_json::json!({"text": "A", "shadow_color": -16711936});
+        let text = to_text(&packed, &mut |_| Text::empty());
+        assert_eq!(text.spans[0].style.shadow_color, Some(0xff00ff00));
+        assert_eq!(text.component()["shadow_color"], -16711936);
+        let rgba = serde_json::json!({"text": "A", "shadow_color": [1, 0, 0.5, 1]});
+        let text = to_text(&rgba, &mut |_| Text::empty());
+        assert_eq!(text.spans[0].style.shadow_color, Some(0xffff007f));
+        let translucent = serde_json::json!({"text": "A", "shadow_color": [1, 0, 0.5, 0.5]});
+        let text = to_text(&translucent, &mut |_| Text::empty());
+        assert_eq!(text.spans[0].style.shadow_color, Some(0x7fff007f));
+        let no_shadow = serde_json::json!({"text": "A", "shadow_color": 0});
+        let text = to_text(&no_shadow, &mut |_| Text::empty());
+        assert_eq!(text.spans[0].style.shadow_color, Some(0));
+    }
+
     #[test]
     fn player_object_survives_text_parsing_and_keeps_its_siblings() {
         let component = serde_json::json!({

crates/horizon-client-core/src/lang.rs

@@ -60,6 +60,9 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/ru_ru.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/ru_ru.json")
             }
+            "assets/horizon/lang/pl_pl.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/pl_pl.json")
+            }
             "assets/horizon/lang/uk_ua.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/uk_ua.json")
             }
@@ -269,6 +272,16 @@ mod tests {
         assert_eq!(en.get("horizon.options.controller"), Some("Controller"));
         let ru = Language::load(&[&empty], "ru_ru");
         assert_eq!(ru.get("horizon.options.controller"), Some("Геймпад"));
+        // Every bundled string carries both languages: a key added to one file
+        // and forgotten in the other shows as a key name on screen.
+        for key in en.map().keys() {
+            assert!(ru.get(key).is_some(), "{key} has no ru_ru value");
+        }
+        assert_eq!(en.get("horizon.pages.mods"), Some("Mods"));
+        assert_eq!(ru.get("horizon.pages.mods"), Some("Моды"));
+        let pl = Language::load(&[&empty], "pl_pl");
+        assert_eq!(pl.get("horizon.options.controller"), Some("Kontroler"));
+        assert_eq!(pl.get("horizon.options.vibration"), Some("Wibracje"));
         let uk = Language::load(&[&empty], "uk_ua");
         assert_eq!(
             uk.get("horizon.options.on_screen_keyboard"),

crates/horizon-client-core/src/particle_type.rs

@@ -55,6 +55,12 @@ particle_types! {
     Rain = "rain",
     Bubble = "bubble",
     SulfurBubbles = "sulfur_bubbles",
+    NoxiousGas = "noxious_gas",
+    NoxiousGasCloud = "noxious_gas_cloud",
+    Geyser = "geyser",
+    GeyserBase = "geyser_base",
+    GeyserPoof = "geyser_poof",
+    GeyserPlume = "geyser_plume",
     BubblePop = "bubble_pop",
     BubbleColumnUp = "bubble_column_up",
     CurrentDown = "current_down",
@@ -149,6 +155,10 @@ impl ParticleType {
         matches!(
             self,
             Self::BlockMarker
+                | Self::Geyser
+                | Self::GeyserBase
+                | Self::GeyserPoof
+                | Self::GeyserPlume
                 | Self::DamageIndicator
                 | Self::ExplosionEmitter
                 | Self::Explosion
@@ -191,6 +201,8 @@ impl ParticleType {
             // SpellParticle.
             | Self::Effect | Self::InstantEffect | Self::EntityEffect
             | Self::Witch | Self::Infested | Self::TrialOmen | Self::RaidOmen
+            // NoxiousGasParticle.
+            | Self::NoxiousGas
             // EmissiveRisingParticle.
             | Self::Soul | Self::SculkSoul
             // SculkChargeParticle, SculkChargePopParticle, ShriekParticle,

crates/horizon-client-core/src/scoreboard.rs

@@ -112,6 +112,7 @@ pub fn style_from_json(v: &Value) -> Style {
                 .and_then(|h| u32::from_str_radix(h, 16).ok())
         });
     }
+    s.shadow_color = o.get("shadow_color").and_then(component::shadow_color);
     let flag = |k: &str| o.get(k).and_then(Value::as_bool);
     s.bold = flag("bold");
     s.italic = flag("italic");
@@ -1563,3 +1564,49 @@ mod tests {
         );
     }
 }
+
+/// `DamageSource.getLocalizedDeathMessage`: the cause's item with a custom
+/// name gets the `<id>.item` message, with the item's name as a third
+/// argument.
+pub fn death_message_args(
+    key: &str,
+    victim: &Text,
+    cause: &Text,
+    item: Option<&Text>,
+) -> (String, Vec<Text>) {
+    match item {
+        Some(item) => (
+            format!("{key}.item"),
+            vec![victim.clone(), cause.clone(), item.clone()],
+        ),
+        None => (key.to_owned(), vec![victim.clone(), cause.clone()]),
+    }
+}
+
+#[cfg(test)]
+mod death_message_tests {
+    use super::*;
+
+    #[test]
+    fn the_death_message_names_the_causes_item_when_it_has_a_custom_name() {
+        let victim = Text::literal("Steve");
+        let cause = Text::literal("Zombie");
+        // DamageSource.getLocalizedDeathMessage: the item variant, with the
+        // item's name as the third argument.
+        let (key, args) = death_message_args(
+            "death.attack.arrow",
+            &victim,
+            &cause,
+            Some(&Text::literal("My Sword")),
+        );
+        assert_eq!(key, "death.attack.arrow.item");
+        assert_eq!(args.len(), 3);
+        assert_eq!(args[0].plain(), "Steve");
+        assert_eq!(args[1].plain(), "Zombie");
+        assert_eq!(args[2].plain(), "My Sword");
+        // Without a custom name the message keeps its two arguments.
+        let (key, args) = death_message_args("death.attack.arrow", &victim, &cause, None);
+        assert_eq!(key, "death.attack.arrow");
+        assert_eq!(args.len(), 2);
+    }
+}

crates/horizon-client-core/src/text.rs

@@ -84,6 +84,8 @@ impl InlineObject {
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct Style {
     pub color: Option<u32>,
+    /// Text component `shadow_color` as packed ARGB. Zero suppresses shadows.
+    pub shadow_color: Option<u32>,
     pub bold: Option<bool>,
     pub italic: Option<bool>,
     pub underlined: Option<bool>,
@@ -116,6 +118,7 @@ impl Style {
     /// Fill unset fields from `base` (Style.applyTo).
     pub fn inherit(&mut self, base: &Style) {
         self.color = self.color.or(base.color);
+        self.shadow_color = self.shadow_color.or(base.shadow_color);
         self.bold = self.bold.or(base.bold);
         self.italic = self.italic.or(base.italic);
         self.underlined = self.underlined.or(base.underlined);
@@ -520,8 +523,9 @@ impl Text {
 }
 
 /// The style fields of a component's JSON.
-const STYLE_KEYS: [&str; 10] = [
+const STYLE_KEYS: [&str; 11] = [
     "color",
+    "shadow_color",
     "bold",
     "italic",
     "underlined",
@@ -542,6 +546,9 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
             .map_or_else(|| format!("#{c:06X}"), |n| n.1.to_owned());
         out.push(("color".to_owned(), name.into()));
     }
+    if let Some(shadow) = style.shadow_color {
+        out.push(("shadow_color".to_owned(), Value::from(shadow as i32)));
+    }
     for (key, flag) in [
         ("bold", style.bold),
         ("italic", style.italic),

crates/horizon-client-input/src/interaction_input.rs

@@ -13,6 +13,12 @@ pub enum Button {
 }
 
 pub trait InteractionWorld {
+    /// Minecraft.pick before handleKeybinds: the tick's `hitResult`, which
+    /// every click of the tick reads, even after one of them changed the
+    /// block it names (a creative break, then a use that replaces it).
+    fn pick_hit_result(&mut self);
+    /// The tick's clicks are done: later picks follow the crosshair again.
+    fn release_hit_result(&mut self);
     fn using_item(&self) -> bool;
     fn release_using(&mut self);
     fn start_attack(&mut self) -> bool;
@@ -48,6 +54,7 @@ impl InteractionInput {
 
     pub fn tick(&mut self, world: &mut impl InteractionWorld, attack_down: bool, use_down: bool) {
         let [attack, use_item, pick] = std::mem::take(&mut self.clicks);
+        world.pick_hit_result();
         let mut instant = false;
         if world.using_item() {
             if !use_down {
@@ -70,6 +77,7 @@ impl InteractionInput {
             world.start_use();
         }
         world.continue_attack(!instant && attack_down);
+        world.release_hit_result();
     }
 }
 
@@ -86,6 +94,8 @@ mod tests {
         events: Vec<&'static str>,
     }
     impl InteractionWorld for World {
+        fn pick_hit_result(&mut self) {}
+        fn release_hit_result(&mut self) {}
         fn using_item(&self) -> bool {
             self.using
         }
@@ -183,4 +193,67 @@ mod tests {
         input.tick(&mut world, false, false);
         assert_eq!(world.events, ["release", "continue"]);
     }
+
+    /// A floating block in front of the crosshair, nothing behind it, and a
+    /// block item in the hand of a creative player.
+    #[derive(Default)]
+    struct Column {
+        block: bool,
+        hit: Option<Option<()>>,
+        placed: bool,
+    }
+    impl Column {
+        /// Minecraft.hitResult: the tick's pick, or a fresh one outside it.
+        fn target(&self) -> Option<()> {
+            self.hit.unwrap_or(self.block.then_some(()))
+        }
+    }
+    impl InteractionWorld for Column {
+        fn pick_hit_result(&mut self) {
+            self.hit = Some(self.target());
+        }
+        fn release_hit_result(&mut self) {
+            self.hit = None;
+        }
+        fn using_item(&self) -> bool {
+            false
+        }
+        fn release_using(&mut self) {}
+        fn start_attack(&mut self) -> bool {
+            // MultiPlayerGameMode.startDestroyBlock in creative: the
+            // predicted break leaves air.
+            if self.target().is_some() {
+                self.block = false;
+            }
+            !self.block
+        }
+        fn start_use(&mut self) {
+            // BlockItem.place: the clicked block, now air, can be replaced.
+            if self.target().is_some() && !self.block {
+                self.block = true;
+                self.placed = true;
+            }
+        }
+        fn pick(&mut self) {}
+        fn use_delay(&self) -> u32 {
+            0
+        }
+        fn continue_attack(&mut self, _: bool) {}
+    }
+
+    #[test]
+    fn attack_and_use_in_one_tick_share_the_hit_result() {
+        // #3006: both buttons at once replace the block the crosshair is on.
+        let mut input = InteractionInput::default();
+        let mut world = Column {
+            block: true,
+            ..Default::default()
+        };
+        input.press(Button::Attack);
+        input.press(Button::Use);
+        input.tick(&mut world, false, false);
+        assert!(world.placed, "the use acts on the block the attack broke");
+        assert!(world.block);
+        assert!(world.hit.is_none(), "the next pick follows the crosshair");
+    }
 }

crates/horizon-client-render/src/assets.rs

@@ -192,9 +192,17 @@ impl Assets {
     pub fn reload(&self, root: &Path) -> Result<RenderAssets> {
         RenderAssets::load(root, self)
     }
+    /// [`Assets::reload`] for a server, which draws nothing: the models and
+    /// the sprites' layers, without the textures' pixels.
+    pub fn reload_for_server(&self, root: &Path) -> Result<RenderAssets> {
+        RenderAssets::load_with(root, self, false)
+    }
 }
 impl RenderAssets {
     pub fn load(root: &Path, assets: &Assets) -> Result<Self> {
+        Self::load_with(root, assets, true)
+    }
+    fn load_with(root: &Path, assets: &Assets, pixels: bool) -> Result<Self> {
         let registry = assets.registry;
         let mut sprites = crate::sprites::Sprites::with_disk_cache(root);
         for name in MATERIALS {
@@ -218,7 +226,11 @@ impl RenderAssets {
             sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
         }
         sprites.save_disk_cache();
-        sprites.finish();
+        if pixels {
+            sprites.finish();
+        } else {
+            sprites.finish_without_pixels();
+        }
         // `finish` grows the buffer by doubling: keep only the bytes in use.
         sprites.pixels.shrink_to_fit();
         Ok(Self {
@@ -241,6 +253,7 @@ impl RenderAssets {
 #[cfg(test)]
 mod tests {
     use crate::items::ConsumeEffect;
+    use horizon_world::loot::PackOverlay;
 
     #[test]
     fn always_edible_and_consume_effects_loaded() {
@@ -251,7 +264,8 @@ mod tests {
         }
         let assets = crate::assets::Assets::load(&root).unwrap();
         let facts = crate::blocks::BlockFacts::load(&root, assets.registry).unwrap();
-        let items = crate::items::Items::load(&root, assets.registry, &facts).unwrap();
+        let items =
+            crate::items::Items::load(&root, assets.registry, &facts, &PackOverlay::NONE).unwrap();
 
         let apple = items.get("minecraft:golden_apple").expect("golden apple");
         assert!(apple.can_always_eat);

crates/horizon-client-render/src/block_entities.rs

@@ -64,6 +64,10 @@ pub struct BlockEntities {
     /// Positions whose block entity `take` took and `put` has not brought
     /// back.
     out: FxHashSet<Pos>,
+    /// Positions a loaded chunk gave a new block entity over an old one: at
+    /// the next tick their slot stays only if their block state ticks
+    /// (`updateBlockEntityTicker`: rebind, or remove without a ticker).
+    replaced: FxHashSet<Pos>,
     /// `Ticking` by block state id; empty until the game builds it.
     states: Vec<Ticking>,
 }
@@ -239,15 +243,20 @@ impl BlockEntities {
         self.added.clear();
         self.pending.clear();
         self.out.clear();
+        self.replaced.clear();
         self.freed = false;
     }
     /// A loaded or generated chunk's block entities, in the order the chunk
     /// lists them; they tick in its block entity map's order
-    /// (`registerAllBlockEntitiesAfterLevelLoad`).
+    /// (`registerAllBlockEntitiesAfterLevelLoad`). One replacing an entity
+    /// already at its position (`LevelChunk.setBlockEntity`) drops that one;
+    /// its slot is decided by the block state at the next tick.
     pub fn load_chunk(&mut self, entities: Vec<(Pos, BlockEntity)>) {
         let order = chunk_map_order(entities.iter().map(|(p, _)| *p));
         for (p, e) in entities {
-            self.map.insert(p, e);
+            if self.map.insert(p, e).is_some() {
+                self.replaced.insert(p);
+            }
         }
         for p in order {
             self.add(p);
@@ -291,6 +300,11 @@ impl BlockEntities {
             self.live.insert(pos, slot);
             Arc::make_mut(&mut self.tickers).push((pos, slot));
         }
+        for pos in std::mem::take(&mut self.replaced) {
+            if self.live.contains_key(&pos) && self.ticking(state(pos)) != Ticking::Yes {
+                self.cancel(&pos);
+            }
+        }
         if !std::mem::take(&mut self.freed) && self.out.is_empty() {
             return Arc::clone(&self.tickers);
         }
@@ -390,4 +404,33 @@ mod tests {
         let order = chunk_map_order(many.iter().copied().chain(many.iter().copied()));
         assert_eq!(order.len(), 100);
     }
+
+    /// A chunk loaded over a block entity already there: the new one replaces
+    /// it, and keeps the old slot only while its block state ticks.
+    #[test]
+    fn loaded_chunk_replaces_block_entity_by_state() {
+        let mut b = level();
+        let mut s = HashMap::new();
+        let (p, q) = ((0, 0, 0), (1, 0, 0));
+        for pos in [p, q] {
+            s.insert(pos, 1);
+        }
+        // Two chunks, so the order is the order they load in.
+        b.load_chunk(vec![(p, hopper())]);
+        b.load_chunk(vec![(q, hopper())]);
+        assert_eq!(order(&mut b, &s), [p, q]);
+        // Replaced where the state ticks: the slot stays in its place.
+        b.load_chunk(vec![(p, hopper())]);
+        assert_eq!(order(&mut b, &s), [p, q]);
+        // Replaced where the state has no ticker: the slot is freed, and the
+        // new block entity is the one in the map.
+        s.insert(p, 2);
+        b.load_chunk(vec![(p, BlockEntity::Chest(vec![None; 27]))]);
+        assert_eq!(order(&mut b, &s), [q]);
+        assert!(matches!(b.get(&p), Some(BlockEntity::Chest(items)) if items.len() == 27));
+        // Ticking again later appends it, as any new ticker does.
+        s.insert(p, 1);
+        b.state_changed(p, 2, 1);
+        assert_eq!(order(&mut b, &s), [q, p]);
+    }
 }

crates/horizon-client-render/src/block_entity_render.rs

@@ -865,13 +865,23 @@ const VIEW_DISTANCE: f64 = 64.0;
 
 impl BlockEntityRenderer {
     pub fn load(root: &Path, registry: &BlockRegistry) -> crate::Result<Self> {
+        let visibility = crate::models::load_visibility(root, registry)?;
+        Self::load_with_visibility(root, registry, visibility)
+    }
+    /// [`BlockEntityRenderer::load`] over the face visibility the meshes use
+    /// (`MeshTables::visibility`): a clone shares its shapes and their faces.
+    pub fn load_with_visibility(
+        root: &Path,
+        registry: &BlockRegistry,
+        visibility: FaceVisibility,
+    ) -> crate::Result<Self> {
         let all: Value = serde_json::from_slice(&std::fs::read(root.join("entity-models.json"))?)?;
         let models = MODELS
             .iter()
             .filter_map(|(key, layer)| all.get(*layer).map(|v| (*key, ModelPart::parse(v))))
             .collect();
         let mut renderer = Self::new(models, registry);
-        renderer.visibility = Some(Mutex::new(crate::models::load_visibility(root, registry)?));
+        renderer.visibility = Some(Mutex::new(visibility));
         // Sherd items: provides_pottery_pattern -> decorated_pot_pattern asset id.
         if let Ok(bytes) = std::fs::read(root.join("items.json")) {
             let items: Value = serde_json::from_slice(&bytes)?;
@@ -2363,6 +2373,7 @@ mod tests {
             lines: [line.into(), "two".into(), String::new(), "four".into()],
             color: 3,
             glowing,
+            ..Default::default()
         };
         let first_text = crate::signs::SignData {
             front: text("one", false),

crates/horizon-client-render/src/brewing.rs

@@ -7,6 +7,7 @@ use crate::{
     items::{ItemStack, Items},
     providers::Providers,
 };
+use horizon_world::loot::PackOverlay;
 use serde_json::Value;
 use std::{collections::HashSet, fs, path::Path};
 
@@ -50,20 +51,30 @@ pub fn tooltip(
             Category::Neutral,
         )];
     }
-    def.effects
-        .iter()
+    effect_lines(def.effects.iter().copied(), scale, translate)
+}
+/// `PotionContents.addPotionTooltip`'s line per effect: its name, potency and
+/// scaled duration, for (effect id, duration, amplifier) entries.
+pub fn effect_lines<'a>(
+    effects: impl IntoIterator<Item = (&'a str, i32, i32)>,
+    scale: f32,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Vec<(String, Category)> {
+    effects
+        .into_iter()
         .map(|(e, duration, amp)| {
+            let e = e.trim_start_matches("minecraft:");
             let mut line =
-                translate(&format!("effect.minecraft.{e}")).unwrap_or_else(|| (*e).to_owned());
-            if *amp > 0 {
+                translate(&format!("effect.minecraft.{e}")).unwrap_or_else(|| e.to_owned());
+            if amp > 0 {
                 line.push(' ');
                 line.push_str(
                     &translate(&format!("potion.potency.{amp}"))
-                        .unwrap_or_else(|| crate::enchant::level_name(*amp as u32 + 1)),
+                        .unwrap_or_else(|| crate::enchant::level_name(amp as u32 + 1)),
                 );
             }
             let instant = effect(e).is_some_and(|d| d.instant);
-            let scaled = (*duration as f32 * scale) as i32;
+            let scaled = (duration as f32 * scale) as i32;
             if !instant && scaled > 20 {
                 line = format!("{line} ({})", format_duration(scaled));
             }
@@ -132,20 +143,41 @@ pub struct Brewing {
     pub inputs: HashSet<String>,
 }
 impl Brewing {
-    pub fn load(root: &Path, items: &Items) -> Self {
-        let mut files: Vec<_> = fs::read_dir(root.join("data/minecraft/recipe/brewing"))
-            .into_iter()
-            .flatten()
-            .flatten()
-            .map(|e| e.path())
-            .collect();
-        files.sort();
-        let mut recipes = Vec::new();
-        for p in files {
-            let Ok(bytes) = fs::read(&p) else { continue };
-            let Ok(v) = serde_json::from_slice::<Value>(&bytes) else {
+    pub fn load(root: &Path, items: &Items, overlay: &PackOverlay) -> Self {
+        let mut sources: Vec<(String, Value)> =
+            fs::read_dir(root.join("data/minecraft/recipe/brewing"))
+                .into_iter()
+                .flatten()
+                .flatten()
+                .filter_map(|e| {
+                    let bytes = fs::read(e.path()).ok()?;
+                    let v = serde_json::from_slice::<Value>(&bytes).ok()?;
+                    Some((
+                        format!(
+                            "minecraft:brewing/{}",
+                            e.file_name().to_string_lossy().strip_suffix(".json")?
+                        ),
+                        v,
+                    ))
+                })
+                .collect();
+        // The world's packs' brewing recipes over the game's own: the top
+        // pack's file for each id replaces it (`SimpleJsonResourceReloadListener`).
+        for (id, files) in overlay.kind("recipe") {
+            if !id.starts_with("minecraft:brewing/") {
+                continue;
+            }
+            let Ok(v) = serde_json::from_slice::<Value>(PackOverlay::top(files)) else {
                 continue;
             };
+            match sources.iter_mut().find(|(n, _)| n == id) {
+                Some(slot) => slot.1 = v,
+                None => sources.push((id.to_owned(), v)),
+            }
+        }
+        sources.sort_by(|a, b| a.0.cmp(&b.0));
+        let mut recipes = Vec::new();
+        for (id, v) in sources {
             if v["type"] != "minecraft:brewing" {
                 continue;
             }
@@ -159,10 +191,7 @@ impl Brewing {
                 output = output.with_potion(potion);
             }
             recipes.push(BrewingRecipe {
-                id: format!(
-                    "minecraft:brewing/{}",
-                    p.file_stem().and_then(|s| s.to_str()).unwrap_or("")
-                ),
+                id,
                 input: PotionIngredient::parse(&v["input"], items),
                 reagent: PotionIngredient::parse(&v["reagent"], items),
                 output,

crates/horizon-client-render/src/chunk.rs

@@ -8,10 +8,170 @@ use std::sync::{Arc, OnceLock};
 
 pub mod block_entity;
 
+/// The vanilla Overworld's column, which every dimension's chunks hold for
+/// now (`LevelShape::column`).
 pub const MIN_Y: i32 = -64;
 pub const HEIGHT: i32 = 384;
 pub const SECTIONS: usize = (HEIGHT / 16) as usize;
 
+/// A level's build range and skylight, from its dimension type (`min_y`,
+/// `height`, `logical_height`, `has_skylight`), as `LevelHeightAccessor` and
+/// `SerializableChunkData.write` read them.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct LevelShape {
+    pub sky_light: bool,
+    pub min_y: i32,
+    pub height: i32,
+    /// `DimensionType.logicalHeight`: how high portals and chorus fruit reach.
+    pub logical_height: i32,
+}
+impl LevelShape {
+    pub const OVERWORLD: Self = Self {
+        sky_light: true,
+        min_y: MIN_Y,
+        height: HEIGHT,
+        logical_height: HEIGHT,
+    };
+    pub const NETHER: Self = Self {
+        sky_light: false,
+        min_y: 0,
+        height: 256,
+        logical_height: 128,
+    };
+    pub const END: Self = Self {
+        sky_light: true,
+        min_y: 0,
+        height: 256,
+        logical_height: 256,
+    };
+    /// A dimension type's shape, checked as its codec checks it.
+    pub fn new(
+        min_y: i32,
+        height: i32,
+        logical_height: i32,
+        sky_light: bool,
+    ) -> Result<Self, String> {
+        ColumnLayout::new(min_y, height)?;
+        if !(0..=height).contains(&logical_height) {
+            return Err(format!(
+                "logical_height {logical_height} is outside 0..={height}"
+            ));
+        }
+        Ok(Self {
+            sky_light,
+            min_y,
+            height,
+            logical_height,
+        })
+    }
+    /// One above the highest block (`getMaxY() + 1`).
+    pub fn max_y(self) -> i32 {
+        self.min_y + self.height
+    }
+    pub fn min_section(self) -> i32 {
+        self.min_y >> 4
+    }
+    pub fn section_count(self) -> usize {
+        (self.height >> 4) as usize
+    }
+    /// Whether section `y` (a section coordinate) is inside the level.
+    pub fn has_section(self, y: i32) -> bool {
+        (self.min_section()..self.min_section() + self.section_count() as i32).contains(&y)
+    }
+    /// The shape of a dimension folder (`dimensions/minecraft/<name>`, or the
+    /// old `DIM-1` and `DIM1`).
+    pub fn for_dir(root: &std::path::Path) -> Self {
+        if root.ends_with("the_nether") || root.ends_with("DIM-1") {
+            Self::NETHER
+        } else if root.ends_with("the_end") || root.ends_with("DIM1") {
+            Self::END
+        } else {
+            Self::OVERWORLD
+        }
+    }
+    /// The sections a chunk of this level holds: the level's, widened to the
+    /// vanilla Overworld's `-64..320` so that vanilla's Nether and End keep
+    /// the 24 sections they have always had.
+    pub fn column(self) -> ColumnLayout {
+        let low = self.min_y.min(MIN_Y);
+        let high = self.max_y().max(MIN_Y + HEIGHT);
+        ColumnLayout {
+            min_y: low,
+            sections: ((high - low) / 16) as usize,
+        }
+    }
+}
+
+/// The span of block Y a chunk holds: from `min_y`, `sections` sections up
+/// (`LevelShape::column`).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ColumnLayout {
+    min_y: i32,
+    sections: usize,
+}
+impl ColumnLayout {
+    pub const VANILLA: Self = Self {
+        min_y: MIN_Y,
+        sections: SECTIONS,
+    };
+    /// `DimensionType.MIN_Y`, `MAX_Y`: 12 bits of `BlockPos` Y, less 32.
+    pub const LOWEST_Y: i32 = -2032;
+    pub const HIGHEST_Y: i32 = 2031;
+    /// A dimension type's `min_y` and `height`, as its codec accepts them:
+    /// multiples of 16, at least 16 high, within `LOWEST_Y..=HIGHEST_Y`.
+    pub fn new(min_y: i32, height: i32) -> Result<Self, String> {
+        if min_y % 16 != 0 || height % 16 != 0 {
+            return Err(format!(
+                "min_y {min_y} and height {height} must be multiples of 16"
+            ));
+        }
+        if height < 16 {
+            return Err(format!("height {height} is below 16"));
+        }
+        if min_y < Self::LOWEST_Y
+            || i64::from(min_y) + i64::from(height) > i64::from(Self::HIGHEST_Y) + 1
+        {
+            return Err(format!(
+                "min_y {min_y} with height {height} leaves {}..={}",
+                Self::LOWEST_Y,
+                Self::HIGHEST_Y
+            ));
+        }
+        Ok(Self {
+            min_y,
+            sections: (height / 16) as usize,
+        })
+    }
+    pub fn min_y(self) -> i32 {
+        self.min_y
+    }
+    /// One above the highest block.
+    pub fn max_y(self) -> i32 {
+        self.min_y + self.height()
+    }
+    pub fn height(self) -> i32 {
+        self.sections as i32 * 16
+    }
+    pub fn sections(self) -> usize {
+        self.sections
+    }
+    /// The index of the section holding block `y`, if the column holds it.
+    pub fn section_index(self, y: i32) -> Option<usize> {
+        usize::try_from((y - self.min_y) >> 4)
+            .ok()
+            .filter(|&s| s < self.sections)
+    }
+    /// The minimum block Y of section `index`.
+    pub fn section_y(self, index: usize) -> i32 {
+        self.min_y + index as i32 * 16
+    }
+}
+impl Default for ColumnLayout {
+    fn default() -> Self {
+        Self::VANILLA
+    }
+}
+
 /// Biomes are 4x4x4 containers over the biome table (67 entries: a 7-bit
 /// global palette).
 pub const BIOME_STRATEGY: Strategy = Strategy::biomes(7);
@@ -138,9 +298,11 @@ impl Section {
 pub struct Chunk {
     pub x: i32,
     pub z: i32,
+    /// The minimum block Y of `sections[0]` (the layout's when it was made).
+    min_y: i32,
     pub sections: Vec<Arc<Section>>,
     /// `Heightmap.Types.WORLD_SURFACE` per column (`z << 4 | x`): one above
-    /// the highest non-air block, or `MIN_Y`. Built on the first read; a
+    /// the highest non-air block, or the column's minimum Y. Built on the first read; a
     /// `set` that can move a column's surface drops it.
     surface: OnceLock<Box<[i16; 256]>>,
     /// `Heightmap.Types.MOTION_BLOCKING` per column, kept like `surface`.
@@ -169,11 +331,16 @@ pub struct Chunk {
     pub structure_starts: Vec<Arc<horizon_world::worldgen::structure::start::StructureStart>>,
 }
 impl Chunk {
+    /// An all-air chunk in the current `layout`.
     pub fn empty(x: i32, z: i32) -> Self {
+        Self::with_layout(x, z, ColumnLayout::VANILLA)
+    }
+    pub fn with_layout(x: i32, z: i32, layout: ColumnLayout) -> Self {
         Self {
             x,
             z,
-            sections: (0..SECTIONS)
+            min_y: layout.min_y(),
+            sections: (0..layout.sections())
                 .map(|_| Arc::new(Section::default()))
                 .collect(),
             surface: OnceLock::new(),
@@ -190,13 +357,36 @@ impl Chunk {
             entities: Vec::new(),
         }
     }
+    /// The minimum block Y of the column.
+    #[inline]
+    pub fn min_y(&self) -> i32 {
+        self.min_y
+    }
+    /// The column the chunk holds.
+    pub fn layout(&self) -> ColumnLayout {
+        ColumnLayout {
+            min_y: self.min_y,
+            sections: self.sections.len(),
+        }
+    }
+    /// One above the column's highest block.
+    #[inline]
+    pub fn max_y(&self) -> i32 {
+        self.min_y + self.sections.len() as i32 * 16
+    }
+    /// The index of the section holding block `y`, if the column holds it.
+    #[inline]
+    pub fn section_index(&self, y: i32) -> Option<usize> {
+        usize::try_from((y - self.min_y) >> 4)
+            .ok()
+            .filter(|&s| s < self.sections.len())
+    }
     #[inline]
     pub fn get(&self, x: i32, y: i32, z: i32) -> u32 {
-        let s = (y - MIN_Y) >> 4;
-        if !(0..SECTIONS as i32).contains(&s) {
-            return 0;
+        match self.section_index(y) {
+            Some(s) => self.sections[s].get(index(x, y, z)),
+            None => 0,
         }
-        self.sections[s as usize].get(index(x, y, z))
     }
     #[inline]
     pub fn block(&self, x: i32, y: i32, z: i32) -> BlockStateId {
@@ -211,16 +401,15 @@ impl Chunk {
             .rev()
             .filter(|(_, section)| !section.is_uniform(skip))
             .find_map(|(s, _)| {
-                let base = MIN_Y + s as i32 * 16;
+                let base = self.min_y + s as i32 * 16;
                 (base..base + 16).rev().find(|&y| matches(y))
             })
     }
     pub fn set(&mut self, x: i32, y: i32, z: i32, v: u32) -> u32 {
-        let s = (y - MIN_Y) >> 4;
-        if !(0..SECTIONS as i32).contains(&s) {
+        let Some(s) = self.section_index(y) else {
             return v;
-        }
-        let previous = Arc::make_mut(&mut self.sections[s as usize]).set(index(x, y, z), v);
+        };
+        let previous = Arc::make_mut(&mut self.sections[s]).set(index(x, y, z), v);
         // `Heightmap.update`: a write two or more below a map's height can't
         // move it. Any other change rebuilds that map on the next read.
         if previous != v {
@@ -236,7 +425,8 @@ impl Chunk {
         previous
     }
     /// `getHeight(Heightmap.Types.WORLD_SURFACE, x, z)` (`x`, `z` within the
-    /// chunk): one above the highest block that isn't `air`, or `MIN_Y`.
+    /// chunk): one above the highest block that isn't `air`, or the column's
+    /// minimum Y.
     /// Sections must change only through `set` once this has been read.
     pub fn world_surface(&self, x: i32, z: i32, air: impl Fn(u32) -> bool) -> i32 {
         let surface = self.surface.get_or_init(|| self.prime(|v| !air(v)));
@@ -244,7 +434,8 @@ impl Chunk {
     }
     /// `getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)` (`x`, `z` within
     /// the chunk): one above the highest state where `blocks` (a motion
-    /// blocking block or a fluid), or `MIN_Y`. Kept as `world_surface` is.
+    /// blocking block or a fluid), or the column's minimum Y. Kept as
+    /// `world_surface` is.
     pub fn motion_blocking(&self, x: i32, z: i32, blocks: impl Fn(u32) -> bool) -> i32 {
         let heights = self.motion_blocking.get_or_init(|| self.prime(blocks));
         i32::from(heights[column(x, z)])
@@ -252,7 +443,7 @@ impl Chunk {
     /// `Heightmap.primeHeightmaps`: each section from the top, skipping
     /// those of one state that doesn't count, until every column is found.
     fn prime(&self, counts: impl Fn(u32) -> bool) -> Box<[i16; 256]> {
-        let mut surface = Box::new([MIN_Y as i16; 256]);
+        let mut surface = Box::new([self.min_y as i16; 256]);
         let mut found = [false; 256];
         let mut left = 256;
         let mut values = [0u32; 4096];
@@ -264,7 +455,7 @@ impl Chunk {
                 continue;
             }
             section.unpack(&mut values);
-            let base = MIN_Y + s as i32 * 16;
+            let base = self.min_y + s as i32 * 16;
             for i in 0..256 {
                 if found[i] {
                     continue;
@@ -280,11 +471,11 @@ impl Chunk {
     }
     #[inline]
     pub fn light(&self, x: i32, y: i32, z: i32) -> u8 {
-        let s = (y - MIN_Y) >> 4;
+        let s = (y - self.min_y) >> 4;
         if s < 0 {
             return 0;
         }
-        if s >= SECTIONS as i32 {
+        if s >= self.sections.len() as i32 {
             return 0xF0;
         }
         self.sections[s as usize].light(index(x, y, z))
@@ -297,7 +488,7 @@ impl Chunk {
     /// the quart y clamped to the column).
     #[inline]
     pub fn biome(&self, x: i32, y: i32, z: i32) -> u16 {
-        let qy = ((y - MIN_Y) >> 2).clamp(0, HEIGHT / 4 - 1);
+        let qy = ((y - self.min_y) >> 2).clamp(0, self.sections.len() as i32 * 4 - 1);
         self.sections[(qy >> 2) as usize]
             .biomes
             .get(((qy & 3) << 4 | ((z & 15) >> 2) << 2 | (x & 15) >> 2) as usize) as u16
@@ -504,4 +695,69 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn shapes_follow_the_dimension_type_codec() {
+        assert_eq!(ColumnLayout::new(-64, 384), Ok(ColumnLayout::VANILLA));
+        assert_eq!(ColumnLayout::default(), ColumnLayout::VANILLA);
+        // To The Max's Overworld: the highest top vanilla allows.
+        let tall = ColumnLayout::new(-64, 2096).unwrap();
+        assert_eq!((tall.sections(), tall.max_y()), (131, 2032));
+        assert!(ColumnLayout::new(-2032, 4064).is_ok());
+        for (min_y, height) in [(-64, 2112), (-2048, 64), (-60, 384), (0, 250), (0, 0)] {
+            assert!(
+                ColumnLayout::new(min_y, height).is_err(),
+                "{min_y} {height}"
+            );
+        }
+        assert_eq!(tall.section_index(-65), None);
+        assert_eq!(tall.section_index(-64), Some(0));
+        assert_eq!(tall.section_index(2031), Some(130));
+        assert_eq!(tall.section_index(2032), None);
+        assert_eq!(tall.section_y(130), 2016);
+        assert_eq!(
+            LevelShape::new(-64, 384, 384, true),
+            Ok(LevelShape::OVERWORLD)
+        );
+        assert_eq!(LevelShape::new(0, 256, 128, false), Ok(LevelShape::NETHER));
+        assert!(LevelShape::new(0, 256, 257, true).is_err());
+        assert!(LevelShape::new(-60, 384, 384, true).is_err());
+    }
+
+    #[test]
+    fn vanilla_levels_keep_the_overworld_column() {
+        for shape in [LevelShape::OVERWORLD, LevelShape::NETHER, LevelShape::END] {
+            assert_eq!(shape.column(), ColumnLayout::VANILLA, "{shape:?}");
+        }
+        let tall = LevelShape::new(-64, 2096, 2096, true).unwrap();
+        assert_eq!(tall.column(), ColumnLayout::new(-64, 2096).unwrap());
+        let deep = LevelShape::new(-512, 256, 256, false).unwrap();
+        assert_eq!(deep.column(), ColumnLayout::new(-512, 832).unwrap());
+        assert!(LevelShape::NETHER.has_section(15) && !LevelShape::NETHER.has_section(16));
+        assert!(!LevelShape::NETHER.has_section(-1));
+    }
+
+    #[test]
+    fn a_tall_column_stores_its_whole_height() {
+        let layout = ColumnLayout::new(-64, 2096).unwrap();
+        let mut chunk = Chunk::with_layout(0, 0, layout);
+        assert_eq!(
+            (chunk.min_y(), chunk.max_y(), chunk.sections.len()),
+            (-64, 2032, 131)
+        );
+        let stone = 1;
+        assert_eq!(chunk.set(5, 2031, 6, stone), 0);
+        assert_eq!(chunk.set(5, 2032, 6, stone), stone, "above the column");
+        assert_eq!(chunk.get(5, 2031, 6), stone);
+        assert_eq!(chunk.get(5, 2032, 6), 0);
+        assert_eq!(chunk.world_surface(5, 6, |v| v == 0), 2032);
+        assert_eq!(chunk.world_surface(0, 0, |v| v == 0), -64);
+        assert_eq!(chunk.highest(0, |y| y < 1000), None);
+        chunk.set(5, 999, 6, stone);
+        assert_eq!(chunk.highest(0, |y| y < 1000), Some(999));
+        assert_eq!(chunk.light(0, 2100, 0), 0xF0);
+        assert_eq!(chunk.light(0, -65, 0), 0);
+        chunk.set_biome_cell(0, 130 * 4 + 3, 0, 9);
+        assert_eq!(chunk.biome(0, 5000, 0), 9);
+    }
 }

crates/horizon-client-render/src/chunk/block_entity.rs

@@ -80,6 +80,24 @@ pub enum BlockEntity {
     Shelf(Box<Shelf>),
     /// `ChiseledBookShelfBlockEntity`: a `Container` of six one-book slots.
     ChiseledBookshelf(Box<ChiseledBookshelf>),
+    /// `PotentSulfurBlockEntity` (`game/potent_sulfur.rs`).
+    PotentSulfur(PotentSulfur),
+}
+/// `PotentSulfurBlockEntity`: the seconds left to the geyser's next change of
+/// state (`waitingCountdown`, saved as `countdown`) and the game time of its
+/// last eruption block event, which the client's plume counts from.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PotentSulfur {
+    pub waiting_countdown: i32,
+    pub eruption_tick: i64,
+}
+impl Default for PotentSulfur {
+    fn default() -> Self {
+        Self {
+            waiting_countdown: -1,
+            eruption_tick: -1,
+        }
+    }
 }
 /// `BrushableBlockEntity`: the loot table is resolved on the first brush.
 #[derive(Clone, Debug, Default)]
@@ -228,6 +246,8 @@ pub struct SignText {
     /// `DyeColor` id.
     pub color: u8,
     pub glowing: bool,
+    /// The `click_event` in each line's component style, as saved.
+    pub click: [Option<Tag>; 4],
 }
 /// `SignBlockEntity` / `HangingSignBlockEntity` data.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
@@ -236,6 +256,8 @@ pub struct SignData {
     pub front: SignText,
     pub back: SignText,
     pub waxed: bool,
+    /// `allow_op_features`: the sign's click events may run commands.
+    pub allow_op_features: bool,
 }
 /// `VibrationInfo`.
 #[derive(Clone, Copy, Debug, PartialEq)]

crates/horizon-client-render/src/chunk_map.rs

@@ -82,6 +82,9 @@ impl crate::light::LightWorld for ChunkMap {
     fn set_section_light(&mut self, cx: i32, s: usize, cz: i32, light: crate::chunk::Light) {
         self.columns.set_section_light(cx, s, cz, light);
     }
+    fn layout(&self) -> crate::chunk::ColumnLayout {
+        self.columns.layout()
+    }
 }
 
 #[cfg(test)]

crates/horizon-client-render/src/containers.rs

@@ -3,7 +3,7 @@
 //! from the data-driven `context_int_provider`/`context_float_provider` files.
 pub use crate::chunk::block_entity::{
     Banner, Beacon, BlockEntity, Brushable, Campfire, ChiseledBookshelf, Crafter, CreakingHeart,
-    EndGateway, Furnace, FurnaceKind, Jukebox, Lectern, Shelf, Skull, SkullSkin,
+    EndGateway, Furnace, FurnaceKind, Jukebox, Lectern, PotentSulfur, Shelf, Skull, SkullSkin,
 };
 use crate::items::ItemStack;
 use std::collections::HashMap;
@@ -306,6 +306,9 @@ impl BlockEntity {
         if name == "minecraft:chiseled_bookshelf" {
             return Some(Self::ChiseledBookshelf(Box::default()));
         }
+        if name == "minecraft:potent_sulfur" {
+            return Some(Self::PotentSulfur(PotentSulfur::default()));
+        }
         let size = match name {
             "minecraft:chest" | "minecraft:trapped_chest" | "minecraft:barrel" => 27,
             n if n.ends_with("copper_chest") => 27,
@@ -349,6 +352,7 @@ impl BlockEntity {
             Self::Campfire(_) => "minecraft:campfire",
             Self::ChiseledBookshelf(_) => "minecraft:chiseled_bookshelf",
             Self::Shelf(_) => "minecraft:shelf",
+            Self::PotentSulfur(_) => "minecraft:potent_sulfur",
         }
     }
     pub fn contents(&self) -> Vec<ItemStack> {
@@ -367,6 +371,7 @@ impl BlockEntity {
             | Self::CommandBlock(_)
             | Self::EndGateway(_)
             | Self::Skull(_)
+            | Self::PotentSulfur(_)
             | Self::DaylightDetector
             | Self::Brushable(_) => Vec::new(),
             Self::Lectern(l) => l.book.iter().cloned().collect(),
@@ -391,6 +396,7 @@ impl BlockEntity {
             | Self::Banner(_)
             | Self::EndGateway(_)
             | Self::Skull(_)
+            | Self::PotentSulfur(_)
             | Self::DaylightDetector
             | Self::Brushable(_) => &[],
             Self::Crafter(c) => &c.items,
@@ -419,6 +425,7 @@ impl BlockEntity {
             | Self::Banner(_)
             | Self::EndGateway(_)
             | Self::Skull(_)
+            | Self::PotentSulfur(_)
             | Self::DaylightDetector
             | Self::Brushable(_) => &mut [],
             Self::Crafter(c) => &mut c.items,

crates/horizon-client-render/src/datapack.rs

@@ -423,9 +423,31 @@ pub struct DataStore {
     pub predicates: BTreeMap<String, serde_json::Value>,
     /// `item_modifier` files, for `/item modify`.
     pub item_modifiers: BTreeMap<String, serde_json::Value>,
+    /// The content tables' raw files from the packs after the built-in one:
+    /// `recipe/`, `loot_table/`, `advancement/` and `tags/…/` files, by
+    /// `<kind-dir>/<ns>:<path>`, each id's files in pack order. The tables
+    /// merge them over what they read from the resource root.
+    pub files: BTreeMap<String, Vec<Vec<u8>>>,
     /// Functions that failed to parse (id, message), for logging.
     pub errors: Vec<(String, String)>,
 }
+/// `<kind-dir>/<ns>:<path>` for a pack file the content tables read:
+/// `recipe/`, `loot_table/`, `advancement/` or `tags/<sub>/`, where the id
+/// keeps the sub path so a nested tag kind stays addressable.
+fn content_id(file: &str) -> Option<String> {
+    let rest = file.strip_prefix("data/")?;
+    let (ns, rest) = rest.split_once('/')?;
+    let (kind, rest) = rest.split_once('/')?;
+    let kind = match kind {
+        "recipe" | "loot_table" | "advancement" => kind,
+        "tags" => {
+            let (sub, name) = rest.rsplit_once('/')?;
+            return Some(format!("tags/{sub}/{ns}:{}", name.strip_suffix(".json")?));
+        }
+        _ => return None,
+    };
+    Some(format!("{kind}/{ns}:{}", rest.strip_suffix(".json")?))
+}
 /// `ns:path` for a file `data/<ns>/<kind>/<path>.<ext>`.
 fn resource_id(file: &str, kind: &str, ext: &str) -> Option<String> {
     let rest = file.strip_prefix("data/")?;
@@ -440,7 +462,22 @@ impl DataStore {
     pub fn load(packs: &[&DataPack]) -> Self {
         let mut s = Self::default();
         for pack in packs {
-            for f in pack.list_kinds(&["function", "item_modifier", "predicate", "tags/function"]) {
+            // `tags` walks the whole tags tree, so a `tags/function` file is
+            // listed by both kinds: handle every file once.
+            let mut seen = std::collections::BTreeSet::new();
+            let builtin = pack.id == "vanilla";
+            for f in pack.list_kinds(&[
+                "advancement",
+                "function",
+                "item_modifier",
+                "loot_table",
+                "predicate",
+                "recipe",
+                "tags",
+            ]) {
+                if !seen.insert(f.clone()) {
+                    continue;
+                }
                 if let Some(id) = resource_id(&f, "function", ".mcfunction")
                     && let Some(bytes) = pack.read(&f)
                 {
@@ -470,6 +507,14 @@ impl DataStore {
                     && let Ok(v) = serde_json::from_slice(&bytes)
                 {
                     s.item_modifiers.insert(id, v);
+                } else if !builtin
+                    && let Some(id) = content_id(&f)
+                    && let Some(bytes) = pack.read(&f)
+                {
+                    // The built-in pack's content files are the resource
+                    // root's own, which the tables read from disk; only the
+                    // world's packs come through here.
+                    s.files.entry(id).or_default().push(bytes);
                 }
             }
         }
@@ -479,11 +524,21 @@ impl DataStore {
     /// included, each function once).
     pub fn tag_functions(&self, id: &str) -> Vec<String> {
         let mut out = Vec::new();
-        self.expand(id, &mut out, 0);
+        let mut seen_fns = std::collections::HashSet::new();
+        let mut seen_tags = std::collections::HashSet::new();
+        self.expand(id, &mut out, &mut seen_fns, &mut seen_tags);
         out
     }
-    fn expand(&self, id: &str, out: &mut Vec<String>, depth: usize) {
-        if depth > 16 {
+    /// Depth-first walk keeping first-seen order. Each tag is expanded at most
+    /// once, so reference cycles end and nesting depth is not capped.
+    fn expand<'a>(
+        &'a self,
+        id: &'a str,
+        out: &mut Vec<String>,
+        seen_fns: &mut std::collections::HashSet<&'a str>,
+        seen_tags: &mut std::collections::HashSet<&'a str>,
+    ) {
+        if !seen_tags.insert(id) {
             return;
         }
         let Some(entries) = self.function_tags.get(id) else {
@@ -491,9 +546,9 @@ impl DataStore {
         };
         for (e, required) in entries {
             match e.strip_prefix('#') {
-                Some(inner) => self.expand(inner, out, depth + 1),
+                Some(inner) => self.expand(inner, out, seen_fns, seen_tags),
                 None => {
-                    if (self.functions.contains_key(e) || *required) && !out.contains(e) {
+                    if (self.functions.contains_key(e) || *required) && seen_fns.insert(e) {
                         out.push(e.clone());
                     }
                 }
@@ -767,6 +822,40 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
 
+    #[test]
+    fn tag_resolution_dedupes_fast_ends_cycles_and_nests_deeply() {
+        let mut store = DataStore::default();
+        let big: Vec<(String, bool)> = (0..50_000)
+            .map(|i| (format!("t:f{}", i % 25_000), true))
+            .collect();
+        store.function_tags.insert("t:big".into(), big);
+        let start = std::time::Instant::now();
+        let got = store.tag_functions("t:big");
+        assert_eq!(got.len(), 25_000);
+        assert_eq!(got[0], "t:f0");
+        assert!(start.elapsed() < std::time::Duration::from_secs(5));
+        // A cycle terminates and keeps first-seen order.
+        store.function_tags.insert(
+            "t:a".into(),
+            vec![("#t:b".into(), true), ("t:x".into(), true)],
+        );
+        store.function_tags.insert(
+            "t:b".into(),
+            vec![("#t:a".into(), true), ("t:y".into(), true)],
+        );
+        assert_eq!(store.tag_functions("t:a"), ["t:y", "t:x"]);
+        // Nesting deeper than the old cap of 16 still resolves.
+        for i in 0..40 {
+            store
+                .function_tags
+                .insert(format!("d:{i}"), vec![(format!("#d:{}", i + 1), true)]);
+        }
+        store
+            .function_tags
+            .insert("d:40".into(), vec![("t:deep".into(), true)]);
+        assert_eq!(store.tag_functions("d:0"), ["t:deep"]);
+    }
+
     #[test]
     fn folder_packs_list_the_needed_kinds_in_walk_order() {
         let dir = std::env::temp_dir().join(format!("hz-datapack-kinds-{}", std::process::id()));

crates/horizon-client-render/src/entity.wgsl

@@ -53,10 +53,13 @@ struct Out {
     @location(9) light_color: vec4<f32>,
     @location(10) @interpolate(flat) weather_rect: vec4<f32>,
     // The `GLINT_TEXTURING` sample for overlay 7 (item foil), or the model UV
-    // `ARMOR_ENTITY_GLINT_TEXTURING` scrolls for overlay 13 (armour).
+    // `ARMOR_ENTITY_GLINT_TEXTURING` scrolls for overlay 36 (armour).
     @location(11) glint_uv: vec2<f32>,
     // 1 drops the quad's back-facing pixels (Vertex::normal w = 1), like a culling render type.
     @location(12) @interpolate(flat) cull: u32,
+    // HDR tier of a light-giving particle (mesher::hdr_tier), from the overlay's
+    // high bits (particles.rs): fs_hdr_mark marks the frame with it.
+    @location(13) @interpolate(flat) tier: u32,
 }
 // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed.
 fn entity_light(normal: vec3<f32>, nether: bool) -> f32 {
@@ -126,8 +129,9 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
 @vertex fn vs_entity(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
     @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>,
     @location(5) normal: vec4<f32>, @location(6) glint_uv: vec2<f32>) -> Out {
-    var out = entity_vertex(position, uv, overlay, color, light, normal);
+    var out = entity_vertex(position, uv, overlay & 0xffffu, color, light, normal);
     out.glint_uv = glint_uv;
+    out.tier = overlay >> 16u;
     return out;
 }
 // Retained bolt-local geometry, translated using the same f64 camera
@@ -250,8 +254,8 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
         // Enchantment glint: item.fsh's GLINT path, sampled from
         // enchanted_glint_item at the `GLINT_TEXTURING` UV.
         color = glint_over(color, textureSample(glint_tex, glint_sampler, in.glint_uv));
-    } else if in.overlay == 13u {
-        // Enchanted armour: enchanted_glint_armor at the scrolling model UV.
+    } else if in.overlay == 36u {
+        // Enchanted armour (mobs::render::ARMOR_GLINT): enchanted_glint_armor at the scrolling model UV.
         color = glint_over(
             color,
             textureSample(glint_armor_tex, glint_sampler, armor_glint_uv(in.glint_uv)),
@@ -279,6 +283,14 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
     return vec4(in.color.rgb, 1.0);
 }
 
+// HDR output: a light-giving particle's pixels marked in the frame's alpha the
+// way terrain.wgsl marks a light source's, drawn again after the entities with
+// only alpha written, so its colour stays as blended.
+@fragment fn fs_hdr_mark(in: Out) -> @location(0) vec4<f32> {
+    if in.tier == 0u || textureSample(atlas, atlas_sampler, in.uv).a < 0.1 { discard; }
+    return vec4(0.0, 0.0, 0.0, 0.7 * f32(4u - min(in.tier, 4u)) / 4.0);
+}
+
 fn celestial_color(in: Out) -> vec4<f32> {
     return textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
 }

crates/horizon-client-render/src/environment.rs

@@ -389,3 +389,36 @@ pub fn apply_weather(sky: &mut Sky, rain: f32, thunder: f32) {
         );
     }
 }
+
+pub fn sky_darken(environment: &Environment, day_time: i64, rain: f32, thunder: f32) -> i32 {
+    let mut sky = environment.sample(day_time, None, None);
+    apply_weather(&mut sky, rain, thunder);
+    // Level.updateSkyBrightness: darkening from the sky light level.
+    (15.0 - 15.0 * sky.sky_light_level).round() as i32
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn overworld() -> Option<Environment> {
+        let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client/26.3");
+        root.join("data/minecraft/timeline/day.json")
+            .exists()
+            .then(|| Environment::load(&root).unwrap())
+    }
+
+    #[test]
+    fn dark_outside_follows_time_and_weather_levels() {
+        let Some(env) = overworld() else {
+            return;
+        };
+        let dark = |time, rain, thunder| sky_darken(&env, time, rain, thunder) >= 4;
+        assert!(!dark(6000, 0.0, 0.0), "clear noon");
+        assert!(!dark(6000, 1.0, 0.0), "rainy noon");
+        assert!(dark(6000, 1.0, 1.0), "thunderstorm at noon");
+        assert!(dark(18000, 0.0, 0.0), "clear midnight");
+        assert!(!dark(1000, 0.0, 0.0), "clear morning");
+    }
+}

crates/horizon-client-render/src/gfx.rs

@@ -7,6 +7,7 @@ use crate::{
     graphics::GraphicsApi,
     hud::{HudBatch, HudRenderer},
     mesher::{SectionMesh, Sides, TerrainVertex, Vertex},
+    section_mask::SectionMask,
     sprites::SpriteAnimation,
 };
 use glam::{DVec3, Mat4, Vec3, Vec4};
@@ -105,8 +106,6 @@ mod view;
 mod wgsl_prefix;
 mod world_post;
 
-/// A column whose every section has its mesh (`Renderer::lod_detail_columns`).
-const COMPLETE_COLUMN: u32 = (1 << (crate::chunk::HEIGHT / 16)) - 1;
 /// A section's instance: its camera-relative origin and, in `w`, the step of
 /// its fixed-point UVs (`terrain.wgsl`'s `terrain_uv`).
 /// The world pass again after occlusion culling's test: it loads both
@@ -428,6 +427,7 @@ pub struct Renderer {
     crosshair_group: wgpu::BindGroup,
     crosshair_globals: wgpu::Buffer,
     entity_pipeline: wgpu::RenderPipeline,
+    hdr_mark_pipeline: wgpu::RenderPipeline,
     weather: weather::Weather,
     crumbling_pipeline: wgpu::RenderPipeline,
     shadow_blob_pipeline: wgpu::RenderPipeline,
@@ -516,7 +516,7 @@ pub struct Renderer {
     lod_retiring: crate::fast_hash::FxHashSet<SectionKey>,
     /// Finished tile meshes `upload_lods` has yet to upload.
     lod_pending: Option<lod::Pending>,
-    detail_columns: crate::fast_hash::FxHashMap<(i32, i32), u32>,
+    detail_columns: crate::fast_hash::FxHashMap<(i32, i32), SectionMask>,
     /// Bumped whenever a column becomes or stops being complete.
     detail_revision: u64,
     arena: arena::Arena,
@@ -555,6 +555,9 @@ pub struct Renderer {
     block_entity_revision: u64,
     /// VisGraph face connectivity per meshed section (cave culling).
     occlusion: occlusion::Occlusion,
+    /// The column `occlusion`, `sections` and `detail_columns` count in: the
+    /// level's (`clear_sections`).
+    layout: crate::chunk::ColumnLayout,
     /// Resolution scale, FXAA and TAA (Horizon settings).
     world_post: world_post::Post,
     /// HDR output (Horizon setting): `Some` while the swapchain is HDR.
@@ -2127,6 +2130,18 @@ impl Renderer {
             "fs_energy_swirl",
             wgpu::ColorWrites::ALL,
         );
+        // HDR output's mark on light-giving particles (entity.wgsl fs_hdr_mark).
+        let hdr_mark_pipeline = entity_pipeline_with(
+            "HDR particle mark",
+            None,
+            false,
+            wgpu::CompareFunction::GreaterEqual,
+            Default::default(),
+            wgpu::BlendState::REPLACE,
+            false,
+            "fs_hdr_mark",
+            wgpu::ColorWrites::ALPHA,
+        );
         // Attribute 7: 6 is the entity vertex buffer's glint UV.
         let lightning_attributes = wgpu::vertex_attr_array![7=>Float32x3];
         let lightning_vertex = [
@@ -2640,6 +2655,7 @@ impl Renderer {
             crosshair_group,
             crosshair_globals,
             entity_pipeline,
+            hdr_mark_pipeline,
             weather,
             crumbling_pipeline,
             shadow_blob_pipeline,
@@ -2730,6 +2746,7 @@ impl Renderer {
             block_entities: Default::default(),
             block_entity_revision: next_block_entity_revision(),
             occlusion: occlusion::Occlusion::new(crate::chunk::MIN_Y, crate::chunk::HEIGHT / 16),
+            layout: crate::chunk::ColumnLayout::VANILLA,
             world_post,
             hdr: None,
             hdr_output,
@@ -3166,7 +3183,8 @@ impl Renderer {
     pub fn block_entity_revision(&self) -> u64 {
         self.block_entity_revision
     }
-    pub fn clear_sections(&mut self) {
+    /// Drops every section, for a level whose chunks hold `layout`.
+    pub fn clear_sections(&mut self, layout: crate::chunk::ColumnLayout) {
         self.block_entities.clear();
         self.block_entity_revision = next_block_entity_revision();
         self.sections.clear();
@@ -3182,12 +3200,23 @@ impl Renderer {
         }
         self.sorted_indices.clear();
         self.translucency_cursor = 0;
-        self.occlusion.clear();
+        if layout == self.layout {
+            self.occlusion.clear();
+        } else {
+            self.layout = layout;
+            self.occlusion = occlusion::Occlusion::new(layout.min_y(), layout.sections() as i32);
+            self.sections.set_min_y(layout.min_y());
+        }
+    }
+    /// A column whose every section has its mesh (`lod_detail_columns`).
+    fn complete_column(&self) -> SectionMask {
+        SectionMask::below(self.layout.sections())
     }
     pub fn lod_detail_columns(&self) -> impl Iterator<Item = (i32, i32)> + '_ {
+        let complete = self.complete_column();
         self.detail_columns
             .iter()
-            .filter_map(move |(&column, &mask)| (mask == COMPLETE_COLUMN).then_some(column))
+            .filter_map(move |(&column, &mask)| (mask == complete).then_some(column))
     }
     /// Changes whenever `lod_detail_columns` does.
     pub fn lod_detail_revision(&self) -> u64 {
@@ -3196,16 +3225,22 @@ impl Renderer {
     /// Whether the section at `key` has its mesh, for `lod_detail_columns`.
     fn set_detail(&mut self, key: SectionKey, meshed: bool) {
         let column = (key.0, key.2);
-        let mask = self.detail_columns.get(&column).copied().unwrap_or(0);
-        let next = if meshed {
-            mask | 1 << key.1
+        let mask = self
+            .detail_columns
+            .get(&column)
+            .copied()
+            .unwrap_or_default();
+        let mut next = mask;
+        if meshed {
+            next.insert(key.1 as usize);
         } else {
-            mask & !(1 << key.1)
-        };
-        if (mask == COMPLETE_COLUMN) != (next == COMPLETE_COLUMN) {
+            next.remove(key.1 as usize);
+        }
+        let complete = self.complete_column();
+        if (mask == complete) != (next == complete) {
             self.detail_revision += 1;
         }
-        if next == 0 {
+        if next.is_empty() {
             self.detail_columns.remove(&column);
         } else {
             self.detail_columns.insert(column, next);
@@ -3218,12 +3253,12 @@ impl Renderer {
         let mut released = Vec::new();
         let mut block_entities = false;
         for (x, z) in columns {
-            if self.detail_columns.remove(&(x, z)) == Some(COMPLETE_COLUMN) {
+            if self.detail_columns.remove(&(x, z)) == Some(self.complete_column()) {
                 self.detail_revision += 1;
             }
             self.occlusion.remove_column(x, z);
             let retiring = !self.lod_cutout.is_empty() && self.lod_cutout.contains(&(x, z));
-            for sy in 0..crate::chunk::SECTIONS as i32 {
+            for sy in 0..self.layout.sections() as i32 {
                 let key = (x, sy, z);
                 block_entities |= self.block_entities.remove(&key).is_some();
                 if retiring {
@@ -3913,7 +3948,7 @@ impl Renderer {
             planes: frustum(cull_proj),
         };
         let camera = frame.camera;
-        let camera_section = camera_section(camera);
+        let camera_section = camera_section(camera, self.layout.min_y());
         // Solid quads facing away from the eye are left out: the bob moves
         // the eye off `camera`, so it is found from the projection.
         let eye = projection_center(cull_proj).filter(|_| self.sides_on);
@@ -4127,7 +4162,7 @@ impl Renderer {
                 let scheduled = (i + count - self.translucency_cursor) % count < budget;
                 let origin = [
                     v.key.0 * 16,
-                    crate::chunk::MIN_Y + v.key.1 * 16,
+                    self.layout.min_y() + v.key.1 * 16,
                     v.key.2 * 16,
                 ];
                 if (!s.sort.is_sorted() || nearby || scheduled)
@@ -4230,7 +4265,7 @@ impl Renderer {
                 {
                     let origin = [
                         v.key.0 * 16,
-                        crate::chunk::MIN_Y + v.key.1 * 16,
+                        self.layout.min_y() + v.key.1 * 16,
                         v.key.2 * 16,
                     ];
                     if let Some(indices) =
@@ -4926,6 +4961,10 @@ impl Renderer {
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                 pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
+                if self.hdr.is_some() {
+                    pass.set_pipeline(&self.hdr_mark_pipeline);
+                    pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
+                }
                 pass.set_bind_group(0, &self.group, &[]);
             }
             if text_quads > 0 {
@@ -5402,6 +5441,16 @@ impl Renderer {
         if let (Some(hdr), Some(f)) = (&self.hdr, &surface_frame) {
             hdr.present(&self.queue, &mut encoder, &f.texture, !frame.title);
         }
+        // With HDR on, a full-frame screenshot gets an HDR10 copy beside it.
+        let hdr_readback = readback
+            .as_ref()
+            .filter(|(request, _)| request.size.is_none())
+            .zip(self.hdr.as_ref())
+            .and_then(|(_, hdr)| {
+                let texture = hdr.capture(&self.device, &self.queue, &mut encoder, !frame.title)?;
+                let size = [self.config.width, self.config.height];
+                Some(copy_frame(&self.device, &mut encoder, &texture, size))
+            });
         let commands = crate::spans::time("encode", || encoder.finish());
         let first_frame = self.first_frame == FirstFrame::Submit;
         if first_frame {
@@ -5420,6 +5469,16 @@ impl Renderer {
             timer.submitted(&self.queue);
         }
         if let Some((request, buffer)) = readback {
+            if let Some(hdr_buffer) = hdr_readback {
+                let hdr_path = hdr_screenshot_path(&request.path);
+                match self.write_hdr_screenshot(&hdr_path, &hdr_buffer) {
+                    Ok(()) => log::info!("Saved HDR screenshot to {}", hdr_path.display()),
+                    Err(e) => log::warn!(
+                        "Horizon renderer: HDR screenshot {}: {e}",
+                        hdr_path.display()
+                    ),
+                }
+            }
             self.screenshot_result = Some(
                 self.write_screenshot(&request, &buffer)
                     .map_err(|e| e.to_string()),
@@ -5528,11 +5587,8 @@ impl Renderer {
             None
         }
     }
-    fn write_screenshot(
-        &self,
-        request: &ScreenshotRequest,
-        buffer: &wgpu::Buffer,
-    ) -> Result<[u32; 2]> {
+    /// The pixels `copy_frame` read back into `buffer`, 4 bytes each, row after row.
+    fn read_frame(&self, buffer: &wgpu::Buffer) -> Result<Vec<[u8; 4]>> {
         let (sender, receiver) = std::sync::mpsc::channel();
         buffer.map_async(wgpu::MapMode::Read, .., move |r| {
             let _ = sender.send(r);
@@ -5545,28 +5601,34 @@ impl Renderer {
             .map_err(|e| e.to_string())?
             .map_err(|e| e.to_string())?;
         let (width, height, row) = (
-            self.config.width,
-            self.config.height,
+            self.config.width as usize,
+            self.config.height as usize,
             padded_row(self.config.width) as usize,
         );
+        let mut pixels = Vec::with_capacity(width * height);
+        {
+            let data = buffer.get_mapped_range(..).map_err(|e| e.to_string())?;
+            for y in 0..height {
+                pixels.extend_from_slice(data[y * row..y * row + width * 4].as_chunks::<4>().0);
+            }
+        }
+        buffer.unmap();
+        Ok(pixels)
+    }
+    fn write_screenshot(
+        &self,
+        request: &ScreenshotRequest,
+        buffer: &wgpu::Buffer,
+    ) -> Result<[u32; 2]> {
         let bgra = matches!(
             self.config.format.remove_srgb_suffix(),
             wgpu::TextureFormat::Bgra8Unorm
         );
-        let mut pixels = Vec::with_capacity((width * height * 4) as usize);
-        {
-            let data = buffer.get_mapped_range(..).map_err(|e| e.to_string())?;
-            for y in 0..height as usize {
-                for px in data[y * row..y * row + width as usize * 4]
-                    .as_chunks::<4>()
-                    .0
-                {
-                    let (r, b) = if bgra { (px[2], px[0]) } else { (px[0], px[2]) };
-                    pixels.extend_from_slice(&[r, px[1], b, 255]);
-                }
-            }
+        let mut pixels = Vec::with_capacity((self.config.width * self.config.height * 4) as usize);
+        for px in self.read_frame(buffer)? {
+            let (r, b) = if bgra { (px[2], px[0]) } else { (px[0], px[2]) };
+            pixels.extend_from_slice(&[r, px[1], b, 255]);
         }
-        buffer.unmap();
         // NativeImage.resizeSubRectTo on takeAutoScreenshot's grab: the icon
         // is the frame's centre square averaged down to its size.
         let (width, height, pixels) = match request.size {
@@ -5587,6 +5649,50 @@ impl Renderer {
         encoder.write_header()?.write_image_data(&pixels)?;
         Ok([width, height])
     }
+    /// The HDR10 copy (`Hdr::capture`) as a 16-bit PNG tagged BT.2020 with PQ (cICP, PNG's
+    /// third edition), with the peak and paper white as its content light levels (cLLI).
+    fn write_hdr_screenshot(&self, path: &std::path::Path, buffer: &wgpu::Buffer) -> Result<()> {
+        let Some(hdr) = &self.hdr else {
+            return Ok(());
+        };
+        let pixels = hdr10_to_rgb16(&self.read_frame(buffer)?);
+        let mut encoder = png::Encoder::new(
+            std::io::BufWriter::new(std::fs::File::create(path)?),
+            self.config.width,
+            self.config.height,
+        );
+        encoder.set_color(png::ColorType::Rgb);
+        encoder.set_depth(png::BitDepth::Sixteen);
+        let mut writer = encoder.write_header()?;
+        // BT.2020 primaries, PQ, RGB, full range.
+        writer.write_chunk(png::chunk::cICP, &[9, 16, 0, 1])?;
+        let nits = |n: f32| ((n * 10_000.0) as u32).to_be_bytes();
+        let peak = hdr.peak.max(hdr.paper_white);
+        writer.write_chunk(
+            png::chunk::cLLI,
+            &[nits(peak), nits(hdr.paper_white.min(peak))].concat(),
+        )?;
+        writer.write_image_data(&pixels)?;
+        Ok(())
+    }
+}
+/// `screenshots/2026-10-28_12.00.00.png` -> `screenshots/2026-10-28_12.00.00-hdr.png`.
+fn hdr_screenshot_path(path: &std::path::Path) -> PathBuf {
+    let stem = path.file_stem().unwrap_or_default().to_string_lossy();
+    path.with_file_name(format!("{stem}-hdr.png"))
+}
+/// `Rgb10a2Unorm` pixels as 16-bit RGB, big-endian as PNG stores it: each 10-bit value
+/// with its top bits repeated below, so 0 stays 0 and 1023 becomes 65535.
+fn hdr10_to_rgb16(pixels: &[[u8; 4]]) -> Vec<u8> {
+    let mut out = Vec::with_capacity(pixels.len() * 6);
+    for &px in pixels {
+        let v = u32::from_le_bytes(px);
+        for shift in [0, 10, 20] {
+            let c = (v >> shift & 0x3ff) as u16;
+            out.extend_from_slice(&(c << 6 | c >> 4).to_be_bytes());
+        }
+    }
+    out
 }
 /// Centre-crop the frame to a square and average it down to `size`.
 pub(crate) fn square_downscale(pixels: &[u8], width: u32, height: u32, size: [u32; 2]) -> Vec<u8> {
@@ -5660,10 +5766,10 @@ impl Frustum {
 /// are GREATER_THAN_OR_EQUAL), which keeps far faces a hair apart, like
 /// fire_side's 0.01 pixel in front of its block, from z-fighting.
 /// The section the camera is in.
-fn camera_section(camera: DVec3) -> SectionKey {
+fn camera_section(camera: DVec3, min_y: i32) -> SectionKey {
     (
         (camera.x.floor() as i32) >> 4,
-        (camera.y.floor() as i32 - crate::chunk::MIN_Y) >> 4,
+        (camera.y.floor() as i32 - min_y) >> 4,
         (camera.z.floor() as i32) >> 4,
     )
 }
@@ -5940,6 +6046,17 @@ mod tests {
         assert_eq!(blend.alpha.dst_factor, wgpu::BlendFactor::Zero);
     }
     #[test]
+    fn hdr_screenshots_keep_every_10_bit_step() {
+        // Rgb10a2Unorm: red in the low 10 bits, then green, then blue.
+        let px = |r: u32, g: u32, b: u32| (r | g << 10 | b << 20 | 3 << 30).to_le_bytes();
+        let out = super::hdr10_to_rgb16(&[px(0, 1023, 512)]);
+        assert_eq!(out, [0, 0, 0xff, 0xff, 0x80, 0x20]);
+        assert_eq!(
+            super::hdr_screenshot_path(std::path::Path::new("screenshots/2026-10-28_12.00.00.png")),
+            std::path::Path::new("screenshots/2026-10-28_12.00.00-hdr.png")
+        );
+    }
+    #[test]
     fn shader_globals_match_the_rust_layout() {
         // terrain.wgsl and entity.wgsl bind the same buffer: same fields, same order.
         let fields = |source: &str| -> Vec<String> {
@@ -6201,6 +6318,8 @@ static DISPLAY_LOG: std::sync::Mutex<DisplayLog> = std::sync::Mutex::new(Display
     pending: None,
 });
 const DISPLAY_LOG_QUIET: std::time::Duration = std::time::Duration::from_secs(1);
+// Only Wayland's HDR reports call it so far.
+#[cfg(target_os = "linux")]
 fn log_display(line: String) {
     let now = std::time::Instant::now();
     let mut log = DISPLAY_LOG

crates/horizon-client-render/src/gfx/hdr.rs

@@ -60,6 +60,38 @@ struct Targets {
     group: wgpu::BindGroup,
 }
 
+/// How one tier of light sources (`mesher::hdr_tier`) shines: `share` of the headroom for
+/// its brightest pixels, lifted from brightness `start` (none) to `full` (all of it).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Tier {
+    pub share: f32,
+    pub start: f32,
+    pub full: f32,
+}
+/// Low, incandescent, bright and very bright.
+pub const TIERS: [Tier; 4] = [
+    Tier {
+        share: 0.2,
+        start: 0.08,
+        full: 0.09,
+    },
+    Tier {
+        share: 0.5,
+        start: 0.14,
+        full: 0.38,
+    },
+    Tier {
+        share: 0.6,
+        start: 0.14,
+        full: 0.38,
+    },
+    Tier {
+        share: 1.0,
+        start: 0.14,
+        full: 0.38,
+    },
+];
+
 pub struct Hdr {
     layout: wgpu::BindGroupLayout,
     pipeline: wgpu::RenderPipeline,
@@ -70,17 +102,22 @@ pub struct Hdr {
     /// output keeps the hand at the world's brightness.
     hand_mark: wgpu::RenderPipeline,
     params: wgpu::Buffer,
+    /// The same pass drawing HDR10 for a screenshot (`capture`), with its own parameters,
+    /// so it can differ from the swapchain's in one frame.
+    capture_pipeline: wgpu::RenderPipeline,
+    capture_params: wgpu::Buffer,
     pub output: Output,
     /// The frame's format: what every other pipeline draws in.
     format: wgpu::TextureFormat,
     targets: Option<Targets>,
-    /// `HORIZON_HDR_DEBUG=1`: paint expanded pixels magenta.
+    /// `HORIZON_HDR_DEBUG=1`: grey what isn't expanded, tint what is magenta.
     debug: bool,
     /// Paper white and peak brightness, in nits.
     pub paper_white: f32,
     pub peak: f32,
     /// The display's black level, in nits: shadows are lifted onto it (`hdr.wgsl`).
     pub black: f32,
+    pub tiers: [Tier; 4],
     /// The HUD and menus' brightness, as a share of paper white (0.25..=1).
     pub ui: f32,
 }
@@ -123,31 +160,33 @@ impl Hdr {
             bind_group_layouts: &[Some(&layout)],
             ..Default::default()
         });
-        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
-            label: Some("Horizon HDR"),
-            layout: Some(&pipeline_layout),
-            vertex: wgpu::VertexState {
-                module: &shader,
-                entry_point: Some("vs_hdr"),
-                compilation_options: Default::default(),
-                buffers: &[],
-            },
-            primitive: Default::default(),
-            depth_stencil: None,
-            multisample: Default::default(),
-            fragment: Some(wgpu::FragmentState {
-                module: &shader,
-                entry_point: Some("fs_hdr"),
-                compilation_options: Default::default(),
-                targets: &[Some(wgpu::ColorTargetState {
-                    format: output.format(),
-                    blend: None,
-                    write_mask: wgpu::ColorWrites::ALL,
-                })],
-            }),
-            multiview_mask: None,
-            cache: None,
-        });
+        let pipeline_for = |format| {
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some("Horizon HDR"),
+                layout: Some(&pipeline_layout),
+                vertex: wgpu::VertexState {
+                    module: &shader,
+                    entry_point: Some("vs_hdr"),
+                    compilation_options: Default::default(),
+                    buffers: &[],
+                },
+                primitive: Default::default(),
+                depth_stencil: None,
+                multisample: Default::default(),
+                fragment: Some(wgpu::FragmentState {
+                    module: &shader,
+                    entry_point: Some("fs_hdr"),
+                    compilation_options: Default::default(),
+                    targets: &[Some(wgpu::ColorTargetState {
+                        format,
+                        blend: None,
+                        write_mask: wgpu::ColorWrites::ALL,
+                    })],
+                }),
+                multiview_mask: None,
+                cache: None,
+            })
+        };
         let alpha_pass = |label, blend| {
             device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                 label: Some(label),
@@ -190,18 +229,22 @@ impl Hdr {
                 alpha: scale_alpha,
             }),
         );
-        let params = device.create_buffer(&wgpu::BufferDescriptor {
-            label: Some("Horizon HDR parameters"),
-            size: 32,
-            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
-            mapped_at_creation: false,
-        });
+        let params = || {
+            device.create_buffer(&wgpu::BufferDescriptor {
+                label: Some("Horizon HDR parameters"),
+                size: 80,
+                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+                mapped_at_creation: false,
+            })
+        };
         Self {
             layout,
-            pipeline,
+            pipeline: pipeline_for(output.format()),
             clear_alpha,
             hand_mark,
-            params,
+            params: params(),
+            capture_pipeline: pipeline_for(Output::Pq.format()),
+            capture_params: params(),
             output,
             format,
             targets: None,
@@ -209,6 +252,7 @@ impl Hdr {
             paper_white: 200.0,
             peak: 1000.0,
             black: 0.0,
+            tiers: TIERS,
             ui: 1.0,
         }
     }
@@ -341,18 +385,89 @@ impl Hdr {
         let Some(t) = &self.targets else {
             return;
         };
+        queue.write_buffer(
+            &self.params,
+            0,
+            bytemuck::cast_slice(&self.params(world, self.output == Output::Pq)),
+        );
+        Self::draw(encoder, &self.pipeline, &t.group, target);
+    }
+
+    /// The frame `present` writes, as HDR10 (BT.2020, PQ, 10 bits a channel) whatever
+    /// the swapchain is, in a texture of its own for a screenshot (`Rgb10a2Unorm`).
+    pub fn capture(
+        &self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        encoder: &mut wgpu::CommandEncoder,
+        world: bool,
+    ) -> Option<wgpu::Texture> {
+        let t = self.targets.as_ref()?;
+        let texture = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some("Horizon HDR screenshot"),
+            size: t.frame.size(),
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: Output::Pq.format(),
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+            view_formats: &[],
+        });
+        let view = |t: &wgpu::Texture| t.create_view(&Default::default());
+        let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("Horizon HDR screenshot bindings"),
+            layout: &self.layout,
+            entries: &[
+                wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(&view(&t.frame)),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 1,
+                    resource: wgpu::BindingResource::TextureView(&view(&t.world)),
+                },
+                wgpu::BindGroupEntry {
+                    binding: 2,
+                    resource: self.capture_params.as_entire_binding(),
+                },
+            ],
+        });
+        queue.write_buffer(
+            &self.capture_params,
+            0,
+            bytemuck::cast_slice(&self.params(world, true)),
+        );
+        Self::draw(encoder, &self.capture_pipeline, &group, &texture);
+        Some(texture)
+    }
+
+    /// hdr.wgsl's `Params`.
+    fn params(&self, world: bool, pq: bool) -> [f32; 20] {
         let paper = self.paper_white.max(1.0);
-        let params = [
+        let mut params = [0.0; 20];
+        params[..5].copy_from_slice(&[
             paper / 80.0,
             (self.peak / paper).max(1.0),
             f32::from(u8::from(world)),
             f32::from(u8::from(self.debug)),
-            f32::from(u8::from(self.output == Output::Pq)),
-            self.black.clamp(0.0, paper),
-            self.ui.clamp(0.25, 1.0),
-            0.0,
-        ];
-        queue.write_buffer(&self.params, 0, bytemuck::cast_slice(&params));
+            f32::from(u8::from(pq)),
+        ]);
+        params[5] = self.black.clamp(0.0, paper);
+        params[6] = self.ui.clamp(0.25, 1.0);
+        for (i, t) in self.tiers.iter().enumerate() {
+            params[8 + i] = t.share;
+            params[12 + i] = t.start;
+            params[16 + i] = t.full;
+        }
+        params
+    }
+
+    fn draw(
+        encoder: &mut wgpu::CommandEncoder,
+        pipeline: &wgpu::RenderPipeline,
+        group: &wgpu::BindGroup,
+        target: &wgpu::Texture,
+    ) {
         let view = target.create_view(&Default::default());
         let attachments = [Some(wgpu::RenderPassColorAttachment {
             view: &view,
@@ -368,8 +483,8 @@ impl Hdr {
             color_attachments: &attachments,
             ..Default::default()
         });
-        pass.set_pipeline(&self.pipeline);
-        pass.set_bind_group(0, &t.group, &[]);
+        pass.set_pipeline(pipeline);
+        pass.set_bind_group(0, group, &[]);
         pass.draw(0..3, 0..1);
     }
 }
@@ -379,6 +494,24 @@ mod tests {
     use super::{Output, pick};
     use wgpu::{SurfaceColorSpaces as S, TextureFormat as F};
 
+    #[test]
+    fn hdr_shaders_validate() {
+        let entity = crate::overlay::wgsl_constants() + include_str!("../entity.wgsl");
+        for source in [
+            include_str!("../hdr.wgsl"),
+            include_str!("../terrain.wgsl"),
+            &entity,
+        ] {
+            let module = naga::front::wgsl::parse_str(source).unwrap();
+            naga::valid::Validator::new(
+                naga::valid::ValidationFlags::all(),
+                naga::valid::Capabilities::all(),
+            )
+            .validate(&module)
+            .unwrap();
+        }
+    }
+
     fn caps(offered: &[(F, S)]) -> wgpu::SurfaceCapabilities {
         wgpu::SurfaceCapabilities {
             format_capabilities: offered

crates/horizon-client-render/src/gfx/resident.rs

@@ -27,6 +27,8 @@ impl Column {
 /// Values of type `T` per section key, in a dense list with stable keys and
 /// slots that move only when a section is removed.
 pub struct Resident<T> {
+    /// The minimum Y of section index 0 (the level's column).
+    min_y: i32,
     items: Vec<(SectionKey, T)>,
     slots: FxHashMap<SectionKey, u32>,
     columns: Vec<Column>,
@@ -36,6 +38,7 @@ pub struct Resident<T> {
 impl<T> Default for Resident<T> {
     fn default() -> Self {
         Self {
+            min_y: crate::chunk::MIN_Y,
             items: Vec::new(),
             slots: FxHashMap::default(),
             columns: Vec::new(),
@@ -61,6 +64,10 @@ impl<T> Resident<T> {
     pub fn get_mut(&mut self, slot: u32) -> &mut T {
         &mut self.items[slot as usize].1
     }
+    /// Sections from now on count from `min_y` (a level of another column).
+    pub fn set_min_y(&mut self, min_y: i32) {
+        self.min_y = min_y;
+    }
     pub fn clear(&mut self) {
         self.items.clear();
         self.slots.clear();
@@ -144,10 +151,10 @@ pub struct Visible {
 }
 
 /// The camera-relative origin of the section at `key`.
-fn origin(key: SectionKey, camera: DVec3) -> DVec3 {
+fn origin(key: SectionKey, min_y: i32, camera: DVec3) -> DVec3 {
     DVec3::new(
         f64::from(key.0 * 16),
-        f64::from(crate::chunk::MIN_Y + key.1 * 16),
+        f64::from(min_y + key.1 * 16),
         f64::from(key.2 * 16),
     ) - camera
 }
@@ -169,18 +176,19 @@ fn in_view(key: SectionKey, camera: DVec3, radius: i32, frustum: &Frustum) -> Op
     if !in_view_distance(camera_column(camera), radius, key.0, key.2) {
         return None;
     }
-    in_frustum(key, camera, frustum, false)
+    in_frustum(key, crate::chunk::MIN_Y, camera, frustum, false)
 }
 
 /// `in_view` without the distance test; `inside`: the section's column is
 /// entirely inside the frustum, so the section is too.
 fn in_frustum(
     key: SectionKey,
+    min_y: i32,
     camera: DVec3,
     frustum: &Frustum,
     inside: bool,
 ) -> Option<(f64, Vec3)> {
-    let origin = origin(key, camera);
+    let origin = origin(key, min_y, camera);
     let min = origin.as_vec3();
     if !inside && !frustum.intersects(min, min + Vec3::splat(16.0)) {
         return None;
@@ -216,8 +224,8 @@ impl<T> Resident<T> {
             if !near && !beyond(column.x, column.z) {
                 continue;
             }
-            let min = origin((column.x, column.low, column.z), camera).as_vec3();
-            let top = origin((column.x, column.high, column.z), camera).as_vec3();
+            let min = origin((column.x, column.low, column.z), self.min_y, camera).as_vec3();
+            let top = origin((column.x, column.high, column.z), self.min_y, camera).as_vec3();
             let max = top + Vec3::splat(16.0);
             let inside = frustum.contains(min, max);
             if !inside && !frustum.intersects(min, max) {
@@ -228,7 +236,7 @@ impl<T> Resident<T> {
                 if near && !reachable(key) {
                     continue;
                 }
-                if let Some((d, o)) = in_frustum(key, camera, frustum, inside) {
+                if let Some((d, o)) = in_frustum(key, self.min_y, camera, frustum, inside) {
                     out.push(Visible {
                         distance: d.to_bits(),
                         key,
@@ -286,7 +294,7 @@ mod tests {
                         if near {
                             in_view(k, camera, radius, &frustum).filter(|_| reachable(k))
                         } else if beyond(k.0, k.2) {
-                            in_frustum(k, camera, &frustum, false)
+                            in_frustum(k, crate::chunk::MIN_Y, camera, &frustum, false)
                         } else {
                             None
                         }
@@ -329,8 +337,8 @@ mod tests {
             .columns
             .iter()
             .filter(|c| {
-                let min = origin((c.x, c.low, c.z), camera).as_vec3();
-                let top = origin((c.x, c.high, c.z), camera).as_vec3();
+                let min = origin((c.x, c.low, c.z), crate::chunk::MIN_Y, camera).as_vec3();
+                let top = origin((c.x, c.high, c.z), crate::chunk::MIN_Y, camera).as_vec3();
                 frustum.contains(min, top + Vec3::splat(16.0))
             })
             .count();

crates/horizon-client-render/src/hdr.wgsl

@@ -12,7 +12,7 @@ struct Params {
     peak: f32,
     // 1 when this frame drew a world.
     world: f32,
-    // 1 paints expanded pixels magenta (HORIZON_HDR_DEBUG=1).
+    // 1 greys what isn't expanded and tints what is (HORIZON_HDR_DEBUG=1).
     debug: f32,
     // 1 for an HDR10 swapchain, 0 for scRGB.
     pq: f32,
@@ -20,19 +20,23 @@ struct Params {
     black: f32,
     // The HUD and menus' brightness as a share of paper white.
     ui: f32,
+    // Per tier, low to very bright (hdr.rs `Tier`): the share of the headroom
+    // the brightest pixels get, and the brightness where the lift starts and
+    // where it is full.
+    share: vec4<f32>,
+    start: vec4<f32>,
+    full: vec4<f32>,
 };
 @group(0) @binding(2) var<uniform> params: Params;
 
 // Light sources are lifted evenly rather than by a highlight curve: vanilla's
 // textures were drawn for SDR, so a curve on their brightest pixels blows out
 // near-white spots (glowstone) and leaves the rest (lava, a jack o'lantern's
-// face) nearly as it was. Pixels brighter than LIFT_FULL get STRENGTH of the
-// headroom, dimmer ones less down to none at LIFT_START (lava's crust, a
-// lantern's metal), and no channel goes past the peak. Brightness is the mean
-// of luminance and the brightest channel, so saturated light counts as bright.
-const LIFT_START: f32 = 0.18;
-const LIFT_FULL: f32 = 0.42;
-const STRENGTH: f32 = 0.7;
+// face) nearly as it was. Each tier's pixels brighter than its `full` get its
+// `share` of the headroom, dimmer ones less down to none at its `start`
+// (lava's crust, a lantern's metal), and no channel goes past the peak.
+// Brightness is the mean of luminance and the brightest channel, so saturated
+// light counts as bright.
 
 // Whether `c` still shows the world pixel `w`: the same, or darkened evenly
 // across its channels, as the vignette and other screen-wide tints darken it.
@@ -99,24 +103,34 @@ fn lift_black(e: vec3<f32>) -> vec3<f32> {
     // Gamma 2.2, as SDR displays and the compositors' SDR paths decode it.
     var light = pow(max(c, vec3(0.0)), vec3(2.2));
     let w = textureLoad(world, at, 0);
-    // The world's alpha is 0 on light-emitting blocks, the sun and the moon
-    // (terrain.wgsl, the celestial pipeline): only those shine, and only where
-    // nothing was drawn over them since: grey text over the white sun still looks
-    // like the sun darkened, but it raised the frame's alpha.
+    // The world's alpha is below 0.75 on light sources, the sun and the moon
+    // (terrain.wgsl, the celestial pipeline): only those shine, by the tier it
+    // holds, the lower the brighter, and only where nothing was drawn over them
+    // since: grey text over the white sun still looks like the sun darkened, but
+    // it raised the frame's alpha.
+    var lifted = false;
     if params.world > 0.5 && params.peak > 1.0 && w.a < 0.75 && !covered
         && shows_world(c, w.rgb) {
         // Brightness of the world pixel, before the vignette darkens the frame
         // toward its edges: a light source shines the same anywhere on screen.
         let wl = pow(max(w.rgb, vec3(0.0)), vec3(2.2));
         let y = 0.5 * (dot(wl, vec3(0.2126, 0.7152, 0.0722)) + max(wl.r, max(wl.g, wl.b)));
-        let lift = smoothstep(LIFT_START, LIFT_FULL, y);
+        let tier = u32(clamp(round(4.0 - 4.0 * w.a / 0.7), 1.0, 4.0)) - 1u;
+        let lift = smoothstep(params.start[tier], params.full[tier], y);
         if lift > 0.0 {
             let top = max(light.r, max(light.g, light.b));
-            let gain = min(1.0 + (params.peak - 1.0) * STRENGTH * lift, params.peak / max(top, 1e-4));
+            let gain = min(1.0 + (params.peak - 1.0) * params.share[tier] * lift, params.peak / max(top, 1e-4));
             light *= max(gain, 1.0);
-            if params.debug > 0.5 {
-                light = mix(light, vec3(gain, 0.0, gain), 0.6);
-            }
+            lifted = true;
+        }
+    }
+    // HORIZON_HDR_DEBUG=1: what isn't lifted turns grey, what is keeps its
+    // colour with a magenta tint, so a lift shows on any colour.
+    if params.debug > 0.5 && params.world > 0.5 {
+        if lifted {
+            light *= vec3(1.0, 0.6, 1.0);
+        } else {
+            light = vec3(dot(light, vec3(0.2126, 0.7152, 0.0722)));
         }
     }
     // The HUD and menus at their own brightness, by how much they cover.

crates/horizon-client-render/src/hud.rs

@@ -92,9 +92,9 @@ pub const MAP_SLOTS: usize = 256;
 /// The atlas slot the minimap extra draws into.
 pub const MINIMAP_SPRITE: &str = "horizon/minimap";
 /// Atlas slots for downloaded player skins (`skins/<sha1>`), 64x64 each.
-/// Vanilla registers a texture per skin. Here a skin evicted from its slot
-/// is not stored again, and its player falls back to the default skin, so
-/// the slots must cover a busy server's player list.
+/// Vanilla registers a texture per skin. Here the slots are shared
+/// (`skins::SkinSlots`): skins drawn in the last frame keep theirs, and a
+/// skin past them shows the default skin until a slot frees up.
 pub const SKIN_SLOTS: usize = 128;
 /// Reused by the visible rows of the classic world selector.
 pub const WORLD_ICON_SLOTS: usize = 32;
@@ -1108,6 +1108,7 @@ impl HudBatch {
                 cursor,
                 g,
                 c,
+                style.shadow_color,
                 bold,
                 style.is_italic(),
                 style.underlined == Some(true),
@@ -1120,8 +1121,12 @@ impl HudBatch {
         }
         self.patches.extend(font.take_patches());
         let white = font.white();
-        let passes: &[bool] = if shadow { &[true, false] } else { &[false] };
-        // ARGB.scaleRGB(color, 0.25): the shadow's colour.
+        let has_shadow = shadow
+            || glyphs
+                .iter()
+                .any(|glyph| glyph.3.is_some_and(|color| color != 0));
+        let passes: &[bool] = if has_shadow { &[true, false] } else { &[false] };
+        // ARGB.scaleRGB(color, 0.25): the default shadow colour.
         let shade = |c: u32| {
             let b = c.to_le_bytes();
             rgba(
@@ -1132,20 +1137,42 @@ impl HudBatch {
             )
         };
         for &is_shadow in passes {
-            for (gx, g, c, bold, italic, underline, strike, first, advance, object) in &glyphs {
+            for (
+                gx,
+                g,
+                c,
+                custom_shadow,
+                bold,
+                italic,
+                underline,
+                strike,
+                first,
+                advance,
+                object,
+            ) in &glyphs
+            {
                 if let Some(object) = object {
                     if !is_shadow {
                         self.draw_inline_object(atlas, object, *gx, y, alpha);
                     }
                     continue;
                 }
-                // In the world a glyph whose shadow is 0 has none (hasShadow).
-                let has_shadow = shadow && !(world && shade(*c) == 0);
+                let shadow_color = if let Some(argb) = custom_shadow {
+                    let text_alpha = (c >> 24) as u8 as u16;
+                    let shadow_alpha = (argb >> 24) as u8 as u16;
+                    let alpha = (shadow_alpha * text_alpha / 255) as u8;
+                    rgba((argb >> 16) as u8, (argb >> 8) as u8, *argb as u8, alpha)
+                } else {
+                    shade(*c)
+                };
+                let has_shadow = (custom_shadow.is_some_and(|argb| argb != 0)
+                    || custom_shadow.is_none() && shadow)
+                    && !(world && shadow_color == 0);
                 if is_shadow && !has_shadow {
                     continue;
                 }
                 let (dx, col) = if is_shadow {
-                    (g.offset, shade(*c))
+                    (g.offset, shadow_color)
                 } else {
                     (0.0, *c)
                 };
@@ -2025,6 +2052,52 @@ mod tests {
         assert!(missing.rect.is_none() && missing.right == 5.0);
     }
 
+    #[test]
+    fn component_shadow_color_overrides_text_call_shadow() {
+        let root = two_glyph_font("component-shadow");
+        let atlas = HudAtlas::build(&root).unwrap();
+        let mut batch = HudBatch::new([320, 240]);
+        let text = crate::text::Text::styled(
+            "a",
+            crate::text::Style {
+                shadow_color: Some(0x8040_2010),
+                ..Default::default()
+            },
+        );
+        batch.text_styled(&atlas, &text, 10.0, 10.0, u32::MAX, false);
+        assert_eq!(batch.vertices.len(), 12);
+        assert_eq!(batch.vertices[0].color, rgba(0x40, 0x20, 0x10, 0x80));
+        batch.vertices.clear();
+        batch.text_styled_world(&atlas, &text, 10.0, 10.0, u32::MAX, false);
+        assert_eq!(batch.vertices.len(), 12);
+        assert_eq!(batch.vertices[0].depth, 0.0);
+        assert_eq!(batch.vertices[6].depth, 0.03);
+        batch.vertices.clear();
+        let no_shadow = crate::text::Text::styled(
+            "a",
+            crate::text::Style {
+                shadow_color: Some(0),
+                ..Default::default()
+            },
+        );
+        batch.text_styled(&atlas, &no_shadow, 10.0, 10.0, u32::MAX, true);
+        assert_eq!(batch.vertices.len(), 6);
+        batch.vertices.clear();
+        let gradient = crate::component::to_text(
+            &serde_json::json!({
+                "text": "",
+                "extra": [
+                    {"text": "a", "color": "#ff0000"},
+                    {"text": "b", "color": "#0000ff"}
+                ]
+            }),
+            &mut |_| crate::text::Text::empty(),
+        );
+        batch.text_styled(&atlas, &gradient, 10.0, 10.0, u32::MAX, false);
+        assert_eq!(batch.vertices[0].color, rgba(255, 0, 0, 255));
+        assert_eq!(batch.vertices[6].color, rgba(0, 0, 255, 255));
+    }
+
     #[test]
     fn player_object_draws_an_inline_head() {
         let root = two_glyph_font("inline-head");

crates/horizon-client-render/src/lib.rs

@@ -59,10 +59,12 @@ pub mod packs;
 pub mod par;
 pub mod particles;
 pub mod poi_sections;
+pub mod potent_sulfur;
 pub mod providers;
 pub mod screen_draw;
 pub mod screen_effects;
 pub mod sculk;
+pub mod section_mask;
 pub mod settings;
 pub mod shader_pack_list;
 pub mod signs;

crates/horizon-client-render/src/light.rs

@@ -17,7 +17,7 @@
 use crate::fast_hash::FxHashMap;
 use crate::{
     blocks::BlockFacts,
-    chunk::{Chunk, HEIGHT, Light, MIN_Y, SECTIONS, Section, index},
+    chunk::{Chunk, ColumnLayout, Light, Section, index},
 };
 use horizon_core::geometry::{Direction, ShapeOp, VoxelShape};
 use horizon_world::registry::{BlockRegistry, BlockStateId};
@@ -273,7 +273,7 @@ pub fn light_chunk(
     tables: &LightTables,
     sky_light: bool,
 ) -> Vec<Light> {
-    region[1][1].expect("centre chunk");
+    let sections = region[1][1].expect("centre chunk").sections.len();
     // Highest occupied section in the region bounds the work.
     let mut top_section = 0;
     for chunk in region.iter().flatten().flatten() {
@@ -286,7 +286,7 @@ pub fn light_chunk(
     }
     // One extra section above the highest occupied one: block light rises
     // up to 14 blocks into it (sky light there is always 15).
-    let h = ((top_section + 1) * 16).min(HEIGHT as usize);
+    let h = ((top_section + 1) * 16).min(sections * 16);
     let at = |x: usize, y: usize, z: usize| (y * W + z) * W + x;
     // Packed cells (`type << 4 | dampening`), not state ids: the flood fill
     // then never touches the large `LightTables::cells` table.
@@ -422,14 +422,21 @@ pub fn light_chunk(
     };
     spread(&mut sky, &mut sky_queue);
     spread(&mut block, &mut queue);
-    pack_lighting(h, &sky, &block, sky_light)
+    pack_lighting(sections, h, &sky, &block, sky_light)
 }
 
-/// Extract just the centre column's light; never copy worker snapshot sections.
-fn pack_lighting(h: usize, sky: &[u8], block: &[u8], sky_light: bool) -> Vec<Light> {
+/// Extract just the centre column's light (`sections` of it); never copy
+/// worker snapshot sections.
+fn pack_lighting(
+    sections: usize,
+    h: usize,
+    sky: &[u8],
+    block: &[u8],
+    sky_light: bool,
+) -> Vec<Light> {
     let at = |x: usize, y: usize, z: usize| (y * W + z) * W + x;
     let open = if sky_light { 0xF0 } else { 0x00 };
-    (0..SECTIONS)
+    (0..sections)
         .map(|si| {
             if si * 16 >= h {
                 return Light::Uniform(open);
@@ -467,6 +474,7 @@ pub fn apply_lighting(chunk: &mut Chunk, lights: Vec<Light>) {
 /// `apply_lighting` for a chunk lit before: writes only the sections whose
 /// light changed and adds the cells that changed to `changed`.
 pub fn apply_relighting(chunk: &mut Chunk, lights: Vec<Light>, changed: &mut LightChanges) {
+    changed.keyed(chunk.layout());
     for (sy, (section, light)) in chunk.sections.iter_mut().zip(lights).enumerate() {
         let old = &section.light;
         if let (Light::Uniform(a), Light::Uniform(b)) = (old, &light)
@@ -506,7 +514,8 @@ pub fn light_from_layers<L: AsRef<[u8]>>(
     mut above: [u8; 256],
     sky_light: bool,
 ) {
-    for (si, (sky, block)) in layers.iter().enumerate().take(SECTIONS).rev() {
+    let sections = chunk.sections.len();
+    for (si, (sky, block)) in layers.iter().enumerate().take(sections).rev() {
         let sky = sky.as_ref().filter(|_| sky_light);
         let section = Arc::make_mut(&mut chunk.sections[si]);
         if sky.is_none() && block.is_none() && above.iter().all(|&v| v == above[0]) {
@@ -539,7 +548,8 @@ pub fn update_light_layers<L: AsRef<[u8]>>(
     sky_light: bool,
 ) -> Vec<usize> {
     let mut changed = Vec::new();
-    for (si, (sky, block)) in layers.iter().enumerate().take(SECTIONS) {
+    let sections = chunk.sections.len();
+    for (si, (sky, block)) in layers.iter().enumerate().take(sections) {
         let sky = sky.as_ref().filter(|_| sky_light);
         if sky.is_none() && block.is_none() {
             continue;
@@ -569,8 +579,15 @@ pub trait LightWorld {
     fn section(&self, cx: i32, s: usize, cz: i32) -> Option<&Arc<Section>>;
     /// Replace the light of a section `section` returned.
     fn set_section_light(&mut self, cx: i32, s: usize, cz: i32, light: Light);
+    /// The column the world's chunks hold (its level's).
+    fn layout(&self) -> ColumnLayout;
 }
 impl<S: std::hash::BuildHasher> LightWorld for HashMap<(i32, i32), Arc<Chunk>, S> {
+    fn layout(&self) -> ColumnLayout {
+        self.values()
+            .next()
+            .map_or(ColumnLayout::VANILLA, |c| c.layout())
+    }
     fn section(&self, cx: i32, s: usize, cz: i32) -> Option<&Arc<Section>> {
         self.get(&(cx, cz))
             .filter(|c| c.lit)
@@ -587,6 +604,7 @@ impl<S: std::hash::BuildHasher> LightWorld for HashMap<(i32, i32), Arc<Chunk>, S
 /// gets written is copied out on the first write and stored back by `finish`.
 struct Region<'w> {
     world: &'w mut dyn LightWorld,
+    layout: ColumnLayout,
     slots: Vec<Slot>,
     /// Section key (cx, s, cz) to slot, `NONE` where the chunk isn't lit.
     index: FxHashMap<Pos, u32>,
@@ -602,6 +620,7 @@ const NONE: u32 = u32::MAX;
 impl<'w> Region<'w> {
     fn new(world: &'w mut dyn LightWorld) -> Self {
         Self {
+            layout: world.layout(),
             world,
             slots: Vec::new(),
             index: FxHashMap::default(),
@@ -610,10 +629,8 @@ impl<'w> Region<'w> {
     }
     #[inline]
     fn slot(&mut self, x: i32, y: i32, z: i32) -> Option<usize> {
-        if !(MIN_Y..MIN_Y + HEIGHT).contains(&y) {
-            return None;
-        }
-        let key = (x >> 4, (y - MIN_Y) >> 4, z >> 4);
+        let s = self.layout.section_index(y)?;
+        let key = (x >> 4, s as i32, z >> 4);
         if self.last.0 != key {
             self.last = (key, self.load(key));
         }
@@ -702,12 +719,20 @@ type Pos = (i32, i32, i32);
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct LightChanges {
     sections: FxHashMap<Pos, u32>,
+    /// The column the section indexes count in.
+    layout: ColumnLayout,
 }
 impl LightChanges {
+    /// Changes in chunks of `layout`: what the relighter or a light job adds
+    /// after this (they all come from one level).
+    fn keyed(&mut self, layout: ColumnLayout) {
+        debug_assert!(self.sections.is_empty() || self.layout == layout);
+        self.layout = layout;
+    }
     /// A cell whose stored light changed.
     #[inline]
     pub fn push(&mut self, (x, y, z): Pos) {
-        let key = (x >> 4, (y - MIN_Y) >> 4, z >> 4);
+        let key = (x >> 4, (y - self.layout.min_y()) >> 4, z >> 4);
         *self.sections.entry(key).or_default() |= 1 << Self::class(x, y, z);
     }
     /// Cells of section `key` (x, section index, z) in the given classes.
@@ -732,7 +757,7 @@ impl LightChanges {
         self.sections.keys().copied()
     }
     /// Every section (x, section index, z) whose cells lie within one block
-    /// of a changed cell, section indexes outside `0..SECTIONS` left out (a
+    /// of a changed cell, section indexes outside the column left out (a
     /// section next to several changed ones comes once for each).
     pub fn dirty_sections(&self, mut out: impl FnMut(Pos)) {
         // Per class, the bit set of neighbour offsets (dx, dy, dz in -1..=1,
@@ -759,6 +784,7 @@ impl LightChanges {
             }
             reach
         };
+        let sections = self.layout.sections() as i32;
         for (&(x, sy, z), &classes) in &self.sections {
             let mut offsets = 0;
             let mut rest = classes;
@@ -770,7 +796,7 @@ impl LightChanges {
                 let o = offsets.trailing_zeros() as i32;
                 offsets &= offsets - 1;
                 let s = sy + o / 3 % 3 - 1;
-                if (0..SECTIONS as i32).contains(&s) {
+                if (0..sections).contains(&s) {
                     out((x + o % 3 - 1, s, z + o / 9 - 1));
                 }
             }
@@ -794,11 +820,12 @@ fn set_level(world: &mut Region, sky: bool, p: Pos, value: u8) {
 /// `ChunkSkyLightSources`: the Y of the upper block of the highest occluded
 /// edge in the column (every block at or above it is a sky source).
 fn lowest_sky_source(world: &mut Region, tables: &LightTables, x: i32, z: i32) -> i32 {
-    let mut y = MIN_Y + HEIGHT - 1;
+    let (min_y, max_y) = (world.layout.min_y(), world.layout.max_y());
+    let mut y = max_y - 1;
     let Some(mut top) = world.state(x, y, z) else {
-        return MIN_Y;
+        return min_y;
     };
-    while y > MIN_Y {
+    while y > min_y {
         let Some(bottom) = world.state(x, y - 1, z) else {
             break;
         };
@@ -808,7 +835,7 @@ fn lowest_sky_source(world: &mut Region, tables: &LightTables, x: i32, z: i32) -
         top = bottom;
         y -= 1;
     }
-    MIN_Y
+    min_y
 }
 /// Vanilla's `checkBlock` + `runLightUpdates` for changed positions on
 /// resident, lit chunks: clear the light that may have come through or from
@@ -825,6 +852,7 @@ pub fn relight(
     changed: &mut LightChanges,
 ) {
     let mut region = Region::new(world);
+    changed.keyed(region.layout);
     relight_region(&mut region, tables, sky_light, positions, force, changed);
     region.finish();
 }
@@ -840,6 +868,7 @@ fn relight_region(
         relight_layer(world, tables, false, positions.to_vec(), force, changed)
     });
     if sky_light {
+        let (min_y, max_y) = (world.layout.min_y(), world.layout.max_y());
         let mut seeds = positions.to_vec();
         let mut columns: FxHashMap<(i32, i32), i32> = FxHashMap::default();
         crate::spans::time("lt_columns", || {
@@ -851,13 +880,13 @@ fn relight_region(
                 columns.insert((x, z), source);
                 // Cells whose source status changed: non-15 at or above the new
                 // lowest source, and old 15s (sources) below it.
-                for y in source..MIN_Y + HEIGHT {
+                for y in source..max_y {
                     if level(world, true, (x, y, z)).is_some_and(|l| l != 15) {
                         seeds.push((x, y, z));
                     }
                 }
                 let mut y = source - 1;
-                while y >= MIN_Y && level(world, true, (x, y, z)) == Some(15) {
+                while y >= min_y && level(world, true, (x, y, z)) == Some(15) {
                     seeds.push((x, y, z));
                     y -= 1;
                 }
@@ -977,6 +1006,7 @@ fn relight_layer(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::chunk::{HEIGHT, MIN_Y, SECTIONS};
 
     const AIR: u32 = 0;
     const STONE: u32 = 1;
@@ -1004,11 +1034,18 @@ mod tests {
         )
     }
     fn world(edit: impl Fn(&mut Chunk)) -> HashMap<(i32, i32), Arc<Chunk>> {
+        world_of(crate::chunk::ColumnLayout::VANILLA, edit)
+    }
+    /// Lit chunks around (0, 0) of `layout`, stone up to y 0.
+    fn world_of(
+        layout: crate::chunk::ColumnLayout,
+        edit: impl Fn(&mut Chunk),
+    ) -> HashMap<(i32, i32), Arc<Chunk>> {
         let mut chunks = HashMap::new();
         for z in -1..=1 {
             for x in -1..=1 {
-                let mut c = Chunk::empty(x, z);
-                for y in MIN_Y..0 {
+                let mut c = Chunk::with_layout(x, z, layout);
+                for y in layout.min_y()..0 {
                     for i in 0..256 {
                         c.set(i & 15, y, i >> 4, STONE);
                     }
@@ -1218,6 +1255,66 @@ mod tests {
         }
     }
     #[test]
+    fn a_tall_column_is_lit_to_its_top() {
+        let layout = crate::chunk::ColumnLayout::new(-64, 2096).unwrap();
+        let mut chunk = Chunk::with_layout(0, 0, layout);
+        for i in 0..256 {
+            chunk.set(i & 15, 1600, i >> 4, STONE);
+        }
+        chunk.set(8, 1500, 8, TORCH);
+        let region = [[None; 3], [None, Some(&chunk), None], [None; 3]];
+        let lights = light_chunk(&region, &tables(), true);
+        assert_eq!(lights.len(), 131);
+        apply_lighting(&mut chunk, lights);
+        assert_eq!(chunk.light(8, 1500, 8) & 15, 14);
+        assert_eq!(chunk.light(8, 1501, 8) & 15, 13);
+        assert_eq!(chunk.light(8, 1601, 8) >> 4, 15);
+        assert_eq!(chunk.light(8, 1599, 8) >> 4, 0, "under the roof");
+        assert_eq!(chunk.light(8, 2031, 8), 0xF0);
+    }
+    #[test]
+    fn a_tall_column_relights_as_its_full_light_and_keys_its_sections() {
+        let layout = crate::chunk::ColumnLayout::new(-64, 2096).unwrap();
+        let mut w = world_of(layout, |c| {
+            for i in 0..256 {
+                c.set(i & 15, 1900, i >> 4, STONE);
+            }
+        });
+        let edits = [
+            ((8, 1800, 8), TORCH),
+            ((8, 1900, 8), AIR),
+            ((3, 2020, 3), TORCH),
+        ];
+        let mut changed = LightChanges::default();
+        for ((x, y, z), state) in edits {
+            Arc::make_mut(w.get_mut(&(0, 0)).unwrap()).set(x, y, z, state);
+            relight(&mut w, &tables(), true, &[(x, y, z)], false, &mut changed);
+        }
+        let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| {
+            std::array::from_fn(|dx| w.get(&(dx as i32 - 1, dz as i32 - 1)).map(|c| &**c))
+        });
+        let full = light_chunk(&region, &tables(), true);
+        assert_eq!(full.len(), 131);
+        for (si, s) in full.iter().enumerate() {
+            for i in 0..4096 {
+                assert_eq!(
+                    s.get(i),
+                    w[&(0, 0)].sections[si].light(i),
+                    "section {si} index {i}"
+                );
+            }
+        }
+        // y 2020 is section 130 of the tall column, the top one.
+        assert!(
+            changed
+                .sections()
+                .any(|(x, sy, z)| (x, sy, z) == (0, 130, 0))
+        );
+        let mut dirty = Vec::new();
+        changed.dirty_sections(|s| dirty.push(s.1));
+        assert!(dirty.iter().all(|&sy| (0..131).contains(&sy)), "{dirty:?}");
+    }
+    #[test]
     fn incremental_relight_matches_full_relight() {
         let mut w = world(|c| {
             c.set(8, 0, 8, TORCH);
@@ -1521,7 +1618,7 @@ mod tests {
         let mut old = fixture.clone();
         let mut new = fixture.clone();
         baseline_apply(&mut old, baseline_pack(&fixture, h, &sky, &block));
-        apply_lighting(&mut new, pack_lighting(h, &sky, &block, true));
+        apply_lighting(&mut new, pack_lighting(SECTIONS, h, &sky, &block, true));
         for (a, b) in old.sections.iter().zip(&new.sections) {
             for i in 0..4096 {
                 assert_eq!(a.light(i), b.light(i));
@@ -1538,14 +1635,20 @@ mod tests {
                     let mut current = fixture.clone();
                     let held = shared.then(|| current.clone());
                     // Warm up and detach for the uniquely-owned scenario.
-                    apply_lighting(&mut current, pack_lighting(h, &sky, &block, true));
+                    apply_lighting(&mut current, pack_lighting(SECTIONS, h, &sky, &block, true));
                     let started = Instant::now();
                     for _ in 0..500 {
                         let retained = shared.then(|| current.clone());
                         if optimized {
                             apply_lighting(
                                 black_box(&mut current),
-                                pack_lighting(h, black_box(&sky), black_box(&block), true),
+                                pack_lighting(
+                                    SECTIONS,
+                                    h,
+                                    black_box(&sky),
+                                    black_box(&block),
+                                    true,
+                                ),
                             );
                         } else {
                             baseline_apply(

crates/horizon-client-render/src/lod.rs

@@ -161,6 +161,31 @@ impl Column {
             self.spans.push(span);
         }
     }
+    /// Open water and its floor lit as open sky, as the seed's far columns
+    /// are: a chunk's own light fades a level per block of water, so the
+    /// chunks a player passed drew a darker band through the seed's sea.
+    /// The water is one span again.
+    fn light_open_water(&mut self, kinds: &[u8]) {
+        // Water; lava glows.
+        let water = |span: &Span| {
+            let kind = kinds.get(span.state.0 as usize).copied().unwrap_or(0);
+            kind & FLUID != 0 && kind >> 4 == 0
+        };
+        if !self.spans.last().is_some_and(water) {
+            return;
+        }
+        let floor = self
+            .spans
+            .iter()
+            .rposition(|span| !water(span))
+            .unwrap_or(0);
+        for (i, mut span) in std::mem::take(&mut self.spans).into_iter().enumerate() {
+            if i >= floor {
+                span.light |= 0xf0;
+            }
+            self.push(span);
+        }
+    }
     /// `kinds`: `state_kinds`, per block state.
     fn from_chunk(chunk: &Chunk, kinds: &[u8], x: i32, z: i32) -> Self {
         let kind = |state: BlockStateId| kinds.get(state.0 as usize).copied().unwrap_or(0);
@@ -212,6 +237,7 @@ impl Column {
                 });
             }
         }
+        column.light_open_water(kinds);
         let mut water = None;
         for span in column.spans.iter().rev() {
             if kind(span.state) & FLUID != 0 {
@@ -1772,6 +1798,48 @@ mod tests {
         );
     }
     #[test]
+    fn open_water_and_its_floor_are_lit_as_the_seed_lights_them() {
+        let span = |min, max, state, light| Span {
+            min,
+            max,
+            state: BlockStateId(state),
+            biome: 0,
+            light,
+        };
+        // 0 air, 1 stone, 2 water, 3 lava.
+        let kinds = [AIR, KEPT, KEPT | FLUID, KEPT | FLUID | 15 << 4];
+        // A chunk's own light: a cave, the floor, water fading a level a block.
+        let mut sea = Column {
+            surface: None,
+            spans: vec![
+                span(30, 40, 1, 0),
+                span(40, 48, 1, 0x10 | 2 << 12),
+                span(48, 61, 2, 0x20),
+                span(61, 62, 2, 0xe0),
+                span(62, 63, 2, 0xf0),
+            ],
+        };
+        sea.light_open_water(&kinds);
+        assert_eq!(
+            sea.spans,
+            [
+                span(30, 40, 1, 0),
+                span(40, 48, 1, 0xf0 | 2 << 12),
+                span(48, 63, 2, 0xf0)
+            ]
+        );
+        // Land, and lava, keep their light.
+        for top in [1, 3] {
+            let mut column = Column {
+                surface: None,
+                spans: vec![span(40, 50, 2, 0x20), span(50, 63, top, 0x80)],
+            };
+            let before = column.spans.clone();
+            column.light_open_water(&kinds);
+            assert_eq!(column.spans, before);
+        }
+    }
+    #[test]
     fn coarse_voxels_reduce_the_area_instead_of_inflating_one_leaf() {
         let span = |min, max, state| Span {
             min,

crates/horizon-client-render/src/mesher.rs

@@ -123,9 +123,25 @@ mod vertex_tests {
     fn emission_keeps_the_colour_and_the_free_bits() {
         let rgb = super::pack_rgb([0x12, 0x34, 0x56]);
         assert_eq!(super::emitting(rgb, 0), rgb);
-        assert_eq!(super::emitting(rgb, 9), 0xF656_3412);
-        assert_eq!(super::emitting(rgb, 15), 0xF056_3412);
-        assert_eq!(super::emitting(rgb, 15) | super::EMISSION_BITS, rgb);
+        assert_eq!(super::emitting(rgb, super::INCANDESCENT), 0xFD56_3412);
+        assert_eq!(super::emitting(rgb, super::VERY_BRIGHT), 0xFB56_3412);
+        assert_eq!(
+            super::emitting(rgb, super::VERY_BRIGHT) | super::EMISSION_BITS,
+            rgb
+        );
+    }
+    #[test]
+    fn light_sources_shine_by_kind_not_light_level() {
+        use super::{BRIGHT, INCANDESCENT, LOW, hdr_tier};
+        assert_eq!(hdr_tier("glowstone", 15), BRIGHT);
+        // A candle's flame is a particle: the block keeps only its wick.
+        assert_eq!(hdr_tier("torch", 14), INCANDESCENT);
+        assert_eq!(hdr_tier("red_candle", 3), LOW);
+        assert_eq!(hdr_tier("glow_lichen", 7), 0);
+        assert_eq!(hdr_tier("stone", 0), 0);
+        // Unlisted ones by their light level.
+        assert_eq!(hdr_tier("ochre_froglight", 15), INCANDESCENT);
+        assert_eq!(hdr_tier("sculk_sensor", 1), LOW);
     }
 }
 pub struct SectionMesh {
@@ -263,6 +279,8 @@ enum Tint {
     /// `BlockTintSources.grassBlock`: grass in the world, none on its particles.
     GrassBlock,
     TallGrassUpper,
+    SugarCane,
+    LilyPad,
     Foliage,
     DryFoliage,
     Water,
@@ -282,6 +300,8 @@ struct Info {
     /// `getShadeBrightness` (ambient occlusion contribution).
     shade: f32,
     emission: u8,
+    /// `hdr_tier`.
+    tier: u8,
     /// `emissiveRendering`: drawn and sampled at full brightness.
     emissive: bool,
     fluid: FluidState,
@@ -329,6 +349,10 @@ pub struct MeshTables {
     lava_still: u16,
     lava_flow: u16,
 }
+fn stem_color(age: u8) -> u32 {
+    let a = u32::from(age);
+    (a * 32) << 16 | (255 - a * 8) << 8 | (a * 4)
+}
 fn redstone_color(power: u8) -> u32 {
     // RedstoneWireBlock.COLORS
     let f = f32::from(power) / 15.0;
@@ -377,10 +401,9 @@ impl MeshTables {
                         ([Tint::Grass; 2], 1)
                     }
                 }
-                "fern" | "short_grass" | "potted_fern" | "bush" | "sugar_cane" => {
-                    ([Tint::Grass; 2], 1)
-                }
+                "fern" | "short_grass" | "potted_fern" | "bush" => ([Tint::Grass; 2], 1),
                 "grass_block" => ([Tint::GrassBlock; 2], 1),
+                "sugar_cane" => ([Tint::SugarCane; 2], 1),
                 "pink_petals" | "wildflowers" => ([Tint::None, Tint::Grass], 2),
                 "spruce_leaves" => ([Tint::Constant(0x61_9961); 2], 1),
                 "birch_leaves" => ([Tint::Constant(0x80_A755); 2], 1),
@@ -395,7 +418,7 @@ impl MeshTables {
                     ([Tint::Constant(0xE0_C71C); 2], 1)
                 }
                 "melon_stem" | "pumpkin_stem" => ([Tint::Stem(prop("age")); 2], 1),
-                "lily_pad" => ([Tint::Constant(0x20_8030); 2], 1),
+                "lily_pad" => ([Tint::LilyPad; 2], 1),
                 _ => ([Tint::None; 2], 0),
             };
             // getShadeBrightness overrides; the default is 0.2 for full collision shapes.
@@ -450,6 +473,7 @@ impl MeshTables {
                 permeable: !s.solid_render || s.dampening == 0,
                 shade,
                 emission: s.emission,
+                tier: hdr_tier(name, s.emission),
                 emissive,
                 fluid: FluidState::from_block(state)?,
                 model: s.render_shape == RenderShape::Model,
@@ -491,6 +515,25 @@ impl MeshTables {
             tint_sources: i.tint_count,
         })
     }
+    /// `BlockTintSource.color(state)`: block-model colour without a level.
+    /// `grass` is `GrassColor.getDefaultColor()` from the active pack's colormap.
+    /// Untinted faces, blank sources and invalid tint indices return `None`.
+    pub fn default_tint(&self, state: BlockStateId, index: i32, grass: u32) -> Option<u32> {
+        let info = self.info.get(state.0 as usize)?;
+        if index < 0 || index >= i32::from(info.tint_count) {
+            return None;
+        }
+        Some(match info.tints[index as usize] {
+            Tint::None | Tint::SugarCane | Tint::Water => return None,
+            Tint::Grass | Tint::GrassBlock | Tint::TallGrassUpper => grass & 0xFF_FFFF,
+            Tint::Foliage => 0x48_B518,
+            Tint::DryFoliage => 0x5C_3C32,
+            Tint::LilyPad => 0x71_C35C,
+            Tint::Constant(c) => c,
+            Tint::Redstone(p) => redstone_color(p),
+            Tint::Stem(age) => stem_color(age),
+        })
+    }
     /// `TerrainParticle`'s colour: tint source 0's `colorAsTerrainParticle`,
     /// which is the in-world (biome-blended) colour except on grass blocks,
     /// whose dirt crumbs stay untinted. `None` when the state has no source.
@@ -513,6 +556,56 @@ impl MeshTables {
         let mut tints = Tints::new(region, biomes, zoom, blend_radius, origin);
         Mesher::tint(info, 0, &mut tints, [x & 15, y & 15, z & 15])
     }
+    /// `BlockColors` for each of the state's tint indices at `pos`, as the
+    /// chunk mesher tints them (grass blocks included): `None` for an
+    /// untinted (-1) layer. For block models drawn outside the chunk mesh.
+    pub fn block_tints(
+        &self,
+        state: BlockStateId,
+        pos: [i32; 3],
+        region: &[[Option<&Chunk>; 3]; 3],
+        biomes: &Biomes,
+        zoom: BiomeZoom,
+        blend_radius: i32,
+    ) -> impl Fn(i32) -> Option<u32> + use<> {
+        let sources = self.info.get(state.0 as usize).map(|info| {
+            let [x, y, z] = pos;
+            let origin = [x >> 4, z >> 4, y & !15];
+            let mut tints = Tints::new(region, biomes, zoom, blend_radius, origin);
+            let local = [x & 15, y & 15, z & 15];
+            let colors = [0, 1].map(|i| Mesher::tint(info, i, &mut tints, local));
+            (colors, i32::from(info.tint_count))
+        });
+        move |index| {
+            let (colors, count) = sources?;
+            if index < 0 || index >= count {
+                return None;
+            }
+            colors[(index as usize).min(1)]
+        }
+    }
+    /// `ModelBlockRenderer.tesselateFlat`'s light coords (`LightCoordsUtil`
+    /// packing, the quad's own emission included) for `quad` of `state`
+    /// drawn as the only block at `pos`, as `MovingBlockRenderState` gives
+    /// it: `light` is the world's stored light (sky << 4 | block) at a
+    /// position. For block models drawn outside the chunk mesh.
+    pub fn flat_light(
+        &self,
+        state: BlockStateId,
+        pos: [i32; 3],
+        quad: &horizon_assets::bake::ModelQuad,
+        light: impl Fn([i32; 3]) -> u8,
+    ) -> u32 {
+        let own = self.info.get(state.0 as usize);
+        let full = own.is_some_and(|i| i.full);
+        let at = lighting::flat_position(pos, &quad.positions, quad.facing, quad.cull, full);
+        let packed = light(at);
+        let coords = match own {
+            Some(own) => lighting::packed_coords(own, packed),
+            None => u32::from(packed & 15) << 4 | u32::from(packed >> 4) << 20,
+        };
+        lighting::with_emission(coords, quad.light_emission)
+    }
     /// `BlockState.getOffset` for blocks with a random model offset.
     pub fn offset(&self, state: BlockStateId, x: i32, z: i32) -> Option<[f64; 3]> {
         offset(self.info.get(state.0 as usize)?, x, z)
@@ -546,7 +639,7 @@ impl Padded {
     fn new(region: &[[Option<&Chunk>; 3]; 3], sy: i32) -> Self {
         let mut blocks = vec![0u32; P * P * P];
         let mut light = vec![0u8; P * P * P];
-        let base_y = MIN_Y + sy * 16;
+        let base_y = region[1][1].map_or(MIN_Y, Chunk::min_y) + sy * 16;
         // The section itself is unpacked in one pass; the border cells of the
         // neighbouring sections are read one by one.
         let mut own = Box::new([0u32; 4096]);
@@ -580,13 +673,37 @@ impl Padded {
 }
 /// Set on a terrain vertex's sprite layer when its texture alpha must be ignored.
 pub const OPAQUE_LAYER: u16 = 1 << 15;
-/// The bits of `TerrainVertex::color`'s alpha byte that hold the light its face emits, for
-/// HDR output's highlights (`gfx/hdr.rs`): 15 minus the level, so the usual 0xFF means none.
-/// The byte's other four bits stay set.
+/// The bits of `TerrainVertex::color`'s alpha byte that hold how brightly its face shines
+/// in HDR output (`gfx/hdr.rs`): 15 minus the tier, so the usual 0xFF means none. The
+/// byte's other four bits stay set.
 pub const EMISSION_BITS: u32 = 0x0F00_0000;
-/// `color` marked as emitting light `level` (0 to 15).
-pub fn emitting(color: u32, level: u8) -> u32 {
-    color & !EMISSION_BITS | u32::from(15 - level.min(15)) << 24
+/// HDR tiers, by the kind of light rather than its level: a candle's flame is as bright as
+/// a torch's, it only lights less around it. 0 stays as in SDR.
+pub const LOW: u8 = 1;
+pub const INCANDESCENT: u8 = 2;
+pub const BRIGHT: u8 = 3;
+/// The sun and lightning.
+pub const VERY_BRIGHT: u8 = 4;
+/// `color` marked as shining at `tier` (0 to `VERY_BRIGHT`).
+pub fn emitting(color: u32, tier: u8) -> u32 {
+    color & !EMISSION_BITS | u32::from(15 - tier.min(VERY_BRIGHT)) << 24
+}
+/// The HDR tier of block `name` (no namespace), which emits light `level`.
+pub fn hdr_tier(name: &str, level: u8) -> u8 {
+    match name {
+        _ if level == 0 => 0,
+        "glowstone" | "jack_o_lantern" | "campfire" | "soul_campfire" | "soul_lantern"
+        | "soul_torch" | "soul_wall_torch" | "soul_fire" => BRIGHT,
+        "torch" | "wall_torch" | "lantern" | "lava" | "crying_obsidian" | "fire"
+        | "sea_lantern" => INCANDESCENT,
+        "redstone_torch" | "redstone_wall_torch" | "magma_block" => LOW,
+        // Its flame is a particle.
+        _ if name.ends_with("candle") || name.ends_with("candle_cake") => LOW,
+        // A faint glow in the dark, as in SDR.
+        "glow_lichen" => 0,
+        _ if level >= 10 => INCANDESCENT,
+        _ => LOW,
+    }
 }
 const UNSET: u32 = u32::MAX;
 const NO_BIOME: u16 = u16::MAX;
@@ -731,7 +848,7 @@ impl Mesher<'_> {
         }
         let pad = Padded::new(region, sy);
         out.visibility = visibility(&pad, &self.tables.info);
-        let base_y = MIN_Y + sy * 16;
+        let base_y = center.min_y() + sy * 16;
         let mut tints = Tints::new(
             region,
             self.biomes,
@@ -838,17 +955,15 @@ impl Mesher<'_> {
         }
         Some(match state.tints[(index as usize).min(1)] {
             Tint::None => return None,
-            Tint::Grass | Tint::GrassBlock => tints.get(Resolver::Grass, x, y, z),
+            Tint::Grass | Tint::GrassBlock | Tint::SugarCane => tints.get(Resolver::Grass, x, y, z),
             Tint::TallGrassUpper => tints.get(Resolver::Grass, x, y, z),
             Tint::Foliage => tints.get(Resolver::Foliage, x, y, z),
             Tint::DryFoliage => tints.get(Resolver::Dry, x, y, z),
             Tint::Water => tints.get(Resolver::Water, x, y, z),
             Tint::Constant(c) => c,
+            Tint::LilyPad => 0x20_8030,
             Tint::Redstone(p) => redstone_color(p),
-            Tint::Stem(age) => {
-                let a = u32::from(age);
-                (a * 32) << 16 | (255 - a * 8) << 8 | (a * 4)
-            }
+            Tint::Stem(age) => stem_color(age),
         })
     }
     #[allow(clippy::too_many_arguments)]
@@ -864,6 +979,7 @@ impl Mesher<'_> {
         state: &Info,
     ) {
         let q = &face.quad;
+        let tier = state.tier.max(hdr_tier("", q.light_emission));
         let shade_face = q.shade_direction_override.unwrap_or(q.facing);
         let directional = lighting::cardinal(self.nether_shading, shade_face);
         // Grey level per vertex before tinting, and vanilla light coords.
@@ -903,7 +1019,7 @@ impl Mesher<'_> {
                 } else {
                     face.layer as u16
                 },
-                emitting(pack_rgb(rgb), state.emission.max(q.light_emission)),
+                emitting(pack_rgb(rgb), tier),
                 pack_coords(lighting::with_emission(coords[i], q.light_emission)),
             ));
         }

crates/horizon-client-render/src/mesher/fluid.rs

@@ -227,8 +227,11 @@ pub(super) fn tesselate(
     } else {
         0xFF_FFFF
     };
-    // Lava emits light level 15.
-    let emission = if water { 0 } else { 15 };
+    let emission = if water {
+        0
+    } else {
+        crate::mesher::INCANDESCENT
+    };
     let color = |by: f32| {
         let rgb = [16, 8, 0].map(|shift| lighting::scale((tint >> shift & 255) as i32, by) as u32);
         crate::mesher::emitting(pack_rgb(rgb), emission)

crates/horizon-client-render/src/mesher/lighting.rs

@@ -39,10 +39,13 @@ fn state<'a>(pad: &Padded, info: &'a [Info], p: [i32; 3]) -> &'a Info {
 /// `LightCoordsUtil.getLightCoords`: light at `p` as seen through `state`
 /// (block level << 4 | sky level << 20).
 pub(super) fn coords(pad: &Padded, state: &Info, p: [i32; 3]) -> u32 {
+    packed_coords(state, pad.light[pi(p[0], p[1], p[2])])
+}
+/// `coords` of a stored light byte (sky level << 4 | block level).
+pub(super) fn packed_coords(state: &Info, packed: u8) -> u32 {
     if state.emissive {
         return FULL_BRIGHT;
     }
-    let packed = pad.light[pi(p[0], p[1], p[2])];
     let block = u32::from((packed & 15).max(state.emission));
     block << 4 | u32::from(packed >> 4) << 20
 }
@@ -274,8 +277,28 @@ pub(super) fn flat(
     positions: &[[f32; 3]; 4],
     face: D,
 ) -> u32 {
-    let cubic = shape(positions, face, own.full).cubic;
-    coords(pad, own, if cubic { step(pos, face) } else { pos })
+    coords(
+        pad,
+        own,
+        flat_position(pos, positions, face, None, own.full),
+    )
+}
+/// Where `tesselateFlat` reads the light of a quad of a block at `pos`: the
+/// neighbour on its cull face, else `prepareQuadFlat`'s choice (the neighbour
+/// when the quad is cubic, else the block itself). `full` is the block's
+/// `isCollisionShapeFullBlock`.
+pub(super) fn flat_position(
+    pos: [i32; 3],
+    positions: &[[f32; 3]; 4],
+    face: D,
+    cull: Option<D>,
+    full: bool,
+) -> [i32; 3] {
+    match cull {
+        Some(d) => step(pos, d),
+        None if shape(positions, face, full).cubic => step(pos, face),
+        None => pos,
+    }
 }
 /// `prepareQuadAmbientOcclusion`: per-vertex AO brightness (before `ARGB.gray`)
 /// and smooth light coords, by vertex index.
@@ -398,6 +421,39 @@ mod tests {
         assert_eq!(max_coords(packed(3, 9), packed(7, 2)), packed(7, 9));
     }
     #[test]
+    fn flat_light_reads_the_neighbour_a_face_looks_at() {
+        let pos = [4, 64, -2];
+        let full_top = [
+            [0.0, 1.0, 0.0],
+            [0.0, 1.0, 1.0],
+            [1.0, 1.0, 1.0],
+            [1.0, 1.0, 0.0],
+        ];
+        // A cull face samples its neighbour, whatever the quad's shape.
+        let inset = full_top.map(|[x, _, z]| [x, 0.75, z]);
+        assert_eq!(
+            flat_position(pos, &inset, D::Up, Some(D::Up), false),
+            [4, 65, -2]
+        );
+        // A flush quad without a cull face samples its neighbour too: a block
+        // drawn at a cell that is now opaque (a moving block, #3002) still
+        // takes the light around it.
+        assert_eq!(
+            flat_position(pos, &full_top, D::Up, None, false),
+            [4, 65, -2]
+        );
+        let west = [
+            [0.0, 0.0, 0.0],
+            [0.0, 0.0, 1.0],
+            [0.0, 1.0, 1.0],
+            [0.0, 1.0, 0.0],
+        ];
+        assert_eq!(flat_position(pos, &west, D::West, None, false), [3, 64, -2]);
+        // An inset quad (a piston head's arm) takes the block's own light.
+        assert_eq!(flat_position(pos, &inset, D::Up, None, false), pos);
+        assert_eq!(flat_position(pos, &inset, D::Up, None, true), [4, 65, -2]);
+    }
+    #[test]
     fn quad_shape_classifies_partial_and_cubic_faces() {
         let full_top = [
             [0.0, 1.0, 0.0],

crates/horizon-client-render/src/mesher/particle_tests.rs

@@ -54,3 +54,40 @@ fn terrain_particles_use_the_particle_sprite_and_vanilla_tint_sources() {
     assert_eq!(tint("minecraft:pink_petals"), None);
     assert_eq!(tint("minecraft:stone"), None);
 }
+
+/// Blocks drawn outside the chunk mesh (moved by a piston) take the chunk
+/// mesher's per-layer tints: a grass block's top and side overlay are tinted
+/// as in the world, not left gray like its particles.
+#[test]
+fn block_tints_match_the_chunk_mesh_for_grass_blocks() {
+    let root =
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
+    if !root.join("horizon-resources.json").exists() {
+        return;
+    }
+    let assets = Assets::load(&root).unwrap();
+    let render = assets.reload(&root).unwrap();
+    let facts = BlockFacts::load(&root, assets.registry).unwrap();
+    let visibility = crate::models::load_visibility(&root, assets.registry).unwrap();
+    let tables = MeshTables::new(&assets, &render, &facts, visibility).unwrap();
+    let biomes = Biomes::load(&root).unwrap();
+    let state = |name| assets.registry.default_state(name).unwrap();
+    let center = Chunk::empty(0, 0);
+    let mut region = [[None; 3]; 3];
+    region[1][1] = Some(&center);
+    let tints = |name| {
+        tables.block_tints(
+            state(name),
+            [5, 70, 9],
+            &region,
+            &biomes,
+            BiomeZoom::new(0),
+            2,
+        )
+    };
+    let grass = tints("minecraft:grass_block");
+    assert!(grass(0).is_some());
+    assert_eq!(grass(-1), None);
+    assert_eq!(tints("minecraft:spruce_leaves")(0), Some(0x61_9961));
+    assert_eq!(tints("minecraft:stone")(0), None);
+}

crates/horizon-client-render/src/mesher/visibility_tests.rs

@@ -77,6 +77,7 @@ fn info(solid: bool) -> Info {
         permeable: false,
         shade: 1.0,
         emission: 0,
+        tier: 0,
         emissive: false,
         fluid: FluidState::EMPTY,
         model: false,

crates/horizon-client-render/src/options_ui.rs

@@ -254,7 +254,7 @@ impl Opt {
             Opt::NotificationDisplayTime => "options.notifications.display_time",
             Opt::Narrator => "options.narrator",
             Opt::TextBackground => "options.accessibility.text_background",
-            Opt::ChatDelay => "Chat Delay",
+            Opt::ChatDelay => "horizon.options.chat_delay",
             Opt::DistortionEffects => "options.screenEffectScale",
             Opt::FovEffects => "options.fovEffectScale",
             Opt::DarknessPulsing => "options.darknessEffectScale",
@@ -673,25 +673,25 @@ impl Opt {
             } else {
                 "options.key.hold"
             }),
-            Opt::PadLightbar => Text::literal(match s.controller.lightbar {
-                gamepad::Lightbar::Health => "Health",
-                gamepad::Lightbar::Dimension => "Dimension",
-                gamepad::Lightbar::Off => "Off",
+            Opt::PadLightbar => tr(match s.controller.lightbar {
+                gamepad::Lightbar::Health => "horizon.options.lightbar.health",
+                gamepad::Lightbar::Dimension => "horizon.options.lightbar.dimension",
+                gamepad::Lightbar::Off => "options.off",
             }),
-            Opt::PadGlyphs => Text::literal(match s.controller.glyphs {
-                GlyphStyle::Auto => "Auto",
-                GlyphStyle::Xbox => "Xbox",
-                GlyphStyle::PlayStation => "PlayStation",
-                GlyphStyle::Nintendo => "Nintendo",
+            Opt::PadGlyphs => tr(match s.controller.glyphs {
+                GlyphStyle::Auto => "horizon.options.glyphs.auto",
+                GlyphStyle::Xbox => "horizon.options.glyphs.xbox",
+                GlyphStyle::PlayStation => "horizon.options.glyphs.playstation",
+                GlyphStyle::Nintendo => "horizon.options.glyphs.nintendo",
             }),
-            Opt::PadMenuNav => Text::literal(match s.controller.menu_nav {
-                gamepad::MenuNav::Focus => "Focus",
-                gamepad::MenuNav::Pointer => "Pointer",
+            Opt::PadMenuNav => tr(match s.controller.menu_nav {
+                gamepad::MenuNav::Focus => "horizon.options.menu_focus",
+                gamepad::MenuNav::Pointer => "horizon.options.menu_pointer",
             }),
-            Opt::PadKeyboard => Text::literal(match s.controller.keyboard {
-                gamepad::TextKeyboard::Auto => "Auto",
-                gamepad::TextKeyboard::Horizon => "Horizon",
-                gamepad::TextKeyboard::Steam => "Steam",
+            Opt::PadKeyboard => tr(match s.controller.keyboard {
+                gamepad::TextKeyboard::Auto => "horizon.options.keyboard.auto",
+                gamepad::TextKeyboard::Horizon => "horizon.options.keyboard.horizon",
+                gamepad::TextKeyboard::Steam => "horizon.options.keyboard.steam",
             }),
             _ => Text::empty(),
         }
@@ -1273,22 +1273,14 @@ fn option_widget(s: &Settings, opt: Opt, x: f32, y: f32, w: f32) -> Widget {
 /// What a button opening one of Horizon's pages says on hover.
 fn horizon_page_tooltip(page: Page) -> Option<&'static str> {
     Some(match page {
-        Page::Horizon => "Horizon's own settings: graphics, controllers, extras and mods.",
-        Page::Graphics => "Graphics, simply: each setting says what it costs.",
-        Page::GraphicsAdvanced => {
-            "Every graphics setting, Horizon's included, with what each costs."
-        }
-        Page::Controller => "Controllers: their buttons, sticks, vibration and menu navigation.",
-        Page::Extras => {
-            "Optional additions, all off by default: the game stays vanilla until you turn one on."
-        }
-        Page::Agent => "Let your own AI agent play: horizon-ctl and MCP clients on this computer.",
-        Page::ShaderPacks => {
-            "Shader packs from the shaderpacks folder: Horizon's own and those in the shaders/ format. One runs at a time."
-        }
-        Page::Mods => {
-            "Mods made for Horizon, from the horizon-mods folder. Each runs in a sandbox and stays off until you turn it on."
-        }
+        Page::Horizon => "horizon.pages.settings.tooltip",
+        Page::Graphics => "horizon.pages.graphics.tooltip",
+        Page::GraphicsAdvanced => "horizon.pages.graphics_advanced.tooltip",
+        Page::Controller => "horizon.pages.controller.tooltip",
+        Page::Extras => "horizon.pages.extras.tooltip",
+        Page::Agent => "horizon.pages.agent.tooltip",
+        Page::ShaderPacks => "horizon.pages.shader_packs.tooltip",
+        Page::Mods => "horizon.pages.mods.tooltip",
         _ => return None,
     })
 }
@@ -1421,16 +1413,16 @@ impl OptionsUi {
             Page::Language => "options.language.title",
             Page::Font => "options.font.title",
             Page::Packs => "resourcePack.title",
-            Page::Mods => "Mods",
+            Page::Mods => "horizon.pages.mods",
             Page::NativeMod(_) => "Mod Settings",
-            Page::ShaderPacks => "Shader Packs",
+            Page::ShaderPacks => "horizon.pages.shader_packs",
             Page::Graphics | Page::GraphicsAdvanced | Page::GraphicsHdr => "options.videoTitle",
-            Page::Controller => "Controller Settings",
-            Page::PadBinds => "Controller Binds",
-            Page::Extras => "Horizon Extras",
+            Page::Controller => "horizon.pages.controller",
+            Page::PadBinds => "horizon.pages.controller_binds",
+            Page::Extras => "horizon.pages.extras",
             Page::Credits => "credits_and_attribution.screen.title",
-            Page::Horizon => "Horizon Settings",
-            Page::Agent => "AI Agent",
+            Page::Horizon => "horizon.pages.settings",
+            Page::Agent => "horizon.pages.agent",
         }
     }
     fn scrollbar_x(&self, width: f32) -> f32 {
@@ -1568,21 +1560,23 @@ impl OptionsUi {
             Page::Horizon => {
                 // Two to a row, as vanilla's OptionsList.addSmall lays out
                 // buttons; each opens a page built from vanilla's widgets.
-                let open = |label: &str, page: Page| {
-                    button(0.0, 0.0, 150.0, Text::literal(label), Act::Push(page))
-                };
+                let open =
+                    |key: &str, page: Page| button(0.0, 0.0, 150.0, tr(key), Act::Push(page));
                 vec![
                     Row::Buttons(
-                        open("Graphics...", Page::Graphics),
-                        Some(open("Advanced Graphics...", Page::GraphicsAdvanced)),
+                        open("horizon.pages.open.graphics", Page::Graphics),
+                        Some(open(
+                            "horizon.pages.open.graphics_advanced",
+                            Page::GraphicsAdvanced,
+                        )),
                     ),
                     Row::Buttons(
-                        open("Shader Packs...", Page::ShaderPacks),
-                        Some(open("Controller Settings...", Page::Controller)),
+                        open("horizon.pages.open.shader_packs", Page::ShaderPacks),
+                        Some(open("horizon.pages.open.controller", Page::Controller)),
                     ),
                     Row::Buttons(
-                        open("Extras...", Page::Extras),
-                        Some(open("Mods...", Page::Mods)),
+                        open("horizon.pages.open.extras", Page::Extras),
+                        Some(open("horizon.pages.open.mods", Page::Mods)),
                     ),
                     // No AI hides the AI Agent page and everything AI.
                     Row::Buttons(
@@ -1590,7 +1584,7 @@ impl OptionsUi {
                         Some(if s.extras.no_ai {
                             self.extra_button(s, crate::extras::Item::NoAi)
                         } else {
-                            open("AI Agent...", Page::Agent)
+                            open("horizon.pages.open.agent", Page::Agent)
                         }),
                     ),
                 ]
@@ -1609,7 +1603,7 @@ impl OptionsUi {
                         0.0,
                         0.0,
                         150.0,
-                        Text::literal("Copy Connection Details"),
+                        tr("horizon.agent.copy_details"),
                         Act::CopyAgentDetails,
                     )),
                 )];
@@ -1623,14 +1617,14 @@ impl OptionsUi {
                         0.0,
                         0.0,
                         150.0,
-                        Text::literal("Horizon Graphics..."),
+                        tr("horizon.pages.open.horizon_graphics"),
                         Act::Push(Page::Graphics),
                     ),
                     Some(button(
                         0.0,
                         0.0,
                         150.0,
-                        Text::literal("Advanced Graphics..."),
+                        tr("horizon.pages.open.graphics_advanced"),
                         Act::Push(Page::GraphicsAdvanced),
                     )),
                 )];
@@ -1723,7 +1717,7 @@ impl OptionsUi {
                         0.0,
                         0.0,
                         310.0,
-                        Text::literal("Controller Settings..."),
+                        tr("horizon.pages.open.controller"),
                         Act::Push(Page::Controller),
                     ),
                     None,
@@ -1736,7 +1730,7 @@ impl OptionsUi {
                         0.0,
                         0.0,
                         310.0,
-                        Text::literal("Controller Binds..."),
+                        tr("horizon.pages.open.controller_binds"),
                         Act::Push(Page::PadBinds),
                     ),
                     None,
@@ -1794,9 +1788,7 @@ impl OptionsUi {
             Page::Font => pairs(&[Opt::ForceUnicode, Opt::JapaneseGlyphs]),
             Page::Mods => {
                 if s.mods.installed.is_empty() {
-                    return vec![Row::Header(
-                        "No mods: put .hmod files in the horizon-mods folder",
-                    )];
+                    return vec![Row::Header("horizon.mods.empty")];
                 }
                 s.mods
                     .installed
@@ -1806,9 +1798,9 @@ impl OptionsUi {
                         let mut label = Text::literal(format!("{}: ", installed.title))
                             .append(on_off(s.mods.is_on(i)));
                         if installed.problem.is_some() {
-                            label = label.append(" (Stopped)");
+                            label = label.append(tr("horizon.mods.stopped"));
                         } else if installed.dev {
-                            label = label.append(" (Dev)");
+                            label = label.append(tr("horizon.mods.dev"));
                         }
                         let dead = installed.dev || installed.id.is_empty();
                         // A native mod gets its settings page's button beside
@@ -1819,7 +1811,7 @@ impl OptionsUi {
                                 0.0,
                                 0.0,
                                 150.0,
-                                Text::literal("Settings"),
+                                tr("horizon.mods.settings"),
                                 Act::ModSettings(i),
                             );
                             Row::Buttons(
@@ -1836,17 +1828,17 @@ impl OptionsUi {
             Page::NativeMod(i) => self.native_rows(s, i),
             Page::ShaderPacks => {
                 if s.shader_packs.is_empty() {
-                    return vec![Row::Header(
-                        "No shader packs: put them in the shaderpacks folder",
-                    )];
+                    return vec![Row::Header("horizon.shader_packs.empty")];
                 }
                 s.shader_packs
                     .iter()
                     .enumerate()
                     .map(|(i, pack)| {
                         let kind = match pack.kind {
-                            crate::shader_pack_list::Kind::Horizon => " (Horizon)",
-                            crate::shader_pack_list::Kind::Classic => "",
+                            crate::shader_pack_list::Kind::Horizon => {
+                                lang::get("horizon.shader_packs.kind_horizon")
+                            }
+                            crate::shader_pack_list::Kind::Classic => String::new(),
                         };
                         let label = Text::literal(format!("{}{kind}: ", pack.title))
                             .append(on_off(s.horizon.shader_pack == pack.file));
@@ -1906,8 +1898,8 @@ impl OptionsUi {
                     // Vanilla's Telemetry Data and Credits slots: Horizon's
                     // settings and its mods, as a mod adds its button here.
                     // Credits & Attribution (WinScreen's credits) follows them.
-                    ("Horizon Settings...", Some(Page::Horizon)),
-                    ("Mods...", Some(Page::Mods)),
+                    ("horizon.pages.open.horizon_settings", Some(Page::Horizon)),
+                    ("horizon.pages.open.mods", Some(Page::Mods)),
                     ("options.credits_and_attribution", Some(Page::Credits)),
                 ];
                 let rows = entries.len().div_ceil(2) as f32;
@@ -2340,18 +2332,12 @@ impl OptionsUi {
                 content = y + self.scroll - top + 2.0;
                 out[list_start..].iter_mut().for_each(|w| w.list = true);
                 let folder = match page {
-                    Page::Mods => Some(("Open Mod Folder", Act::OpenModFolder)),
-                    Page::ShaderPacks => Some(("Open Pack Folder", Act::OpenShaderPackFolder)),
+                    Page::Mods => Some(("horizon.mods.open_folder", Act::OpenModFolder)),
+                    Page::ShaderPacks => Some(("pack.openFolder", Act::OpenShaderPackFolder)),
                     _ => None,
                 };
                 if let Some((label, act)) = folder {
-                    out.push(button(
-                        cx - 154.0,
-                        h - 27.0,
-                        150.0,
-                        Text::literal(label),
-                        act,
-                    ));
+                    out.push(button(cx - 154.0, h - 27.0, 150.0, tr(label), act));
                     out.push(button(cx + 4.0, h - 27.0, 150.0, tr("gui.done"), Act::Done));
                 } else {
                     out.push(done(h - 27.0));
@@ -2464,7 +2450,7 @@ impl OptionsUi {
                 } = &wd.kind
                     && let Some(text) = horizon_page_tooltip(*page)
                 {
-                    tooltip = Some(atlas.font.split(&Text::literal(text), 170.0));
+                    tooltip = Some(atlas.font.split(&tr(text), 170.0));
                 }
                 let key = match &wd.kind {
                     WKind::Button {
@@ -2491,10 +2477,7 @@ impl OptionsUi {
                 } = &wd.kind
                     && !opt.available()
                 {
-                    tooltip = Some(atlas.font.split(
-                        &Text::literal("This feature is not yet available in Horizon."),
-                        170.0,
-                    ));
+                    tooltip = Some(atlas.font.split(&tr("horizon.options.unavailable"), 170.0));
                 }
                 if let WKind::Button {
                     act: Act::ToggleMod(i),
@@ -2635,9 +2618,7 @@ impl OptionsUi {
             if search.value.is_empty() && !search.focused {
                 batch.text_styled(
                     atlas,
-                    &Text::literal("Search settings...")
-                        .with_color(text::GRAY)
-                        .italic(),
+                    &tr("horizon.options.search").with_color(text::GRAY).italic(),
                     search.text_x(),
                     search.text_y(),
                     u32::MAX,
@@ -2816,26 +2797,7 @@ impl OptionsUi {
                         }
                         Act::Done => events.extend(self.back(s)),
                         Act::Cycle(opt) => {
-                            opt.cycle(s, right, framebuffer);
-                            if opt == Opt::Preset {
-                                apply_preset(s);
-                            }
-                            if opt == Opt::HighContrast {
-                                // Options.highContrast: the built-in pack follows the option.
-                                let on = s.resource_packs.iter().any(|id| id == "high_contrast");
-                                if on != s.high_contrast {
-                                    s.resource_packs.retain(|id| id != "high_contrast");
-                                    if s.high_contrast {
-                                        s.resource_packs.push("high_contrast".into());
-                                    }
-                                    // PackSelectionScreen reads the repository each time it
-                                    // opens: the next one starts from this selection.
-                                    self.pack_selection = s.resource_packs.clone();
-                                    self.pack_screen = None;
-                                    events.push(Event::Packs(s.resource_packs.clone()));
-                                }
-                            }
-                            events.push(Event::Changed);
+                            events.extend(self.cycle_option(s, opt, right, framebuffer));
                         }
                         Act::Extra(item) => {
                             if let Some(name) = item.key_name() {
@@ -2943,6 +2905,77 @@ impl OptionsUi {
         self.scroll -= amount * 18.0;
         self.clamp_scroll(top, bottom, content);
     }
+    /// `CycleButton.cycleValue` on an option, then what the option changes:
+    /// the preset's values, High Contrast's built-in pack.
+    fn cycle_option(
+        &mut self,
+        s: &mut Settings,
+        opt: Opt,
+        back: bool,
+        framebuffer: [i32; 2],
+    ) -> Vec<Event> {
+        let mut events = Vec::new();
+        opt.cycle(s, back, framebuffer);
+        if opt == Opt::Preset {
+            apply_preset(s);
+        }
+        if opt == Opt::HighContrast {
+            // Options.highContrast: the built-in pack follows the option.
+            let on = s.resource_packs.iter().any(|id| id == "high_contrast");
+            if on != s.high_contrast {
+                s.resource_packs.retain(|id| id != "high_contrast");
+                if s.high_contrast {
+                    s.resource_packs.push("high_contrast".into());
+                }
+                // PackSelectionScreen reads the repository each time it
+                // opens: the next one starts from this selection.
+                self.pack_selection = s.resource_packs.clone();
+                self.pack_screen = None;
+                events.push(Event::Packs(s.resource_packs.clone()));
+            }
+        }
+        events.push(Event::Changed);
+        events
+    }
+    /// The mouse wheel at the cursor. Over a cycle button it takes the step
+    /// (`CycleButton.mouseScrolled`: up goes back) and the list stays put.
+    pub fn wheel(
+        &mut self,
+        s: &mut Settings,
+        size: (f32, f32),
+        cursor: (f32, f32),
+        framebuffer: [i32; 2],
+        amount: f32,
+    ) -> Vec<Event> {
+        let plain = self.resource_error.is_none()
+            && Self::graphics_level(self.page()).is_none()
+            && !(self.pack_screen.is_some() && self.stack.last() == Some(&Page::Packs));
+        if !plain {
+            self.scroll_at(s, size, cursor, amount);
+            return Vec::new();
+        }
+        let (widgets, top, bottom, _) = self.layout(s, size.0, size.1);
+        let hovered = widgets.iter().find_map(|wd| match &wd.kind {
+            WKind::Button {
+                active: true,
+                act: Act::Cycle(opt),
+                ..
+            } if ui::hovered(cursor, wd.x, wd.y, wd.w, wd.h)
+                && !(wd.list && (cursor.1 < top || cursor.1 >= bottom)) =>
+            {
+                Some(*opt)
+            }
+            _ => None,
+        });
+        match hovered {
+            Some(opt) if amount != 0.0 => self.cycle_option(s, opt, amount > 0.0, framebuffer),
+            Some(_) => Vec::new(),
+            None => {
+                self.scroll_at(s, size, cursor, amount);
+                Vec::new()
+            }
+        }
+    }
     /// The mouse wheel at the cursor.
     pub fn scroll_at(&mut self, s: &Settings, size: (f32, f32), cursor: (f32, f32), amount: f32) {
         if self.resource_error.is_some() {
@@ -2959,6 +2992,33 @@ impl OptionsUi {
             _ => self.scroll(s, size, amount),
         }
     }
+    /// `VideoSettingsScreen.mouseScrolled`: with Ctrl held the wheel steps the GUI scale
+    /// (auto counts as one past the maximum) and the list goes back to the top.
+    pub fn video_wheel_gui_scale(
+        &mut self,
+        s: &mut Settings,
+        framebuffer: [i32; 2],
+        amount: f32,
+    ) -> Vec<Event> {
+        let max = i64::from(crate::window::calculate_scale(
+            framebuffer,
+            0,
+            s.force_unicode,
+        ));
+        let old = if s.gui_scale == 0 {
+            max + 1
+        } else {
+            i64::from(s.gui_scale)
+        };
+        let step = i64::from(amount > 0.0) - i64::from(amount < 0.0);
+        let new = old + step;
+        if new == 0 || new > max {
+            return Vec::new();
+        }
+        s.gui_scale = new as u32;
+        self.scroll = 0.0;
+        vec![Event::Changed]
+    }
     /// The pack screen at this GUI size, made on first use.
     fn packs(&mut self, atlas: &HudAtlas, size: (f32, f32)) -> &mut crate::pack_screen::PackScreen {
         let m = crate::screen_draw::Measure(&atlas.font);
@@ -3446,8 +3506,15 @@ mod tests {
         ui.show(Page::Mods);
         let empty = ui.layout(&s, size.0, size.1).0;
         assert!(empty.iter().any(|w| {
-            matches!(&w.kind, WKind::Text { text, .. } if text.plain().contains(".hmod"))
+            matches!(&w.kind, WKind::Text { text, .. } if text.plain() == "horizon.mods.empty")
         }));
+        // The empty page points at the bundled key; the English line behind it
+        // is what a player reads, so both halves are checked here.
+        let en = crate::lang::Language::load(&[], "en_us");
+        assert!(
+            en.get("horizon.mods.empty")
+                .is_some_and(|line| line.contains(".hmod"))
+        );
         let open_folder = empty
             .iter()
             .find(|w| {

crates/horizon-client-render/src/packs.rs

@@ -581,7 +581,15 @@ fn build_overlay_uncached(
                     Some(p) => link(p, &target)?,
                     None => {
                         if let Some(Some(z)) = zips.get(*owner) {
-                            fs::write(&target, z.read(inner)?)?;
+                            // One unreadable entry costs that file, not the
+                            // pack: an error here failed the build and the
+                            // reload dropped every server pack in the stack.
+                            match z.read(inner) {
+                                Ok(bytes) => fs::write(&target, bytes)?,
+                                Err(e) => log::warn!(
+                                    "Horizon: skipping unreadable pack entry {inner}: {e}"
+                                ),
+                            }
                         }
                     }
                 }

crates/horizon-client-render/src/particles.rs

@@ -44,6 +44,9 @@ pub struct ParticleOptions {
     /// `ItemParticleOption`: the particle sprite of each layer of the item's
     /// model as resolved for the ground.
     pub item: Option<Vec<String>>,
+    /// `GeyserParticleOptions.waterBlocks` and `GeyserBaseParticleOptions`'
+    /// `waterBlocks` and `burstImpulseBase` (0 where the type has none).
+    pub geyser: Option<(i32, f32)>,
 }
 impl ParticleOptions {
     pub fn simple(ty: ParticleType) -> Self {
@@ -55,6 +58,21 @@ impl ParticleOptions {
             to_color: [1.0, 0.0, 0.0],
             trail: None,
             item: None,
+            geyser: None,
+        }
+    }
+    /// `GeyserParticleOptions(type, waterBlocks)`.
+    pub fn geyser(ty: ParticleType, water_blocks: i32) -> Self {
+        Self {
+            geyser: Some((water_blocks, 0.0)),
+            ..Self::simple(ty)
+        }
+    }
+    /// `GeyserBaseParticleOptions(type, waterBlocks, burstImpulseBase)`.
+    pub fn geyser_base(ty: ParticleType, water_blocks: i32, burst_impulse_base: f32) -> Self {
+        Self {
+            geyser: Some((water_blocks, burst_impulse_base)),
+            ..Self::simple(ty)
         }
     }
     /// `ItemParticleOption`: the stack's layer particle sprites (`BreakingItemParticle`).
@@ -189,6 +207,29 @@ enum Behaviour {
         size_start: f32,
         y_prev: f64,
     },
+    /// `NoxiousGasParticle`: fades out from `fade_start` ticks of age.
+    NoxiousGas {
+        fade_start: f32,
+    },
+    /// `NoxiousGasCloudParticle`: every second tick, a gas particle where the
+    /// gas reaches.
+    NoxiousGasCloud,
+    /// `GeyserEruptionParticle`: the base puffs, the plume and the poofs of
+    /// one eruption; `aux` is the speed its provider was given.
+    GeyserEruption {
+        water_blocks: i32,
+        aux: [f64; 3],
+    },
+    /// `GeyserPlumeParticle`: shoots up `plumeHeight` blocks, then falls back.
+    GeyserPlume {
+        start_y: f64,
+        max_y: f64,
+        propulsion: f32,
+        spray: [f32; 2],
+        min_size: f32,
+        max_size: f32,
+        done: bool,
+    },
     BubblePop,
     BubbleColumnUp,
     CurrentDown {
@@ -869,6 +910,26 @@ impl Particle {
         (age / self.lifetime as f32).clamp(0.0, 1.0)
     }
 }
+/// `NoxiousGasCloudParticle.pickRandomParticleSpawnPoint`: a point up to three
+/// blocks from the centre of `center_block` in a random horizontal direction,
+/// a quarter block lower, from the level's random.
+fn pick_random_particle_spawn_point(random: &mut LegacyRandom, center_block: [i32; 3]) -> [f64; 3] {
+    let dx = f64::from(random.next_float() - 0.5);
+    let dz = f64::from(random.next_float() - 0.5);
+    // Vec3.normalize.
+    let length = (dx * dx + dz * dz).sqrt();
+    let (dx, dz) = if length < f64::from(1.0e-5f32) {
+        (0.0, 0.0)
+    } else {
+        (dx / length, dz / length)
+    };
+    let distance = f64::from(random.next_float() * 3.0);
+    [
+        f64::from(center_block[0]) + 0.5 + dx * distance,
+        f64::from(center_block[1]) + 0.5 - 0.25,
+        f64::from(center_block[2]) + 0.5 + dz * distance,
+    ]
+}
 /// `FireflyParticle.getFadeAmount`.
 fn fade_amount(progress: f32, fade_in: f32, fade_out: f32) -> f32 {
     if progress >= 1.0 - fade_in {
@@ -928,7 +989,7 @@ impl ParticleLevel<'_> {
             Err(_) => d,
         }
     }
-    fn block_at(p: [f64; 3]) -> [i32; 3] {
+    pub(crate) fn block_at(p: [f64; 3]) -> [i32; 3] {
         [
             p[0].floor() as i32,
             p[1].floor() as i32,
@@ -950,7 +1011,7 @@ impl ParticleLevel<'_> {
         (s.fluid, height)
     }
     /// The fluid at a block and whether it is a source (`FluidState.isSource`).
-    fn fluid_source(&self, b: [i32; 3]) -> (Fluid, bool) {
+    pub(crate) fn fluid_source(&self, b: [i32; 3]) -> (Fluid, bool) {
         let s = self.facts.get(self.world.block(b[0], b[1], b[2]));
         (s.fluid, s.fluid_level == 8 && !s.fluid_falling)
     }
@@ -1165,6 +1226,17 @@ impl ParticleEngine {
             self.create(options, p, v);
         }
     }
+    /// `NoxiousGasCloudParticle.spawnNoxiousGasParticle`: the gas, as an
+    /// always visible particle (`ClientLevel.addAlwaysVisibleParticle`).
+    fn spawn_noxious_gas_particle(&mut self, pos: [f64; 3]) {
+        self.add_with(
+            &ParticleOptions::simple(ParticleType::NoxiousGas),
+            pos,
+            [0.0; 3],
+            false,
+            true,
+        );
+    }
     /// `ClientLevel.calculateParticleLevel`: minimal still shows one in ten
     /// always-visible particles as decreased, and decreased drops a third.
     fn calculate_particle_level(&mut self, always_show: bool) -> u8 {
@@ -1562,7 +1634,15 @@ impl ParticleEngine {
                 q.set = set;
                 q
             }
-            T::Smoke | T::LargeSmoke | T::WhiteSmoke | T::Ash | T::WhiteAsh | T::DustPlume => {
+            T::Smoke
+            | T::LargeSmoke
+            | T::WhiteSmoke
+            | T::Ash
+            | T::WhiteAsh
+            | T::DustPlume
+            | T::NoxiousGas
+            | T::GeyserBase
+            | T::GeyserPoof => {
                 // BaseAshSmokeParticle(dir, xa, scale, colorRandom, maxLifetime, gravity, hasPhysics).
                 let (dir, scale, color_random, max_lifetime, gravity, physics, vel) = match ty {
                     T::Smoke | T::WhiteSmoke => ([0.1, 0.1, 0.1], 1.0, 0.3, 8, -0.1, true, v),
@@ -1578,6 +1658,22 @@ impl ParticleEngine {
                         false,
                         [v[0], v[1] + f64::from(0.15f32), v[2]],
                     ),
+                    // NoxiousGasParticle.Provider: scale 3.
+                    T::NoxiousGas => ([0.1, 0.1, 0.1], 3.0, 0.3, 5, -0.02, true, v),
+                    // GeyserBaseParticle: the burst impulse scales every axis.
+                    T::GeyserBase | T::GeyserPoof => {
+                        let (water_blocks, burst_impulse_base) = o.geyser?;
+                        let burst_impulse = burst_impulse_base + 0.25 * water_blocks as f32;
+                        (
+                            [f64::from(burst_impulse); 3],
+                            3.0 + 0.125 * water_blocks as f32,
+                            0.0,
+                            0,
+                            0.0,
+                            true,
+                            v,
+                        )
+                    }
                     _ => {
                         // WhiteAshParticle.Provider draws the motion.
                         let pr = &mut self.random;
@@ -1593,6 +1689,18 @@ impl ParticleEngine {
                         ([0.1, -0.1, 0.1], 1.0, 0.0, 20, 0.0125, false, [xa, ya, za])
                     }
                 };
+                // GeyserBaseParticle.Provider: a random spot half a block
+                // around the point, a fifth of a block up (the provider's
+                // random, as float arithmetic added to the double position).
+                let p = if matches!(ty, T::GeyserBase | T::GeyserPoof) {
+                    let pr = &mut self.random;
+                    let x = p[0] + f64::from((pr.next_float() - 0.5) * 0.5);
+                    let y = p[1] + f64::from((pr.next_float() - 0.5) * 0.5) + f64::from(0.2f32);
+                    let z = p[2] + f64::from((pr.next_float() - 0.5) * 0.5);
+                    [x, y, z]
+                } else {
+                    p
+                };
                 let mut q = Particle::moving(r, ty, p, [0.0; 3]);
                 q.friction = 0.96;
                 q.gravity = gravity;
@@ -1621,6 +1729,87 @@ impl ParticleEngine {
                     );
                     q.behaviour = Behaviour::DustPlume;
                 }
+                match ty {
+                    // NoxiousGasParticle: white, living `6 / (0.5 to 1) * 3`
+                    // ticks, fading out over its second half.
+                    T::NoxiousGas => {
+                        q.set_color(1.0, 1.0, 1.0);
+                        q.lifetime = (6.0 / (f64::from(r.next_float()) * 0.5 + 0.5)
+                            * f64::from(3.0f32)) as i32;
+                        q.behaviour = Behaviour::NoxiousGas {
+                            fade_start: q.lifetime as f32 / 2.0,
+                        };
+                    }
+                    // GeyserBaseParticle: white, only ever rising, 20 to 25 ticks.
+                    T::GeyserBase | T::GeyserPoof => {
+                        q.friction = 0.725;
+                        q.set_color(1.0, 1.0, 1.0);
+                        q.velocity[1] = q.velocity[1].abs();
+                        let lifetime_factor = 0.8 + 0.2 * self.level_random.next_float();
+                        q.lifetime = (25.0 * lifetime_factor) as i32;
+                    }
+                    _ => {}
+                }
+                q.set = set;
+                q
+            }
+            // NoxiousGasCloudParticle: lives 20 ticks, draws nothing itself.
+            T::NoxiousGasCloud => {
+                let mut q = Particle::base_at(r, ty, p);
+                q.lifetime = 20;
+                q.no_render = true;
+                q.behaviour = Behaviour::NoxiousGasCloud;
+                q
+            }
+            // GeyserEruptionParticle: lives 20 ticks, draws nothing itself.
+            T::Geyser => {
+                let (water_blocks, _) = o.geyser?;
+                let mut q = Particle::base_at(r, ty, p);
+                q.lifetime = 20;
+                q.no_render = true;
+                q.behaviour = Behaviour::GeyserEruption {
+                    water_blocks,
+                    aux: v,
+                };
+                q
+            }
+            // GeyserPlumeParticle, after its provider's random placement.
+            T::GeyserPlume => {
+                let (water_blocks, _) = o.geyser?;
+                let pr = &mut self.random;
+                let at = [
+                    p[0] + f64::from((pr.next_float() - 0.5) * 0.2),
+                    p[1] + f64::from(pr.next_float()),
+                    p[2] + f64::from((pr.next_float() - 0.5) * 0.2),
+                ];
+                let plume_height = 5 * water_blocks.max(1);
+                let mut q = Particle::moving(r, ty, at, v);
+                q.has_physics = true;
+                q.speed_up_when_y_blocked = true;
+                q.lifetime = plume_height * 5;
+                q.velocity[1] = 0.0;
+                let level = &mut self.level_random;
+                let spray = [
+                    (level.next_float() - 0.5) * 0.2,
+                    (level.next_float() - 0.5) * 0.2,
+                ];
+                q.friction = 1.0;
+                let propulsion =
+                    (if water_blocks == 1 { 1.5 } else { 1.0 }) * plume_height as f32 * 1.45;
+                q.gravity = -propulsion;
+                let initial_size = q.size * 0.75;
+                let min_size = initial_size * (2.0 + plume_height as f32 / 8.0);
+                let max_size = initial_size * (3.0 + plume_height as f32 / 8.0);
+                q.size = min_size;
+                q.behaviour = Behaviour::GeyserPlume {
+                    start_y: at[1],
+                    max_y: at[1] + f64::from(plume_height) - 1.0,
+                    propulsion,
+                    spray,
+                    min_size,
+                    max_size,
+                    done: false,
+                };
                 q.set = set;
                 q
             }
@@ -3198,6 +3387,98 @@ impl ParticleEngine {
                     y_prev: p.position[1],
                 };
             }
+            Behaviour::NoxiousGas { fade_start } => {
+                p.base_tick(level);
+                self.sprite_from_age(p);
+                if p.age as f32 > fade_start {
+                    let frames_since_fade_out_start = p.age as f32 - fade_start;
+                    p.rgba[3] =
+                        (p.lifetime as f32 - frames_since_fade_out_start) / p.lifetime as f32;
+                }
+            }
+            Behaviour::NoxiousGasCloud => {
+                p.base_tick(level);
+                if p.age % 2 == 0 {
+                    let source = ParticleLevel::block_at(p.position);
+                    let spawn = pick_random_particle_spawn_point(&mut self.level_random, source);
+                    if crate::potent_sulfur::can_be_reached_by_noxious_gas(level, source, spawn) {
+                        self.spawn_noxious_gas_particle(spawn);
+                    }
+                }
+            }
+            Behaviour::GeyserEruption { water_blocks, aux } => {
+                p.base_tick(level);
+                if p.age % 2 == 0 {
+                    for _ in 0..2 {
+                        self.add(
+                            &ParticleOptions::geyser_base(
+                                ParticleType::GeyserBase,
+                                water_blocks,
+                                1.5,
+                            ),
+                            p.position,
+                            aux,
+                        );
+                    }
+                }
+                for _ in 0..water_blocks + 2 {
+                    self.add(
+                        &ParticleOptions::geyser(ParticleType::GeyserPlume, water_blocks),
+                        p.position,
+                        aux,
+                    );
+                }
+                if p.age % 10 == 0 {
+                    for _ in 0..20 {
+                        self.add(
+                            &ParticleOptions::geyser_base(
+                                ParticleType::GeyserPoof,
+                                water_blocks,
+                                2.0,
+                            ),
+                            p.position,
+                            aux,
+                        );
+                    }
+                }
+            }
+            Behaviour::GeyserPlume {
+                start_y,
+                max_y,
+                propulsion,
+                spray,
+                min_size,
+                max_size,
+                mut done,
+            } => {
+                p.base_tick(level);
+                if !done
+                    && (p.velocity[1] < 0.0
+                        || p.position[1] > max_y
+                        || p.position[1] == p.previous[1])
+                {
+                    p.lifetime = p.lifetime.min(p.age + 5);
+                    p.friction = 0.0;
+                    done = true;
+                }
+                let y_progress_linear =
+                    ((p.position[1] - start_y) / (max_y - start_y)).clamp(0.0, 1.0);
+                let y_progress_exponential = horizon_core::jmath::pow(y_progress_linear, 3.0);
+                p.gravity = propulsion * y_progress_exponential as f32 * 0.12;
+                p.velocity[0] = y_progress_linear * f64::from(spray[0]);
+                p.velocity[2] = y_progress_linear * f64::from(spray[1]);
+                self.sprite_from_age(p);
+                p.size = min_size + (y_progress_linear * f64::from(max_size - min_size)) as f32;
+                p.behaviour = Behaviour::GeyserPlume {
+                    start_y,
+                    max_y,
+                    propulsion,
+                    spray,
+                    min_size,
+                    max_size,
+                    done,
+                };
+            }
             Behaviour::BubbleColumnUp => {
                 p.base_tick(level);
                 if !p.removed && level.fluid(ParticleLevel::block_at(p.position)).0 != Fluid::Water
@@ -3818,7 +4099,7 @@ impl ParticleEngine {
                         layer: if layer {
                             crate::gfx::TRANSLUCENT_PARTICLE_OVERLAY
                         } else {
-                            0
+                            u32::from(hdr_tier(p.ty)) << 16
                         },
                         color,
                         light,
@@ -3830,6 +4111,27 @@ impl ParticleEngine {
         }
     }
 }
+/// How brightly particle `ty` shines in HDR output, as `mesher::hdr_tier`: flames and
+/// glowing drops, not their smoke. Only opaque-layer particles are marked.
+fn hdr_tier(ty: ParticleType) -> u8 {
+    use ParticleType as P;
+    match ty {
+        P::Flame
+        | P::SoulFireFlame
+        | P::CopperFireFlame
+        | P::SmallFlame
+        | P::Lava
+        | P::DrippingLava
+        | P::FallingLava
+        | P::LandingLava
+        | P::DrippingDripstoneLava
+        | P::FallingDripstoneLava => crate::mesher::INCANDESCENT,
+        P::DrippingObsidianTear | P::FallingObsidianTear | P::LandingObsidianTear => {
+            crate::mesher::LOW
+        }
+        _ => 0,
+    }
+}
 /// `Particle.LifetimeAlpha.currentAlphaForAge`.
 fn lifetime_alpha(a: [f32; 4], age: i32, lifetime: i32, partial: f32) -> f32 {
     if (a[0] - a[1]).abs() < 1.0e-5 {

crates/horizon-client-render/src/potent_sulfur.rs

@@ -0,0 +1,119 @@
+//! `PotentSulfurBlockEntity`'s reads of the level: where the noxious gas of a
+//! potent sulfur block comes out, how far a geyser throws, and whether the gas
+//! reaches a point. The client's particles and the server's nausea and
+//! launches read the level the same way, through a [`ParticleLevel`].
+use crate::{blocks::Fluid, collisions::SceneCollisions, particles::ParticleLevel};
+use horizon_core::{
+    geometry::{Vec3, traverse_blocks},
+    position::BlockPos,
+};
+
+/// `PotentSulfurBlock.ALLOWED_WATER_BLOCKS_ABOVE`.
+const ALLOWED_WATER_BLOCKS_ABOVE: i32 = 4;
+
+/// `PotentSulfurBlockEntity.isGeyserPassableBlock`: air, water, or a block
+/// with no collision shape.
+pub fn is_geyser_passable_block(level: &ParticleLevel, pos: [i32; 3]) -> bool {
+    let state = level.world.block(pos[0], pos[1], pos[2]);
+    if level.facts.is_air(state) || &*level.facts.get(state).name == "minecraft:water" {
+        return true;
+    }
+    let mut scene = SceneCollisions {
+        world: level.world,
+        binding: level.collision,
+        subject: None,
+    };
+    match level.collision.collision_shape(&mut scene, state, pos) {
+        Ok(shape) => shape.is_empty(),
+        Err(_) => !level.facts.get(state).full_collision,
+    }
+}
+
+/// `PotentSulfurBlockEntity.isWater`: the block at `pos` holds a water source
+/// (`FluidState.isSourceOfType`).
+fn is_water_source(level: &ParticleLevel, pos: [i32; 3]) -> bool {
+    let (fluid, source) = level.fluid_source(pos);
+    fluid == Fluid::Water && source
+}
+
+/// `PotentSulfurBlockEntity.findNoxiousGasSourceBlock`: the first block above
+/// the sulfur, within the water column's reach, that is not water-filled and
+/// lets gas through; None when something solid or a deeper column stops it.
+pub fn find_noxious_gas_source_block(level: &ParticleLevel, origin: [i32; 3]) -> Option<[i32; 3]> {
+    let max_y = origin[1] + ALLOWED_WATER_BLOCKS_ABOVE + 1;
+    let mut pos = [origin[0], origin[1] + 1, origin[2]];
+    while pos[1] <= max_y {
+        let state = level.world.block(pos[0], pos[1], pos[2]);
+        let is_water_block = &*level.facts.get(state).name == "minecraft:water";
+        if !is_water_source(level, pos)
+            || (!is_water_block && !is_geyser_passable_block(level, pos))
+        {
+            if level.facts.is_air(state) || is_geyser_passable_block(level, pos) {
+                return Some(pos);
+            }
+            break;
+        }
+        pos[1] += 1;
+    }
+    None
+}
+
+/// `PotentSulfurBlockEntity.getUnobstructedBlockCount`: how many blocks from
+/// `pos` up, at most six per water block, a geyser's push goes through.
+pub fn unobstructed_block_count(level: &ParticleLevel, pos: [i32; 3], water_blocks: i32) -> i32 {
+    let geyser_force_height = 6 * water_blocks;
+    for i in 0..geyser_force_height {
+        if !is_geyser_passable_block(level, [pos[0], pos[1] + i, pos[2]]) {
+            return i;
+        }
+    }
+    geyser_force_height
+}
+
+/// `PotentSulfurBlockEntity.canBeReachedByNoxiousGas`: `pos` is in a block gas
+/// can enter, within three blocks of the source block's centre, and above
+/// water the source's water can be seen from.
+pub fn can_be_reached_by_noxious_gas(
+    level: &ParticleLevel,
+    source_block: [i32; 3],
+    pos: [f64; 3],
+) -> bool {
+    let block = ParticleLevel::block_at(pos);
+    if !is_geyser_passable_block(level, block) {
+        return false;
+    }
+    let center = source_block.map(|c| f64::from(c) + 0.5);
+    let distance_sqr =
+        (center[0] - pos[0]).powi(2) + (center[1] - pos[1]).powi(2) + (center[2] - pos[2]).powi(2);
+    if distance_sqr > 9.0 {
+        return false;
+    }
+    let below_source = [center[0], f64::from(source_block[1] - 1) + 0.5, center[2]];
+    let below_pos = [pos[0], pos[1] - 1.0, pos[2]];
+    is_water_source(level, ParticleLevel::block_at(below_pos))
+        && have_line_of_sight(level, below_source, below_pos)
+}
+
+/// `PotentSulfurBlockEntity.haveLineOfSight`: a clip over collider shapes and
+/// no fluids (as the mobs' line of sight does) finds no block between the
+/// points.
+fn have_line_of_sight(level: &ParticleLevel, a: [f64; 3], b: [f64; 3]) -> bool {
+    let (from, to) = (Vec3::new(a[0], a[1], a[2]), Vec3::new(b[0], b[1], b[2]));
+    let mut scene = SceneCollisions {
+        world: level.world,
+        binding: level.collision,
+        subject: None,
+    };
+    let hit = traverse_blocks(from, to, 512, |p: BlockPos| {
+        let state = level.world.block(p.x, p.y, p.z);
+        if level.facts.is_air(state) {
+            return None;
+        }
+        let shape = level
+            .collision
+            .collision_shape(&mut scene, state, [p.x, p.y, p.z])
+            .ok()?;
+        shape.clip(from, to, p).map(|_| ())
+    });
+    !matches!(hit, Ok(Some(())))
+}

crates/horizon-client-render/src/sculk.rs

@@ -121,6 +121,10 @@ pub fn warden_can_listen(event: &str) -> bool {
         || event == SHRIEK
         || shrieker_can_listen(event)
 }
+/// `GameEventTags.ALLAY_CAN_LISTEN`: note block notes.
+pub fn allay_can_listen(event: &str) -> bool {
+    event == "minecraft:note_block_play"
+}
 /// `GameEventTags.IGNORE_VIBRATIONS_SNEAKING`.
 pub fn ignored_when_sneaking(event: &str) -> bool {
     matches!(

crates/horizon-client-render/src/section_mask.rs

@@ -0,0 +1,164 @@
+//! Sets of section indexes in a chunk column, a bit per section.
+//!
+//! Vanilla's tallest level has 254 sections (`DimensionType.Y_SIZE / 16`), and
+//! light data adds a section below and above it: 256 bits hold every layout a
+//! dimension type allows.
+
+/// Section indexes of one column, 0 being the lowest.
+#[derive(Clone, Copy, Default, PartialEq, Eq, Hash)]
+pub struct SectionMask([u64; 4]);
+
+impl SectionMask {
+    pub const CAPACITY: usize = 256;
+    pub const EMPTY: Self = Self([0; 4]);
+    pub const ALL: Self = Self([u64::MAX; 4]);
+
+    /// The indexes `0..n`.
+    pub const fn below(n: usize) -> Self {
+        let mut words = [0; 4];
+        let mut w = 0;
+        while w < 4 {
+            let bits = n.saturating_sub(w * 64);
+            words[w] = if bits >= 64 {
+                u64::MAX
+            } else {
+                (1 << bits) - 1
+            };
+            w += 1;
+        }
+        Self(words)
+    }
+    pub fn single(i: usize) -> Self {
+        let mut mask = Self::EMPTY;
+        mask.insert(i);
+        mask
+    }
+    #[inline]
+    pub fn contains(&self, i: usize) -> bool {
+        i < Self::CAPACITY && self.0[i >> 6] >> (i & 63) & 1 != 0
+    }
+    #[inline]
+    pub fn insert(&mut self, i: usize) {
+        self.0[i >> 6] |= 1 << (i & 63);
+    }
+    #[inline]
+    pub fn remove(&mut self, i: usize) {
+        self.0[i >> 6] &= !(1 << (i & 63));
+    }
+    pub fn is_empty(&self) -> bool {
+        self.0 == [0; 4]
+    }
+    pub fn len(&self) -> usize {
+        self.0.iter().map(|w| w.count_ones() as usize).sum()
+    }
+    /// The indexes from `i` up.
+    pub fn from(self, i: usize) -> Self {
+        self & !Self::below(i)
+    }
+    /// The indexes, lowest first.
+    pub fn iter(self) -> Indexes {
+        Indexes(self)
+    }
+}
+
+impl std::ops::BitOr for SectionMask {
+    type Output = Self;
+    fn bitor(self, other: Self) -> Self {
+        Self(std::array::from_fn(|w| self.0[w] | other.0[w]))
+    }
+}
+impl std::ops::BitOrAssign for SectionMask {
+    fn bitor_assign(&mut self, other: Self) {
+        *self = *self | other;
+    }
+}
+impl std::ops::BitAnd for SectionMask {
+    type Output = Self;
+    fn bitand(self, other: Self) -> Self {
+        Self(std::array::from_fn(|w| self.0[w] & other.0[w]))
+    }
+}
+impl std::ops::Not for SectionMask {
+    type Output = Self;
+    fn not(self) -> Self {
+        Self(self.0.map(|w| !w))
+    }
+}
+impl std::fmt::Debug for SectionMask {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_set().entries(self.iter()).finish()
+    }
+}
+impl FromIterator<usize> for SectionMask {
+    fn from_iter<I: IntoIterator<Item = usize>>(indexes: I) -> Self {
+        let mut mask = Self::EMPTY;
+        for i in indexes {
+            mask.insert(i);
+        }
+        mask
+    }
+}
+
+/// `SectionMask::iter`: the set's indexes in ascending order.
+#[derive(Clone, Copy, Debug)]
+pub struct Indexes(SectionMask);
+impl Iterator for Indexes {
+    type Item = usize;
+    #[inline]
+    fn next(&mut self) -> Option<usize> {
+        let words = &mut (self.0).0;
+        let w = words.iter().position(|&w| w != 0)?;
+        let bit = words[w].trailing_zeros() as usize;
+        words[w] &= words[w] - 1;
+        Some(w * 64 + bit)
+    }
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.0.len();
+        (len, Some(len))
+    }
+}
+impl ExactSizeIterator for Indexes {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sets_across_words() {
+        let mut mask = SectionMask::EMPTY;
+        for i in [0, 23, 63, 64, 130, 255] {
+            mask.insert(i);
+        }
+        assert_eq!(mask.iter().collect::<Vec<_>>(), [0, 23, 63, 64, 130, 255]);
+        assert_eq!(mask.len(), 6);
+        assert!(mask.contains(130) && !mask.contains(131) && !mask.contains(300));
+        mask.remove(64);
+        assert_eq!(mask.from(24).iter().collect::<Vec<_>>(), [63, 130, 255]);
+        assert_eq!(mask.from(256), SectionMask::EMPTY);
+        assert_eq!(mask.from(0), mask);
+        assert!(SectionMask::EMPTY.is_empty() && !mask.is_empty());
+    }
+
+    #[test]
+    fn below_counts_whole_and_partial_words() {
+        for n in [0, 1, 24, 63, 64, 65, 131, 254, 256] {
+            let mask = SectionMask::below(n);
+            assert_eq!(mask.len(), n);
+            assert_eq!(mask.iter().collect::<Vec<_>>(), (0..n).collect::<Vec<_>>());
+        }
+        assert_eq!(SectionMask::below(1000), SectionMask::ALL);
+    }
+
+    #[test]
+    fn operators() {
+        let a: SectionMask = [1, 70, 200].into_iter().collect();
+        let b: SectionMask = [70, 3].into_iter().collect();
+        assert_eq!((a | b).iter().collect::<Vec<_>>(), [1, 3, 70, 200]);
+        assert_eq!((a & b).iter().collect::<Vec<_>>(), [70]);
+        assert_eq!(
+            (!a & SectionMask::below(4)).iter().collect::<Vec<_>>(),
+            [0, 2, 3]
+        );
+        assert_eq!(format!("{a:?}"), "{1, 70, 200}");
+    }
+}

crates/horizon-client-render/src/settings.rs

@@ -150,6 +150,8 @@ pub struct Settings {
     pub chat_links: bool,
     pub chat_links_prompt: bool,
     pub chat_opacity: f32,
+    /// Chat Delay in seconds (`chatDelay`): player chat shows this far apart.
+    pub chat_delay: f64,
     pub text_background_opacity: f32,
     pub chat_scale: f32,
     pub chat_width: f32,
@@ -246,6 +248,7 @@ impl Default for Settings {
             chat_links: true,
             chat_links_prompt: true,
             chat_opacity: 1.0,
+            chat_delay: 0.0,
             text_background_opacity: 0.5,
             chat_scale: 1.0,
             chat_width: 1.0,
@@ -448,6 +451,7 @@ impl Settings {
             chat_links: f.bool("chatLinks"),
             chat_links_prompt: f.bool("chatLinksPrompt"),
             chat_opacity: f.double("chatOpacity") as f32,
+            chat_delay: f.double("chatDelay"),
             text_background_opacity: f.double("textBackgroundOpacity") as f32,
             chat_scale: f.double("chatScale") as f32,
             chat_width: f.double("chatWidth") as f32,
@@ -551,6 +555,9 @@ impl Settings {
         put_b(&mut f, "chatLinks", self.chat_links);
         put_b(&mut f, "chatLinksPrompt", self.chat_links_prompt);
         put_f(&mut f, "chatOpacity", self.chat_opacity);
+        if self.chat_delay != f.double("chatDelay") {
+            f.set("chatDelay", V::Double(self.chat_delay));
+        }
         put_f(
             &mut f,
             "textBackgroundOpacity",

crates/horizon-client-render/src/signs.rs

@@ -31,9 +31,45 @@ impl Default for SignText {
             lines: Default::default(),
             color: BLACK,
             glowing: false,
+            click: Default::default(),
         }
     }
 }
+/// The click events `SignBlockEntity.executeClickCommandsIfPresent` acts on.
+#[derive(Debug, PartialEq)]
+pub enum ClickAction<'a> {
+    /// `ClickEvent.RunCommand`.
+    RunCommand(String),
+    /// `ClickEvent.ShowDialog`: a registry id or the dialog itself.
+    ShowDialog(&'a Tag),
+    /// `ClickEvent.Custom`.
+    Custom {
+        id: String,
+        payload: Option<&'a Tag>,
+    },
+}
+/// A saved `click_event` as its action: the three a sign acts on, read the
+/// way `ClickEvent.CODEC` does; any other action or a malformed one is None.
+pub fn click_action(event: &Tag) -> Option<ClickAction<'_>> {
+    let Some(Tag::String(action)) = event.get("action") else {
+        return None;
+    };
+    match action.to_string_lossy().as_str() {
+        "run_command" => match event.get("command") {
+            Some(Tag::String(command)) => Some(ClickAction::RunCommand(command.to_string_lossy())),
+            _ => None,
+        },
+        "show_dialog" => event.get("dialog").map(ClickAction::ShowDialog),
+        "custom" => match event.get("id") {
+            Some(Tag::String(id)) => Some(ClickAction::Custom {
+                id: id.to_string_lossy(),
+                payload: event.get("payload"),
+            }),
+            _ => None,
+        },
+        _ => None,
+    }
+}
 impl SignText {
     pub fn is_empty(&self) -> bool {
         self.lines.iter().all(String::is_empty)
@@ -42,6 +78,14 @@ impl SignText {
     pub fn text_color(&self) -> u32 {
         DYE_TEXT[usize::from(self.color.min(15))].1
     }
+    /// `SignText.hasAnyClickCommands`: a line whose style has a `run_command`
+    /// click event.
+    pub fn has_any_click_commands(&self) -> bool {
+        self.click
+            .iter()
+            .flatten()
+            .any(|event| matches!(click_action(event), Some(ClickAction::RunCommand(_))))
+    }
     /// `AbstractSignRenderer.getDarkColor`.
     pub fn dark_color(&self) -> u32 {
         let c = self.text_color();
@@ -70,6 +114,13 @@ impl SignData {
     pub fn line_height(&self) -> f32 {
         if self.hanging { 9.0 } else { 10.0 }
     }
+    /// `SignBlockEntity.canExecuteClickCommands`: a waxed sign whose side
+    /// has a `run_command` click event. (Horizon keeps no filtered text, so
+    /// `Player.isTextFilteringEnabled` never selects it.)
+    pub fn can_execute_click_commands(&self, front: bool) -> bool {
+        let side = if front { &self.front } else { &self.back };
+        self.waxed && side.has_any_click_commands()
+    }
     /// NBT entries after the common block-entity header.
     pub fn encode(&self) -> Vec<(&'static str, Tag)> {
         let side = |t: &SignText| {
@@ -79,7 +130,18 @@ impl SignData {
                     Tag::List(
                         t.lines
                             .iter()
-                            .map(|l| Tag::String(l.as_str().into()))
+                            .zip(&t.click)
+                            .map(|(line, click)| {
+                                let text = Tag::String(line.as_str().into());
+                                match click {
+                                    // The line's style keeps its click event.
+                                    Some(event) => Tag::compound([
+                                        ("text", text),
+                                        ("click_event", event.clone()),
+                                    ]),
+                                    None => text,
+                                }
+                            })
                             .collect(),
                     ),
                 ),
@@ -90,19 +152,25 @@ impl SignData {
                 ("has_glowing_text", Tag::Byte(i8::from(t.glowing))),
             ])
         };
-        vec![
+        let mut out = Vec::new();
+        if self.allow_op_features {
+            out.push(("allow_op_features", Tag::Byte(1)));
+        }
+        out.extend([
             ("front_text", side(&self.front)),
             ("back_text", side(&self.back)),
             ("is_waxed", Tag::Byte(i8::from(self.waxed))),
-        ]
+        ]);
+        out
     }
     pub fn decode(&mut self, tag: &Tag) {
         let side = |t: Option<&Tag>| -> SignText {
             let mut out = SignText::default();
             let Some(t) = t else { return out };
             if let Some(Tag::List(messages)) = t.get("messages") {
-                for (line, m) in out.lines.iter_mut().zip(messages) {
+                for ((line, click), m) in out.lines.iter_mut().zip(&mut out.click).zip(messages) {
                     *line = component_text(m);
+                    *click = click_event(m);
                 }
             }
             if let Some(Tag::String(c)) = t.get("color") {
@@ -117,6 +185,21 @@ impl SignData {
         self.front = side(tag.get("front_text"));
         self.back = side(tag.get("back_text"));
         self.waxed = matches!(tag.get("is_waxed"), Some(Tag::Byte(b)) if *b != 0);
+        self.allow_op_features =
+            matches!(tag.get("allow_op_features"), Some(Tag::Byte(b)) if *b != 0);
+    }
+}
+/// The `click_event` in the style of a stored line: the one of a component
+/// object, or of the first component of a list (`createFromList` copies it
+/// and appends the rest as siblings).
+fn click_event(tag: &Tag) -> Option<Tag> {
+    let root = match tag {
+        Tag::List(list) => list.first()?,
+        other => other,
+    };
+    match root.get("click_event") {
+        Some(event @ Tag::Compound(_)) => Some(event.clone()),
+        _ => None,
     }
 }
 /// Plain text of a stored text component (string, `{text: ...}` or JSON string).

crates/horizon-client-render/src/skins.rs

@@ -468,7 +468,10 @@ pub fn head_skin(
     {
         let location = skin_location(&hash);
         match downloads.state(Kind::Skin, &url) {
-            Download::Ready if atlas(&location) => return location,
+            Download::Ready if atlas(&location) => {
+                downloads.drawn(&location);
+                return location;
+            }
             // Its slot was evicted: offer the image again.
             Download::Ready => {
                 downloads.again(&location);
@@ -681,6 +684,8 @@ pub struct Downloader {
     /// atlas uploads again (`again`); the disk cache backs anything dropped.
     images: std::collections::HashMap<String, Vec<u8>>,
     image_order: std::collections::VecDeque<String>,
+    /// Skins and capes drawn from the atlas since `take_drawn`.
+    drawn: std::collections::HashSet<String>,
 }
 /// `images` is bounded only so a long session on a busy server does not grow
 /// without end; the disk cache holds everything it drops.
@@ -697,6 +702,7 @@ impl Downloader {
             queued: Default::default(),
             images: Default::default(),
             image_order: Default::default(),
+            drawn: Default::default(),
         }
     }
     /// How the download of `url` stands, starting it the first time.
@@ -801,6 +807,77 @@ impl Downloader {
         }
         std::mem::take(&mut self.ready)
     }
+    /// A skin or cape in the atlas drawn this frame: `SkinSlots` keeps its slot.
+    pub fn drawn(&mut self, location: &str) {
+        if !self.drawn.contains(location) {
+            self.drawn.insert(location.to_owned());
+        }
+    }
+    /// The skins and capes drawn since the last call.
+    pub fn take_drawn(&mut self) -> std::collections::HashSet<String> {
+        std::mem::take(&mut self.drawn)
+    }
+}
+
+/// Which downloaded skins and capes hold the atlas's skin slots
+/// (`hud::SKIN_SLOTS`). Vanilla's `SkinManager.TextureCache.getOrLoad`
+/// registers a texture per skin and keeps it. Here the slots are shared: a
+/// new skin takes a free slot, else the least recently drawn skin's, but
+/// never one drawn in the last frame. With every slot drawn, the new skin
+/// waits (its player keeps the default skin) instead of pushing out one in
+/// use, which then came back by pushing out another, so players vanished
+/// for a frame and heads swapped textures as the slots went round.
+pub struct SkinSlots {
+    capacity: usize,
+    /// Stored locations and their slot, the least recently drawn first.
+    slots: Vec<(String, usize)>,
+    /// Drawn in the last frame, or stored since: kept from eviction.
+    kept: std::collections::HashSet<String>,
+}
+impl SkinSlots {
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            capacity,
+            slots: Vec::new(),
+            kept: Default::default(),
+        }
+    }
+    /// Whether `location` is in a slot.
+    pub fn contains(&self, location: &str) -> bool {
+        self.slots.iter().any(|(l, _)| l == location)
+    }
+    /// A new frame: the skins `drawn` in the last one
+    /// (`Downloader::take_drawn`) become the most recently drawn, and keep
+    /// their slots through this frame's `place`s.
+    pub fn next_frame(&mut self, drawn: std::collections::HashSet<String>) {
+        let (recent, old): (Vec<_>, Vec<_>) = std::mem::take(&mut self.slots)
+            .into_iter()
+            .partition(|(l, _)| drawn.contains(l));
+        self.slots = old;
+        self.slots.extend(recent);
+        self.kept = drawn;
+    }
+    /// A slot for `location`: its own, a free one, else the least recently
+    /// drawn one not kept, with the location it held. `None` while every
+    /// slot is kept.
+    pub fn place(&mut self, location: String) -> Option<(usize, Option<String>)> {
+        if let Some((_, slot)) = self.slots.iter().find(|(l, _)| *l == location) {
+            return Some((*slot, None));
+        }
+        let (slot, evicted) = if self.slots.len() < self.capacity {
+            (self.slots.len(), None)
+        } else {
+            let i = self
+                .slots
+                .iter()
+                .position(|(l, _)| !self.kept.contains(l))?;
+            let (old, slot) = self.slots.remove(i);
+            (slot, Some(old))
+        };
+        self.kept.insert(location.clone());
+        self.slots.push((location, slot));
+        Some((slot, evicted))
+    }
 }
 
 /// A GET over HTTP or HTTPS (textures.minecraft.net serves both; vanilla
@@ -999,6 +1076,63 @@ mod tests {
         assert!(super::resolve_profile(&super::NameOrId::Name("Notch".into()), &doc).is_none());
     }
 
+    /// More skins drawn every frame than there are slots (#3829): a frame's
+    /// uploads used to push out skins drawn the frame before, which then
+    /// uploaded again and pushed out others, so the drawn skins went missing
+    /// in turn. Those drawn keep their slots; the rest wait.
+    #[test]
+    fn skins_drawn_last_frame_keep_their_slots() {
+        let mut d = super::Downloader::new(std::env::temp_dir().join("horizon-test-skin-slots"));
+        let skins: Vec<String> = (0..6).map(|i| format!("skins/{i}")).collect();
+        for (i, s) in skins.iter().enumerate() {
+            d.remember(s.clone(), vec![i as u8]);
+        }
+        let mut slots = super::SkinSlots::new(4);
+        let mut last: Option<Vec<String>> = None;
+        for frame in 0..8 {
+            // draw_tab_list: the downloads that finished go to the atlas.
+            slots.next_frame(d.take_drawn());
+            let mut uploads = 0;
+            for (location, _) in d.take_ready() {
+                if slots.place(location).is_some() {
+                    uploads += 1;
+                }
+            }
+            // update_remote_skins: every skin is drawn, from its slot, or
+            // asked for again while it has none.
+            let mut shown = Vec::new();
+            for s in &skins {
+                if slots.contains(s) {
+                    d.drawn(s);
+                    shown.push(s.clone());
+                } else {
+                    d.again(s);
+                }
+            }
+            if frame >= 2 {
+                assert_eq!(uploads, 0, "frame {frame} uploaded again");
+                assert_eq!(Some(&shown), last.as_ref(), "frame {frame} lost a skin");
+            }
+            // The first frame asks for the skins; from the next, four show.
+            assert_eq!(shown.len(), if frame == 0 { 0 } else { 4 });
+            last = Some(shown);
+        }
+        // A skin no longer drawn gives up its slot to a waiting one.
+        let mut slots = super::SkinSlots::new(2);
+        slots.next_frame(Default::default());
+        assert_eq!(slots.place("skins/a".into()), Some((0, None)));
+        assert_eq!(slots.place("skins/b".into()), Some((1, None)));
+        assert_eq!(slots.place("skins/c".into()), None);
+        slots.next_frame(["skins/b".to_owned()].into());
+        assert_eq!(
+            slots.place("skins/c".into()),
+            Some((0, Some("skins/a".into())))
+        );
+        // Stored this frame, kept through it.
+        assert_eq!(slots.place("skins/d".into()), None);
+        assert!(slots.contains("skins/b") && slots.contains("skins/c"));
+    }
+
     /// A skin evicted from the atlas re-uploads (`again`), once per ask.
     #[test]
     fn evicted_skins_upload_again() {

crates/horizon-client-render/src/sprites.rs

@@ -159,6 +159,14 @@ impl Sprites {
     /// up to a power of two and limited to [`MAX_ARRAY_BYTES`]. Smaller
     /// textures are scaled up by whole pixels, so UVs stay per layer.
     pub fn finish(&mut self) {
+        self.lay_out(true);
+    }
+    /// [`Sprites::finish`] for a server, which draws nothing: the layers'
+    /// size, but neither their pixels nor the animations' frames.
+    pub fn finish_without_pixels(&mut self) {
+        self.lay_out(false);
+    }
+    fn lay_out(&mut self, pixels: bool) {
         let layers = self.native.len().max(1) as u64;
         let largest = self.native.iter().map(|n| n.0).max().unwrap_or(SPRITE_SIZE);
         self.minimum_size = self.native.iter().map(|n| n.0).min().unwrap_or(SPRITE_SIZE);
@@ -166,6 +174,12 @@ impl Sprites {
         while size > SPRITE_SIZE && layers * u64::from(size * size) * 4 > MAX_ARRAY_BYTES {
             size /= 2;
         }
+        if !pixels {
+            self.pixels = Vec::new();
+            self.animations = Vec::new();
+            self.size = size;
+            return;
+        }
         let mut resized = Vec::with_capacity(self.native.len());
         self.pixels.clear();
         for (from, frames, initial) in &self.native {

crates/horizon-client-render/src/streaming.rs

@@ -4,7 +4,7 @@
 //! so stale work is dropped.
 use crate::fast_hash::{FxHashMap, FxHashSet};
 use crate::{
-    chunk::{Chunk, SECTIONS},
+    chunk::Chunk,
     light::{LightChanges, LightTables, apply_lighting, apply_relighting, light_chunk},
     mesher::{MeshTables, Mesher, Region, SectionMesh, borrow},
     world::World,
@@ -16,11 +16,15 @@ use std::{
     collections::{BinaryHeap, HashSet, VecDeque},
     sync::{
         Arc, Condvar, Mutex, MutexGuard, RwLock, TryLockError,
-        atomic::{AtomicBool, Ordering},
+        atomic::{AtomicBool, AtomicUsize, Ordering},
     },
     thread,
 };
 
+/// How long a worker waits with nothing to do before it gives back its
+/// generator's scratch buffers ([`ChunkGenerator::idle`]).
+pub const IDLE_RELEASE: std::time::Duration = std::time::Duration::from_secs(5);
+
 /// A chunk under generation, opaque to the streamer.
 pub type Proto = Box<dyn std::any::Any + Send>;
 /// Chunk generation in vanilla's stages: a neighbour-independent proto chunk
@@ -57,6 +61,9 @@ pub trait ChunkGenerator: Send + Sync + 'static {
     /// What a loaded chunk needs from the generator before the game uses it,
     /// on the worker that loaded it.
     fn prepare_loaded(&self, _worker: &mut Self::Worker, _chunk: &Chunk) {}
+    /// The worker has had nothing to do for [`IDLE_RELEASE`]: give back what
+    /// it keeps between jobs only to go faster.
+    fn idle(&self, _worker: &mut Self::Worker) {}
     fn proto(&self, worker: &mut Self::Worker, x: i32, z: i32) -> Proto;
     fn decorates(&self) -> bool {
         false
@@ -220,6 +227,9 @@ struct Shared {
     /// packs reload; each mesh job takes the current one.
     context: RwLock<Arc<WorkerContext>>,
     done: Mailbox,
+    /// Workers that have freed their buffers ([`IDLE_RELEASE`]) and taken no
+    /// job since: the last of them gives the freed memory back to the OS.
+    released: AtomicUsize,
 }
 /// Finished jobs, from the workers to the game thread, in the order they
 /// finished. Not an `mpsc` channel: its receiver waits for a sender it finds
@@ -275,6 +285,11 @@ pub struct Streaming {
     generation_scan: GenerationScan,
     /// Proto chunks: `None` while checked out to a decoration or save job.
     protos: FxHashMap<(i32, i32), Option<Proto>>,
+    /// The light jobs' views of proto chunks past the area (`light_region`),
+    /// built once per proto: each is a neighbour of up to three columns and
+    /// waits in failed regions until the last one loads. Dropped whenever
+    /// the proto is checked out, replaced or removed.
+    light_views: FxHashMap<(i32, i32), Arc<Chunk>>,
     decorated: FxHashSet<(i32, i32)>,
     decorating: usize,
     /// Save jobs in flight.
@@ -305,6 +320,8 @@ pub struct Streaming {
     deferred: Vec<Done>,
     sequence: u64,
     pub center: (i32, i32),
+    /// The view distance around `center`; below 0, no area there (a dedicated
+    /// server nobody is on).
     pub radius: i32,
     /// `/forceload`ed chunks: kept loaded whatever the distance.
     pub forced: HashSet<(i32, i32)>,
@@ -444,8 +461,14 @@ impl GenerationScan {
                     wanted.push((input.ranges.priority(x, z, input.loading), x, z));
                 }
             }
-            // Forced chunks and their generation neighbourhood.
-            let reach = margin - 1;
+            // Forced chunks and their generation neighbourhood: the ring that
+            // is decorated (or finished, without decoration) and the one its
+            // 3x3 needs.
+            let reach = if input.decorates {
+                FORCED_TERRAIN_RING
+            } else {
+                FORCED_FEATURES_RING
+            };
             for &(fx, fz) in input.ranges.forced {
                 for dz in -reach..=reach {
                     for dx in -reach..=reach {
@@ -502,7 +525,9 @@ impl Streaming {
             stop: AtomicBool::new(false),
             context: RwLock::new(context.clone()),
             done: Mailbox::default(),
+            released: AtomicUsize::new(0),
         });
+        let workers = threads.max(1);
         let light_tables = context.light.clone();
         let saves: Arc<dyn Saves> = generator.clone();
         let threads = (0..threads.max(1))
@@ -523,14 +548,42 @@ impl Streaming {
                         loop {
                             let job = {
                                 let mut queue = shared.queue.lock().unwrap();
+                                let mut released = false;
                                 loop {
                                     if shared.stop.load(Ordering::Relaxed) {
                                         return;
                                     }
                                     if let Some(job) = queue.pop() {
+                                        if released {
+                                            shared.released.fetch_sub(1, Ordering::Relaxed);
+                                        }
                                         break job.job;
                                     }
-                                    queue = shared.ready.wait(queue).unwrap();
+                                    if released {
+                                        queue = shared.ready.wait(queue).unwrap();
+                                        continue;
+                                    }
+                                    let (woken, wait) =
+                                        shared.ready.wait_timeout(queue, IDLE_RELEASE).unwrap();
+                                    queue = woken;
+                                    if wait.timed_out() && queue.is_empty() {
+                                        // A server nobody is on, a client standing still:
+                                        // free the generator's buffers (and the mesher's
+                                        // face cache) until the next job needs them.
+                                        drop(queue);
+                                        generator.idle(&mut worker);
+                                        faces = None;
+                                        released = true;
+                                        // The allocator keeps freed pages until memory
+                                        // runs short: once every worker has freed its own,
+                                        // hand them back.
+                                        if shared.released.fetch_add(1, Ordering::Relaxed) + 1
+                                            == workers
+                                        {
+                                            horizon_threads::release_free_memory();
+                                        }
+                                        queue = shared.queue.lock().unwrap();
+                                    }
                                 }
                             };
                             let done = match job {
@@ -610,6 +663,7 @@ impl Streaming {
             generating: Default::default(),
             generation_scan: GenerationScan::default(),
             protos: Default::default(),
+            light_views: Default::default(),
             decorated: Default::default(),
             decorating: 0,
             saving: 0,
@@ -665,7 +719,7 @@ impl Streaming {
         self.meshing.clear();
         for &(x, z) in world.chunks.keys() {
             if self.lit.contains(&(x, z)) {
-                for sy in 0..SECTIONS as i32 {
+                for sy in 0..world.layout().sections() as i32 {
                     world.dirty_sections.insert((x, sy, z));
                 }
             }
@@ -683,7 +737,7 @@ impl Streaming {
         self.generated_total += 1;
         for dz in -1..=1 {
             for dx in -1..=1 {
-                for sy in 0..SECTIONS as i32 {
+                for sy in 0..world.layout().sections() as i32 {
                     world.dirty_sections.insert((key.0 + dx, sy, key.1 + dz));
                 }
             }
@@ -698,7 +752,7 @@ impl Streaming {
                 for dy in -1..=1 {
                     for dx in -1..=1 {
                         let s = sy as i32 + dy;
-                        if (0..SECTIONS as i32).contains(&s) {
+                        if (0..world.layout().sections() as i32).contains(&s) {
                             world.dirty_sections.insert((x + dx, s, z + dz));
                         }
                     }
@@ -724,7 +778,7 @@ impl Streaming {
         self.lighting.remove(&(x, z));
         // By key, not by a pass over every pending section: a moved or
         // shrunk storage forgets thousands of columns in one frame.
-        for sy in 0..SECTIONS as i32 {
+        for sy in 0..world.layout().sections() as i32 {
             self.meshing.remove(&(x, sy, z));
             self.waiting.remove(&(x, sy, z));
         }
@@ -770,6 +824,7 @@ impl Streaming {
         self.decorated.insert((x, z));
         for (i, proto) in region.into_iter().enumerate() {
             let key = (x + (i % 3) as i32 - 1, z + (i / 3) as i32 - 1);
+            self.light_views.remove(&key);
             self.protos.insert(key, Some(proto));
             self.written.insert(key);
         }
@@ -780,6 +835,7 @@ impl Streaming {
         self.generation_scan.exhausted = false;
         self.saving -= 1;
         for (key, proto) in protos {
+            self.light_views.remove(&key);
             self.protos.insert(key, Some(proto));
         }
     }
@@ -787,7 +843,11 @@ impl Streaming {
     fn save_checked_out(&mut self, keys: impl IntoIterator<Item = (i32, i32)>) {
         let protos: Vec<((i32, i32), Proto)> = keys
             .into_iter()
-            .filter_map(|k| Some((k, self.protos.get_mut(&k)?.take()?)))
+            .filter_map(|k| {
+                let proto = self.protos.get_mut(&k)?.take()?;
+                self.light_views.remove(&k);
+                Some((k, proto))
+            })
             .collect();
         if !protos.is_empty() {
             self.saving += 1;
@@ -836,7 +896,7 @@ impl Streaming {
         world.chunks.insert(key, Arc::new(chunk));
         if loaded {
             self.lit.insert(key);
-            for sy in 0..SECTIONS as i32 {
+            for sy in 0..world.layout().sections() as i32 {
                 world.dirty_sections.insert((key.0, sy, key.1));
             }
         }
@@ -856,7 +916,7 @@ impl Streaming {
     /// The 3x3 a light job reads: the finished columns, and for a neighbour
     /// that will not finish (past the area), its decorated proto chunk, as
     /// vanilla lights its last FULL ring against neighbours at FEATURES.
-    fn light_region(&self, world: &World, x: i32, z: i32) -> Option<Box<Region>> {
+    fn light_region(&mut self, world: &World, x: i32, z: i32) -> Option<Box<Region>> {
         let mut region: Region = Default::default();
         for dz in 0..3 {
             for dx in 0..3 {
@@ -864,8 +924,14 @@ impl Streaming {
                 region[dz][dx] = Some(match world.chunks.get(&n) {
                     Some(chunk) => chunk.clone(),
                     None if !self.in_range(n.0, n.1, 1) && self.decorated.contains(&n) => {
-                        let proto = self.protos.get(&n)?.as_ref()?;
-                        Arc::new((self.light_view)(proto)?)
+                        if let Some(view) = self.light_views.get(&n) {
+                            view.clone()
+                        } else {
+                            let proto = self.protos.get(&n)?.as_ref()?;
+                            let view = Arc::new((self.light_view)(proto)?);
+                            self.light_views.insert(n, view.clone());
+                            view
+                        }
                     }
                     None => return None,
                 });
@@ -975,6 +1041,7 @@ impl Streaming {
                     self.generation_scan.exhausted = false;
                     self.generating.remove(&(x, z));
                     if self.in_range(x, z, 4) || self.near_finished(x, z, 2) {
+                        self.light_views.remove(&(x, z));
                         self.protos.insert((x, z), Some(proto));
                         if decorated || !self.decorates {
                             self.decorated.insert((x, z));
@@ -1012,7 +1079,7 @@ impl Streaming {
                         if first {
                             for dz in -1..=1 {
                                 for dx in -1..=1 {
-                                    for sy in 0..SECTIONS as i32 {
+                                    for sy in 0..world.layout().sections() as i32 {
                                         world.dirty_sections.insert((x + dx, sy, z + dz));
                                     }
                                 }
@@ -1080,13 +1147,15 @@ impl Streaming {
                 .iter()
                 .filter(|&(&(x, z), p)| {
                     p.is_some()
-                        && i64::from(x - center.0).pow(2) + i64::from(z - center.1).pow(2) > r4 * r4
+                        && (self.radius < 0
+                            || i64::from(x - center.0).pow(2) + i64::from(z - center.1).pow(2)
+                                > r4 * r4)
                         && !ranges.in_extra(x, z, 4)
                         && !ranges.in_band(x, z, 4)
-                        && !ranges
-                            .forced
-                            .iter()
-                            .any(|f| (x - f.0).abs() <= 3 && (z - f.1).abs() <= 3)
+                        && !ranges.forced.iter().any(|f| {
+                            (x - f.0).abs() <= FORCED_TERRAIN_RING
+                                && (z - f.1).abs() <= FORCED_TERRAIN_RING
+                        })
                 })
                 .map(|(k, _)| *k)
                 .collect();
@@ -1101,6 +1170,7 @@ impl Streaming {
                     written.push(key);
                 } else {
                     self.protos.remove(&key);
+                    self.light_views.remove(&key);
                 }
             }
             self.save_checked_out(written);
@@ -1130,6 +1200,7 @@ impl Streaming {
                     .remove(&(x, z))
                     .flatten()
                     .expect("present proto");
+                self.light_views.remove(&(x, z));
                 self.finishing.insert((x, z));
                 self.written.remove(&(x, z));
                 self.submit(Some((x, z)), 0, Job::Finish(proto));
@@ -1228,6 +1299,7 @@ impl Streaming {
                 let region: Vec<Proto> = keys
                     .iter()
                     .map(|k| {
+                        self.light_views.remove(k);
                         self.protos
                             .insert(*k, None)
                             .flatten()
@@ -1303,7 +1375,7 @@ impl Streaming {
             }
             if !self.ranges().in_view(x, z) {
                 world.dirty_sections.take_column(x, z);
-                for sy in section_indexes(sections) {
+                for sy in sections.iter().map(|sy| sy as i32) {
                     self.waiting.insert((x, sy, z));
                 }
                 continue;
@@ -1327,7 +1399,7 @@ impl Streaming {
                 continue;
             };
             world.dirty_sections.take_column(x, z);
-            for sy in section_indexes(sections) {
+            for sy in sections.iter().map(|sy| sy as i32) {
                 let first = self.meshed.insert((x, z));
                 self.sequence += 1;
                 self.meshing.insert((x, sy, z), self.sequence);
@@ -1444,7 +1516,7 @@ impl Streaming {
     fn mark_light_changes(world: &mut World, changed: &LightChanges) {
         if let Some(log) = &mut world.light_log {
             for (x, sy, z) in changed.sections() {
-                *log.entry((x, z)).or_default() |= 1 << sy;
+                log.entry((x, z)).or_default().insert(sy as usize);
             }
         }
         changed.dirty_sections(|section| {
@@ -1528,6 +1600,16 @@ impl Streaming {
     fn in_range(&self, x: i32, z: i32, margin: i32) -> bool {
         self.ranges().in_range(x, z, margin)
     }
+    /// Rank the 3x3 a chunk loaded to FULL decorates, in one generation
+    /// task's order (`ChunkGenerationTask`: x-outer, z-inner), after every
+    /// chunk ranked before.
+    pub fn rank_full_task(&mut self, x: i32, z: i32) {
+        for dx in -1..=1 {
+            for dz in -1..=1 {
+                self.decoration_order.rank_or_append(x + dx, z + dz);
+            }
+        }
+    }
     pub fn band(&self) -> Option<Band> {
         self.band
     }
@@ -1606,6 +1688,14 @@ pub fn in_view_distance(center: (i32, i32), radius: i32, x: i32, z: i32) -> bool
     let (dx, dz) = (gap(x - center.0), gap(z - center.1));
     dx * dx + dz * dz < i64::from(radius) * i64::from(radius)
 }
+/// The rings around a `/forceload`ed chunk, in chunks. Vanilla's FORCED
+/// ticket is level 31 (`ChunkMap.FORCED_TICKET_LEVEL`), the level rises one
+/// per ring (`ChunkTracker.computeLevelFromNeighbor`), and the level picks
+/// the column's status (`ChunkLevel.generationStatus`): full (33) two rings
+/// out, features (34) at three, terrain (35) at four.
+const FORCED_FULL_RING: i32 = 2;
+const FORCED_FEATURES_RING: i32 = 3;
+const FORCED_TERRAIN_RING: i32 = 4;
 /// The areas kept loaded: circles around the player and `extra`, and forced chunks.
 struct Ranges<'a> {
     center: (i32, i32),
@@ -1825,7 +1915,7 @@ impl Ranges<'_> {
         let (dx, dz) = (gap(x - self.center.0), gap(z - self.center.1));
         let r = i64::from(self.radius + 1);
         // The extra areas are squares: their finished square grown by `reach`.
-        dx * dx + dz * dz <= r * r
+        (self.radius >= 0 && dx * dx + dz * dz <= r * r)
             || self.in_extra(x, z, 1 + reach)
             || self.in_band(x, z, 1 + reach)
     }
@@ -1858,10 +1948,19 @@ impl Ranges<'_> {
     fn in_main_range(&self, x: i32, z: i32, margin: i32) -> bool {
         let r = i64::from(self.radius + margin);
         let (dx, dz) = (i64::from(x - self.center.0), i64::from(z - self.center.1));
-        if dx * dx + dz * dz <= r * r {
+        if self.radius >= 0 && dx * dx + dz * dz <= r * r {
             return true;
         }
-        let reach = (margin - 1).max(0);
+        // A forced chunk holds a FORCED ticket at level 31
+        // (`ChunkMap.FORCED_TICKET_LEVEL`), and the level rises one per ring
+        // (`ChunkTracker.computeLevelFromNeighbor`): the margin is the
+        // vanilla status ring the caller asks for.
+        let reach = match margin {
+            1 => FORCED_FULL_RING,
+            2 => FORCED_FEATURES_RING,
+            3 => FORCED_TERRAIN_RING,
+            _ => margin + 1,
+        };
         self.forced
             .iter()
             .any(|f| (x - f.0).abs() <= reach && (z - f.1).abs() <= reach)
@@ -1886,16 +1985,6 @@ impl Drop for Streaming {
         }
     }
 }
-/// The section indexes set in a column's bits, lowest first.
-fn section_indexes(mut bits: u32) -> impl Iterator<Item = i32> {
-    std::iter::from_fn(move || {
-        (bits != 0).then(|| {
-            let sy = bits.trailing_zeros() as i32;
-            bits &= bits - 1;
-            sy
-        })
-    })
-}
 /// The queued jobs' priorities computed again from each one's column
 /// `distance` (`Streaming::submit`).
 fn rank_again(queue: &mut BinaryHeap<Queued>, distance: impl Fn(i32, i32) -> i64) {
@@ -2130,9 +2219,14 @@ mod tests {
                 }
             }
         }
+        let forced_reach = if input.decorates {
+            FORCED_TERRAIN_RING
+        } else {
+            FORCED_FEATURES_RING
+        };
         for &(fx, fz) in input.ranges.forced {
-            for dz in -(margin - 1)..=(margin - 1) {
-                for dx in -(margin - 1)..=(margin - 1) {
+            for dz in -forced_reach..=forced_reach {
+                for dx in -forced_reach..=forced_reach {
                     let (x, z) = (fx + dx, fz + dz);
                     if missing(x, z) {
                         wanted.push((input.ranges.distance(x, z), x, z));
@@ -2479,6 +2573,34 @@ mod tests {
         }
     }
 
+    /// An idle dedicated server keeps no area around its centre: only a spawn
+    /// search's chunk (FULL alone: its 3x3 decorated, 5x5 generated) and the
+    /// forced chunks.
+    #[test]
+    fn no_area_around_an_idle_servers_centre() {
+        let forced = HashSet::from([(30, 30)]);
+        let extra = [((5, -3), -1)];
+        let r = Ranges {
+            center: (5, -3),
+            radius: -1,
+            extra: &extra,
+            forced: &forced,
+            cover: None,
+            band: None,
+        };
+        for x in -5i32..=15 {
+            for z in -13i32..=7 {
+                let d = (x - 5).abs().max((z + 3).abs());
+                assert_eq!(r.in_range(x, z, 1), d == 0, "({x}, {z})");
+                assert_eq!(r.chunk_kept(x, z, true), d <= 2, "({x}, {z})");
+                assert_eq!(r.requested(x, z, true), d <= 2, "({x}, {z})");
+            }
+        }
+        assert!(r.in_range(30, 30, 1));
+        let idle = Ranges { extra: &[], ..r };
+        assert!(!idle.requested(5, -3, true) && idle.unloaded(5, -3, true));
+    }
+
     /// A server player's area (`lan_update_streaming`: the server view
     /// distance + 1) finishes vanilla's FULL square: PLAYER_LOADING tickets at
     /// level 31 out to the view distance, FULL (33) two chunks past it. Every
@@ -2534,6 +2656,57 @@ mod tests {
             }
         }
     }
+
+    /// A `/forceload`ed chunk holds a FORCED ticket at level 31
+    /// (`ChunkMap.FORCED_TICKET_LEVEL`): the level rises one per ring
+    /// (`ChunkTracker.computeLevelFromNeighbor`) and picks the column's
+    /// status (`ChunkLevel.generationStatus`). So vanilla finishes the two
+    /// rings around it (33), gives the third its features (34) and the
+    /// fourth its terrain (35), and the rings past that are left alone.
+    #[test]
+    fn forced_chunks_reach_vanillas_rings() {
+        let forced: HashSet<(i32, i32)> = [(40, -40)].into();
+        let r = Ranges {
+            // The player's own area, far away.
+            center: (-400, 300),
+            radius: 2,
+            extra: &[],
+            forced: &forced,
+            cover: None,
+            band: None,
+        };
+        let level = |x: i32, z: i32| 31 + (x - 40).abs().max((z + 40).abs());
+        for x in 40 - 6..=40 + 6 {
+            for z in -40 - 6..=-40 + 6 {
+                // The full ring: the column becomes a level chunk.
+                assert_eq!(r.in_range(x, z, 1), level(x, z) <= 33, "({x}, {z})");
+                // The features ring, and the terrain ring.
+                assert_eq!(r.in_range(x, z, 2), level(x, z) <= 34, "({x}, {z})");
+                assert_eq!(r.in_range(x, z, 3), level(x, z) <= 35, "({x}, {z})");
+                assert_eq!(r.requested(x, z, true), level(x, z) <= 35, "({x}, {z})");
+                assert_eq!(r.chunk_kept(x, z, true), level(x, z) <= 35, "({x}, {z})");
+                assert_eq!(r.unloaded(x, z, true), level(x, z) > 35, "({x}, {z})");
+            }
+        }
+        // Generation reaches the terrain ring: the features ring is
+        // decorated from it.
+        let mut fixture = GenerationFixture::new(2, true);
+        fixture.center = (-400, 300);
+        fixture.forced = forced;
+        let candidates = GenerationScan::default()
+            .candidates(fixture.input(), usize::MAX)
+            .expect("a scan");
+        for (dx, dz) in [(-4, 0), (4, 0), (0, -4), (0, 4), (3, 3)] {
+            assert!(
+                candidates
+                    .iter()
+                    .any(|&(_, x, z)| (x, z) == (40 + dx, -40 + dz)),
+                "the terrain ring at ({}, {}) is not generated",
+                40 + dx,
+                -40 + dz
+            );
+        }
+    }
 }
 
 #[cfg(test)]

crates/horizon-client-render/src/terrain.wgsl

@@ -146,9 +146,10 @@ fn apply_fog(color: vec4<f32>, spherical: f32, cylindrical: f32) -> vec4<f32> {
     // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
     let color = sprite(in.uv, in.layer & 0x7fffu) * in.color;
     if color.a < 0.5 && (in.layer & 0x8000u) == 0u { discard; }
-    // Alpha 0 tells HDR output (hdr.wgsl) a light-emitting block's bright pixels
-    // may shine. Nothing else reads the frame's alpha.
-    let emissive = select(1.0, 0.0, in.emission > 0u);
+    // Below 0.75, alpha tells HDR output (hdr.wgsl) a light source's bright
+    // pixels may shine, and at which tier (mesher::hdr_tier): 0.525 at the
+    // lowest, 0 at the brightest. Nothing else reads the frame's alpha.
+    let emissive = select(1.0, 0.7 * f32(4u - min(in.emission, 4u)) / 4.0, in.emission > 0u);
     return apply_fog(vec4(color.rgb, emissive), in.spherical, in.cylindrical);
 }
 @fragment fn fs_translucent(in: TerrainOut) -> @location(0) vec4<f32> {

crates/horizon-client-render/src/ui.rs

@@ -1078,6 +1078,21 @@ impl EditBox {
             self.set_cursor(pos, shift);
         }
     }
+    /// `MultilineTextField.selectWordAtCursor` on a book page: the word before
+    /// the cursor is selected, its end found past non-whitespace only
+    /// (`getWordEndPosition`).
+    pub fn select_word_at_cursor(&mut self) {
+        let begin = multiline_word_position(&self.value, -1, self.cursor);
+        let end = begin
+            + self
+                .value
+                .chars()
+                .skip(begin)
+                .take_while(|c| !java_whitespace(*c))
+                .count();
+        self.set_cursor(begin, false);
+        self.set_cursor(end, true);
+    }
     /// EditBox.onDrag: the selection follows the pointer.
     pub fn drag_to(&mut self, atlas: &HudAtlas, x: f32) {
         let pos = self.position_at(atlas, x);

crates/horizon-client-render/src/world.rs

@@ -1,7 +1,10 @@
 //! Resident client world: streamed chunk columns plus the bookkeeping the game
 //! loop needs to relight and remesh after edits.
-use crate::chunk::{Chunk, MIN_Y, SECTIONS};
-use crate::fast_hash::{FxHashMap, FxHashSet};
+use crate::{
+    chunk::{Chunk, ColumnLayout, LevelShape},
+    fast_hash::{FxHashMap, FxHashSet},
+    section_mask::SectionMask,
+};
 use horizon_core::random::LegacyRandom;
 use horizon_world::registry::BlockStateId;
 use std::sync::Arc;
@@ -11,28 +14,30 @@ use std::sync::Arc;
 /// rather than at every section of it.
 #[derive(Clone, Debug, Default)]
 pub struct DirtySections {
-    columns: crate::fast_hash::FxHashMap<(i32, i32), u32>,
+    columns: crate::fast_hash::FxHashMap<(i32, i32), SectionMask>,
 }
-const _: () = assert!(SECTIONS <= 32);
 impl DirtySections {
     pub fn insert(&mut self, (x, sy, z): (i32, i32, i32)) {
-        debug_assert!((0..SECTIONS as i32).contains(&sy));
-        *self.columns.entry((x, z)).or_default() |= 1 << sy;
+        debug_assert!((0..SectionMask::CAPACITY as i32).contains(&sy));
+        self.columns.entry((x, z)).or_default().insert(sy as usize);
     }
     pub fn contains(&self, &(x, sy, z): &(i32, i32, i32)) -> bool {
-        (0..SECTIONS as i32).contains(&sy)
-            && self.columns.get(&(x, z)).is_some_and(|m| m & 1 << sy != 0)
+        (0..SectionMask::CAPACITY as i32).contains(&sy)
+            && self
+                .columns
+                .get(&(x, z))
+                .is_some_and(|m| m.contains(sy as usize))
     }
-    /// The dirty section indexes of column (x, z), as bits, removed.
-    pub fn take_column(&mut self, x: i32, z: i32) -> u32 {
-        self.columns.remove(&(x, z)).unwrap_or(0)
+    /// The dirty section indexes of column (x, z), removed.
+    pub fn take_column(&mut self, x: i32, z: i32) -> SectionMask {
+        self.columns.remove(&(x, z)).unwrap_or_default()
     }
     /// Keep the columns `keep` accepts.
     pub fn retain_columns(&mut self, mut keep: impl FnMut(i32, i32) -> bool) {
         self.columns.retain(|&(x, z), _| keep(x, z));
     }
-    /// The columns holding dirty sections, with their section bits.
-    pub fn columns(&self) -> impl Iterator<Item = ((i32, i32), u32)> + '_ {
+    /// The columns holding dirty sections, with their section indexes.
+    pub fn columns(&self) -> impl Iterator<Item = ((i32, i32), SectionMask)> + '_ {
         self.columns.iter().map(|(&c, &m)| (c, m))
     }
     pub fn clear(&mut self) {
@@ -43,10 +48,13 @@ impl DirtySections {
     }
     /// How many sections are dirty.
     pub fn len(&self) -> usize {
-        self.columns.values().map(|m| m.count_ones() as usize).sum()
+        self.columns.values().map(SectionMask::len).sum()
     }
 }
 pub struct World {
+    /// The level's build range and skylight (its dimension type); its
+    /// chunks hold `shape.column()`.
+    pub shape: LevelShape,
     pub fast_lava: bool,
     pub chunks: crate::chunk_map::ChunkMap,
     pub random: LegacyRandom,
@@ -88,7 +96,7 @@ pub struct World {
     /// The sections whose light changed since the log was last drained, as
     /// a bit per section of each column, kept while `block_log` is
     /// (`ChunkHolder.sectionLightChanged`).
-    pub light_log: Option<crate::fast_hash::FxHashMap<(i32, i32), u32>>,
+    pub light_log: Option<crate::fast_hash::FxHashMap<(i32, i32), SectionMask>>,
     /// The villager POIs of each section (`PoiManager`'s sections).
     pub pois: crate::poi_sections::PoiSections<crate::poi_sections::Poi>,
     /// Moving-piston states removed during the last tick; retained until the
@@ -165,6 +173,7 @@ impl Weather {
 impl World {
     pub fn new(air: BlockStateId, seed: i64) -> Self {
         Self {
+            shape: LevelShape::OVERWORLD,
             chunks: Default::default(),
             random: LegacyRandom::new(seed),
             revision: 0,
@@ -249,6 +258,10 @@ impl World {
         world.revision = 0;
         Ok(world)
     }
+    /// The column the level's chunks hold.
+    pub fn layout(&self) -> ColumnLayout {
+        self.shape.column()
+    }
     /// Resident storage write; marks the touched sections (and neighbours on
     /// section borders) for remeshing and the surrounding chunks for relighting.
     /// Neighbour updates, drops and block entities belong to the gameplay layer.
@@ -256,7 +269,8 @@ impl World {
         let Some(chunk) = self.chunks.get_mut(&(x >> 4, z >> 4)) else {
             return Err("write outside resident chunks".into());
         };
-        if y < MIN_Y || y >= MIN_Y + (SECTIONS as i32) * 16 {
+        let (min_y, sections) = (chunk.min_y(), chunk.sections.len() as i32);
+        if chunk.section_index(y).is_none() {
             return Err("write outside world height".into());
         }
         let previous = Arc::make_mut(chunk).set(x & 15, y, z & 15, state.0);
@@ -276,14 +290,14 @@ impl World {
             // the sections it can reach: this section, the one above/below
             // only on a section face, and a neighbour column only on a chunk
             // border (the diagonal only where both borders meet).
-            let sy = (y - MIN_Y) >> 4;
+            let sy = (y - min_y) >> 4;
             let local_y = y & 15;
             let mark = |dirty: &mut DirtySections, bx: i32, bz: i32| {
                 dirty.insert((bx >> 4, sy, bz >> 4));
                 if local_y == 0 && sy > 0 {
                     dirty.insert((bx >> 4, sy - 1, bz >> 4));
                 }
-                if local_y == 15 && sy + 1 < SECTIONS as i32 {
+                if local_y == 15 && sy + 1 < sections {
                     dirty.insert((bx >> 4, sy + 1, bz >> 4));
                 }
             };
@@ -319,17 +333,20 @@ impl World {
         Ok(())
     }
     /// `getHeight(Heightmap.Types.WORLD_SURFACE, x, z)`: one above the highest
-    /// block that isn't `air`, or `MIN_Y` (also where the chunk isn't loaded).
+    /// block that isn't `air`, or the column's minimum Y (also where the chunk
+    /// isn't loaded).
     pub fn world_surface(&self, x: i32, z: i32, air: impl Fn(BlockStateId) -> bool) -> i32 {
-        self.chunks.get(&(x >> 4, z >> 4)).map_or(MIN_Y, |chunk| {
+        let bottom = self.layout().min_y();
+        self.chunks.get(&(x >> 4, z >> 4)).map_or(bottom, |chunk| {
             chunk.world_surface(x, z, |v| air(BlockStateId(v)))
         })
     }
     /// `getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)`: one above the
     /// highest block where `blocks` (motion blocking or holding a fluid),
-    /// or `MIN_Y` (also where the chunk isn't loaded).
+    /// or the column's minimum Y (also where the chunk isn't loaded).
     pub fn motion_blocking(&self, x: i32, z: i32, blocks: impl Fn(BlockStateId) -> bool) -> i32 {
-        self.chunks.get(&(x >> 4, z >> 4)).map_or(MIN_Y, |chunk| {
+        let bottom = self.layout().min_y();
+        self.chunks.get(&(x >> 4, z >> 4)).map_or(bottom, |chunk| {
             chunk.motion_blocking(x & 15, z & 15, |v| blocks(BlockStateId(v)))
         })
     }
@@ -348,12 +365,13 @@ impl World {
         hi: [i32; 3],
         mut matches: impl FnMut(BlockStateId) -> bool,
     ) -> bool {
-        let top = MIN_Y + SECTIONS as i32 * 16 - 1;
+        let layout = self.layout();
+        let (bottom, top) = (layout.min_y(), layout.max_y() - 1);
         // Heights outside the sections read as state 0.
-        if (lo[1] < MIN_Y || hi[1] > top) && matches(BlockStateId(0)) {
+        if (lo[1] < bottom || hi[1] > top) && matches(BlockStateId(0)) {
             return true;
         }
-        let sections = (lo[1].max(MIN_Y) - MIN_Y) >> 4..=(hi[1].min(top) - MIN_Y) >> 4;
+        let sections = (lo[1].max(bottom) - bottom) >> 4..=(hi[1].min(top) - bottom) >> 4;
         for cx in lo[0] >> 4..=hi[0] >> 4 {
             for cz in lo[2] >> 4..=hi[2] >> 4 {
                 let Some(chunk) = self.chunks.get(&(cx, cz)) else {
@@ -465,8 +483,8 @@ mod tests {
             }
             let mut got: Vec<_> = world.dirty_sections.columns().collect();
             let mut want: Vec<_> = expected.columns().collect();
-            got.sort_unstable();
-            want.sort_unstable();
+            got.sort_unstable_by_key(|&(column, _)| column);
+            want.sort_unstable_by_key(|&(column, _)| column);
             assert_eq!(got, want, "write at {x} {y} {z}");
             if (x & 15, z & 15) == (3, 3) {
                 assert_eq!(world.dirty_sections.len(), 1);

crates/horizon-client-render/src/zip.rs

@@ -77,19 +77,31 @@ impl Zip {
         // A clone shares the bytes and the central directory: reading needs `&mut`.
         let mut archive = self.archive.clone();
         let mut entry = archive.by_index_raw(index).map_err(invalid)?;
-        let (method, size) = (entry.compression(), entry.size() as usize);
+        let method = entry.compression();
         let mut raw = Vec::with_capacity((entry.compressed_size() as usize).min(self.len));
         entry.read_to_end(&mut raw)?;
         match method {
             CompressionMethod::Stored => Ok(raw),
-            CompressionMethod::Deflated => miniz_oxide::inflate::decompress_to_vec_with_limit(
-                &raw,
-                size.max(1)
-                    .saturating_mul(2)
-                    .saturating_add(1024)
-                    .min(MAX_ENTRY),
-            )
-            .map_err(|_| invalid("corrupt deflate stream")),
+            CompressionMethod::Deflated => {
+                // Java's ZipFile trusts neither size an entry declares: it
+                // inflates the stream to its end and keeps what comes out.
+                // Packs in the wild (a Nexo-generated one served through
+                // Dropbox, for one) carry central-directory sizes that point
+                // at other files, and miniz_oxide, which refuses input past
+                // the stream's end, failed whole entries with "corrupt
+                // deflate stream" and with them the whole pack. Only the
+                // size limit stands between the archive and a zip bomb.
+                let decoder = flate2::read::DeflateDecoder::new(raw.as_slice());
+                let mut decoded = Vec::with_capacity(raw.len().min(MAX_ENTRY));
+                decoder
+                    .take(MAX_ENTRY as u64 + 1)
+                    .read_to_end(&mut decoded)
+                    .map_err(|_| invalid("corrupt deflate stream"))?;
+                if decoded.len() > MAX_ENTRY {
+                    return Err(invalid("entry inflates past the size limit"));
+                }
+                Ok(decoded)
+            }
             _ => Err(invalid("unsupported zip compression")),
         }
     }
@@ -214,6 +226,70 @@ mod tests {
         assert!(zip.read("missing").is_err());
     }
 
+    /// The offset of the central-directory header of `name`.
+    fn central_header(bytes: &[u8], name: &str) -> usize {
+        let mut at = 0;
+        while let Some(i) = bytes[at..]
+            .windows(4)
+            .position(|s| s == [0x50, 0x4b, 0x01, 0x02])
+        {
+            let p = at + i;
+            let nlen = u16::from_le_bytes(bytes[p + 28..p + 30].try_into().unwrap()) as usize;
+            if &bytes[p + 46..p + 46 + nlen] == name.as_bytes() {
+                return p;
+            }
+            at = p + 4;
+        }
+        panic!("no central header for {name}");
+    }
+
+    /// Java's `ZipFile` inflates the stream and keeps what comes out, so a
+    /// central directory that names a size other than the stream's (the
+    /// Nexo pack Dropbox serves for one server does) changes nothing.
+    #[test]
+    fn reads_a_deflate_stream_larger_than_its_declared_size() {
+        use std::io::Write;
+        use zip::write::SimpleFileOptions;
+
+        let mut writer = zip::ZipWriter::new(Cursor::new(Vec::new()));
+        writer
+            .start_file(
+                "large.txt",
+                SimpleFileOptions::default().compression_method(CompressionMethod::Deflated),
+            )
+            .unwrap();
+        writer.write_all(&vec![b'x'; 4096]).unwrap();
+        let mut bytes = writer.finish().unwrap().into_inner();
+        let central = central_header(&bytes, "large.txt");
+        bytes[central + 24..central + 28].copy_from_slice(&1u32.to_le_bytes());
+
+        let zip = Zip::from_bytes(bytes).unwrap();
+        assert_eq!(zip.read("large.txt").unwrap(), vec![b'x'; 4096]);
+    }
+
+    /// Some pack writers leave an entry's compressed size longer than its
+    /// deflate stream, so the bytes past the stream's end are part of it.
+    /// Java inflates to the stream's end and ignores them; miniz_oxide
+    /// refused the input and failed the entry, and with it the whole pack.
+    #[test]
+    fn reads_past_trailing_bytes_after_the_deflate_stream() {
+        let mut bytes = written();
+        let name = "Pack-main/assets/minecraft/lang/en_us.json";
+        let central = central_header(&bytes, name);
+        let local =
+            u32::from_le_bytes(bytes[central + 42..central + 46].try_into().unwrap()) as usize;
+        for at in [central + 20, local + 18] {
+            let csize = u32::from_le_bytes(bytes[at..at + 4].try_into().unwrap());
+            bytes[at..at + 4].copy_from_slice(&(csize + 8).to_le_bytes());
+        }
+
+        let zip = Zip::from_bytes(bytes).unwrap();
+        assert_eq!(
+            zip.read(name).unwrap(),
+            "{\"a\":\"b\"}".repeat(100).as_bytes()
+        );
+    }
+
     /// Loka's server pack (#3413) names its metadata `pack.mcmeta/`.
     /// `ZipFile.getEntry("pack.mcmeta")` falls back to that folder entry and
     /// vanilla reads its bytes; a file of the exact name still comes first.

crates/horizon-client/assets/horizon/lang/en_us.json

@@ -11,5 +11,57 @@
   "horizon.options.look_deadzone": "Look Deadzone",
   "horizon.options.button_glyphs": "Button Glyphs",
   "horizon.options.menu_navigation": "Menu Navigation",
-  "horizon.options.on_screen_keyboard": "On-Screen Keyboard"
+  "horizon.options.on_screen_keyboard": "On-Screen Keyboard",
+  "horizon.options.chat_delay": "Chat Delay",
+  "horizon.options.lightbar.health": "Health",
+  "horizon.options.lightbar.dimension": "Dimension",
+  "horizon.options.glyphs.auto": "Auto",
+  "horizon.options.glyphs.xbox": "Xbox",
+  "horizon.options.glyphs.playstation": "PlayStation",
+  "horizon.options.glyphs.nintendo": "Nintendo",
+  "horizon.options.menu_focus": "Focus",
+  "horizon.options.menu_pointer": "Pointer",
+  "horizon.options.keyboard.auto": "Auto",
+  "horizon.options.keyboard.horizon": "Horizon",
+  "horizon.options.keyboard.steam": "Steam",
+  "horizon.options.unavailable": "This feature is not yet available in Horizon.",
+  "horizon.options.search": "Search settings...",
+  "horizon.pages.mods": "Mods",
+  "horizon.pages.shader_packs": "Shader Packs",
+  "horizon.pages.controller": "Controller Settings",
+  "horizon.pages.controller_binds": "Controller Binds",
+  "horizon.pages.extras": "Horizon Extras",
+  "horizon.pages.settings": "Horizon Settings",
+  "horizon.pages.agent": "AI Agent",
+  "horizon.pages.settings.tooltip": "Horizon's own settings: graphics, controllers, extras and mods.",
+  "horizon.pages.graphics.tooltip": "Graphics, simply: each setting says what it costs.",
+  "horizon.pages.graphics_advanced.tooltip": "Every graphics setting, Horizon's included, with what each costs.",
+  "horizon.pages.controller.tooltip": "Controllers: their buttons, sticks, vibration and menu navigation.",
+  "horizon.pages.extras.tooltip": "Optional additions, all off by default: the game stays vanilla until you turn one on.",
+  "horizon.pages.agent.tooltip": "Let your own AI agent play: horizon-ctl and MCP clients on this computer.",
+  "horizon.pages.shader_packs.tooltip": "Shader packs from the shaderpacks folder: Horizon's own and those in the shaders/ format. One runs at a time.",
+  "horizon.pages.mods.tooltip": "Mods made for Horizon, from the horizon-mods folder. Each runs in a sandbox and stays off until you turn it on.",
+  "horizon.pages.open.graphics": "Graphics...",
+  "horizon.pages.open.graphics_advanced": "Advanced Graphics...",
+  "horizon.pages.open.shader_packs": "Shader Packs...",
+  "horizon.pages.open.controller": "Controller Settings...",
+  "horizon.pages.open.extras": "Extras...",
+  "horizon.pages.open.mods": "Mods...",
+  "horizon.pages.open.agent": "AI Agent...",
+  "horizon.pages.open.horizon_graphics": "Horizon Graphics...",
+  "horizon.pages.open.controller_binds": "Controller Binds...",
+  "horizon.pages.open.horizon_settings": "Horizon Settings...",
+  "horizon.mods.empty": "No mods: put .hmod files in the horizon-mods folder",
+  "horizon.mods.stopped": " (Stopped)",
+  "horizon.mods.dev": " (Dev)",
+  "horizon.mods.settings": "Settings",
+  "horizon.mods.open_folder": "Open Mod Folder",
+  "horizon.shader_packs.empty": "No shader packs: put them in the shaderpacks folder",
+  "horizon.shader_packs.kind_horizon": " (Horizon)",
+  "horizon.agent.copy_details": "Copy Connection Details",
+  "horizon.multiplayer.join": "Join",
+  "horizon.multiplayer.cancel_reconnecting": "Cancel Reconnecting",
+  "horizon.multiplayer.join_friend": "Join a Friend",
+  "horizon.multiplayer.invite_code": "Invite Code",
+  "horizon.multiplayer.relay": "Relay (optional)"
 }

crates/horizon-client/assets/horizon/lang/pl_pl.json

@@ -0,0 +1,15 @@
+{
+  "horizon.options.controller": "Kontroler",
+  "horizon.options.vibration": "Wibracje",
+  "horizon.options.adaptive_triggers": "Adaptacyjne spusty",
+  "horizon.options.lightbar": "Pasek świetlny",
+  "horizon.options.look_sensitivity": "Czułość rozglądania",
+  "horizon.options.invert_x": "Odwróć oś X rozglądania",
+  "horizon.options.invert_y": "Odwróć oś Y rozglądania",
+  "horizon.options.sneak_button": "Przycisk skradania",
+  "horizon.options.move_deadzone": "Martwa strefa ruchu",
+  "horizon.options.look_deadzone": "Martwa strefa rozglądania",
+  "horizon.options.button_glyphs": "Symbole przycisków",
+  "horizon.options.menu_navigation": "Nawigacja po menu",
+  "horizon.options.on_screen_keyboard": "Klawiatura ekranowa"
+}

crates/horizon-client/assets/horizon/lang/ru_ru.json

@@ -11,5 +11,57 @@
   "horizon.options.look_deadzone": "Мёртвая зона обзора",
   "horizon.options.button_glyphs": "Символы кнопок",
   "horizon.options.menu_navigation": "Навигация по меню",
-  "horizon.options.on_screen_keyboard": "Экранная клавиатура"
+  "horizon.options.on_screen_keyboard": "Экранная клавиатура",
+  "horizon.options.chat_delay": "Задержка чата",
+  "horizon.options.lightbar.health": "Здоровье",
+  "horizon.options.lightbar.dimension": "Измерение",
+  "horizon.options.glyphs.auto": "Авто",
+  "horizon.options.glyphs.xbox": "Xbox",
+  "horizon.options.glyphs.playstation": "PlayStation",
+  "horizon.options.glyphs.nintendo": "Nintendo",
+  "horizon.options.menu_focus": "Фокус",
+  "horizon.options.menu_pointer": "Указатель",
+  "horizon.options.keyboard.auto": "Авто",
+  "horizon.options.keyboard.horizon": "Horizon",
+  "horizon.options.keyboard.steam": "Steam",
+  "horizon.options.unavailable": "Эта возможность в Horizon пока недоступна.",
+  "horizon.options.search": "Поиск настроек...",
+  "horizon.pages.mods": "Моды",
+  "horizon.pages.shader_packs": "Шейдерпаки",
+  "horizon.pages.controller": "Настройки контроллера",
+  "horizon.pages.controller_binds": "Назначения кнопок контроллера",
+  "horizon.pages.extras": "Дополнения Horizon",
+  "horizon.pages.settings": "Настройки Horizon",
+  "horizon.pages.agent": "ИИ-агент",
+  "horizon.pages.settings.tooltip": "Собственные настройки Horizon: графика, контроллеры, дополнения и моды.",
+  "horizon.pages.graphics.tooltip": "Графика без лишнего: у каждой настройки написано, чего она стоит.",
+  "horizon.pages.graphics_advanced.tooltip": "Все графические настройки, включая собственные настройки Horizon, и их цена.",
+  "horizon.pages.controller.tooltip": "Контроллеры: кнопки, стики, вибрация и навигация по меню.",
+  "horizon.pages.extras.tooltip": "Дополнительные возможности, все выключены по умолчанию: игра остаётся ванильной, пока вы не включите что-то.",
+  "horizon.pages.agent.tooltip": "Пусть играет ваш ИИ-агент: horizon-ctl и MCP-клиенты на этом компьютере.",
+  "horizon.pages.shader_packs.tooltip": "Шейдерпаки из папки shaderpacks: собственные паки Horizon и паки в формате shaders/. Одновременно работает один.",
+  "horizon.pages.mods.tooltip": "Моды для Horizon из папки horizon-mods. Каждый работает в песочнице и выключен, пока вы его не включите.",
+  "horizon.pages.open.graphics": "Графика...",
+  "horizon.pages.open.graphics_advanced": "Продвинутая графика...",
+  "horizon.pages.open.shader_packs": "Шейдерпаки...",
+  "horizon.pages.open.controller": "Настройки контроллера...",
+  "horizon.pages.open.extras": "Дополнения...",
+  "horizon.pages.open.mods": "Моды...",
+  "horizon.pages.open.agent": "ИИ-агент...",
+  "horizon.pages.open.horizon_graphics": "Графика Horizon...",
+  "horizon.pages.open.controller_binds": "Назначения кнопок...",
+  "horizon.pages.open.horizon_settings": "Настройки Horizon...",
+  "horizon.mods.empty": "Модов нет: положите файлы .hmod в папку horizon-mods",
+  "horizon.mods.stopped": " (остановлен)",
+  "horizon.mods.dev": " (разработка)",
+  "horizon.mods.settings": "Настройки",
+  "horizon.mods.open_folder": "Открыть папку модов",
+  "horizon.shader_packs.empty": "Шейдерпаков нет: положите их в папку shaderpacks",
+  "horizon.shader_packs.kind_horizon": " (Horizon)",
+  "horizon.agent.copy_details": "Скопировать данные подключения",
+  "horizon.multiplayer.join": "Подключиться",
+  "horizon.multiplayer.cancel_reconnecting": "Отменить переподключение",
+  "horizon.multiplayer.join_friend": "Играть с другом",
+  "horizon.multiplayer.invite_code": "Код приглашения",
+  "horizon.multiplayer.relay": "Ретранслятор (необязательно)"
 }

crates/horizon-client/examples/mod_port_probe.rs

@@ -18,6 +18,7 @@ use horizon_client::{
 };
 use horizon_core::{geometry::Axis, random::LegacyRandom};
 use horizon_world::chunk::BlockState;
+use horizon_world::loot::PackOverlay;
 use serde_json::{Map, Value, json};
 use std::{collections::BTreeMap, fs, path::Path};
 
@@ -77,9 +78,9 @@ fn main() -> Result<()> {
     let assets = Assets::load(&root).map_err(step("assets"))?;
     let registry = assets.registry;
     let facts = BlockFacts::load(&root, registry).map_err(step("block facts"))?;
-    let items = Items::load(&root, registry, &facts).map_err(step("items"))?;
-    let recipes = Recipes::load(&root, &items).map_err(step("recipes"))?;
-    let stations = StationRecipes::load(&root, &items);
+    let items = Items::load(&root, registry, &facts, &PackOverlay::NONE).map_err(step("items"))?;
+    let recipes = Recipes::load(&root, &items, &PackOverlay::NONE).map_err(step("recipes"))?;
+    let stations = StationRecipes::load(&root, &items, &PackOverlay::NONE);
     let collisions =
         horizon_client::collisions::load(&root, registry).map_err(step("collisions"))?;
     let loaded = began.elapsed().as_secs_f64() - built;

crates/horizon-client/examples/portal_scan_bench.rs

@@ -7,6 +7,7 @@ use horizon_client::{
     chunk::{Chunk, MIN_Y, SECTIONS, Section},
     fast_hash::FxHashMap,
     portal_sections::PortalSections,
+    section_mask::SectionMask,
 };
 use horizon_core::{
     geometry::{Aabb, Vec3},
@@ -83,17 +84,14 @@ fn may_hold_portal_cached(
     if count > 64 {
         return true;
     }
-    let mut y_mask = 0u32;
-    for sy in y0..=y1 {
-        y_mask |= 1 << sy;
-    }
+    let y_mask = SectionMask::below(y1 as usize + 1).from(y0 as usize);
     (x0..=x1).any(|cx| {
         (z0..=z1).any(|cz| {
             world.get(&(cx, cz)).is_some_and(|chunk| {
-                cache.get((cx, cz), chunk, |v| {
+                let portals = cache.get((cx, cz), chunk, |v| {
                     behaviours.portal_axis(BlockStateId(v)).is_some()
-                }) & y_mask
-                    != 0
+                });
+                !(portals & y_mask).is_empty()
             })
         })
     })

crates/horizon-client/examples/probe/block_entity_anim_fixture.rs

@@ -16,6 +16,7 @@ use horizon_client::{
     items::Items,
 };
 use horizon_core::random::LegacyRandom;
+use horizon_world::loot::PackOverlay;
 use horizon_world::registry::{BlockRegistry, BlockStateId};
 use serde_json::Value;
 use std::{
@@ -127,7 +128,7 @@ pub fn main() -> Result<()> {
     let registry = assets.registry;
     let facts = BlockFacts::load(root, registry)?;
     let renderer = BlockEntityRenderer::load(root, registry)?;
-    let tags = Items::tags_only(root)?;
+    let tags = Items::tags_only(root, &PackOverlay::NONE)?;
     let frames = tags
         .block_tags
         .get("minecraft:conduit_effect_block")

crates/horizon-client/examples/probe/block_tint_probe.rs

@@ -0,0 +1,37 @@
+//! Block-model tints without a level, including blank and invalid tint indices.
+use horizon_client::{
+    assets::Assets, blocks::BlockFacts, item_render::ItemRenderer, mesher::MeshTables, models,
+};
+use horizon_world::registry::BlockStateId;
+use serde_json::Value;
+use std::{
+    fs,
+    io::{BufWriter, Write},
+    path::Path,
+};
+
+pub fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args: Vec<_> = crate::args().collect();
+    let input: Value = serde_json::from_slice(&fs::read(&args[1])?)?;
+    let root = Path::new(input["resources"].as_str().unwrap());
+    let assets = Assets::load(root)?;
+    let render = assets.reload(root)?;
+    let facts = BlockFacts::load(root, assets.registry)?;
+    let tables = MeshTables::new(
+        &assets,
+        &render,
+        &facts,
+        models::load_visibility(root, assets.registry)?,
+    )?;
+    let grass = ItemRenderer::load(root)?.grass_color(0.5, 1.0) as u32;
+    let mut output = BufWriter::new(fs::File::create(&args[2])?);
+    for row in input["cases"].as_array().unwrap() {
+        let state = row[0].as_u64().unwrap() as u32;
+        let index = row[1].as_i64().unwrap() as i32;
+        let color = tables
+            .default_tint(BlockStateId(state), index, grass)
+            .map_or(-1, |rgb| (0xFF00_0000 | rgb) as i32);
+        writeln!(output, "{state} {index} {color}")?;
+    }
+    Ok(())
+}

crates/horizon-client/examples/probe/block_transform_fixture.rs

@@ -9,6 +9,7 @@ use horizon_client::{
     items::Items,
 };
 use horizon_world::chunk::BlockState;
+use horizon_world::loot::PackOverlay;
 use std::{fs, path::Path};
 
 fn parse(text: &str) -> BlockState {
@@ -58,7 +59,7 @@ pub fn main() -> horizon_client::Result<()> {
             .ok_or("usage: block_transform_fixture RESOURCES INPUT OUTPUT")?,
     );
     let input = fs::read_to_string(args.get(2).ok_or("missing INPUT")?)?;
-    let items = Items::catalog(root)?;
+    let items = Items::catalog(root, &PackOverlay::NONE)?;
     let assets = Assets::load(root)?;
     let transformers = Transformers::load(root, assets.registry)?;
     let mut out = String::new();

crates/horizon-client/examples/probe/cauldron_fixture.rs

@@ -10,6 +10,7 @@ use horizon_client::{
     menu::{Env, Kind, Menu},
 };
 use horizon_world::chunk::BlockState;
+use horizon_world::loot::PackOverlay;
 use serde_json::Value;
 use std::{fs, path::Path};
 
@@ -77,9 +78,9 @@ pub fn main() -> horizon_client::Result<()> {
             .ok_or("usage: cauldron_fixture RESOURCES INPUT OUTPUT")?,
     );
     let input = fs::read_to_string(args.get(2).ok_or("missing INPUT")?)?;
-    let items = Items::catalog(root)?;
-    let recipes = Recipes::load(root, &items)?;
-    let brewing = horizon_client::brewing::Brewing::load(root, &items);
+    let items = Items::catalog(root, &PackOverlay::NONE)?;
+    let recipes = Recipes::load(root, &items, &PackOverlay::NONE)?;
+    let brewing = horizon_client::brewing::Brewing::load(root, &items, &PackOverlay::NONE);
     // The inventory menu never reads banner patterns.
     let banners = horizon_client::banner::Banners::default();
     let station_recipes = horizon_client::stations::StationRecipes::default();

crates/horizon-client/examples/probe/creative_mining_probe.rs

@@ -3,6 +3,7 @@ use horizon_client::{
     item_data::StackData,
     items::{ItemStack, Items},
 };
+use horizon_world::loot::PackOverlay;
 use horizon_world::nbt::Tag;
 use serde_json::Value;
 use std::{
@@ -14,7 +15,7 @@ use std::{
 pub fn main() -> Result<()> {
     let args: Vec<_> = crate::args().collect();
     let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../.local/horizon-client/26.3");
-    let items = Items::catalog(&root)?;
+    let items = Items::catalog(&root, &PackOverlay::NONE)?;
     let mut out = BufWriter::new(File::create(&args[2])?);
     for line in BufReader::new(File::open(&args[1])?).lines() {
         let row: Value = serde_json::from_str(&line?)?;

crates/horizon-client/examples/probe/enchanting_fixture.rs

@@ -8,6 +8,7 @@ use horizon_client::{
     items::{ItemStack, Items},
     stations,
 };
+use horizon_world::loot::PackOverlay;
 use std::{fmt::Write as _, fs, path::Path};
 
 pub fn main() -> horizon_client::Result<()> {
@@ -17,7 +18,7 @@ pub fn main() -> horizon_client::Result<()> {
             .ok_or("usage: enchanting_fixture RESOURCES INPUT OUTPUT")?,
     );
     let input = fs::read_to_string(args.get(2).ok_or("missing INPUT")?)?;
-    let items = Items::tags_only(root)?;
+    let items = Items::tags_only(root, &PackOverlay::NONE)?;
     let e = Enchantments::load(root);
     let mut out = String::new();
     for line in input.lines() {

crates/horizon-client/examples/probe/entity_anim_fixture.rs

@@ -150,7 +150,7 @@ fn entity_state(mob: &mut Mob, species: Species, case: &Value) {
             mob.extra.crouching = flag("isCrouching");
             mob.extra.passenger = flag("isPassenger");
             if flag("isHoldingBow") {
-                mob.extra.main_hand = Some("minecraft:bow".into());
+                mob.extra.set_main_hand(Some("minecraft:bow".into()));
             }
         }
         Species::IronGolem => {
@@ -298,7 +298,7 @@ fn entity_state(mob: &mut Mob, species: Species, case: &Value) {
             }
         }
         Species::Witch if flag("isHoldingItem") => {
-            mob.extra.main_hand = Some("minecraft:potion".into());
+            mob.extra.set_main_hand(Some("minecraft:potion".into()));
         }
         _ => {}
     }
@@ -386,7 +386,7 @@ pub fn main() -> horizon_client::Result<()> {
             .cloned()
             .unwrap_or_else(|| kind.model.clone());
         let mut mob = Mob::new(7, kind, Vec3::new(0.0, 64.0, 0.0), 0.0);
-        mob.extra.main_hand = None;
+        mob.extra.set_main_hand(None);
         let case = &v["case"];
         let f = |k: &str| case[k].as_f64().unwrap_or(0.0) as f32;
         if baby {
@@ -593,6 +593,7 @@ pub fn main() -> horizon_client::Result<()> {
                     num("maxCrossbowChageDuration"),
                     num("ticksUsingItem"),
                     false,
+                    flag("isRiding"),
                 );
             }
             Species::Evoker | Species::Illusioner | Species::Pillager | Species::Vindicator => {

crates/horizon-client/examples/probe/entity_death_loot_fixture.rs

@@ -8,7 +8,7 @@ use horizon_client::{
     random_sequences::RandomSequences,
 };
 use horizon_core::{geometry::Vec3, random::LegacyRandom};
-use horizon_world::loot::{LootDamage, LootData, LootEntity, LootStack};
+use horizon_world::loot::{LootDamage, LootData, LootEntity, LootStack, PackOverlay};
 use std::{collections::BTreeMap, fmt::Write as _, fs, path::Path, sync::Arc};
 
 /// `id[;enchantment:level...]`.
@@ -64,7 +64,7 @@ pub fn main() -> horizon_client::Result<()> {
     );
     let input = fs::read_to_string(args.get(2).ok_or("missing INPUT")?)?;
     let types = MobTypes::load(root)?;
-    let loot = LootData::load(root)?;
+    let loot = LootData::load(root, &PackOverlay::NONE)?;
     let mut out = String::new();
     for raw in input.lines() {
         if raw.trim().is_empty() || raw.starts_with('#') {
@@ -134,7 +134,7 @@ pub fn main() -> horizon_client::Result<()> {
                     let item: Option<Arc<str>> = Some(Arc::from(s.item.as_str()));
                     let index = match *slot {
                         "mainhand" => {
-                            m.extra.main_hand = item;
+                            m.extra.set_main_hand(item);
                             Some(gear::MAIN)
                         }
                         "offhand" => {

crates/horizon-client/examples/probe/finalize_spawn_fixture.rs

@@ -23,6 +23,7 @@ use horizon_core::{
     geometry::{Aabb, Vec3},
     random::{LegacyRandom, RandomSource},
 };
+use horizon_world::loot::PackOverlay;
 use std::{collections::HashMap, fmt::Write as _, fs, path::Path, sync::Arc};
 
 struct Level<'a> {
@@ -142,8 +143,8 @@ const GENES: [&str; 7] = [
     "aggressive",
 ];
 const MEMORIES: [&str; 7] = [
-    "long_jump_cooldown",
-    "ram_cooldown",
+    "long_jump_cooling_down",
+    "ram_cooldown_ticks",
     "attack_target_cooldown",
     "hunted_recently",
     "dig_cooldown",
@@ -399,7 +400,7 @@ pub fn main() -> horizon_client::Result<()> {
     let assets = Assets::load(root)?;
     let facts = BlockFacts::load(root, assets.registry)?;
     let mob_data = MobData::load(root, &facts);
-    let items = Items::tags_only(root)?;
+    let items = Items::tags_only(root, &PackOverlay::NONE)?;
     let enchantments = Enchantments::load(root);
     let types = MobTypes::load(root)?;
     let registries = SpawnRegistries::load(root);
@@ -506,6 +507,7 @@ pub fn main() -> horizon_client::Result<()> {
                 difficulty,
                 data: &data,
                 created: Vec::new(),
+                jockey_rider: None,
             };
             group = finalize::finalize(&mut cx, &mut mob, reason, group);
             let created = std::mem::take(&mut cx.created);

crates/horizon-client/examples/probe/ghost_recipe_fixture.rs

@@ -10,6 +10,7 @@ use horizon_client::{
     items::Items,
     recipe_book::{Book, BookType, GhostTarget, RecipeIndex},
 };
+use horizon_world::loot::PackOverlay;
 use serde_json::Value;
 use std::{fmt::Write as _, fs, path::Path};
 
@@ -18,9 +19,9 @@ pub fn main() -> horizon_client::Result<()> {
     let usage = "usage: ghost_recipe_fixture RESOURCES CASES OUTPUT";
     let root = Path::new(args.get(1).ok_or(usage)?);
     let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
-    let items = Items::catalog(root)?;
-    let recipes = Recipes::load(root, &items)?;
-    let index = RecipeIndex::load(root);
+    let items = Items::catalog(root, &PackOverlay::NONE)?;
+    let recipes = Recipes::load(root, &items, &PackOverlay::NONE)?;
+    let index = RecipeIndex::load(root, &PackOverlay::NONE);
     let mut book = Book::build(&recipes, &items);
     book.set_display_ids(&index);
     let mut out = String::new();

crates/horizon-client/examples/probe/hotbar_fixture.rs

@@ -5,6 +5,7 @@
 //!
 //! usage: hotbar_fixture RESOURCES CASES OUTPUT
 use horizon_client::{hotbar, item_data::canon_stack, items::Items};
+use horizon_world::loot::PackOverlay;
 use horizon_world::nbt::{Tag, parse_snbt};
 use serde_json::Value;
 use std::path::Path;
@@ -13,7 +14,10 @@ use std::{fmt::Write as _, fs};
 pub fn main() -> horizon_client::Result<()> {
     let args: Vec<String> = crate::args().collect();
     let usage = "usage: hotbar_fixture RESOURCES CASES OUTPUT";
-    let items = Items::catalog(Path::new(args.first().and(args.get(1)).ok_or(usage)?))?;
+    let items = Items::catalog(
+        Path::new(args.first().and(args.get(1)).ok_or(usage)?),
+        &PackOverlay::NONE,
+    )?;
     let known = |id: &str| items.get(id).is_some();
     let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
     let mut out = String::new();

crates/horizon-client/examples/probe/interaction_input_fixture.rs

@@ -15,6 +15,9 @@ struct World {
     passing: bool,
 }
 impl InteractionWorld for World {
+    // The fixture's targets don't change within a tick.
+    fn pick_hit_result(&mut self) {}
+    fn release_hit_result(&mut self) {}
     fn using_item(&self) -> bool {
         self.using
     }

crates/horizon-client/examples/probe/main.rs

@@ -19,6 +19,7 @@ mod block_entity_anim_fixture;
 mod block_entity_render_fixture;
 mod block_entity_tickers_fixture;
 mod block_particles_fixture;
+mod block_tint_probe;
 mod block_transform_fixture;
 mod breaking_fixture;
 mod camera_probe;
@@ -113,6 +114,7 @@ probes! {
     block_particles_fixture,
     block_transform_fixture,
     breaking_fixture,
+    block_tint_probe,
     camera_probe,
     squid_client_probe,
     creative_mining_probe,

crates/horizon-client/examples/probe/menu_fixture.rs

@@ -13,6 +13,7 @@ use horizon_client::{
     menu::{Env, Input, Kind, Menu},
 };
 use horizon_protocol::registry::Ids;
+use horizon_world::loot::PackOverlay;
 use serde_json::Value;
 use std::{
     cell::{Cell, RefCell},
@@ -83,11 +84,12 @@ pub fn main() -> horizon_client::Result<()> {
             .ok_or("usage: menu_fixture RESOURCES INPUT OUTPUT")?,
     );
     let input = fs::read_to_string(args.get(2).ok_or("missing INPUT")?)?;
-    let items = Items::catalog(root)?;
-    let recipes = Recipes::load(root, &items)?;
-    let brewing = horizon_client::brewing::Brewing::load(root, &items);
+    let items = Items::catalog(root, &PackOverlay::NONE)?;
+    let recipes = Recipes::load(root, &items, &PackOverlay::NONE)?;
+    let brewing = horizon_client::brewing::Brewing::load(root, &items, &PackOverlay::NONE);
     let banners = horizon_client::banner::Banners::load(root);
-    let station_recipes = horizon_client::stations::StationRecipes::load(root, &items);
+    let station_recipes =
+        horizon_client::stations::StationRecipes::load(root, &items, &PackOverlay::NONE);
     let enchantments = horizon_client::enchant::Enchantments::load(root);
     let names = horizon_client::creative::Names::load(root);
     let case_maps = CaseMaps::default();

crates/horizon-client/examples/probe/mob_ai_probe.rs

@@ -27,6 +27,7 @@ use horizon_core::{
     geometry::{Aabb, Vec3},
     random::LegacyRandom,
 };
+use horizon_world::loot::PackOverlay;
 use horizon_world::{chunk::BlockState, registry::BlockRegistry, registry::BlockStateId};
 use std::{
     collections::{BTreeMap, HashMap},
@@ -196,8 +197,21 @@ fn who(w: Option<Who>) -> String {
 fn goal_name(m: &Mob, name: &str) -> String {
     let vanilla = match name {
         "Float" => "FloatGoal",
+        "RandomFloatAround" => "RandomFloatAroundGoal",
+        "GhastLook" => "GhastLookGoal",
+        "GhastShoot" => "GhastShootFireballGoal",
         "Stroll" => "WaterAvoidingRandomStrollGoal",
+        "ParrotWander" => "ParrotWanderGoal",
         "RandomStroll" => "RandomStrollGoal",
+        // AbstractFish's private subclass of RandomSwimmingGoal.
+        "RandomSwimming"
+            if matches!(
+                m.species(),
+                Species::Cod | Species::Salmon | Species::TropicalFish | Species::Pufferfish
+            ) =>
+        {
+            "FishSwimGoal"
+        }
         "RandomSwimming" => "RandomSwimmingGoal",
         "LookAtPlayer" => "LookAtPlayerGoal",
         "RandomLookAround" => "RandomLookAroundGoal",
@@ -214,6 +228,8 @@ fn goal_name(m: &Mob, name: &str) -> String {
         "MoveThroughVillage" => "MoveThroughVillageGoal",
         "RestrictSun" => "RestrictSunGoal",
         "FleeSun" => "FleeSunGoal",
+        // `Cat.CatAvoidEntityGoal`, `Fox.FoxAvoidEntityGoal`... name their subclass.
+        "AvoidEntity" if m.species() == Species::Cat => "CatAvoidEntityGoal",
         "AvoidEntity" => "AvoidEntityGoal",
         "BowAttack" => "RangedBowAttackGoal",
         "Swell" => "SwellGoal",
@@ -864,7 +880,7 @@ pub fn main() -> horizon_client::Result<()> {
         .map(|(k, v)| (k.clone(), Arc::new(v.clone())))
         .collect();
     let biomes = Biomes::load(root)?;
-    let items = Items::load(root, registry, &facts)?;
+    let items = Items::load(root, registry, &facts, &PackOverlay::NONE)?;
     let tables = LightTables::load(root, registry, &facts)?;
     let collision = collisions::load(root, registry)?;
     let air = registry.default_state("minecraft:air").ok_or("no air")?;

crates/horizon-client/examples/probe/natural_spawn_fixture.rs

@@ -53,7 +53,8 @@ use horizon_core::{
     random::{LegacyRandom, RandomSource},
 };
 use horizon_world::{
-    block_collision::BlockCollisionRegistry, chunk::BlockState, nbt::Tag, registry::BlockStateId,
+    block_collision::BlockCollisionRegistry, chunk::BlockState, loot::PackOverlay, nbt::Tag,
+    registry::BlockStateId,
 };
 use serde_json::Value;
 use std::{
@@ -522,11 +523,11 @@ pub fn main() -> horizon_client::Result<()> {
     let registry = assets.registry;
     let facts = BlockFacts::load(root, registry)?;
     let data = MobData::load(root, &facts);
-    let items = Items::tags_only(root)?;
+    let items = Items::tags_only(root, &PackOverlay::NONE)?;
     // Trial spawner rewards: the loot tables and the configs.
     let loot = if input.contains("mode=trial") || input.contains("mode=vault") {
         horizon_client::mobs::trial_spawner::load_registry(root);
-        horizon_client::structure_blocks::loot_data(root)
+        horizon_client::structure_blocks::loot_data(root, &PackOverlay::NONE)
     } else {
         None
     };
@@ -795,7 +796,7 @@ pub fn main() -> horizon_client::Result<()> {
                 chunk,
                 &mut gen_random,
                 &mut rules,
-                &mut spawn,
+                &mut |l, r, _| spawn(l, r).is_some(),
                 &mut |e| match e {
                     GenEvent::Column(x, z) => log.push(format!("col {x} {z}")),
                     GenEvent::Spawn(t, p, yaw) => spawns.push(format!(

crates/horizon-client/examples/probe/particle_providers_probe.rs

@@ -76,6 +76,14 @@ fn options(case: &Value) -> Option<ParticleOptions> {
             ..ParticleOptions::simple(ty)
         },
         ParticleType::SculkCharge => ParticleOptions::sculk_charge(scale),
+        ParticleType::Geyser | ParticleType::GeyserPlume => {
+            ParticleOptions::geyser(ty, o["water_blocks"].as_i64()? as i32)
+        }
+        ParticleType::GeyserBase | ParticleType::GeyserPoof => ParticleOptions::geyser_base(
+            ty,
+            o["water_blocks"].as_i64()? as i32,
+            o["burst_impulse_base"].as_f64()? as f32,
+        ),
         ParticleType::Shriek => ParticleOptions::shriek(scale as i32),
         ParticleType::Trail => {
             let t = &o["target"];

crates/horizon-client/examples/probe/place_recipe_fixture.rs

@@ -10,6 +10,7 @@ use horizon_client::{
     items::Items,
     menu::{Env, Kind, Menu, place::PostPlace},
 };
+use horizon_world::loot::PackOverlay;
 use serde_json::Value;
 use std::{fs, path::Path};
 
@@ -34,9 +35,9 @@ pub fn main() -> horizon_client::Result<()> {
     let root = Path::new(args.get(1).ok_or(usage)?);
     let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
     let orders = fs::read_to_string(args.get(3).ok_or(usage)?)?;
-    let items = Items::catalog(root)?;
-    let recipes = Recipes::load(root, &items)?;
-    let brewing = horizon_client::brewing::Brewing::load(root, &items);
+    let items = Items::catalog(root, &PackOverlay::NONE)?;
+    let recipes = Recipes::load(root, &items, &PackOverlay::NONE)?;
+    let brewing = horizon_client::brewing::Brewing::load(root, &items, &PackOverlay::NONE);
     let banners = horizon_client::banner::Banners::default();
     let station_recipes = horizon_client::stations::StationRecipes::default();
     let enchantments = horizon_client::enchant::Enchantments::default();

crates/horizon-client/examples/probe/raid_fixture.rs

@@ -19,6 +19,7 @@ use horizon_client::{
     raid::{self, Action, BarName, RaidLevel, RaidPlayer, RaiderInfo, Raids},
 };
 use horizon_core::random::{LegacyRandom, RandomSource};
+use horizon_world::loot::PackOverlay;
 use horizon_world::{chunk::BlockState, nbt::Tag, registry::BlockStateId};
 use std::{
     cell::RefCell,
@@ -470,7 +471,7 @@ pub fn main() -> horizon_client::Result<()> {
     let registry = assets.registry;
     let facts = BlockFacts::load(root, registry)?;
     let data = MobData::load(root, &facts);
-    let items = Items::tags_only(root)?;
+    let items = Items::tags_only(root, &PackOverlay::NONE)?;
     let attributes = GameplayAttributes::load(root);
     let shared = Shared {
         facts: &facts,

crates/horizon-client/examples/probe/recipe_book_fixture.rs

@@ -9,6 +9,7 @@ use horizon_protocol::{
     buf::{Codec, Reader, Writer},
     packets::recipes::RecipeBookChangeSettings,
 };
+use horizon_world::loot::PackOverlay;
 use horizon_world::nbt::Tag;
 use serde_json::Value;
 use std::{collections::BTreeSet, fs, path::Path};
@@ -66,7 +67,7 @@ pub fn main() -> horizon_client::Result<()> {
     let usage = "usage: recipe_book_fixture RESOURCES CASES OUTPUT";
     let root = Path::new(args.get(1).ok_or(usage)?);
     let cases = fs::read_to_string(args.get(2).ok_or(usage)?)?;
-    let index = RecipeIndex::load(root);
+    let index = RecipeIndex::load(root, &PackOverlay::NONE);
     let mut out = String::new();
     for line in cases.lines() {
         let case: Value = serde_json::from_str(line)?;