Attributes: static registry ids, not format! per mob and tick

The type's default of an attribute (base_value, read by mob movement and
every tick's entity tracking) and the LAN attribute sync built the id
"minecraft:<name>" with format! on each call: for a server's 2000 mobs that
is several allocations per mob per tick. Attr::id returns the id as a
static string.

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

.github/pull_request_template.md

@@ -21,6 +21,12 @@
 <!-- The vanilla classes and methods this follows (tools/rea_vanilla.py), and the harness that checks it.
      "Horizon-only" for a feature vanilla doesn't have; "none" for tooling or docs. -->
 
+## Other projects' code
+
+<!-- "none", or for each project you read or copied from: its link at the commit, its license (only MIT,
+     BSD-2-Clause, BSD-3-Clause, Apache-2.0, ISC, zlib, 0BSD, MIT-0, Unlicense or CC0-1.0), and what you took.
+     CONTRIBUTING.md "Only original code". -->
+
 ## Self-check
 
 <!-- Paste the block `python3 tools/pr_ready.py` prints (`--base upstream/main` from a fork). -->

.github/workflows/ci.yml

@@ -1,7 +1,7 @@
 name: checks
 # verify: every pull request and every push to main, on GitHub's runners (the repository is public). It is the
-# check main requires, so it never has a condition: a skipped job counts as passed, and every run of this workflow
-# must report a real verify (a pull request that changes no Rust finishes it in seconds instead).
+# check main requires, so it always runs: a skipped job counts as passed, and every run of this workflow must report
+# a real verify. It gathers the python, clippy and tests jobs (a change to docs alone skips their Rust steps).
 # parity: the vanilla harnesses a pull request's changes can affect, on the Mac mini's runner, which holds the
 # maintainer's own Minecraft files (Horizon never downloads the game); .github/workflows/parity.yml. Only for a pull
 # request that changes a harness, oracle, probe or the runner: the rest are checked on main by parity-main. A fork's pull
@@ -24,7 +24,10 @@ env:
   HORIZON_TELEMETRY_URL: "off"
 
 jobs:
-  verify:
+  # verify's checks run as three jobs at once (python, clippy, tests: ~4 min instead of ~8 one after another), and
+  # verify gathers them. A failed job makes its dependents skip, and a skipped required check counts as passed, so
+  # verify runs always() and fails unless all three passed.
+  python:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
@@ -34,6 +37,28 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
+      # A pull request adds only its own commits to main, so it reads those; main's pushes read every ref's history.
+      - name: Keep game artifacts out of Git
+        env:
+          EVENT: ${{ github.event_name }}
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: |
+          python tools/check_public_tree.py
+          if [ "$EVENT" = pull_request ]; then
+            python tools/check_public_tree.py --range "$BASE_SHA..$HEAD_SHA"
+          else
+            python tools/check_public_tree.py --history
+          fi
+      - name: Test offline research tooling
+        run: python -m unittest discover -s tests -v
+  clippy:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - name: Does this pull request need Rust checks?
         if: github.event_name == 'pull_request'
         id: rust
@@ -41,22 +66,16 @@ jobs:
           BASE_SHA: ${{ github.event.pull_request.base.sha }}
           HEAD_SHA: ${{ github.event.pull_request.head.sha }}
         run: python3 tools/ci/rust_changes.py "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
-      - name: Keep game artifacts out of Git
-        run: |
-          python tools/check_public_tree.py
-          python tools/check_public_tree.py --history
-      - name: Test offline research tooling
-        run: python -m unittest discover -s tests -v
       - name: Install Rust toolchain and the ALSA and udev headers the client links against
         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
-      # Dependencies and the workspace's own build, saved from main's runs (pull requests read main's cache).
+      # Dependencies and the workspace's own check, saved from main's runs (pull requests read main's cache).
       - uses: Swatinem/rust-cache@v2
         if: steps.rust.outputs.required != 'false'
         with:
-          shared-key: verify
+          shared-key: verify-clippy
           save-if: ${{ github.ref == 'refs/heads/main' }}
       - name: Check formatting and lint
         if: steps.rust.outputs.required != 'false'
@@ -65,8 +84,35 @@ jobs:
           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
-      # Libraries, binaries and integration tests, then doc tests: not the ~275 examples, which clippy above already
+  tests:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Does this pull request need Rust checks?
+        if: github.event_name == 'pull_request'
+        id: rust
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: python3 tools/ci/rust_changes.py "$BASE_SHA" "$HEAD_SHA" >> "$GITHUB_OUTPUT"
+      - name: Install Rust toolchain and the ALSA and udev headers the client links against
+        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
+      # 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'
+        with:
+          shared-key: verify
+          save-if: ${{ github.ref == 'refs/heads/main' }}
+      # Libraries, binaries and integration tests, then doc tests: not the ~275 examples, which clippy already
       # type-checks and the parity job builds and runs (they were most of this step's build and link time).
+      # cargo test, not nextest: nextest's process per test reloads each binary's shared tables for every test, and on
+      # these 4-core runners it was no faster (#4978).
       - name: Test Rust core and voxel kernel correctness
         if: steps.rust.outputs.required != 'false'
         run: |
@@ -75,6 +121,18 @@ jobs:
           # prepared vanilla data, so without it they pass at once.
           cargo +stable test --workspace --lib mod_content::tests:: -- --ignored
           cargo +stable test --workspace --doc
+  verify:
+    if: always()
+    needs: [python, clippy, tests]
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: Did python, clippy and tests pass?
+        env:
+          RESULTS: ${{ join(needs.*.result, ' ') }}
+        run: |
+          echo "python, clippy, tests: $RESULTS"
+          for result in $RESULTS; do [ "$result" = success ] || exit 1; done
   # 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/game-build.yml

@@ -1,6 +1,7 @@
 name: game build
 # Builds the game for every platform from `ref`: the Java exporters, then Linux and the Linux server and Windows on
-# GitHub, macOS on the Mac mini's runner with a 1500-frame offscreen run of a new world (smoke-test.json). Called by
+# GitHub, macOS on the Mac mini's runner with a 1500-frame offscreen run of a new world (smoke-test.json): Apple
+# Silicon, and Intel cross-built there for x86_64-apple-darwin and checked under Rosetta 2 (#1161). Called by
 # release.yml (the releases) and nightly-build.yml (the opt-in Nightly), always from main's copy of this file: the
 # caller's commit, never the one being built. It holds no secrets: signing the checksums is the callers' own job,
 # which never runs what this one built. See docs/release-flow.md.
@@ -104,6 +105,13 @@ jobs:
             mac: true
             dir: horizon-macos-arm64
             asset: horizon-macos-arm64.zip
+          # Intel Macs: built on the same runner for another target; its checks and smoke test run the x86_64
+          # programs under Rosetta 2.
+          - name: macos-x64
+            mac: true
+            target: x86_64-apple-darwin
+            dir: horizon-macos-x64
+            asset: horizon-macos-x64.zip
     runs-on: ${{ matrix.mac && (inputs.trusted && vars.MAC_RUNNER || fromJSON('["self-hosted", "macOS", "horizon-nightly"]')) || matrix.os }}
     # Notarizing the zip can take a few minutes.
     timeout-minutes: ${{ matrix.mac && 60 || 40 }}
@@ -114,6 +122,8 @@ jobs:
       HORIZON_VERSION: ${{ inputs.version }}
       # A nightly's date and commit ("2026-10-28 0c02067"), which the game shows; empty for a release.
       HORIZON_NIGHTLY: ${{ inputs.nightly }}
+      # Where cargo puts the programs: target/release, or target/<target>/release for another target.
+      BIN: ${{ matrix.target && format('target/{0}/release', matrix.target) || 'target/release' }}
     defaults:
       run:
         shell: bash
@@ -128,6 +138,8 @@ jobs:
           # keeps its preparations outside the checkout.
           clean: true
       - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v2
         if: runner.environment == 'github-hosted'
         with:
@@ -138,11 +150,11 @@ jobs:
         if: runner.os == 'Linux'
         run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
       - name: Build the client, horizon-ctl, horizon-prepare and horizon-server
-        run: cargo build --release --locked -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
+        run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
       - name: Every program the release folder takes was built
         run: |
           for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
-            test -f "target/release/$binary${{ matrix.exe }}" || { echo "::error::target/release/$binary${{ matrix.exe }} is missing"; exit 1; }
+            test -f "$BIN/$binary${{ matrix.exe }}" || { echo "::error::$BIN/$binary${{ matrix.exe }} is missing"; exit 1; }
           done
       - name: The signing keychain, unlocked
         if: runner.os == 'macOS' && vars.MACOS_SIGN_IDENTITY != '' && inputs.developer_id
@@ -157,15 +169,15 @@ jobs:
         run: |
           for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
             codesign --force --options runtime --timestamp --keychain "$MACOS_SIGN_KEYCHAIN" \
-              --identifier "dev.horizon.${binary#horizon-}" --sign "$MACOS_SIGN_IDENTITY" "target/release/$binary"
-            codesign --verify --strict --verbose=2 "target/release/$binary"
+              --identifier "dev.horizon.${binary#horizon-}" --sign "$MACOS_SIGN_IDENTITY" "$BIN/$binary"
+            codesign --verify --strict --verbose=2 "$BIN/$binary"
           done
       - name: Only system libraries
         # Windows: no non-system DLL (a "DLL not found" dialog on some players' machines). Linux: the standard
         # loader and libraries every desktop distribution has. macOS: only the system's own libraries.
         run: |
           for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
-            file="target/release/$binary${{ matrix.exe }}"
+            file="$BIN/$binary${{ matrix.exe }}"
             if [[ "$RUNNER_OS" == macOS ]]; then
               others=$(otool -L "$file" | tail -n +2 | awk '{print $1}' | grep -v -E '^(/usr/lib/|/System/Library/)' || true)
               [[ -z "$others" ]] || { echo "::error::$binary links $others"; exit 1; }
@@ -176,7 +188,7 @@ jobs:
       - name: Every program starts
         run: |
           set -euo pipefail
-          bin=target/release
+          bin=$BIN
           "$bin/horizon-client${{ matrix.exe }}" --help | grep -q -- '--resources'
           "$bin/horizon-ctl${{ matrix.exe }}" --help > /dev/null
           "$bin/horizon-prepare${{ matrix.exe }}" --help | grep -q -- '--minecraft-dir'
@@ -202,7 +214,7 @@ jobs:
           home="$RUNNER_TEMP/horizon-smoke"
           rm -rf "$home" && mkdir -p "$home"
           version=$(sed -n 's/.*"version": *"\([^"]*\)".*/\1/p' research-lock.json | head -1)
-          client="$PWD/target/release/horizon-client"
+          client="$PWD/$BIN/horizon-client"
           resources="$PWD/.local/horizon-client/$version"
           (cd "$home" && HORIZON_HOME="$home" HORIZON_NO_AUDIO=1 "$client" --resources "$resources" --offscreen \
             --world smoke --seed 1 --render-distance 4 --world-frames 1500 --timeout-seconds 180 \
@@ -217,8 +229,9 @@ jobs:
           EOF
           # Published with the release; the publish job checks it again before it publishes anything.
           cp "$home/smoke.json" "$RUNNER_TEMP/smoke-test.json"
+      # One smoke-test.json per build, the Apple Silicon one's; the Intel build must pass its own run too.
       - uses: actions/upload-artifact@v4
-        if: runner.environment == 'self-hosted'
+        if: runner.environment == 'self-hosted' && !matrix.target
         with:
           name: smoke-test.json
           path: ${{ runner.temp }}/smoke-test.json
@@ -231,7 +244,7 @@ jobs:
       - name: Package
         run: |
           set -euo pipefail
-          cargo run --locked -p xtask -- package "target/release/horizon-client${{ matrix.exe }}" "dist/${{ matrix.dir }}"
+          cargo run --locked -p xtask -- package "$BIN/horizon-client${{ matrix.exe }}" "dist/${{ matrix.dir }}"
           cd dist
           rm -f "${{ matrix.asset }}"
           case "${{ matrix.asset }}" in

.github/workflows/launcher.yml

@@ -8,7 +8,8 @@ name: launcher
 # feature. The version and the tag are given to the build (HORIZON_LAUNCHER_VERSION, HORIZON_LAUNCHER_TAG): no bump
 # commits.
 # Never marked latest. Pushes to launcher branches only build. RELEASES_PAUSED=1 stops releases.
-# macOS: with the repository variable MACOS_SIGN_IDENTITY set, Horizon.app and the .dmg are signed with
+# macOS: Apple Silicon, and Intel cross-built for x86_64-apple-darwin on the same runner, its tests and smoke test
+# under Rosetta 2 (#1161). With the repository variable MACOS_SIGN_IDENTITY set, Horizon.app and the .dmg are signed with
 # Developer ID, notarized and stapled, from the runner's signing keychain (packaging/macos/README.md);
 # unset (forks), they are signed ad hoc.
 #   gh workflow run launcher --ref <branch>                    # dry run: builds everything, publishes nothing
@@ -105,6 +106,13 @@ jobs:
             mac: true
             asset: horizon-launcher-macos-arm64.zip
             binary: horizon-launcher
+            mac_arch: arm64
+          - name: macos-x64
+            mac: true
+            target: x86_64-apple-darwin
+            asset: horizon-launcher-macos-x64.zip
+            binary: horizon-launcher
+            mac_arch: x64
           - name: windows
             os: windows-latest
             asset: horizon-launcher-windows-x64.zip
@@ -117,6 +125,8 @@ jobs:
     timeout-minutes: ${{ matrix.mac && 60 || 40 }}
     env:
       RUSTFLAGS: ${{ matrix.rustflags }}
+      # Where cargo puts the launcher: target/release, or target/<target>/release for another target.
+      BIN: ${{ matrix.target && format('target/{0}/release', matrix.target) || 'target/release' }}
       # Horizon's Azure app for Microsoft sign-in (docs/microsoft-account.md): a repository
       # variable, not a secret. Unset, the launcher says sign-in is not configured.
       HORIZON_MSA_CLIENT_ID: ${{ vars.HORIZON_MSA_CLIENT_ID }}
@@ -140,6 +150,8 @@ jobs:
           # parity jobs, and nothing they leave may end up in a launcher release (target/ is rebuilt from scratch).
           clean: true
       - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v2
         if: runner.environment == 'github-hosted'
         with:
@@ -160,17 +172,17 @@ jobs:
             echo "LAUNCHER_FEATURES=gpui/runtime_shaders" >> "$GITHUB_ENV"
           fi
       # Every test target (the library, the binary, tests/), on each system the launcher ships for.
-      - run: cargo test --release --locked ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
-      - run: cargo build --release --locked ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
+      - run: cargo test --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
+      - run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} ${LAUNCHER_FEATURES:+--features "$LAUNCHER_FEATURES"}
       - name: The version is the release's
         run: |
-          out=$(target/release/${{ matrix.binary }} --version)
+          out=$("$BIN/${{ matrix.binary }}" --version)
           echo "$out"
           expected="${HORIZON_LAUNCHER_VERSION:-$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)}"
           [[ "$out" == "horizon-launcher $expected" ]] || { echo "::error::expected horizon-launcher $expected"; exit 1; }
       - name: Only system libraries
         run: |
-          file=target/release/${{ matrix.binary }}
+          file="$BIN/${{ matrix.binary }}"
           case "$RUNNER_OS" in
             Windows) python ../tools/check_imports.py "$file" ;;
             macOS) others=$(otool -L "$file" | tail -n +2 | awk '{print $1}' | grep -v -E '^(/usr/lib/|/System/Library/)' || true)
@@ -185,13 +197,28 @@ jobs:
           export HORIZON_LAUNCHER_HOME="${RUNNER_TEMP//\\//}/horizon-launcher-smoke"
           export HORIZON_HOME="$HORIZON_LAUNCHER_HOME/game"
           rm -rf "$HORIZON_LAUNCHER_HOME"
-          launcher="$PWD/target/release/${{ matrix.binary }}"
+          launcher="$PWD/$BIN/${{ matrix.binary }}"
           # GitHub's API rate-limits shared runner addresses now and then: try a few times.
           retry() { for i in 1 2 3 4; do "$@" && return 0; sleep $((i * 15)); done; return 1; }
           retry "$launcher" versions
+          "$launcher" links --json
+          # The Intel Mac launcher can come out before any game build has its asset (#1161): then there is nothing
+          # to install yet. Only that entry skips, and only on a version list that parsed and had no build here
+          # (exit 3); a launcher or a script that fails still fails the step.
+          if [[ "${{ matrix.name }}" == macos-x64 ]]; then
+            versions=$(retry "$launcher" --json versions)
+            no_build='import json, sys; sys.exit(3 if not any(r["available_here"] for r in json.load(sys.stdin)) else 0)'
+            status=0
+            python3 -c "$no_build" <<<"$versions" || status=$?
+            if [[ $status == 3 ]]; then
+              echo "::warning::No game build has an asset for ${{ matrix.name }} yet: install not tested"
+              rm -rf "$HORIZON_LAUNCHER_HOME"
+              exit 0
+            fi
+            [[ $status == 0 ]] || exit $status
+          fi
           retry "$launcher" install latest
           "$launcher" versions --installed
-          "$launcher" links --json
           # `install latest` is the Nightly since #3342 (versions/nightly-<date>-<commit>), a vX.Y.Z before.
           clients=("$HORIZON_LAUNCHER_HOME"/versions/*/horizon-client*)
           client="${clients[0]}"
@@ -224,11 +251,11 @@ jobs:
             # Developer ID): packaging/macos.
             python3 -m venv "$RUNNER_TEMP/dmg" && "$RUNNER_TEMP/dmg/bin/pip" install --quiet dmgbuild==1.6.5
             version=${HORIZON_LAUNCHER_VERSION:-$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)}
-            DMGBUILD="$RUNNER_TEMP/dmg/bin/dmgbuild" ../packaging/macos/package.sh target/release/${{ matrix.binary }} "$version" out
+            DMGBUILD="$RUNNER_TEMP/dmg/bin/dmgbuild" ../packaging/macos/package.sh "$BIN/${{ matrix.binary }}" "$version" out ${{ matrix.mac_arch }}
             rm -rf out/Horizon.app
           else
             mkdir -p dist
-            cp target/release/${{ matrix.binary }} dist/
+            cp "$BIN/${{ matrix.binary }}" dist/
             if [[ "${{ matrix.asset }}" == *.tar.gz ]]; then
               (cd dist && tar czf ../out/${{ matrix.asset }} ${{ matrix.binary }})
             else

.github/workflows/nightly-build.yml

@@ -172,7 +172,8 @@ jobs:
           EPHEMERAL: ${{ needs.pick.outputs.dry_run == 'true' && 'yes' || '' }}
         run: |
           bash tools/ci/sign_release.sh nightly dist/horizon-linux-x86_64.tar.gz dist/horizon-windows-x64.zip \
-            dist/horizon-macos-arm64.zip dist/horizon-server-linux-x86_64.tar.gz dist/horizon-source.tar.gz
+            dist/horizon-macos-arm64.zip dist/horizon-macos-x64.zip dist/horizon-server-linux-x86_64.tar.gz \
+            dist/horizon-source.tar.gz
       - uses: actions/upload-artifact@v4
         with:
           name: signature
@@ -235,7 +236,8 @@ jobs:
             --title "Nightly $DATE · ${SHA:0:7}" --notes-file dist/nightly-notes.md \
             "dist/horizon-linux-x86_64.tar.gz#Game files the launcher installs (Nightly): Linux (horizon-linux-x86_64.tar.gz)" \
             "dist/horizon-windows-x64.zip#Game files the launcher installs (Nightly): Windows (horizon-windows-x64.zip)" \
-            "dist/horizon-macos-arm64.zip#Game files the launcher installs (Nightly): macOS (horizon-macos-arm64.zip)" \
+            "dist/horizon-macos-arm64.zip#Game files the launcher installs (Nightly): macOS on Apple Silicon (horizon-macos-arm64.zip)" \
+            "dist/horizon-macos-x64.zip#Game files the launcher installs (Nightly): macOS on Intel (horizon-macos-x64.zip)" \
             "dist/horizon-server-linux-x86_64.tar.gz#Nightly dedicated server for Linux (horizon-server-linux-x86_64.tar.gz)" \
             "dist/horizon-source.tar.gz#Source of this Nightly, commit ${SHA:0:7} (horizon-source.tar.gz; kept for good as the tag $SOURCE_TAG)" \
             dist/SHA256SUMS "${signature[@]}" dist/smoke-test.json

CONTRIBUTING.md

@@ -47,14 +47,31 @@ them (`git config core.hooksPath .githooks` runs it before every commit).
 The pre-push hook checks the full history reachable from the branches and tags being pushed. Run
 `python3 tools/check_public_tree.py --history` to audit the history of all local refs.
 
-## Only original code
+## Only original code, or code whose license allows it
 
-Horizon's code is written from Minecraft 26.3 itself and from public documentation, never from another mod, loader
-or renderer. Don't read, copy, translate or paraphrase the source of Iris, OptiFine, Sodium or any other project,
-and don't send code an AI tool wrote from it. Their user documentation and file formats are fine to read, and their
-packs and mods are fine to run and observe. Shader packs were removed on 24 October 2026 (#1561) because their code
-had been written from another project's source; they come back only as a clean-room rewrite from a written
-description of the pack format.
+Horizon is MIT. Its code is written from Minecraft 26.3 itself and from public documentation. Since 30 October 2026
+another project's source may also be read and used, **only when that project's license allows it**:
+
+- **Allowed:** MIT, MIT-0, BSD-2-Clause, BSD-3-Clause, 0BSD, ISC, zlib, Apache-2.0, Unlicense, and the CC0-1.0
+  public-domain dedication. That code may be read, copied or adapted.
+- **Everything else is off limits, even to read:** GPL, LGPL (Iris), AGPL, MPL, EPL, Polyform (Sodium), the Creative
+  Commons licenses (CC BY, CC BY-SA, CC BY-NC and the others; CC0 is a public-domain dedication, not one of them),
+  custom or "source available" licenses, all rights reserved (OptiFine), and any project with no license or an
+  unclear one. Don't read, copy, translate or paraphrase their source, and don't send code an AI tool
+  wrote from it. Being able to download a mod or a pack does not give you the right to read its files.
+- **Check the license yourself.** Read the LICENSE file at the commit you use and the header of each file you take:
+  some repositories mix licenses, and a file under another license is off limits. A license that changed: the one
+  at your commit counts. In doubt, don't: ask in #contributors first.
+- **Say it in the pull request:** the project, a link to the commit, its license, and what you read or copied. A
+  pull request that used another project's source without saying so is closed.
+- **Copied or adapted code** keeps its copyright line and license notice at the top of the file, and gets an entry
+  in [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md). Apache-2.0 code also keeps its NOTICE text and says what
+  was changed.
+
+User documentation and file formats are fine to read, and packs and mods are fine to run and observe, whatever
+their license. Shader packs were removed on 24 October 2026 (#1561) because their code had been written from
+another project's source; they come back only as a clean-room rewrite from a written description of the pack
+format.
 
 ## Before asking for review
 
@@ -82,7 +99,8 @@ claimed on Discord with Kira's `/claim`): pick another, or ask its holder in the
 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.
+5 days, with a comment: open a draft early. You can hold 8 open issues at a time, not counting the ones your
+pull requests already fix. 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.

Cargo.lock

@@ -830,6 +830,16 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "fs4"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e72ed92b67c146290f88e9c89d60ca163ea417a446f61ffd7b72df3e7f1dfd5"
+dependencies = [
+ "rustix 1.1.5",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "futures-core"
 version = "0.3.34"
@@ -1117,6 +1127,7 @@ dependencies = [
  "bytemuck",
  "chrono",
  "flate2",
+ "fs4",
  "gilrs",
  "glam",
  "horizon-anticheat",

Cargo.toml

@@ -53,7 +53,10 @@ large_enum_variant = "allow"
 # UHD 620/630) crashes on it with an access violation (#746). It also fixes the
 # Metal backend's lookup of the CoreGraphics HDR colour space names, which handed
 # CoreGraphics a symbol's address as the string and crashed HDR output on macOS.
-# Drop this and the folder once a wgpu release has both fixes.
+# And gfx-rs/wgpu#10714: on Windows, Vulkan waits for the acquire fence only in
+# FIFO (VSync), where it was meant to pace frames; with VSync off it made every
+# frame wait for the GPU to finish the one before (#4604).
+# Drop this and the folder once a wgpu release has these fixes.
 [patch.crates-io]
 wgpu-hal = { path = "third_party/wgpu-hal" }
 

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="docs/media/banner.webp" alt="Horizon: Minecraft: Java Edition 26.3, rewritten in Rust and checked against vanilla by more than 300 differential harnesses" width="100%">
+  <img src="docs/media/banner.webp" alt="The Horizon website: the game you know, rebuilt in Rust" width="100%">
 </p>
 
 <p align="center">
@@ -24,34 +24,32 @@
 
 # Horizon
 
-Horizon is Minecraft: Java Edition 26.3 rewritten in Rust: a native game that reads the same worlds, follows the same rules and generates the same terrain as the Java game, and is checked against it by more than 300 differential harnesses. You play it through a small launcher, on the files from your own copy of Minecraft. It is free, open source and unofficial.
+Minecraft: Java Edition 26.3, rewritten in Rust. Same worlds, same rules, same terrain, checked against the Java game by more than 300 differential harnesses. Free, open source and unofficial.
 
-> Not an official Minecraft product. Not approved by or associated with Mojang or Microsoft. Horizon contains no Minecraft code, assets or data: you need your own legally obtained copy of Minecraft: Java Edition 26.3.
+> Not an official Minecraft product, nor approved by or associated with Mojang or Microsoft. Horizon contains no Minecraft code, assets or data: you need your own copy of Java Edition 26.3.
 
 ## Download
 
-Horizon is installed through **the Horizon launcher**. Get it from [playhorizon.dev](https://playhorizon.dev) (the Download button picks your system) or from [the launcher releases](https://github.com/horizon-rust/horizon/releases?q=launcher-v&expanded=true), for Linux x86-64, macOS on Apple Silicon or Windows x64. The launcher installs the game and keeps it up to date with each new build (Horizon ships on one channel, the Nightly), prepares its files from your copy of Minecraft (your own install, or downloaded from Mojang for your account), and updates itself.
+Get **the Horizon launcher** from [playhorizon.dev](https://playhorizon.dev) or [the launcher releases](https://github.com/horizon-rust/horizon/releases?q=launcher-v&expanded=true) (Linux x86-64, macOS on Apple Silicon, macOS on Intel from the next Nightly, Windows x64). It installs and updates the game, prepares its files from your copy of Minecraft, and updates itself.
 
-**You need** a Microsoft account that owns Minecraft: Java Edition (the launcher signs in with it, as other launchers do; see [Microsoft account](docs/microsoft-account.md)) and a GPU with Vulkan or OpenGL 3.3 on Linux, Vulkan or DirectX 12 on Windows, or any Apple Silicon Mac. Nothing else: with no Minecraft on your computer, Play downloads 26.3 and the Java it needs from Mojang for your account, as the official launcher does, then prepares it once. An install you already have (the official launcher, Prism, MultiMC and other launchers all work) is used instead. Step by step, with macOS's first-open prompt and the first launch: [Install and first launch](https://playhorizon.dev/docs/install).
+**You need** a Microsoft account that owns Java Edition ([why](docs/microsoft-account.md)) and a GPU with Vulkan or OpenGL 3.3 (Linux), Vulkan or DirectX 12 (Windows), or a Mac (Apple Silicon, or Intel from the next Nightly). An existing Minecraft install (official launcher, Prism, MultiMC...) is reused; without one, Play downloads 26.3 from Mojang for your account. Step by step: [Install and first launch](https://playhorizon.dev/docs/install).
 
 <table>
   <tr>
-    <td width="50%"><img src="docs/media/launcher-play.webp" alt="The launcher's Play page: a version ready to play, its summary, Client and Server, the version picker and Play"></td>
-    <td width="50%"><img src="docs/media/launcher-patch-notes.webp" alt="The launcher's Patch notes page"></td>
+    <td width="50%"><img src="docs/media/launcher-play.webp" alt="The launcher's Home page: the selected instance ready to play, the version picker, Join a friend and the instance's tabs"></td>
+    <td width="50%"><img src="docs/media/launcher-settings.webp" alt="The launcher's Settings page: Microsoft account, offline name, updates, appearance and accent colour"></td>
   </tr>
 </table>
 
 ## What works today
 
-The [documentation](https://playhorizon.dev/docs/) covers each of these.
+- **The game:** vanilla world generation, mobs, villagers, raids, redstone, every command, the HUD and the recipe book, on vanilla saves. Worlds from 1.8 to 26.2 are upgraded. [Status](#project-status).
+- **Extras:** new menus, graphics presets, distant terrain up to 1024 chunks, controllers, zoom, minimap and more, off by default where they change the vanilla look. [Settings](https://playhorizon.dev/docs/settings).
+- **Packs:** resource packs, and data packs with functions, predicates, item modifiers and world generation.
+- **Multiplayer:** invite friends with a code, Open to LAN, join servers (online mode included). [Multiplayer](https://playhorizon.dev/docs/multiplayer).
+- **Mods:** content mods (blocks, items, data) and native Rust mods, built by the launcher with nothing to install. Java mod jars do not run. [Mods](https://playhorizon.dev/docs/mods).
 
-- **The game:** singleplayer with vanilla's world generation, mobs, villagers, raids, redstone, every command, the HUD and the recipe book, on saves in vanilla's format. Worlds from 1.8 to 26.2 are upgraded as vanilla does. [Status table](#project-status).
-- **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, taller levels included (vanilla's 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:** 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:
+In the Rust client, with vanilla assets and no mods or shaders:
 
 <table>
   <tr>
@@ -69,15 +67,15 @@ Screenshots, captured in the Rust client itself with vanilla assets and no mods
 
 ## Host a server
 
-The launcher's **Servers** page creates, starts, backs up and updates a Horizon server with buttons, and invites friends over Tailscale. On a VPS, `horizon-server` installs with one command and runs without Java. Guide: [Host a server](https://playhorizon.dev/docs/hosting) ([reference](docs/hosting.md)).
+The launcher's **Servers** page creates, starts, backs up and updates a server, and invites friends over Tailscale. On a VPS, `horizon-server` installs with one command and needs no Java. [Host a server](https://playhorizon.dev/docs/hosting) ([reference](docs/hosting.md)).
 
 ## Modpacks
 
-The launcher's **Modpacks** page imports a Modrinth or CurseForge pack, shows which of its mods Horizon can carry over, and plays the ones it can as their own profile. Today that means content mods made of data and assets; mods with Java code are not ported yet. See [Modpacks](https://playhorizon.dev/docs/modpacks).
+The launcher imports Modrinth and CurseForge packs and plays the mods Horizon can carry over: today, content mods made of data and assets, not Java code. [Modpacks](https://playhorizon.dev/docs/modpacks).
 
 ## Agent control
 
-AI agents and scripts can play Horizon. `horizon-ctl`, shipped beside the game in every release folder, is a command line that reads the game as JSON and acts like a player; `horizon-ctl mcp` serves the same commands as an MCP server (one tool per command, screenshots returned as images).
+AI agents and scripts can play Horizon. `horizon-ctl`, shipped with the game, reads its state as JSON and acts like a player; `horizon-ctl mcp` serves the same commands over MCP.
 
 ```sh
 horizon-ctl launch --world Survival --seed 5 --wait   # finds the version the launcher installed
@@ -88,16 +86,14 @@ horizon-ctl break -1 65 -3                              # mines it; replies with
 horizon-ctl open-inventory && horizon-ctl click-slot 0  # menus: slots, buttons by label, text fields
 ```
 
-Commands block until the action is done and reply with what happened; errors are JSON with distinct exit codes, `horizon-ctl help` lists every command and `horizon-ctl COMMAND --help` explains one with examples. It talks to the game over a Unix socket on Linux and macOS and over a token-protected localhost port on Windows. See [Agent control in the native client guide](docs/native-client.md#agent-control-horizon-ctl-and-mcp).
+Commands block until done and reply with the result; `horizon-ctl help` lists them all. [Agent control](docs/native-client.md#agent-control-horizon-ctl-and-mcp).
 
 ## Build from source
 
-For developers. Requirements: Rust 1.90 or newer, Python 3.10 or newer, JDK 25, and on Linux the ALSA and udev development headers (`libasound2-dev libudev-dev` on Debian and Ubuntu). Development and the vanilla harnesses run on Linux.
+Needs Rust 1.90+, Python 3.10+, JDK 25, and on Linux `libasound2-dev libudev-dev`. `horizon-prepare` builds the game's resources from **your own copy** of Java Edition 26.3 (checked against `research-lock.json`) and never downloads it:
 
-Horizon contains no game files, and `horizon-prepare` never downloads them (the launcher downloads them from Mojang only for a signed-in account that owns the game). It builds its resources from **your own copy** of Minecraft: Java Edition 26.3, verified against the checksums in `research-lock.json`:
-
-1. **Client:** install Java Edition with the official launcher and play 26.3 once. Horizon reads `versions/26.3/`, `libraries/` and `assets/` from the launcher's game directory (`~/.minecraft` on Linux). If yours lives elsewhere, pass `--minecraft-dir` or set `HORIZON_MINECRAFT_DIR`.
-2. **Server jar:** the 26.3 server jar, from the `downloads.server.url` in your launcher's `versions/26.3/26.3.json` (or [minecraft.net/download/server](https://www.minecraft.net/en-us/download/server) while 26.3 is the current release). Pass it with `--server-jar` or set `HORIZON_SERVER_JAR`. It is only needed the first time.
+1. **Client:** play 26.3 once in the official launcher. Horizon reads `~/.minecraft` (or `--minecraft-dir` / `HORIZON_MINECRAFT_DIR`).
+2. **Server jar:** the 26.3 server jar (`downloads.server.url` in `versions/26.3/26.3.json`), passed once with `--server-jar` or `HORIZON_SERVER_JAR`.
 
 ```sh
 git clone https://github.com/horizon-rust/horizon.git
@@ -107,62 +103,49 @@ cargo run --release -p horizon-prepare -- sounds   # optional: sounds from your
 cargo run --release -p horizon-client
 ```
 
-Everything prepared lands in the gitignored `.local/`. It is derived from the game: never commit it or share it.
-
-The client starts on the title screen. Command-line options (`--world`, `--seed`, `--creative`, `--render-distance`, `--dedicated`), controls, scripting through `horizon-ctl` and the architecture are described in [the native client guide](docs/native-client.md). The rest of the developer documentation is indexed in [docs/README.md](docs/README.md), including [the parity workflow](docs/parity-workflow.md).
+Prepared files land in the gitignored `.local/`: never commit or share them. Options, controls and architecture: [the native client guide](docs/native-client.md); all developer docs: [docs/README.md](docs/README.md).
 
 ## Roadmap
 
-What is being done now, what comes next and where you can help, in plain words and in technical detail: [ROADMAP.md](ROADMAP.md). [playhorizon.dev/hub](https://playhorizon.dev/hub) shows it with the work board, the journal of what shipped and how to help.
+What is in progress, what comes next and where to help: [ROADMAP.md](ROADMAP.md), or [playhorizon.dev/hub](https://playhorizon.dev/hub) with the work board and what shipped.
 
 ## Contributing
 
-Issues and pull requests are welcome: see [CONTRIBUTING.md](CONTRIBUTING.md) for how we work (vanilla first, small pull requests, labels), or [the contributing guide](https://playhorizon.dev/docs/contributing) on the site. Questions and ideas: [Discord](https://discord.gg/HcTeMZxe5E). Before opening a pull request, run the self-check and paste the block it prints:
+Issues and pull requests are welcome: read [CONTRIBUTING.md](CONTRIBUTING.md) (vanilla first, small pull requests). Questions: [Discord](https://discord.gg/HcTeMZxe5E). Before a pull request, run the self-check and paste its output:
 
 ```sh
 git config core.hooksPath .githooks
 python3 tools/pr_ready.py
 ```
 
-It runs rustfmt, clippy with warnings denied, the tests of the crates you touched, the Python tests, the public-tree check, and the vanilla harnesses your change can affect. CI runs the same checks on GitHub's Linux runners; the vanilla harnesses need the game, which Horizon never downloads, so they run on a maintainer's computer holding their own copy. Never commit game files, decompiled source or prepared resources: `tools/check_public_tree.py` rejects them, and tracked Java is allowed only under the project's own `dev/horizonlab` namespace.
+It runs rustfmt, clippy, the touched crates' tests, the Python tests, the public-tree check and the vanilla harnesses your change affects. Never commit game files, decompiled source or prepared resources.
 
 ## 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.
+The table is the project's own audit: every subsystem matches vanilla in every harness that compares it. 100% means 100% of what the harnesses compare, not that nothing else differs.
 
 ### Java parity: 100%
 
-Each subsystem scores 0 (absent), 0.25 (started, not playable), 0.5 (playable,
-major vanilla features missing), 0.75 (playable, mostly complete) or 1 (complete
-and verified against vanilla by differential tests). The percentage is the
-average; `tests/test_parity.py` keeps it in sync with this table. Last audited
-2026-10-13 against the harness results: all 281 harnesses pass on Linux, each
-rerun whenever one of its inputs changed, and the Mac mini now runs every one of
-them too (Rust uses Java's own float maths on each platform).
-
-The harnesses measure behaviour. A second measure is method by method: the [port ledger](tools/port_ledger.py)
-lists every method of vanilla 26.3 next to the Rust functions that port it, with a verdict for each one
-(ported, folded into another function, missing, or needing no port), and the untested ports. Run
-`python3 tools/port_ledger.py build`, then `coverage`, with the vanilla data in `.local/`.
+Scores: 0 (absent), 0.25 (started), 0.5 (playable, major features missing), 0.75 (mostly complete) or 1 (complete and verified by differential tests); the percentage is their average. Last audited 2026-10-13: all 281 harnesses pass on Linux and macOS. The [port ledger](tools/port_ledger.py) adds a method-by-method view of what is ported.
 
 | Subsystem | Score | Main gaps |
 | --- | ---: | --- |
-| Window, input and game loop | 1 | None: the game loop, options, camera, auto-jump, toggle sprint/sneak, local input and the frame limiter match vanilla |
-| Assets and resources | 1 | None: item models match vanilla over 196,290 stacks and the client draws every item through them; the resource pack screen matches vanilla's drawing over 3,000 sessions of clicks, scrolling and searching, its incompatibility confirmation included |
-| Network protocol and multiplayer | 1 | None: joins vanilla servers; the dedicated server (`--dedicated`) matches vanilla's files, status ping, login, configuration, play, chunks, chat, recipes, advancements and command tree, a client built from vanilla's packet code joins it, Horizon joins a vanilla server, and LAN discovery matches over 462 cases (offline mode only) |
+| Window, input and game loop | 1 | None: game loop, options, camera, auto-jump, toggle sprint/sneak and frame limiter match |
+| Assets and resources | 1 | None: item models match over 196,290 stacks; the resource pack screen over 3,000 sessions |
+| Network protocol and multiplayer | 1 | None: joins vanilla servers; the dedicated server matches vanilla's files, login, configuration, play and command tree; LAN discovery over 462 cases (offline mode only) |
 | Chunk storage and palettes | 1 | None: client and saves share paletted containers, identical to vanilla over 266 scenarios |
 | Section meshing | 1 | None: 112 scenes and over a million quads identical to vanilla |
-| Rendering | 1 | None: entity models, block entity renderers (407 cases, End portals, gateways and the loom's banner preview included) and their animations (296 cases, End gateway beams included), the HUD overlays (2,200 states), the recipe book (600 states), the player list, subtitles and the world border match vanilla |
+| Rendering | 1 | None: entity models, block entity renderers (407 cases) and animations (296), HUD overlays (2,200 states), the recipe book (600), player list, subtitles and world border match |
 | Lighting | 1 | None: saved and relit light matches vanilla, slabs and stairs included |
 | World generation | 1 | None: 2,352 whole chunks over 225 structure sites, in all three dimensions, identical to vanilla |
-| Region files and saves | 1 | None: saves round-trip with vanilla, and worlds from 1.8 to 26.2 upgrade as vanilla's DataFixers do, superflat worlds included; old options.txt and hotbar.nbt files are upgraded too |
-| Entities and physics | 1 | None: attributes, dimensions, death loot, spawn rules, natural spawning (15,500 cases), raids and patrols (1,900 cases), spawned mobs' gear, enchantments and state (`finalizeSpawn`, 24,000 cases) and mob AI (92 scenarios: villager breeding and gossip, the warden, ghastlings and copper golems included) match vanilla |
-| Interaction and inventory | 1 | None: menu clicks match over 8,000 click sequences, the loom and the crafter included; recipe book placement (6,000 cases), its buttons (1,200), the saved book (1,500) and the loom and crafter screens (1,600) match vanilla |
-| Menus, HUD and chat | 1 | None: every command runs as vanilla (758 commands over 39,685 parsed inputs), scoreboards and teams match (81,000 operations), the player list matches over 872,000 draw calls with heads drawn from players' skins (authlib's textures, SkinManager's lookup, legacy skin conversion), and the chat matches focused and scrolled; the resource pack screen (selection over 4,000 cases, drawing and its incompatibility confirmation over 3,000 sessions) and the chat input with its command suggestions, usage lines, Tab completion and history (3,000 sessions on vanilla's client command tree) match vanilla |
+| Region files and saves | 1 | None: saves round-trip with vanilla; worlds from 1.8 to 26.2 upgrade as vanilla's DataFixers do |
+| Entities and physics | 1 | None: attributes, spawn rules, natural spawning (15,500 cases), raids and patrols (1,900), `finalizeSpawn` (24,000) and mob AI (92 scenarios) match |
+| Interaction and inventory | 1 | None: menu clicks over 8,000 sequences; recipe book placement (6,000), buttons (1,200), saved book (1,500), loom and crafter screens (1,600) |
+| Menus, HUD and chat | 1 | None: every command (758 over 39,685 inputs), scoreboards (81,000 operations), the player list (872,000 draw calls), chat and its suggestions (3,000 sessions) match |
 | Audio | 1 | None: the sound engine, sound events, music, situational music, ambience and subtitles match vanilla |
-| Block behaviours and ticking | 1 | None: block updates, random ticks, redstone, dispensers (6,000 cases), crafters (4,000 crafts), block entity removal (containers spill, 4,000 cases), copper golem chest sorting and the sculk family (435 scenarios: shrieker warnings and warden summoning included) match vanilla |
+| Block behaviours and ticking | 1 | None: block updates, random ticks, redstone, dispensers (6,000 cases), crafters (4,000), container spills (4,000), copper golems and the sculk family (435 scenarios) match |
 
 ### Known issues
 
@@ -170,9 +153,7 @@ Skins served over https show the default skin unless already cached; pack icons
 
 ## Licence
 
-[MIT](LICENSE), for the project's original work only. Dependencies keep their own licences. Minecraft is a trademark of Mojang Synergies AB; Minecraft code and assets belong to Mojang and Microsoft and are covered by the [Minecraft EULA](https://www.minecraft.net/en-us/eula). Decompiled game source and prepared resources stay on your machine and are never published.
-
-Third-party credits and licenses: [Third-party notices](THIRD_PARTY_NOTICES.md).
+[MIT](LICENSE), for the project's original work; dependencies keep their own licences ([notices](THIRD_PARTY_NOTICES.md)). Minecraft is a trademark of Mojang Synergies AB; its code and assets belong to Mojang and Microsoft under the [Minecraft EULA](https://www.minecraft.net/en-us/eula).
 
 ## Author
 

ROADMAP.md

@@ -326,11 +326,11 @@ A mapping table from intermediary and SRG names so pre-26.1 jars can be classifi
 
 #### A modpack's own resource and shader packs
 
-Importing a modpack also brings the resource packs and shader packs it ships with, where Horizon can use them.
+Imported modpacks carry their resource packs into a profile of their own. Shader-pack conversion is still pending.
 
 <details><summary>Technical</summary>
 
-Porting a pack carries data, assets and worldgen today; the resource packs and shader packs bundled with it are left out. Resource packs can be carried as they are; shader packs go through the converter ([docs/modpacks.md](docs/modpacks.md)).
+Resource-pack carry-over is implemented locally: Modrinth common/client overrides, CurseForge's override folder, installed instances (ZIP and directory packs), and hash-checked indexed ZIP downloads. The launcher keeps profile edits and lets resource-only profiles play; packs are enabled in Resource Packs. Synthetic import and profile tests cover the file pipeline; in-game rendering has not been verified. Shader-pack conversion is still pending, so this combined item remains partial ([docs/modpacks.md](docs/modpacks.md)).
 
 </details>
 

THIRD_PARTY_NOTICES.md

@@ -3,8 +3,9 @@
 ## wgpu-hal
 
 `third_party/wgpu-hal` is [wgpu-hal](https://github.com/gfx-rs/wgpu) 30.0.1 by the gfx-rs
-developers, with one upstream fix applied
-([gfx-rs/wgpu#10124](https://github.com/gfx-rs/wgpu/pull/10124)). It is licensed under MIT or
+developers, with upstream fixes applied
+([gfx-rs/wgpu#10124](https://github.com/gfx-rs/wgpu/pull/10124),
+[gfx-rs/wgpu#10714](https://github.com/gfx-rs/wgpu/pull/10714)). It is licensed under MIT or
 Apache-2.0; both licenses are in that folder (`LICENSE.MIT`, `LICENSE.APACHE`).
 
 ## Pixelify Sans

bench/bench.py

@@ -0,0 +1,457 @@
+#!/usr/bin/env python3
+"""Server load bench: the same horizon-bots load on Horizon, vanilla 26.3 or Pumpkin.
+
+    python3 bench/bench.py --server horizon --exe target/release/horizon-server --bots 50
+    python3 bench/bench.py --server vanilla --jar ~/mc/server.jar --bots 50 --pre-generated ~/worlds/seed12345
+    python3 bench/bench.py --server pumpkin --exe ./pumpkin --bots 50
+
+Every run uses a fresh scratch folder (bound to 127.0.0.1, offline, creative so the bots can fly), starts the
+server, lets `horizon-bots` join one every --join-every seconds, warms up, then measures for --seconds:
+
+- TPS: `time query gametime` at the start and the end of the window, as game ticks per wall-clock second;
+- MSPT: `tick query` every 5 s (average, P50, P95, P99 over the last 100 ticks), averaged over the window;
+- RSS and CPU of the server's whole process tree, once a second (needs `ps`: Linux and macOS);
+- bandwidth: `bytes_in`/`bytes_out` from the bots' report, per player and second online (each bot's whole time
+  on the server, its join included), when the bots report them (they do not yet: the field is null until S-6); join time: the bots' `joined_after_ms`.
+
+It writes one JSON report (--out) and prints the Markdown table of the design (docs/design.md, section 1).
+
+Vanilla is the owner's own server.jar (--jar): nothing of Mojang's is fetched or committed. Pumpkin is a released
+binary run as a black box (--exe); its Bedrock listeners, LAN broadcast and telemetry are turned off in the
+config this script writes (--pumpkin-config adds a TOML file of your own on top if a release names a key
+differently). `--pre-generated DIR` copies a finished world into every run's scratch folder as `world`, so runs
+repeat on the same terrain. Build the bots first: cargo build --release -p horizon-bots
+"""
+
+import argparse
+import datetime
+import json
+import os
+from pathlib import Path
+import platform
+import re
+import shutil
+import socket
+import statistics
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+
+ROOT = Path(__file__).resolve().parent.parent
+EXE = '.exe' if os.name == 'nt' else ''
+SERVERS = ('horizon', 'vanilla', 'pumpkin')
+
+PROPERTIES = {
+    'level-seed': '12345',
+    'view-distance': '10',
+    'simulation-distance': '10',
+    'online-mode': 'false',
+    'white-list': 'false',
+    'gamemode': 'creative',
+    'force-gamemode': 'true',
+    'spawn-protection': '0',
+    'max-players': '200',
+    'difficulty': 'easy',
+    'server-ip': '127.0.0.1',
+    'enable-query': 'false',
+    'enable-rcon': 'false',
+}
+
+# Pumpkin's two config files. Bedrock, LAN broadcast and telemetry (plugins' included) are off.
+PUMPKIN_CONFIGURATION = '''\
+server_address = "127.0.0.1:{port}"
+seed = "{seed}"
+max_players = 200
+view_distance = {view}
+simulation_distance = {view}
+online_mode = false
+default_difficulty = "Easy"
+allow_chat_reports = false
+encryption = false
+lan_broadcast = false
+
+[networking.bedrock]
+enabled = false
+
+[networking.lan_broadcast]
+enabled = false
+
+[networking.query]
+enabled = false
+
+[networking.rcon]
+enabled = false
+'''
+PUMPKIN_FEATURES = '''\
+[telemetry]
+enabled = false
+
+[plugins]
+enabled = false
+'''
+
+DONE = re.compile(r'Done|listening|Server started', re.IGNORECASE)
+TICK_AVERAGE = re.compile(r'Average time per tick: ([0-9.]+) ?ms')
+TICK_PERCENTILES = re.compile(r'P50: ([0-9.]+) ?ms P95: ([0-9.]+) ?ms P99: ([0-9.]+) ?ms')
+GAMETIME = re.compile(r'The time is (-?\d+)')
+
+
+def free_port():
+    with socket.socket() as s:
+        s.bind(('127.0.0.1', 0))
+        return s.getsockname()[1]
+
+
+def parse_tick_query(lines):
+    """MSPT numbers from the lines `tick query` printed, or None until both lines are there."""
+    average = percentiles = None
+    for line in lines:
+        if (m := TICK_AVERAGE.search(line)) and average is None:
+            average = float(m.group(1))
+        if (m := TICK_PERCENTILES.search(line)) and percentiles is None:
+            percentiles = tuple(float(g) for g in m.groups())
+    if average is None or percentiles is None:
+        return None
+    return {'average': average, 'p50': percentiles[0], 'p95': percentiles[1], 'p99': percentiles[2]}
+
+
+def parse_gametime(lines):
+    """The game time `time query gametime` printed, or None."""
+    for line in lines:
+        if m := GAMETIME.search(line):
+            return int(m.group(1))
+    return None
+
+
+def tps(start_ticks, end_ticks, seconds):
+    """Game ticks per wall-clock second over the window, or None when a query went unanswered."""
+    if start_ticks is None or end_ticks is None or seconds <= 0:
+        return None
+    return round((end_ticks - start_ticks) / seconds, 2)
+
+
+def percentile(values, p):
+    if not values:
+        return None
+    ordered = sorted(values)
+    return ordered[min(len(ordered) - 1, int(p / 100 * len(ordered)))]
+
+
+def cpu_seconds(text):
+    """ps's cumulative CPU time: [[DD-]HH:]MM:SS[.ss]."""
+    days, _, rest = text.rpartition('-')
+    seconds = 0.0
+    for part in rest.split(':'):
+        seconds = seconds * 60 + float(part)
+    return seconds + (float(days) * 86400 if days else 0)
+
+
+def tree_usage(root):
+    """RSS (bytes) and CPU seconds of a process and all its descendants; None without `ps`."""
+    try:
+        out = subprocess.run(['ps', '-A', '-o', 'pid=,ppid=,rss=,time='], capture_output=True, text=True).stdout
+    except OSError:
+        return None
+    rows = {}
+    for line in out.splitlines():
+        parts = line.split()
+        if len(parts) == 4:
+            rows[int(parts[0])] = (int(parts[1]), int(parts[2]) * 1024, cpu_seconds(parts[3]))
+    tree, frontier = {root}, [root]
+    while frontier:
+        parent = frontier.pop()
+        for pid, (ppid, _, _) in rows.items():
+            if ppid == parent and pid not in tree:
+                tree.add(pid)
+                frontier.append(pid)
+    return sum(rows[p][1] for p in tree if p in rows), sum(rows[p][2] for p in tree if p in rows)
+
+
+def prepare(kind, directory, port, args):
+    """Writes the server's settings into its scratch folder and returns the command that starts it."""
+    directory = Path(directory)
+    if args.pre_generated:
+        shutil.copytree(args.pre_generated, directory / 'world')
+    props = dict(PROPERTIES, **{'server-port': str(port), 'level-seed': str(args.seed),
+                                'view-distance': str(args.view_distance),
+                                'simulation-distance': str(args.view_distance)})
+    if kind == 'pumpkin':
+        config = directory / 'config'
+        config.mkdir()
+        (config / 'configuration.toml').write_text(PUMPKIN_CONFIGURATION.format(
+            port=port, seed=args.seed, view=args.view_distance))
+        (config / 'features.toml').write_text(PUMPKIN_FEATURES)
+        if args.pumpkin_config:
+            with (config / 'configuration.toml').open('a') as f:
+                f.write('\n' + Path(args.pumpkin_config).read_text())
+        return [Path(args.exe).resolve()]
+    (directory / 'server.properties').write_text(''.join(f'{k}={v}\n' for k, v in props.items()))
+    (directory / 'eula.txt').write_text('eula=true\n')
+    if kind == 'vanilla':
+        return ['java', f'-Xms{args.heap}', f'-Xmx{args.heap}', '-jar', Path(args.jar).resolve(), 'nogui']
+    server = Path(args.exe).resolve()
+    subprocess.run([server, '--dir', directory, 'import', directory / 'server.properties'], check=True,
+                   capture_output=True)
+    toml = directory / 'server.toml'
+    # No web panel in a bench.
+    toml.write_text(re.sub(r'(?m)^bind = "127\.0\.0\.1:8130"', 'bind = ""', toml.read_text()))
+    return [server, '--dir', directory, 'run']
+
+
+class Server:
+    """A server with its console on stdin and its output collected."""
+
+    def __init__(self, command, directory, log_path):
+        self.lines = []
+        self.lock = threading.Lock()
+        self.log = log_path.open('w', encoding='utf-8')
+        env = dict(os.environ, HORIZON_NO_AUDIO='1', HORIZON_HOME=str(directory / 'horizon-home'),
+                   HORIZON_LAUNCHER_NO_SELF_UPDATE='1')
+        self.process = subprocess.Popen([str(c) for c in command], cwd=directory, stdin=subprocess.PIPE,
+                                        stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True,
+                                        encoding='utf-8', errors='replace', env=env)
+        threading.Thread(target=self._read, daemon=True).start()
+
+    def _read(self):
+        for line in self.process.stdout:
+            with self.lock:
+                self.lines.append(line.rstrip('\n'))
+            self.log.write(line)
+            self.log.flush()
+
+    def count(self):
+        with self.lock:
+            return len(self.lines)
+
+    def since(self, n):
+        with self.lock:
+            return self.lines[n:]
+
+    def wait_for(self, regex, timeout):
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if any(regex.search(line) for line in self.since(0)):
+                return
+            if self.process.poll() is not None:
+                raise RuntimeError('the server exited:\n' + '\n'.join(self.since(0)[-20:]))
+            time.sleep(0.1)
+        raise RuntimeError(f'the server was not up within {timeout} s')
+
+    def ask(self, command, parse, timeout=5):
+        """Sends a console command and returns parse(its output lines), or None if nothing parsed in time."""
+        start = self.count()
+        try:
+            self.process.stdin.write(command + '\n')
+            self.process.stdin.flush()
+        except (BrokenPipeError, OSError):
+            return None
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            if (value := parse(self.since(start))) is not None:
+                return value
+            time.sleep(0.05)
+        return None
+
+    def stop(self):
+        if self.process.poll() is None:
+            try:
+                self.process.stdin.write('stop\n')
+                self.process.stdin.flush()
+                self.process.wait(timeout=60)
+            except (BrokenPipeError, OSError, subprocess.TimeoutExpired):
+                self.process.kill()
+                self.process.wait()
+        self.log.close()
+
+
+def bots_command(args, port, total):
+    return [str(args.bots_bin), '--server', f'127.0.0.1:{port}', '--bots', str(args.bots),
+            '--behaviour', args.behaviour, '--join-every', str(args.join_every), '--seconds', str(int(total)),
+            '--seed', str(args.seed), '--view-distance', str(args.view_distance), '--report', '-']
+
+
+def split_bot_output(lines):
+    """The per-second samples (JSON lines with a `t`) and the final summary the bots printed."""
+    samples, rest = [], []
+    for line in lines:
+        try:
+            sample = json.loads(line)
+        except ValueError:
+            sample = None
+        if isinstance(sample, dict) and 't' in sample:
+            samples.append(sample)
+        else:
+            rest.append(line)
+    text = ''.join(rest)
+    return samples, (json.loads(text) if text.strip() else {})
+
+
+def bytes_per_player_second(per_bot, run_seconds, join_every):
+    """The bots' bytes over the seconds they were connected: bot i connects i * join_every after the first and
+    stays to the end of the run. So it is each bot's average from its login on, its join included, not the
+    measuring window's alone (the bots report one total at the end). None until the bots count bytes (S-6)."""
+    counted = [(i, b) for i, b in enumerate(per_bot) if 'bytes_in' in b and not b.get('error')]
+    online = sum(max(run_seconds - i * join_every, 0) for i, _ in counted)
+    if not counted or online <= 0:
+        return None
+    return {k: round(sum(b.get(k, 0) for _, b in counted) / online) for k in ('bytes_in', 'bytes_out')}
+
+
+def summarize(kind, args, ticks, rss, cpu, gametime, window_seconds, summary, start_seconds, run_seconds):
+    mean = lambda xs: round(statistics.fmean(xs), 2) if xs else None
+    joins = [b['joined_after_ms'] for b in summary.get('per_bot', []) if b.get('joined_after_ms', 0) > 0]
+    bandwidth = bytes_per_player_second(summary.get('per_bot', []), run_seconds, args.join_every)
+    return {
+        'server': kind,
+        'bots': args.bots,
+        'behaviour': args.behaviour,
+        'start_seconds': start_seconds,
+        'tps': tps(*gametime, window_seconds),
+        'mspt': {k: mean([t[k] for t in ticks]) for k in ('average', 'p50', 'p95', 'p99')},
+        'mspt_worst_p99': max((t['p99'] for t in ticks), default=None),
+        'rss_mb': {'mean': mean([r / 1e6 for r in rss]), 'max': round(max(rss) / 1e6, 1) if rss else None},
+        'cpu_percent': mean(cpu),
+        'bytes_per_player_second': bandwidth,
+        'join_ms': {'p50': percentile(joins, 50), 'worst': max(joins, default=None)},
+        'bots_joined': summary.get('joined'),
+        'bots_failed': [b for b in summary.get('per_bot', []) if b.get('error')],
+        'chunks_total': summary.get('chunks'),
+        'tick_queries': len(ticks),
+    }
+
+
+def run_once(kind, args, out):
+    scratch = Path(tempfile.mkdtemp(prefix=f'horizon-bench-{kind}-'))
+    result = {'server': kind, 'bots': args.bots, 'behaviour': args.behaviour}
+    server = None
+    try:
+        port = free_port()
+        command = prepare(kind, scratch, port, args)
+        started = time.time()
+        server = Server(command, scratch, out / f'{kind}-{args.bots}.log')
+        server.wait_for(DONE, args.start_timeout)
+        start_seconds = round(time.time() - started, 2)
+        total = args.bots * args.join_every + args.warmup + args.seconds
+        bot_process = subprocess.Popen(bots_command(args, port, total), stdout=subprocess.PIPE,
+                                       stderr=subprocess.PIPE, text=True)
+        bot_lines = []
+        threading.Thread(target=lambda: bot_lines.extend(bot_process.stdout), daemon=True).start()
+        time.sleep(args.bots * args.join_every + args.warmup)
+        first_time = server.ask('time query gametime', parse_gametime)
+        began = time.time()
+        rss, cpu, ticks = [], [], []
+        usage = tree_usage(server.process.pid)
+        last_cpu, last_time = (usage[1] if usage else 0), time.time()
+        next_query = time.time()
+        while time.time() - began < args.seconds:
+            time.sleep(1)
+            now = time.time()
+            if usage and (u := tree_usage(server.process.pid)):
+                rss.append(u[0])
+                cpu.append((u[1] - last_cpu) / (now - last_time) * 100)
+                last_cpu, last_time = u[1], now
+            if now >= next_query:
+                if (t := server.ask('tick query', parse_tick_query)) is not None:
+                    ticks.append(t)
+                next_query = now + 5
+        window = time.time() - began
+        last = server.ask('time query gametime', parse_gametime)
+        bot_process.wait(timeout=total + 120)
+        time.sleep(0.5)
+        _, summary = split_bot_output(list(bot_lines))
+        result.update(summarize(kind, args, ticks, rss, cpu, (first_time, last), window, summary, start_seconds,
+                                total))
+    except Exception as e:  # a failed run is reported, and the next one still runs
+        result['error'] = str(e)
+    finally:
+        if server:
+            server.stop()
+        shutil.rmtree(scratch, ignore_errors=True)
+    return result
+
+
+def table(runs):
+    """The Markdown table of the design: one column per server, one row per measure."""
+    ok = [r for r in runs if 'error' not in r]
+    head = '| | ' + ' | '.join(r['server'] for r in ok) + ' |\n|---|' + '---|' * len(ok) + '\n'
+    def cell(r, path):
+        value = r
+        for key in path:
+            value = value.get(key) if isinstance(value, dict) else None
+        return '-' if value is None else str(value)
+    rows = [
+        ('Players', ('bots',)),
+        ('TPS', ('tps',)),
+        ('MSPT average', ('mspt', 'average')),
+        ('MSPT p99 (mean of 5 s queries)', ('mspt', 'p99')),
+        ('MSPT p99 (worst query)', ('mspt_worst_p99',)),
+        ('RSS mean MB', ('rss_mb', 'mean')),
+        ('CPU %', ('cpu_percent',)),
+        ('Bytes in per player and s online', ('bytes_per_player_second', 'bytes_in')),
+        ('Join p50 ms', ('join_ms', 'p50')),
+        ('Join worst ms', ('join_ms', 'worst')),
+        ('Start s', ('start_seconds',)),
+    ]
+    body = ''.join(f'| {name} | ' + ' | '.join(cell(r, path) for r in ok) + ' |\n' for name, path in rows)
+    failed = ''.join(f'\n{r["server"]} failed: {r["error"].splitlines()[0]}\n' for r in runs if 'error' in r)
+    return head + body + failed
+
+
+def check(args):
+    for kind in args.server:
+        if kind not in SERVERS:
+            sys.exit(f'--server: {kind!r} is not one of {", ".join(SERVERS)}')
+    if 'vanilla' in args.server and not args.jar:
+        sys.exit('vanilla needs --jar, your own server.jar')
+    if any(k != 'vanilla' for k in args.server) and not args.exe:
+        sys.exit('horizon and pumpkin need --exe, the server binary')
+    if not Path(args.bots_bin).exists():
+        sys.exit(f'{args.bots_bin} is missing: cargo build --release -p horizon-bots')
+    if args.pre_generated and not Path(args.pre_generated).is_dir():
+        sys.exit(f'--pre-generated {args.pre_generated} is not a folder')
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__.split('\n\n')[0])
+    parser.add_argument('--server', type=lambda s: s.split(','), default=['horizon'],
+                        help='horizon, vanilla or pumpkin (comma-separated, one run each)')
+    parser.add_argument('--exe', help='the horizon-server or Pumpkin binary')
+    parser.add_argument('--jar', help="vanilla's server.jar (your own copy)")
+    parser.add_argument('--bots-bin', default=str(ROOT / 'target/release' / f'horizon-bots{EXE}'))
+    parser.add_argument('--bots', type=int, default=50)
+    parser.add_argument('--behaviour', default='mixed')
+    parser.add_argument('--join-every', type=float, default=0.5)
+    parser.add_argument('--warmup', type=int, default=30)
+    parser.add_argument('--seconds', type=int, default=60)
+    parser.add_argument('--seed', type=int, default=12345)
+    parser.add_argument('--view-distance', type=int, default=10)
+    parser.add_argument('--heap', default='4g', help='the Java heap for vanilla')
+    parser.add_argument('--pre-generated', help='a finished world folder, copied into every run as `world`')
+    parser.add_argument('--pumpkin-config', help='extra TOML appended to Pumpkin\'s configuration.toml')
+    parser.add_argument('--start-timeout', type=int, default=600)
+    parser.add_argument('--out', type=Path, default=ROOT / '.local/bench', help='the folder for report.json and logs')
+    args = parser.parse_args(argv)
+    check(args)
+    args.out.mkdir(parents=True, exist_ok=True)
+    runs = []
+    for kind in args.server:
+        print(f'{kind}, {args.bots} {args.behaviour} bots...', flush=True)
+        runs.append(run_once(kind, args, args.out))
+        print(json.dumps(runs[-1]), flush=True)
+    report = {
+        'kind': 'horizon-bench',
+        'date': datetime.datetime.now(datetime.timezone.utc).isoformat(timespec='seconds'),
+        'machine': {'system': platform.system(), 'machine': platform.machine(), 'cpus': os.cpu_count()},
+        'settings': {k: str(v) if isinstance(v, Path) else v for k, v in vars(args).items()},
+        'runs': runs,
+    }
+    path = args.out / 'report.json'
+    path.write_text(json.dumps(report, indent=2) + '\n')
+    print('\n' + table(runs) + f'\nWrote {path}')
+    return 1 if any('error' in r for r in runs) else 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

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

@@ -3,8 +3,8 @@ name = "{name}"
 version = "0.1.0"
 description = ""
 authors = []
-# A content mod: blocks and items from data/ and assets/, no code (API 0.2).
+# A content mod: blocks, items and mob effects from data/ and assets/, no code (API 0.2).
 api = "0.2"
 side = "both"
-# registries: "May add blocks and items to your worlds".
+# registries: "May add blocks, items and mob effects to your worlds".
 capabilities = ["registries"]

crates/horizon-anticheat/src/lib.rs

@@ -13,6 +13,7 @@
 
 use serde::{Deserialize, Serialize};
 
+pub mod prediction;
 pub mod timer;
 
 /// What one check's violation level leads to.
@@ -131,6 +132,20 @@ checks! {
     /// the ground to skip fall damage) and walking on water. The claim is always dropped, so vanilla's
     /// fall damage follows; from `setback` on the player is also sent back.
     ground: Ground => GroundConfig [5.0, 15.0, 60.0, 2.0] {}
+
+    /// Prediction: each move played again from the client's own inputs with vanilla's movement code,
+    /// and compared (speed, step, fly, jesus...). Each player's client ticks are recorded
+    /// (`prediction::Record`), with a ping a tick to place what the server changes, and played again
+    /// (horizon-client's `lan::prediction`). A move that lands farther than `tolerance` from the
+    /// replay flags, by how far it lands (one `tolerance` off weighs 1, at most 5 a tick), and the
+    /// setback puts the player back where its moves last agreed. A tick near what the replay can't
+    /// play yet (another entity, a block change or abilities the client hadn't seen, a moving piston,
+    /// a chunk the client doesn't have, a riptide launch) is excused, and so are the ticks after it
+    /// until the moves agree again.
+    prediction: Prediction => PredictionConfig [5.0, 15.0, 60.0, 2.0] {
+        /// How far, in blocks, a move may land from where the replay puts it.
+        tolerance: f64 = 0.03,
+    }
 }
 
 /// How many checks there are.
@@ -171,6 +186,10 @@ impl Config {
                 ));
             }
         }
+        let tolerance = self.prediction.tolerance;
+        if !tolerance.is_finite() || tolerance <= 0.0 {
+            return Err("anticheat.prediction: tolerance is a number of blocks above 0".into());
+        }
         Ok(())
     }
 }
@@ -198,6 +217,8 @@ pub struct Player {
     pub timer: timer::Balance,
     /// The server tick and height where the ground last held the player.
     pub ground: Option<(u64, f64)>,
+    /// The client ticks the prediction plays again (only while it runs).
+    pub record: Option<Box<prediction::Record>>,
 }
 
 impl Player {
@@ -257,6 +278,8 @@ mod tests {
         assert_eq!(c.timer.kick, 0.0);
         assert_eq!(c.timer.tolerance_ms, 500.0);
         assert_eq!(c.timer.alert, TimerConfig::default().alert);
+        let zero = "[anticheat]\n[anticheat.prediction]\ntolerance = 0\n";
+        assert!(Config::from_server_toml(zero).is_err());
         let off = "[anticheat]\nenabled = true\n[anticheat.timer]\nenabled = false\n";
         assert!(!Config::from_server_toml(off).unwrap().runs(Check::Timer));
     }

crates/horizon-anticheat/src/prediction.rs

@@ -0,0 +1,404 @@
+//! The movement prediction's record: each of a player's client ticks as the server heard them, so
+//! the server can play the tick again with vanilla's movement code and compare (docs/anticheat.md).
+//!
+//! A vanilla client ends every tick with ServerboundClientTickEndPacket, after the tick's input
+//! (ServerboundPlayerInputPacket, sent when the keys change) and its move (ServerboundMovePlayerPacket,
+//! when it moved or turned). Those packets arrive in order, so the packets between two tick ends are one
+//! client tick.
+//!
+//! What the server changes about the player (a push, a teleport, an effect) takes effect on the client
+//! when it handles the packet, which is some client ticks after the server sent it. At the end of each of
+//! its ticks the server sends a ClientboundPingPacket whose id is that server tick; the client answers
+//! with ServerboundPongPacket as soon as it handles it, before its next tick runs. A client tick knows
+//! the last server tick it had handled: every change of that server tick or an earlier one was in effect
+//! during the client tick, none of a later one.
+
+use std::collections::VecDeque;
+
+/// Client ticks kept: two seconds at 20 a second.
+pub const KEPT: usize = 40;
+
+/// Server changes kept, the oldest dropped first.
+const CHANGES_KEPT: usize = 64;
+
+/// Changes near the player kept until every kept tick has seen them.
+const NEAR_KEPT: usize = 1024;
+
+/// Something the server sent the player that changes how its client moves. The client applies it when
+/// it handles the packet, before its next tick.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Change {
+    /// ClientboundSetEntityMotionPacket for the player itself: its new velocity, as the client
+    /// decodes it.
+    Velocity([f64; 3]),
+    /// ClientboundExplodePacket's player knockback, added to the velocity.
+    Knockback([f64; 3]),
+    /// ClientboundUpdateAttributesPacket or a mob effect for the player itself: the server's
+    /// attributes and effects, as they are when the replay reaches it.
+    State,
+    /// ClientboundPlayerAbilitiesPacket (a game mode, flight given or taken), or the player's chest
+    /// slot (a glider put on or taken off): the replay takes these from the server every tick, so a
+    /// tick played before the client had them may be off.
+    Abilities,
+}
+
+/// A teleport the client accepted: the replay starts again from it.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Restart {
+    /// Where it put the player.
+    pub at: [f64; 3],
+    /// It kept the player's motion (an End gateway's).
+    pub kept_motion: bool,
+    /// Client ticks ended and changes heard before it: the ones after are the replay's.
+    pub ended: u64,
+    pub changed: u64,
+}
+
+/// One client tick.
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub struct ClientTick {
+    /// The keys held (ServerboundPlayerInputPacket's flags: forward, backward, left, right, jump,
+    /// shift, sprint), as last sent.
+    pub input: u8,
+    /// Sprinting, as the player's commands left it (ServerboundPlayerCommandPacket).
+    pub sprinting: bool,
+    /// The rotation the client last sent.
+    pub yaw: f32,
+    pub pitch: f32,
+    /// Where the tick's move said the player is, if it said: a move with a position.
+    pub position: Option<[f64; 3]>,
+    /// The tick's move packet's flags (1: on the ground, 2: against a wall), if it sent one.
+    pub flags: Option<u8>,
+    /// The last server tick whose packets the client had handled (its pong) before this tick ended.
+    pub seen: Option<u64>,
+}
+
+/// A player's last client ticks.
+#[derive(Clone, Debug, Default)]
+pub struct Record {
+    /// The tick being heard.
+    current: ClientTick,
+    /// The ended ones, oldest first, at most [`KEPT`].
+    ticks: VecDeque<ClientTick>,
+    /// The last server tick the client answered for.
+    seen: Option<u64>,
+    /// Client ticks ended since the record began.
+    ended: u64,
+    /// Where an accepted teleport put the player, until the replay starts again from there.
+    restart: Option<Restart>,
+    /// What the server changed, with the server tick that sent it, oldest first.
+    changes: VecDeque<(u64, Change)>,
+    /// Changes heard since the record began.
+    changed: u64,
+    /// The blocks the server changed near the player (None: an entity it stopped showing the player
+    /// from near it, which counts wherever the player has gone since), with the server tick that sent
+    /// each, until every kept tick has seen them.
+    near: VecDeque<(u64, Option<[i32; 3]>)>,
+    /// The server tick of the last of them dropped early ([`NEAR_KEPT`] came after it).
+    near_dropped: Option<u64>,
+}
+
+impl Record {
+    /// The tick's move: its position if it has one, the rotation if it has one, and its flags.
+    pub fn moved(&mut self, position: Option<[f64; 3]>, rotation: Option<(f32, f32)>, flags: u8) {
+        if position.is_some() {
+            self.current.position = position;
+        }
+        if let Some((yaw, pitch)) = rotation {
+            (self.current.yaw, self.current.pitch) = (yaw, pitch);
+        }
+        self.current.flags = Some(flags);
+    }
+
+    /// ServerboundPongPacket for the ping sent at the end of `server_tick`. False for an answer to a
+    /// ping that was never sent, or one older than an answer already heard: a vanilla client answers
+    /// every ping, once, in order.
+    pub fn pong(&mut self, server_tick: u64, sent_up_to: u64) -> bool {
+        if server_tick > sent_up_to || self.seen.is_some_and(|seen| server_tick <= seen) {
+            return false;
+        }
+        self.seen = Some(server_tick);
+        true
+    }
+
+    /// ServerboundClientTickEndPacket: the tick ends with these keys held and this sprinting. The
+    /// next tick starts with the same keys and rotation, until the client says otherwise.
+    pub fn tick_end(&mut self, input: u8, sprinting: bool) -> &ClientTick {
+        self.current.input = input;
+        self.current.sprinting = sprinting;
+        self.current.seen = self.seen;
+        let next = ClientTick {
+            yaw: self.current.yaw,
+            pitch: self.current.pitch,
+            ..ClientTick::default()
+        };
+        let ended = std::mem::replace(&mut self.current, next);
+        if self.ticks.len() == KEPT {
+            self.ticks.pop_front();
+        }
+        self.ticks.push_back(ended);
+        self.ended += 1;
+        // What the oldest tick kept had seen, every later one had too.
+        if let Some(seen) = self.ticks.front().and_then(|t| t.seen) {
+            while self.near.front().is_some_and(|&(sent, _)| sent <= seen) {
+                self.near.pop_front();
+            }
+            self.near_dropped = self.near_dropped.filter(|&sent| sent > seen);
+        }
+        self.ticks.back().expect("just pushed")
+    }
+
+    /// The ended ticks, oldest first.
+    pub fn ticks(&self) -> impl DoubleEndedIterator<Item = &ClientTick> + ExactSizeIterator {
+        self.ticks.iter()
+    }
+
+    /// The last server tick the client answered for.
+    pub fn seen(&self) -> Option<u64> {
+        self.seen
+    }
+
+    /// Client ticks ended since the record began.
+    pub fn ended(&self) -> u64 {
+        self.ended
+    }
+
+    /// The ticks ended after the first `played`, oldest first; None when some of them are no longer
+    /// kept.
+    pub fn since(&self, played: u64) -> Option<impl Iterator<Item = &ClientTick>> {
+        let new = self.ended.checked_sub(played)?;
+        let new = usize::try_from(new)
+            .ok()
+            .filter(|&n| n <= self.ticks.len())?;
+        Some(self.ticks.iter().skip(self.ticks.len() - new))
+    }
+
+    /// `change`, sent during server tick `server_tick` (before that tick's ping).
+    pub fn changed(&mut self, server_tick: u64, change: Change) {
+        if self.changes.len() == CHANGES_KEPT {
+            self.changes.pop_front();
+        }
+        self.changes.push_back((server_tick, change));
+        self.changed += 1;
+    }
+
+    /// Changes heard since the record began.
+    pub fn changes(&self) -> u64 {
+        self.changed
+    }
+
+    /// The changes after the first `applied`, oldest first; None when some of them are no longer kept.
+    pub fn changes_since(
+        &self,
+        applied: u64,
+    ) -> Option<impl Iterator<Item = &(u64, Change)> + Clone> {
+        let new = self.changed.checked_sub(applied)?;
+        let new = usize::try_from(new)
+            .ok()
+            .filter(|&n| n <= self.changes.len())?;
+        Some(self.changes.iter().skip(self.changes.len() - new))
+    }
+
+    /// During server tick `server_tick` (before that tick's ping) the server sent the client the block
+    /// at `pos`.
+    pub fn changed_near(&mut self, server_tick: u64, pos: [i32; 3]) {
+        self.note_near(server_tick, Some(pos));
+    }
+
+    /// During server tick `server_tick` the server stopped showing the client an entity near it (a
+    /// firework it flew with, a mob that pushed it): the client may still have it, wherever it goes.
+    pub fn entity_gone(&mut self, server_tick: u64) {
+        if self.near.back() != Some(&(server_tick, None)) {
+            self.note_near(server_tick, None);
+        }
+    }
+
+    fn note_near(&mut self, server_tick: u64, pos: Option<[i32; 3]>) {
+        if self.near.len() == NEAR_KEPT {
+            self.near_dropped = self.near.pop_front().map(|(sent, _)| sent);
+        }
+        self.near.push_back((server_tick, pos));
+    }
+
+    /// Whether a client tick that had `seen` up to that server tick (its [`ClientTick::seen`]) may
+    /// not have had a change at a position for which `near` holds: it still had the old block, or the
+    /// entity, where the server no longer has it.
+    pub fn unseen_near(&self, seen: Option<u64>, near: impl Fn([i32; 3]) -> bool) -> bool {
+        let unseen = |sent: u64| seen.is_none_or(|seen| sent > seen);
+        self.near_dropped.is_some_and(unseen)
+            || self
+                .near
+                .iter()
+                .any(|&(sent, pos)| unseen(sent) && pos.is_none_or(&near))
+    }
+
+    /// The client accepted a teleport to `at` (ServerboundAcceptTeleportationPacket): it goes on from
+    /// there, standing still unless the teleport `kept_motion` (an End gateway's). The ticks it ended
+    /// before stay, for a replay that hasn't played them yet; the one under way starts again.
+    pub fn teleported(&mut self, at: [f64; 3], kept_motion: bool) {
+        self.restart_tick();
+        self.restart = Some(Restart {
+            at,
+            kept_motion,
+            ended: self.ended,
+            changed: self.changed,
+        });
+    }
+
+    /// The last teleport the client accepted, once.
+    pub fn take_restart(&mut self) -> Option<Restart> {
+        self.restart.take()
+    }
+
+    /// The ticks before now say nothing about the ones after.
+    pub fn clear(&mut self) {
+        self.ticks.clear();
+        self.restart_tick();
+    }
+
+    fn restart_tick(&mut self) {
+        self.current = ClientTick {
+            yaw: self.current.yaw,
+            pitch: self.current.pitch,
+            ..ClientTick::default()
+        };
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn a_change_near_is_unseen_by_the_ticks_before_its_pong() {
+        let mut r = Record::default();
+        r.changed_near(4, [1, 2, 3]);
+        r.changed_near(5, [7, 2, 3]);
+        let near = |p: [i32; 3]| p[0] < 5;
+        assert!(r.unseen_near(None, near));
+        assert!(r.unseen_near(Some(3), near));
+        assert!(!r.unseen_near(Some(4), near));
+        assert!(r.unseen_near(Some(4), |_| true));
+        // Kept until the oldest tick kept had seen it: one that ended before the pong hadn't.
+        r.tick_end(0, false);
+        assert!(r.pong(5, 5));
+        r.tick_end(0, false);
+        assert!(r.unseen_near(Some(3), near));
+        for _ in 0..KEPT {
+            r.tick_end(0, false);
+        }
+        assert!(!r.unseen_near(None, |_| true));
+        // An entity gone counts anywhere.
+        r.entity_gone(5);
+        r.entity_gone(5);
+        assert!(r.unseen_near(Some(4), |_| false));
+        assert!(!r.unseen_near(Some(5), |_| false));
+        // One dropped early counts for the ticks that hadn't seen it.
+        for i in 0..=NEAR_KEPT as u64 {
+            r.changed_near(6 + i, [100, 0, 0]);
+        }
+        assert!(
+            r.unseen_near(Some(5), near),
+            "a change dropped unseen counts"
+        );
+        assert!(!r.unseen_near(Some(6), near));
+    }
+
+    #[test]
+    fn a_tick_is_the_packets_between_two_tick_ends() {
+        let mut r = Record::default();
+        r.moved(Some([1.0, 2.0, 3.0]), Some((90.0, 10.0)), 1);
+        let t = *r.tick_end(0b1001, true);
+        assert_eq!(t.position, Some([1.0, 2.0, 3.0]));
+        assert_eq!((t.yaw, t.pitch, t.flags), (90.0, 10.0, Some(1)));
+        assert_eq!((t.input, t.sprinting, t.seen), (0b1001, true, None));
+        // A tick without a move keeps the rotation and has no position.
+        let t = *r.tick_end(0, false);
+        assert_eq!((t.position, t.flags, t.yaw), (None, None, 90.0));
+        assert_eq!(r.ticks().len(), 2);
+    }
+
+    #[test]
+    fn pongs_say_which_server_ticks_a_client_tick_had_seen() {
+        let mut r = Record::default();
+        assert!(r.pong(5, 6));
+        r.tick_end(0, false);
+        assert!(r.pong(6, 6));
+        r.tick_end(0, false);
+        r.tick_end(0, false);
+        let seen: Vec<_> = r.ticks().map(|t| t.seen).collect();
+        assert_eq!(seen, [Some(5), Some(6), Some(6)]);
+        // Never sent, answered twice, or out of order.
+        assert!(!r.pong(9, 6));
+        assert!(!r.pong(6, 6));
+        assert!(!r.pong(4, 6));
+        assert_eq!(r.seen(), Some(6));
+    }
+
+    #[test]
+    fn only_the_last_two_seconds_are_kept() {
+        let mut r = Record::default();
+        for i in 0..KEPT + 5 {
+            r.moved(Some([i as f64, 0.0, 0.0]), None, 0);
+            r.tick_end(0, false);
+        }
+        assert_eq!(r.ticks().len(), KEPT);
+        assert_eq!(r.ticks().next().unwrap().position, Some([5.0, 0.0, 0.0]));
+        r.clear();
+        assert_eq!(r.ticks().len(), 0);
+    }
+
+    #[test]
+    fn the_replay_takes_the_ticks_it_has_not_played() {
+        let mut r = Record::default();
+        for i in 0..3 {
+            r.moved(Some([i as f64, 0.0, 0.0]), None, 0);
+            r.tick_end(0, false);
+        }
+        fn x(r: &Record, played: u64) -> Option<Vec<f64>> {
+            r.since(played)
+                .map(|t| t.map(|t| t.position.unwrap()[0]).collect())
+        }
+        assert_eq!(x(&r, 1), Some(vec![1.0, 2.0]));
+        assert_eq!(x(&r, 3), Some(vec![]));
+        // Played ahead of the record, or so far behind the ticks are gone.
+        assert_eq!(x(&r, 4), None);
+        r.clear();
+        assert_eq!(x(&r, 2), None);
+        assert_eq!(x(&r, 3), Some(vec![]));
+        r.moved(Some([8.0, 0.0, 0.0]), None, 0);
+        r.tick_end(0, false);
+        r.moved(Some([9.0, 0.0, 0.0]), None, 0);
+        r.teleported([5.0, 6.0, 7.0], false);
+        // A tick that ends before the replay starts again is still one after the teleport.
+        r.tick_end(0, false);
+        let restart = r.take_restart().unwrap();
+        assert_eq!((restart.at, restart.kept_motion), ([5.0, 6.0, 7.0], false));
+        assert_eq!(r.since(restart.ended).unwrap().count(), 1);
+        // The tick ended before it stays for a replay that hasn't played it; the move of the one
+        // under way is gone.
+        let positions: Vec<_> = r.since(3).unwrap().map(|t| t.position).collect();
+        assert_eq!(positions, [Some([8.0, 0.0, 0.0]), None]);
+        assert_eq!(r.take_restart(), None);
+    }
+
+    #[test]
+    fn changes_keep_the_server_tick_that_sent_them() {
+        let mut r = Record::default();
+        r.changed(3, Change::Velocity([0.0, 0.4, 0.0]));
+        r.changed(5, Change::State);
+        let all: Vec<_> = r.changes_since(0).unwrap().copied().collect();
+        assert_eq!(
+            all,
+            [(3, Change::Velocity([0.0, 0.4, 0.0])), (5, Change::State)]
+        );
+        assert_eq!(r.changes_since(1).unwrap().count(), 1);
+        assert!(r.changes_since(3).is_none());
+        for i in 0..CHANGES_KEPT as u64 {
+            r.changed(6 + i, Change::State);
+        }
+        // The first two are gone.
+        assert!(r.changes_since(1).is_none());
+        assert_eq!(r.changes_since(2).unwrap().count(), CHANGES_KEPT);
+    }
+}

crates/horizon-bots/src/main.rs

@@ -15,10 +15,13 @@
 //! entered the view apart from chunks sent again while the bot still held them (`resent`), and counts the
 //! times the server pulled a bot back (`pulled_back`: a teleport after the first, as for "moved too quickly").
 
+//! The report also has wire bytes in and out (`bytes_in`, `bytes_out`, per bot and in total, after
+//! compression) and join-time percentiles (`join_time`: p50, p99 and max in milliseconds).
+
 use horizon_protocol::{
     PROTOCOL_VERSION,
     buf::{Reader, Writer},
-    connection::{ConnWriter, Connection},
+    connection::{ConnWriter, Connection, Counters},
     crypto::offline_uuid,
     ids,
     item::Stack,
@@ -33,7 +36,7 @@ use serde_json::json;
 use std::{
     collections::HashSet,
     sync::{
-        Arc, LazyLock, Mutex,
+        Arc, LazyLock, Mutex, OnceLock,
         atomic::{AtomicBool, AtomicU64, Ordering},
     },
     thread,
@@ -63,6 +66,8 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
   --attack NAME          attack the player NAME twice a second, from wherever the bot is (a reach test);
                          the report gives each bot's last health
   --attack-after S       start attacking S seconds after joining; default 5
+  --no-loaded            never say the level is loaded (ServerboundPlayerLoadedPacket): a vanilla server
+                         ignores the player's moves and actions for its first 3 seconds
   --no-read              stop reading from the server once spawned (a client that lets the
                          server's replies pile up)
   --join-every SECONDS   default 1
@@ -75,6 +80,12 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
   --height H             blocks above spawn the bots fly at (walk, explore, idle); default 24
   --ground               claim the ground in every move (with --height 0 on a flat world: walking
                          on it; higher, or over water: a no-fall or jesus cheat, to test an anticheat)
+  --give SLOT:ID:COUNT,...  creative-slot packets sent once joined (inventory menu slot, item
+                         registry id, count), to test what a server takes
+  --click X,Y,Z:SLOT:BUTTON:MODE  3 s after joining, open the block at X,Y,Z (a chest), then a second later
+                         click SLOT of its window (ServerboundContainerClickPacket), to test what a server takes
+  --raw TICK:ID:HEX,...  raw serverbound play packets (id, body in hex) sent TICK ticks after joining,
+                         to test what a server takes
   --timer F              cheat, to test an anticheat: tick F times as fast as vanilla's client (1.5: 30 Hz)
   --report FILE          a JSON summary at the end (- prints it after the per-second lines)
 ";
@@ -133,8 +144,15 @@ struct Options {
     attack_after: f64,
     flood: usize,
     no_read: bool,
+    no_loaded: bool,
     height: f64,
     ground: bool,
+    /// --raw: (tick after joining, packet id, body).
+    raw: Vec<(u64, i32, Vec<u8>)>,
+    /// ServerboundSetCreativeModeSlotPackets to send once joined: (slot, item id, count).
+    give: Vec<(i16, i32, i32)>,
+    /// --click: the block to open, then the slot, button and click type in its window.
+    click: Option<([i32; 3], i16, i8, i32)>,
     name: String,
     /// The `minecraft:brand` to send, if any.
     brand: Option<String>,
@@ -158,8 +176,12 @@ fn options() -> Result<Options, String> {
         attack_after: 5.0,
         flood: 100,
         no_read: false,
+        no_loaded: false,
         height: 24.0,
         ground: false,
+        raw: Vec::new(),
+        give: Vec::new(),
+        click: None,
         name: "Bot".into(),
         report: None,
         brand: None,
@@ -175,6 +197,10 @@ fn options() -> Result<Options, String> {
             o.no_read = true;
             continue;
         }
+        if arg == "--no-loaded" {
+            o.no_loaded = true;
+            continue;
+        }
         if arg == "--ground" {
             o.ground = true;
             continue;
@@ -202,6 +228,53 @@ fn options() -> Result<Options, String> {
             "--name" => o.name = value,
             "--report" => o.report = Some(value),
             "--brand" => o.brand = Some(value),
+            "--give" => {
+                for part in value.split(',') {
+                    let n: Vec<&str> = part.split(':').collect();
+                    let parsed = match n[..] {
+                        [s, i, c] => s.parse().ok().zip(i.parse().ok()).zip(c.parse().ok()),
+                        _ => None,
+                    };
+                    let ((slot, item), count) = parsed.ok_or_else(|| number("SLOT:ID:COUNT"))?;
+                    o.give.push((slot, item, count));
+                }
+            }
+            "--click" => {
+                let bad = || number("X,Y,Z:SLOT:BUTTON:MODE");
+                let n: Vec<&str> = value.split(':').collect();
+                let [at, slot, button, mode] = n[..] else {
+                    return Err(bad());
+                };
+                let at: Vec<i32> = at
+                    .split(',')
+                    .map(str::parse)
+                    .collect::<Result<_, _>>()
+                    .map_err(|_| bad())?;
+                let at = <[i32; 3]>::try_from(at).map_err(|_| bad())?;
+                let parse = |s: &str| s.parse::<i32>().map_err(|_| bad());
+                o.click = Some((at, parse(slot)? as i16, parse(button)? as i8, parse(mode)?));
+            }
+            "--raw" => {
+                for part in value.split(',') {
+                    let bad = || number("TICK:ID:HEX");
+                    let [tick, id, hex] = part.split(':').collect::<Vec<_>>()[..] else {
+                        return Err(bad());
+                    };
+                    let body = (0..hex.len())
+                        .step_by(2)
+                        .map(|i| {
+                            hex.get(i..i + 2)
+                                .and_then(|b| u8::from_str_radix(b, 16).ok())
+                        })
+                        .collect::<Option<Vec<u8>>>()
+                        .ok_or_else(bad)?;
+                    o.raw.push((
+                        tick.parse().map_err(|_| bad())?,
+                        id.parse().map_err(|_| bad())?,
+                        body,
+                    ));
+                }
+            }
             "--height" => o.height = value.parse().map_err(|_| number("blocks"))?,
             "--timer" => {
                 o.timer = value.parse().map_err(|_| number("a speed, like 1.5"))?;
@@ -258,6 +331,8 @@ struct Bot {
     teleport: Mutex<Option<[f64; 3]>>,
     error: Mutex<Option<String>>,
     joined_after_ms: AtomicU64,
+    /// The connection's byte counters (wire bytes, after compression and encryption), set once it is open.
+    counters: OnceLock<Arc<Counters>>,
     /// The bot stopped reading (--no-read).
     deaf: AtomicBool,
     /// `--attack`: the target's UUID and, once AddEntity showed it, its entity id.
@@ -267,6 +342,39 @@ struct Bot {
     health: Mutex<Option<f32>>,
 }
 
+impl Bot {
+    fn bytes_in(&self) -> u64 {
+        self.counters
+            .get()
+            .map_or(0, |c| c.bytes_in.load(Ordering::Relaxed).max(0) as u64)
+    }
+    fn bytes_out(&self) -> u64 {
+        self.counters
+            .get()
+            .map_or(0, |c| c.bytes_out.load(Ordering::Relaxed).max(0) as u64)
+    }
+}
+
+/// Nearest-rank percentile (`p` in 0..=100) of an ascending-sorted slice; 0 when it is empty.
+fn percentile(sorted: &[u64], p: u64) -> u64 {
+    if sorted.is_empty() {
+        return 0;
+    }
+    let rank = (p * sorted.len() as u64).div_ceil(100).max(1) as usize;
+    sorted[rank - 1]
+}
+
+/// Join-time summary in milliseconds over the bots that got in: count, p50, p99 and max.
+fn join_summary(mut times: Vec<u64>) -> serde_json::Value {
+    times.sort_unstable();
+    json!({
+        "count": times.len(),
+        "p50_ms": percentile(&times, 50),
+        "p99_ms": percentile(&times, 99),
+        "max_ms": times.last().copied().unwrap_or(0),
+    })
+}
+
 /// A small deterministic generator (SplitMix64), so every run moves the bots the same way.
 struct Random(u64);
 impl Random {
@@ -692,6 +800,7 @@ fn run_bot(
         }
     };
     let (reader, writer) = connection.split();
+    let _ = bot.counters.set(reader.counters.clone());
     let writer = Arc::new(Mutex::new(writer));
     lock(&bot.target).0 = o.attack.as_deref().map(offline_uuid);
     bot.online.store(true, Ordering::SeqCst);
@@ -716,7 +825,9 @@ fn run_bot(
     bot.joined_after_ms
         .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, |_| {}));
+    if !o.no_loaded {
+        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 {
@@ -724,6 +835,15 @@ fn run_bot(
         Behaviour::FloodBook => Some(Stack::new(WRITABLE_BOOK, 1)),
         _ => None,
     };
+    for &(slot, item, count) in &o.give {
+        send(
+            play::Serverbound::SetCreativeModeSlot(play::SetCreativeModeSlot {
+                slot,
+                item: Some(Stack::new(item, count)),
+            })
+            .encode(),
+        );
+    }
     if tool.is_some() {
         send(
             play::Serverbound::SetCreativeModeSlot(play::SetCreativeModeSlot {
@@ -848,6 +968,43 @@ fn run_bot(
                 }
             }
         }
+        if let Some((at, slot, button, input)) = o.click {
+            // Ticks of 50 ms: the block 3 s after joining, the click a second later.
+            if tick == 60 {
+                sequence += 1;
+                send(
+                    play::Serverbound::UseItemOn(play::UseItemOn {
+                        hand: 0,
+                        pos: at,
+                        face: 1,
+                        cursor: [0.5, 1.0, 0.5],
+                        inside: false,
+                        world_border: false,
+                        sequence,
+                    })
+                    .encode(),
+                );
+            } else if tick == 80 {
+                // The first window a player opens is 1.
+                send(
+                    play::Serverbound::ContainerClick(play::ContainerClick {
+                        container: 1,
+                        state: 0,
+                        slot,
+                        button,
+                        input,
+                        changed: Vec::new(),
+                        carried: None,
+                    })
+                    .encode(),
+                );
+            }
+        }
+        for (at, id, body) in &o.raw {
+            if *at == tick {
+                send(raw(*id, |w| w.bytes(body)));
+            }
+        }
         // The costly floods go out wherever the bot is, chunks or not (--no-read gets none).
         for i in 0..o.flood {
             sequence += 1;
@@ -996,10 +1153,20 @@ fn main() {
         "resent": bots.iter().map(|b| b.resent.load(Ordering::Relaxed)).sum::<u64>(),
         "pulled_back": bots.iter().map(|b| b.pulled_back.load(Ordering::Relaxed)).sum::<u64>(),
         "waited_ticks": bots.iter().map(|b| b.waited.load(Ordering::Relaxed)).sum::<u64>(),
+        "bytes_in": bots.iter().map(|b| b.bytes_in()).sum::<u64>(),
+        "bytes_out": bots.iter().map(|b| b.bytes_out()).sum::<u64>(),
+        "join_time": join_summary(
+            bots.iter()
+                .map(|b| b.joined_after_ms.load(Ordering::SeqCst))
+                .filter(|&ms| ms > 0)
+                .collect(),
+        ),
         "per_bot": bots.iter().enumerate().map(|(i, b)| json!({
             "name": format!("{}{i}", o.name),
             "behaviour": behaviour_of(&o.behaviour, i).name(),
             "joined_after_ms": b.joined_after_ms.load(Ordering::SeqCst),
+            "bytes_in": b.bytes_in(),
+            "bytes_out": b.bytes_out(),
             "chunks": b.chunks.load(Ordering::Relaxed),
             "unique_chunks": b.unique.load(Ordering::Relaxed),
             "resent": b.resent.load(Ordering::Relaxed),
@@ -1034,3 +1201,39 @@ fn main() {
     }
     std::process::exit(if errors.is_empty() { 0 } else { 1 });
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn percentiles_use_nearest_rank() {
+        assert_eq!(percentile(&[], 50), 0);
+        assert_eq!(percentile(&[7], 99), 7);
+        let v: Vec<u64> = (1..=100).collect();
+        assert_eq!(percentile(&v, 50), 50);
+        assert_eq!(percentile(&v, 99), 99);
+        assert_eq!(percentile(&[10, 20, 30, 40], 50), 20);
+    }
+
+    #[test]
+    fn join_summary_sorts_and_reports_max() {
+        let s = join_summary(vec![300, 100, 200]);
+        assert_eq!(s["count"], 3);
+        assert_eq!(s["p50_ms"], 200);
+        assert_eq!(s["p99_ms"], 300);
+        assert_eq!(s["max_ms"], 300);
+        assert_eq!(join_summary(vec![])["count"], 0);
+    }
+
+    #[test]
+    fn bot_bytes_come_from_the_connection_counters() {
+        let bot = Bot::default();
+        assert_eq!((bot.bytes_in(), bot.bytes_out()), (0, 0));
+        let counters = Arc::new(Counters::default());
+        counters.bytes_in.store(1234, Ordering::Relaxed);
+        counters.bytes_out.store(56, Ordering::Relaxed);
+        let _ = bot.counters.set(counters);
+        assert_eq!((bot.bytes_in(), bot.bytes_out()), (1234, 56));
+    }
+}

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

@@ -186,6 +186,73 @@ impl Parser<'_> {
         Err("unterminated string".into())
     }
 }
+/// `click_event` / `hover_event`, or the pre-datafixer `clickEvent` /
+/// `hoverEvent` names SNBT and older chat JSON still use.
+fn style_event_object<'a>(
+    o: &'a serde_json::Map<String, Value>,
+    modern: &str,
+    legacy: &str,
+) -> Option<&'a serde_json::Map<String, Value>> {
+    o.get(modern)
+        .or_else(|| o.get(legacy))
+        .and_then(Value::as_object)
+}
+
+/// Style flags from JSON bools, or SNBT `1b`/`0b` which parse as numbers.
+fn style_flag(v: Option<&Value>) -> Option<bool> {
+    match v {
+        Some(Value::Bool(b)) => Some(*b),
+        Some(Value::Number(n)) => n.as_i64().map(|i| i != 0),
+        _ => None,
+    }
+}
+
+fn untrusted_http_url(url: &str) -> bool {
+    // ExtraCodecs.UNTRUSTED_URI / Util.parseAndValidateUntrustedUri: http and
+    // https only, scheme case-insensitive.
+    url.split_once(':').is_some_and(|(scheme, _)| {
+        scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
+    })
+}
+
+/// ClickEvent.CODEC plus the legacy `value` field TextComponentHoverAndClickEventFix
+/// renames (`url` / `command` / `page`).
+fn parse_click_event(e: &serde_json::Map<String, Value>) -> Option<crate::text::ClickEvent> {
+    let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned);
+    let legacy = || text("value");
+    match e.get("action").and_then(Value::as_str) {
+        Some("open_url") => text("url")
+            .or_else(legacy)
+            .filter(|u| untrusted_http_url(u))
+            .map(crate::text::ClickEvent::OpenUrl),
+        Some("change_page") => e
+            .get("page")
+            .and_then(Value::as_i64)
+            .or_else(|| e.get("value").and_then(Value::as_i64))
+            .or_else(|| {
+                e.get("value")
+                    .and_then(Value::as_str)
+                    .and_then(|s| s.parse().ok())
+            })
+            .and_then(|p| i32::try_from(p).ok())
+            .filter(|p| *p >= 1)
+            .map(crate::text::ClickEvent::ChangePage),
+        Some("suggest_command") => text("command")
+            .or_else(legacy)
+            .map(crate::text::ClickEvent::SuggestCommand),
+        Some("run_command") => text("command")
+            .or_else(legacy)
+            .map(crate::text::ClickEvent::RunCommand),
+        Some("copy_to_clipboard") => text("value").map(crate::text::ClickEvent::CopyToClipboard),
+        // ClickEvent.ShowDialog.CODEC: a `minecraft:dialog` registry id or
+        // the dialog itself; the server may send it (isAllowedFromServer).
+        Some("show_dialog") => e.get("dialog").map(|dialog| {
+            crate::text::ClickEvent::ShowDialog(crate::scoreboard::json_to_tag(dialog))
+        }),
+        _ => None,
+    }
+}
+
 /// The style fields of a component object.
 fn object_style(o: &serde_json::Map<String, Value>) -> Style {
     let mut style = Style::default();
@@ -196,52 +263,27 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
         });
     }
     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");
-    style.underlined = flag("underlined");
-    style.strikethrough = flag("strikethrough");
-    style.obfuscated = flag("obfuscated");
+    style.bold = style_flag(o.get("bold"));
+    style.italic = style_flag(o.get("italic"));
+    style.underlined = style_flag(o.get("underlined"));
+    style.strikethrough = style_flag(o.get("strikethrough"));
+    style.obfuscated = style_flag(o.get("obfuscated"));
     style.font = o.get("font").and_then(crate::text::font_id);
     // ClickEvent.CODEC: the actions a chat line acts on here. A component
     // from a server never opens a file.
-    if let Some(e) = o.get("click_event").and_then(Value::as_object) {
-        let text = |k: &str| e.get(k).and_then(Value::as_str).map(str::to_owned);
-        style.click = match e.get("action").and_then(Value::as_str) {
-            // ClickEvent.OpenUrl.CODEC: ExtraCodecs.UNTRUSTED_URI allows http and
-            // https only, the scheme in any case (Util.parseAndValidateUntrustedUri).
-            Some("open_url") => text("url")
-                .filter(|u| {
-                    u.split_once(':').is_some_and(|(scheme, _)| {
-                        scheme.eq_ignore_ascii_case("http") || scheme.eq_ignore_ascii_case("https")
-                    })
-                })
-                .map(crate::text::ClickEvent::OpenUrl),
-            // ClickEvent.ChangePage.CODEC: ExtraCodecs.POSITIVE_INT.
-            Some("change_page") => e
-                .get("page")
-                .and_then(Value::as_i64)
-                .and_then(|p| i32::try_from(p).ok())
-                .filter(|p| *p >= 1)
-                .map(crate::text::ClickEvent::ChangePage),
-            Some("suggest_command") => text("command").map(crate::text::ClickEvent::SuggestCommand),
-            Some("run_command") => text("command").map(crate::text::ClickEvent::RunCommand),
-            Some("copy_to_clipboard") => {
-                text("value").map(crate::text::ClickEvent::CopyToClipboard)
-            }
-            // ClickEvent.ShowDialog.CODEC: a `minecraft:dialog` registry id or
-            // the dialog itself; the server may send it (isAllowedFromServer).
-            Some("show_dialog") => e.get("dialog").map(|dialog| {
-                crate::text::ClickEvent::ShowDialog(crate::scoreboard::json_to_tag(dialog))
-            }),
-            _ => None,
-        };
+    if let Some(e) = style_event_object(o, "click_event", "clickEvent") {
+        style.click = parse_click_event(e);
     }
     // HoverEvent.ShowText, ShowItem and ShowEntity.
-    if let Some(e) = o.get("hover_event").and_then(Value::as_object) {
+    if let Some(e) = style_event_object(o, "hover_event", "hoverEvent") {
         match e.get("action").and_then(Value::as_str) {
             Some("show_text") => {
-                if let Some(value) = e.get("value") {
+                // Modern `value`, or the older `contents` / nested `text`.
+                let value = e
+                    .get("value")
+                    .or_else(|| e.get("contents"))
+                    .or_else(|| e.get("text"));
+                if let Some(value) = value {
                     style.hover = Some(Box::new(to_text(value, &mut |s| Text::literal(s))));
                 }
             }
@@ -506,10 +548,43 @@ mod tests {
         let t = to_text(&v, &mut |_| Text::empty());
         assert_eq!(t.plain(), "Hi there");
         assert_eq!(t.spans[1].style.color, named_color("red"));
+        // SNBT `1b` is a number in JSON; style flags still take it as true.
+        assert_eq!(t.spans[1].style.bold, Some(true));
         let (v, _) = parse_snbt("[\"a\",{\"text\":\"b\"}]").unwrap();
         assert_eq!(to_text(&v, &mut |_| Text::empty()).plain(), "ab");
     }
 
+    #[test]
+    fn legacy_click_event_open_url_uses_value_field() {
+        use crate::text::ClickEvent;
+        let modern = serde_json::json!({
+            "text": "site",
+            "click_event": {"action": "open_url", "url": "https://example.com"},
+            "underlined": true
+        });
+        let legacy = serde_json::json!({
+            "text": "site",
+            "clickEvent": {"action": "open_url", "value": "https://example.com"},
+            "underlined": 1
+        });
+        for component in [modern, legacy] {
+            let text = to_text(&component, &mut |_| Text::empty());
+            assert_eq!(
+                text.spans[0].style.click,
+                Some(ClickEvent::OpenUrl("https://example.com".into()))
+            );
+            assert_eq!(text.spans[0].style.underlined, Some(true));
+        }
+        let snbt = r#"{text:"site",underlined:1b,clickEvent:{action:open_url,value:"https://example.com"}}"#;
+        let (v, _) = parse_snbt(snbt).unwrap();
+        let text = to_text(&v, &mut |_| Text::empty());
+        assert_eq!(
+            text.spans[0].style.click,
+            Some(ClickEvent::OpenUrl("https://example.com".into()))
+        );
+        assert_eq!(text.spans[0].style.underlined, Some(true));
+    }
+
     #[test]
     fn the_font_is_inherited_and_kept() {
         let (v, _) =

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

@@ -66,6 +66,15 @@ impl ResourceSource for Bundled {
             "assets/horizon/lang/uk_ua.json" => {
                 include_str!("../../horizon-client/assets/horizon/lang/uk_ua.json")
             }
+            "assets/horizon/lang/es_es.json"
+            | "assets/horizon/lang/es_ar.json"
+            | "assets/horizon/lang/es_cl.json"
+            | "assets/horizon/lang/es_ec.json"
+            | "assets/horizon/lang/es_mx.json"
+            | "assets/horizon/lang/es_uy.json"
+            | "assets/horizon/lang/es_ve.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/es_es.json")
+            }
             _ => return None,
         };
         Some(body.as_bytes().to_vec())
@@ -287,6 +296,13 @@ mod tests {
             uk.get("horizon.options.on_screen_keyboard"),
             Some("Екранна клавіатура")
         );
+        let es = Language::load(&[&empty], "es_es");
+        assert_eq!(es.get("horizon.options.controller"), Some("Mando"));
+        let es_ve = Language::load(&[&empty], "es_ve");
+        assert_eq!(
+            es_ve.get("horizon.options.on_screen_keyboard"),
+            Some("Teclado en pantalla")
+        );
     }
 
     #[test]

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

@@ -9,7 +9,8 @@ pub enum Category {
     Harmful,
     Neutral,
 }
-/// A `MobEffect`: id (without namespace), colour, category, instantaneous.
+/// A `MobEffect`: id (vanilla's without namespace, a mod's `<ns>:<path>`),
+/// colour, category, instantaneous.
 #[derive(Clone, Copy, Debug)]
 pub struct EffectDef {
     pub id: &'static str,
@@ -84,11 +85,52 @@ pub const EFFECTS: &[EffectDef] = &[
     fx("infested", 9214860, H),
     fx("breath_of_the_nautilus", 65518, B),
 ];
-pub fn effect(id: &str) -> Option<&'static EffectDef> {
-    let id = id.trim_start_matches("minecraft:");
-    EFFECTS.iter().find(|e| e.id == id)
+/// The effects content mods declare, registered after vanilla's.
+static MOD_EFFECTS: OnceLock<Vec<EffectDef>> = OnceLock::new();
+/// Registers the content mods' effects, `<ns>:<path>` ids in registry order.
+/// The list is set once per process: false when it already was, and the
+/// effects stay those of the first call until the game restarts.
+pub fn register_mod_effects(effects: impl IntoIterator<Item = (String, u32, Category)>) -> bool {
+    if MOD_EFFECTS.get().is_some() {
+        return false;
+    }
+    let defs: Vec<EffectDef> = effects
+        .into_iter()
+        .map(|(id, color, category)| {
+            debug_assert!(id.contains(':'), "{id} has no namespace");
+            fx(Box::leak(id.into_boxed_str()), color, category)
+        })
+        .collect();
+    MOD_EFFECTS.set(defs).is_ok()
 }
-/// Namespaced effect ids for mob effect storage.
+/// The content mods' effects, in registry order.
+pub fn mod_effects() -> &'static [EffectDef] {
+    MOD_EFFECTS.get().map_or(&[], Vec::as_slice)
+}
+/// Every registered effect: vanilla's, then the content mods'.
+pub fn all_effects() -> impl Iterator<Item = &'static EffectDef> {
+    EFFECTS.iter().chain(mod_effects())
+}
+pub fn effect(id: &str) -> Option<&'static EffectDef> {
+    let short = id.trim_start_matches("minecraft:");
+    match EFFECTS.iter().find(|e| e.id == short) {
+        Some(e) => Some(e),
+        None => mod_effect(id),
+    }
+}
+/// Out of line, so vanilla's lookups (every frame, every tick) stay as they were.
+#[cold]
+#[inline(never)]
+fn mod_effect(id: &str) -> Option<&'static EffectDef> {
+    mod_effects().iter().find(|e| e.id == id)
+}
+/// `MobEffect.getDescriptionId` (`Util.makeDescriptionId("effect", key)`):
+/// `effect.<namespace>.<path>`, `/` in the path as `.`.
+pub fn description_id(id: &str) -> String {
+    let (namespace, path) = id.split_once(':').unwrap_or(("minecraft", id));
+    format!("effect.{namespace}.{}", path.replace('/', "."))
+}
+/// Namespaced effect ids for mob effect storage; a mod's id already is.
 pub fn namespaced(id: &'static str) -> &'static str {
     static IDS: OnceLock<HashMap<&'static str, &'static str>> = OnceLock::new();
     let key = id.strip_prefix("minecraft:").unwrap_or(id);
@@ -248,3 +290,40 @@ pub fn potion_color(id: Option<&str>) -> u32 {
         _ => BASE_POTION_COLOR,
     }
 }
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn description_ids_keep_the_namespace() {
+        assert_eq!(description_id("speed"), "effect.minecraft.speed");
+        assert_eq!(description_id("minecraft:speed"), "effect.minecraft.speed");
+        assert_eq!(description_id("ruby:curse/dark"), "effect.ruby.curse.dark");
+    }
+
+    /// The only test that registers: the registry is set once per process.
+    #[test]
+    fn mod_effects_follow_vanilla_once_registered() {
+        assert!(register_mod_effects([(
+            "ruby:glow".to_owned(),
+            0xFF0000,
+            Category::Neutral
+        )]));
+        assert!(!register_mod_effects([(
+            "ruby:late".to_owned(),
+            1,
+            Category::Harmful
+        )]));
+        let glow = effect("ruby:glow").unwrap();
+        assert_eq!(
+            (glow.color, glow.category, glow.instant),
+            (0xFF0000, Category::Neutral, false)
+        );
+        assert!(effect("glow").is_none() && effect("ruby:late").is_none());
+        assert_eq!(namespaced(glow.id), "ruby:glow");
+        assert_eq!(effect("minecraft:speed").unwrap().id, "speed");
+        let ids: Vec<_> = all_effects().map(|e| e.id).collect();
+        assert_eq!(ids.len(), EFFECTS.len() + 1);
+        assert_eq!(ids.last(), Some(&"ruby:glow"));
+    }
+}

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

@@ -3,179 +3,8 @@
 //! number formatting.
 use crate::text::{self, Style, Text};
 use horizon_world::nbt::Tag;
-
-/// `Double.toString`.
-pub fn java_double(v: f64) -> String {
-    java_float_text(v, &format!("{v}"), &format!("{v:e}"))
-}
-/// `Float.toString`.
-pub fn java_float(v: f32) -> String {
-    java_float_text(f64::from(v), &format!("{v}"), &format!("{v:e}"))
-}
-fn java_float_text(v: f64, plain: &str, sci: &str) -> String {
-    if v.is_nan() {
-        return "NaN".into();
-    }
-    if v.is_infinite() {
-        return if v > 0.0 { "Infinity" } else { "-Infinity" }.into();
-    }
-    if v == 0.0 {
-        return if v.is_sign_negative() { "-0.0" } else { "0.0" }.into();
-    }
-    let a = v.abs();
-    if (1.0e-3..1.0e7).contains(&a) {
-        if plain.contains('.') {
-            plain.to_owned()
-        } else {
-            format!("{plain}.0")
-        }
-    } else {
-        let (mantissa, exponent) = sci.split_once('e').unwrap_or((sci, "0"));
-        let mantissa = if mantissa.contains('.') {
-            mantissa.to_owned()
-        } else {
-            format!("{mantissa}.0")
-        };
-        format!("{mantissa}E{exponent}")
-    }
-}
-
-/// `SnbtGrammar.escapeControlCharacters`.
-fn escape_control(c: char) -> Option<&'static str> {
-    Some(match c {
-        '\u{8}' => "b",
-        '\u{c}' => "f",
-        '\n' => "n",
-        '\r' => "r",
-        '\t' => "t",
-        _ => return None,
-    })
-}
-/// `StringTag.quoteAndEscape`.
-pub fn quote_and_escape(input: &str) -> String {
-    let mut out = String::from(" ");
-    let mut quote = '\0';
-    for c in input.chars() {
-        if c == '\\' {
-            out.push_str("\\\\");
-        } else if c != '"' && c != '\'' {
-            match escape_control(c) {
-                Some(e) => {
-                    out.push('\\');
-                    out.push_str(e);
-                }
-                None => out.push(c),
-            }
-        } else {
-            if quote == '\0' {
-                quote = if c == '"' { '\'' } else { '"' };
-            }
-            if quote == c {
-                out.push('\\');
-            }
-            out.push(c);
-        }
-    }
-    if quote == '\0' {
-        quote = '"';
-    }
-    out.replace_range(0..1, &quote.to_string());
-    out.push(quote);
-    out
-}
-fn unquoted_key(key: &str) -> bool {
-    if key.eq_ignore_ascii_case("true") || key.eq_ignore_ascii_case("false") {
-        return false;
-    }
-    let mut chars = key.chars();
-    let first_ok = chars
-        .next()
-        .is_some_and(|c| c.is_ascii_alphabetic() || c == '.' || c == '_');
-    // `[A-Za-z._]+[A-Za-z0-9._+-]*`
-    first_ok && chars.all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '+' | '-'))
-}
-fn string_of(t: &horizon_world::nbt::JavaString) -> String {
-    t.to_string_lossy()
-}
-
-/// `Tag.toString` (StringTagVisitor).
-pub fn to_snbt(tag: &Tag) -> String {
-    let mut out = String::new();
-    visit(tag, &mut out);
-    out
-}
-fn visit(tag: &Tag, out: &mut String) {
-    match tag {
-        Tag::End => out.push_str("END"),
-        Tag::Byte(v) => out.push_str(&format!("{v}b")),
-        Tag::Short(v) => out.push_str(&format!("{v}s")),
-        Tag::Int(v) => out.push_str(&v.to_string()),
-        Tag::Long(v) => out.push_str(&format!("{v}L")),
-        Tag::Float(v) => {
-            out.push_str(&java_float(f32::from_bits(*v)));
-            out.push('f');
-        }
-        Tag::Double(v) => {
-            out.push_str(&java_double(f64::from_bits(*v)));
-            out.push('d');
-        }
-        Tag::String(s) => out.push_str(&quote_and_escape(&string_of(s))),
-        Tag::ByteArray(a) => {
-            out.push_str("[B;");
-            out.push_str(
-                &a.iter()
-                    .map(|v| format!("{}B", *v as i8))
-                    .collect::<Vec<_>>()
-                    .join(","),
-            );
-            out.push(']');
-        }
-        Tag::IntArray(a) => {
-            out.push_str("[I;");
-            out.push_str(&a.iter().map(i32::to_string).collect::<Vec<_>>().join(","));
-            out.push(']');
-        }
-        Tag::LongArray(a) => {
-            out.push_str("[L;");
-            out.push_str(
-                &a.iter()
-                    .map(|v| format!("{v}L"))
-                    .collect::<Vec<_>>()
-                    .join(","),
-            );
-            out.push(']');
-        }
-        Tag::List(l) => {
-            out.push('[');
-            for (i, t) in l.iter().enumerate() {
-                if i > 0 {
-                    out.push(',');
-                }
-                visit(t, out);
-            }
-            out.push(']');
-        }
-        Tag::Compound(c) => {
-            out.push('{');
-            let mut entries: Vec<(String, &Tag)> =
-                c.iter().map(|(k, v)| (string_of(k), v)).collect();
-            entries.sort_by(|a, b| a.0.cmp(&b.0));
-            for (i, (k, v)) in entries.iter().enumerate() {
-                if i > 0 {
-                    out.push(',');
-                }
-                if unquoted_key(k) {
-                    out.push_str(k);
-                } else {
-                    out.push_str(&quote_and_escape(k));
-                }
-                out.push(':');
-                visit(v, out);
-            }
-            out.push('}');
-        }
-    }
-}
+use horizon_world::snbt_text::string_of;
+pub use horizon_world::snbt_text::{java_double, java_float, quote_and_escape, to_snbt};
 
 // ---- the coloured form -----------------------------------------------------
 

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

@@ -567,6 +567,34 @@ fn length(v: [f32; 2]) -> f32 {
     (v[0] * v[0] + v[1] * v[1]).sqrt()
 }
 
+/// 8BitDo Ultimate 2 Wireless (`2dc8:6012`). gilrs' bundled SDL DB only has a
+/// Windows row for it; on Linux/Bluetooth the right stick is on ABS_Z/ABS_RX
+/// (`LeftZ`/`RightStickX`) until an SDL mapping matches.
+pub const BITDO_ULTIMATE2_VID_PID: (u16, u16) = (0x2dc8, 0x6012);
+
+/// Stick axes after correcting pads whose right stick gilrs still exposes on
+/// `LeftZ`/`RightStickX` (no matching SDL row for this device version).
+/// `sdl_mapped` is true when gilrs already applied an SDL gamecontroller row.
+pub fn stick_axes(
+    left: [f32; 2],
+    right: [f32; 2],
+    left_z: f32,
+    vendor: Option<u16>,
+    product: Option<u16>,
+    sdl_mapped: bool,
+) -> ([f32; 2], [f32; 2]) {
+    if !sdl_mapped
+        && vendor == Some(BITDO_ULTIMATE2_VID_PID.0)
+        && product == Some(BITDO_ULTIMATE2_VID_PID.1)
+    {
+        // Default map: RightStickX is the stick's Y, LeftZ its X; RightStickY
+        // is the right trigger and must not drive look.
+        (left, [left_z, right[0]])
+    } else {
+        (left, right)
+    }
+}
+
 /// A radial deadzone: inside it the stick is centred; beyond it the rest of
 /// the travel is rescaled to 0..1 in the same direction, so diagonals aren't
 /// clipped and the first movement past the deadzone is small.
@@ -1178,6 +1206,38 @@ mod tests {
         assert_eq!(odd, PadSettings::default());
     }
 
+    #[test]
+    fn ultimate2_right_stick_on_z_without_sdl() {
+        let (left, right) = stick_axes(
+            [0.2, 0.3],
+            [0.7, -0.9],
+            -0.5,
+            Some(BITDO_ULTIMATE2_VID_PID.0),
+            Some(BITDO_ULTIMATE2_VID_PID.1),
+            false,
+        );
+        assert_eq!(left, [0.2, 0.3]);
+        assert_eq!(right, [-0.5, 0.7], "X from LeftZ, Y from RightStickX");
+        let kept = stick_axes(
+            [0.2, 0.3],
+            [0.7, -0.9],
+            -0.5,
+            Some(BITDO_ULTIMATE2_VID_PID.0),
+            Some(BITDO_ULTIMATE2_VID_PID.1),
+            true,
+        );
+        assert_eq!(kept, ([0.2, 0.3], [0.7, -0.9]), "SDL row already remapped");
+        let other = stick_axes(
+            [0.0, 0.0],
+            [1.0, 0.0],
+            0.5,
+            Some(0x045e),
+            Some(0x028e),
+            false,
+        );
+        assert_eq!(other, ([0.0, 0.0], [1.0, 0.0]));
+    }
+
     #[test]
     fn radial_deadzone_rescales() {
         assert_eq!(radial([0.1, 0.05], 0.15), [0.0, 0.0]);

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

@@ -10,6 +10,10 @@ pub struct KeyState {
     released_by_screen_when_down: bool,
     toggle: Option<bool>,
     keyboard: bool,
+    /// Held down by a controller's toggle (Horizon's pad toggle-sneak, which
+    /// vanilla has no option for): until it lets go, the mapping toggles as
+    /// if its vanilla option were on, so a screen releases and restores it.
+    pad_toggled: bool,
 }
 
 impl KeyState {
@@ -20,6 +24,7 @@ impl KeyState {
             released_by_screen_when_down: false,
             toggle: None,
             keyboard: true,
+            pad_toggled: false,
         }
     }
     /// A `ToggleKeyMapping`; `keyboard` is whether the bound key is a keyboard key.
@@ -43,16 +48,28 @@ impl KeyState {
             true
         }
     }
+    /// The mapping toggles: its option is on, or a pad toggled it down.
+    fn needs_toggle(&self, option: bool) -> bool {
+        option || self.pad_toggled
+    }
     /// `setDown`; `needs_toggle` is the mapping's option value.
     pub fn set_down(&mut self, down: bool, needs_toggle: bool) {
-        if self.toggle.is_some() && needs_toggle {
+        if self.toggle.is_some() && self.needs_toggle(needs_toggle) {
             if down {
                 self.is_down = !self.is_down;
+                // Toggled back up: the pad's toggle is over.
+                self.pad_toggled &= self.is_down;
             }
         } else {
             self.is_down = down;
         }
     }
+    /// A controller's toggle button: flips the mapping like `setDown(true)`
+    /// with its option on, whatever the option says.
+    pub fn pad_toggle(&mut self) {
+        self.is_down = !self.is_down;
+        self.pad_toggled = self.is_down;
+    }
     /// `shouldSetOnIngameFocus` for a keyboard-bound, bound key.
     pub fn should_set_on_ingame_focus(&self, needs_toggle: bool) -> bool {
         self.keyboard && (self.toggle.is_none() || !needs_toggle)
@@ -61,7 +78,8 @@ impl KeyState {
     pub fn release(&mut self, needs_toggle: bool) {
         if self.toggle.is_some() {
             // ToggleKeyMapping.release does not clear pending clicks.
-            if needs_toggle && self.is_down || self.released_by_screen_when_down {
+            if self.needs_toggle(needs_toggle) && self.is_down || self.released_by_screen_when_down
+            {
                 self.released_by_screen_when_down = true;
             }
             self.reset();
@@ -70,7 +88,8 @@ impl KeyState {
             self.set_down(false, needs_toggle);
         }
     }
-    /// `ToggleKeyMapping.reset`.
+    /// `ToggleKeyMapping.reset`. A pad toggle stays on record, so the screen
+    /// that released it restores it.
     pub fn reset(&mut self) {
         self.is_down = false;
     }
@@ -83,7 +102,10 @@ impl KeyState {
         let Some(restore) = self.toggle else {
             return false;
         };
-        let result = restore && needs_toggle && self.keyboard && self.released_by_screen_when_down;
+        let result = restore
+            && self.needs_toggle(needs_toggle)
+            && self.keyboard
+            && self.released_by_screen_when_down;
         self.released_by_screen_when_down = false;
         result
     }
@@ -138,6 +160,15 @@ impl ToggleKeys {
             _ => {}
         }
     }
+    /// A controller's toggle button bound to `slot` (the pad's toggle-sneak):
+    /// a press with no screen open flips the mapping and clicks it, as a
+    /// key press does with the mapping's toggle option on.
+    pub fn pad_toggle(&mut self, slot: usize, screen_open: bool) {
+        if !screen_open {
+            self.0[slot].pad_toggle();
+            self.0[slot].click();
+        }
+    }
     /// `MouseHandler.onButton` for a button bound to `slot`: only without a
     /// screen or overlay.
     pub fn button(&mut self, slot: usize, pressed: bool, screen_open: bool, needs_toggle: bool) {
@@ -167,6 +198,9 @@ impl ToggleKeys {
     pub fn respawn(&mut self) {
         for key in &mut self.0 {
             key.reset();
+            // As with the vanilla option, the death screen closing after
+            // this still restores a toggle it released.
+            key.pad_toggled &= key.released_by_screen_when_down;
         }
     }
 }
@@ -197,6 +231,57 @@ mod tests {
         keys.respawn();
         assert!(!keys.is_down(SPRINT));
     }
+    /// #3061: the pad's toggle-sneak (vanilla's toggle crouch off) comes
+    /// back after a screen, as the vanilla option's toggle does; a
+    /// keyboard shift-click in the inventory does not drop it.
+    #[test]
+    fn pad_toggle_is_restored_after_a_screen() {
+        let off = [false; 4];
+        let mut keys = ToggleKeys::default();
+        keys.pad_toggle(SNEAK, false);
+        assert!(keys.is_down(SNEAK));
+        keys.screen_opened(off);
+        assert!(!keys.is_down(SNEAK));
+        keys.key(SNEAK, KeyAction::Press, true, false);
+        keys.key(SNEAK, KeyAction::Release, true, false);
+        keys.screen_closed(off);
+        assert!(keys.is_down(SNEAK), "the pad's toggle is restored");
+        // Toggled back up, it stays up through the next screen.
+        keys.pad_toggle(SNEAK, false);
+        assert!(!keys.is_down(SNEAK));
+        keys.screen_opened(off);
+        keys.screen_closed(off);
+        assert!(!keys.is_down(SNEAK));
+        // A held key is not restored, as before.
+        keys.key(SNEAK, KeyAction::Press, false, false);
+        keys.screen_opened(off);
+        keys.key(SNEAK, KeyAction::Release, true, false);
+        keys.screen_closed(off);
+        assert!(!keys.is_down(SNEAK));
+    }
+    /// After the pad's toggle is over (toggled up, or reset by a respawn
+    /// with no screen to restore it), the shift key holds again.
+    #[test]
+    fn pad_toggle_ends_with_its_release() {
+        let off = [false; 4];
+        let mut keys = ToggleKeys::default();
+        keys.pad_toggle(SNEAK, false);
+        keys.respawn();
+        assert!(!keys.is_down(SNEAK));
+        keys.key(SNEAK, KeyAction::Press, false, false);
+        keys.key(SNEAK, KeyAction::Release, false, false);
+        assert!(!keys.is_down(SNEAK), "held, not toggled");
+        // The death screen releases it and closes after the respawn: the
+        // toggle comes back, as with the vanilla option.
+        keys.pad_toggle(SNEAK, false);
+        keys.screen_opened(off);
+        keys.respawn();
+        keys.screen_closed(off);
+        assert!(keys.is_down(SNEAK));
+        // A press with a screen open does nothing.
+        keys.pad_toggle(SNEAK, true);
+        assert!(keys.is_down(SNEAK));
+    }
     #[test]
     fn screen_release_restores_toggled_state() {
         let mut k = KeyState::toggle(true, true);

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

@@ -673,6 +673,11 @@ mod tests {
             vsync_present_mode(&[PresentMode::Fifo], false),
             Some(PresentMode::Fifo)
         );
+        // Regression guard: GLES capabilities report [Fifo, Immediate] without Mailbox.
+        assert_eq!(
+            vsync_present_mode(&[PresentMode::Fifo, PresentMode::Immediate], false),
+            Some(PresentMode::Immediate)
+        );
     }
     #[test]
     fn vsync_on_waits_for_the_display_whatever_the_present_mode() {

crates/horizon-client-render/Cargo.toml

@@ -32,7 +32,7 @@ flate2 = { version = "1.1.10", default-features = false, features = ["zlib-rs",
 glam = "0.30"
 log = "0.4"
 miniz_oxide = "0.8"
-naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out"] }
+naga = { version = "30.0.1", features = ["wgsl-in", "glsl-in", "hlsl-out"] }
 png = "0.18"
 pollster = "0.4"
 serde = { version = "1", features = ["derive"] }

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

@@ -192,9 +192,8 @@ impl Assets {
     pub fn reload(&self, root: &Path) -> Result<RenderAssets> {
         RenderAssets::load(root, self)
     }
-    /// [`Assets::reload`] for a server, which draws nothing: the item models
-    /// and the sprites' layers, without the block models or the textures'
-    /// pixels.
+    /// [`Assets::reload`] for a server, which draws nothing: the sprites'
+    /// layers, without the block or item models or the textures' pixels.
     pub fn reload_for_server(&self, root: &Path) -> Result<RenderAssets> {
         RenderAssets::load_with(root, self, false)
     }
@@ -209,8 +208,13 @@ impl RenderAssets {
         for name in MATERIALS {
             sprites.insert(root, &format!("minecraft:block/{name}"))?;
         }
-        let parsed = crate::model_library::ParsedModels::load(root);
-        // A server draws no block: its models (about 24 MB baked) stay empty.
+        // A server draws no block and no item: its block models (about 24 MB
+        // baked) and item model library (7 MB) stay empty.
+        let parsed = if draws {
+            crate::model_library::ParsedModels::load(root)
+        } else {
+            crate::model_library::ParsedModels::default()
+        };
         let models = if draws {
             crate::models::prepare_with_models(root, registry, &mut sprites, &parsed)?
         } else {

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

@@ -47,6 +47,12 @@ struct Mixer {
     listener_yaw: f32,
     listener_pitch: f32,
     limiter_peak: f32,
+    /// The output device the stream was opened on (`Library.currentDeviceName`).
+    #[cfg(feature = "audio")]
+    device_name: String,
+    /// The stream reported its device gone (`Library.isCurrentDeviceDisconnected`).
+    #[cfg(feature = "audio")]
+    device_lost: bool,
 }
 /// A sound the player could have heard (`SoundEventListener.onPlaySound`):
 /// what the subtitle overlay needs.
@@ -167,6 +173,15 @@ pub struct Audio {
     pub stopped: std::collections::BTreeMap<String, u32>,
     /// The volume sliders' `SoundPreviewHandler`.
     preview: crate::sound_preview::SoundPreview,
+    /// `SoundEngine.lastSeenDevices`: the system default output last seen.
+    #[cfg(feature = "audio")]
+    default_seen: Option<String>,
+    /// The other half of `lastSeenDevices`: every output device last seen.
+    #[cfg(feature = "audio")]
+    devices_seen: Vec<String>,
+    /// Ticks since the output devices were last looked at (`DeviceTracker.tick`).
+    #[cfg(feature = "audio")]
+    device_ticks: u32,
 }
 fn decode(path: &Path) -> Option<(Vec<f32>, u32)> {
     use symphonia::core::{
@@ -506,19 +521,30 @@ fn open_device(
     use cpal::SampleFormat as F;
     let config = device.default_output_config()?;
     let stream = match config.sample_format() {
-        F::F32 => build_stream::<f32>(device, &config, mixer),
-        F::F64 => build_stream::<f64>(device, &config, mixer),
-        F::I16 => build_stream::<i16>(device, &config, mixer),
-        F::I32 => build_stream::<i32>(device, &config, mixer),
-        F::I8 => build_stream::<i8>(device, &config, mixer),
-        F::U16 => build_stream::<u16>(device, &config, mixer),
-        F::U32 => build_stream::<u32>(device, &config, mixer),
-        F::U8 => build_stream::<u8>(device, &config, mixer),
+        F::F32 => build_stream::<f32>(device, &config, mixer.clone()),
+        F::F64 => build_stream::<f64>(device, &config, mixer.clone()),
+        F::I16 => build_stream::<i16>(device, &config, mixer.clone()),
+        F::I32 => build_stream::<i32>(device, &config, mixer.clone()),
+        F::I8 => build_stream::<i8>(device, &config, mixer.clone()),
+        F::U16 => build_stream::<u16>(device, &config, mixer.clone()),
+        F::U32 => build_stream::<u32>(device, &config, mixer.clone()),
+        F::U8 => build_stream::<u8>(device, &config, mixer.clone()),
         other => Err(format!("unsupported sample format {other}").into()),
     }?;
     stream.play()?;
+    if let Ok(mut m) = mixer.lock() {
+        m.device_name = device.name().unwrap_or_default();
+        m.device_lost = false;
+    }
     Ok((stream, config))
 }
+/// The name of the system's default output device.
+#[cfg(feature = "audio")]
+fn default_output_name() -> Option<String> {
+    cpal::default_host()
+        .default_output_device()
+        .and_then(|d| d.name().ok())
+}
 #[cfg(feature = "audio")]
 fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
     device: &cpal::Device,
@@ -528,6 +554,7 @@ fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
     let rate = config.sample_rate().0;
     let channels = config.channels() as usize;
     let mut scratch = Vec::new();
+    let on_error = mixer.clone();
     let stream = device.build_output_stream(
         &config.config(),
         move |data: &mut [T], _| {
@@ -541,7 +568,14 @@ fn build_stream<T: cpal::SizedSample + cpal::FromSample<f32>>(
                 *out = T::from_sample(*s);
             }
         },
-        |e| log::warn!("Horizon: audio stream error: {e}"),
+        move |e| {
+            log::warn!("Horizon: audio stream error: {e}");
+            if matches!(e, cpal::StreamError::DeviceNotAvailable)
+                && let Ok(mut m) = on_error.lock()
+            {
+                m.device_lost = true;
+            }
+        },
         None,
     )?;
     Ok(stream)
@@ -637,6 +671,12 @@ impl Audio {
             heard: Default::default(),
             stopped: Default::default(),
             preview: Default::default(),
+            #[cfg(feature = "audio")]
+            default_seen: if live { default_output_name() } else { None },
+            #[cfg(feature = "audio")]
+            devices_seen: if live { output_devices() } else { Vec::new() },
+            #[cfg(feature = "audio")]
+            device_ticks: 0,
         }
     }
     #[cfg(not(feature = "audio"))]
@@ -764,8 +804,64 @@ impl Audio {
         }
         self.engine.listening = self.record_heard;
     }
+    /// `SoundEngine.shouldChangeDevice`: the open device was lost, the system
+    /// default changed (with no device chosen in the options), or the chosen
+    /// device came back; the output is then opened again. The devices are looked
+    /// at once a second.
+    #[cfg(feature = "audio")]
+    fn should_change_device(&mut self) -> bool {
+        let (current, lost) = match self.backend.mixer.lock() {
+            Ok(mut m) => (m.device_name.clone(), std::mem::take(&mut m.device_lost)),
+            Err(_) => return false,
+        };
+        if lost {
+            log::info!("Horizon: audio device was lost");
+            self.default_seen = default_output_name();
+            self.devices_seen = output_devices();
+            return true;
+        }
+        self.device_ticks += 1;
+        if self._stream.is_none() || self.device_ticks < 20 {
+            return false;
+        }
+        self.device_ticks = 0;
+        let default = default_output_name();
+        let devices = output_devices();
+        // Only a change in the device lists is looked at, as in vanilla: a
+        // preferred device that is listed but cannot open is not retried.
+        if default == self.default_seen && devices == self.devices_seen {
+            return false;
+        }
+        self.default_seen = default.clone();
+        let wanted = self.device_name.clone();
+        let available = devices.contains(&wanted);
+        self.devices_seen = devices;
+        if wanted.is_empty() {
+            let changed = default.as_deref().is_some_and(|d| d != current);
+            if changed {
+                log::info!("Horizon: system default audio device has changed");
+            }
+            return changed;
+        }
+        let changed = current != wanted && available;
+        if changed {
+            log::info!("Horizon: preferred audio device has become available");
+        }
+        changed
+    }
     /// `SoundManager.tick(paused)`, once per client tick.
     pub fn tick(&mut self, paused: bool, ctx: &TickContext) {
+        #[cfg(feature = "audio")]
+        {
+            if self.should_change_device() {
+                // SoundEngine.reload: stop every sound, open the output again.
+                self.stop_all();
+                let device = self.device_name.clone();
+                if let Err(e) = self.set_device(&device) {
+                    log::warn!("Horizon: could not reopen the audio output: {e}");
+                }
+            }
+        }
         self.sync_volumes();
         self.engine.tick(paused, ctx, &mut self.backend);
     }
@@ -801,6 +897,37 @@ impl Audio {
         let seed = self.random.next_long();
         self.play_seeded(event, at, volume, pitch, seed);
     }
+    /// `ClientLevel.playLocalSound` with `distanceDelay`: a sound more than 10
+    /// blocks from the camera starts `sqrt(distance) / 40` seconds later.
+    pub fn play_distance_delayed(
+        &mut self,
+        event: &str,
+        at: [f64; 3],
+        volume: f32,
+        pitch: f32,
+        camera: [f64; 3],
+    ) {
+        let distance_sqr: f64 = (0..3).map(|i| (at[i] - camera[i]).powi(2)).sum();
+        if distance_sqr <= 100.0 {
+            self.play(event, Some(at), volume, pitch);
+            return;
+        }
+        let seed = self.random.next_long();
+        if let Some(capture) = self.capture.as_mut() {
+            capture.push((event.to_owned(), at, volume, pitch));
+        }
+        *self.heard.entry(event.to_owned()).or_default() += 1;
+        self.sync_volumes();
+        let event = crate::sound_events::normalize(event);
+        let source = self
+            .source_override
+            .unwrap_or_else(|| crate::settings::sound_source(&event));
+        let instance =
+            SoundInstance::at(&event, source, volume, pitch, LegacyRandom::new(seed), at);
+        let id = self.engine.add(instance, false);
+        self.engine
+            .play_delayed(id, (distance_sqr.sqrt() / 40.0 * 20.0) as i32);
+    }
     /// `play` for this client only: a sound a packet's handler plays
     /// (`playLocalSound`), which the guests play from that packet themselves.
     pub fn play_unshared(&mut self, event: &str, at: Option<[f64; 3]>, volume: f32, pitch: f32) {

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

@@ -203,6 +203,46 @@ pub fn endpoint(doc: &serde_json::Value, service: &str, name: &str) -> Option<St
         .map(str::to_owned)
 }
 
+/// `Minecraft`'s constructor futures for the title screen: `UserApiService.fetchProperties`
+/// (the `player` service's `getAttributes`, with the bearer token) and
+/// `SessionService.fetchProfile(uuid, true)` (`getProfileById`). A failed
+/// attributes call falls back to the offline properties, a failed profile call
+/// to no actions, as vanilla does. Blocks: call it off the main thread.
+pub fn fetch_account_status(session: &AuthSession) -> crate::ban_notice::AccountStatus {
+    use crate::ban_notice::{AccountStatus, parse_profile_actions, parse_properties};
+    let Ok(doc) = discovery() else {
+        return AccountStatus::default();
+    };
+    let properties = endpoint(&doc, "player", "getAttributes")
+        .and_then(|url| {
+            agent()
+                .get(&url)
+                .set("Authorization", &format!("Bearer {}", session.access_token))
+                .call()
+                .ok()?
+                .into_string()
+                .ok()
+        })
+        .and_then(|body| parse_properties(&body))
+        .unwrap_or_default();
+    let actions = endpoint(&doc, "session", "getProfileById")
+        .and_then(|url| {
+            let url = url.replace("{profileId}", &format!("{:032x}", session.uuid));
+            agent()
+                .get(&format!("{url}?unsigned=true"))
+                .call()
+                .ok()?
+                .into_string()
+                .ok()
+        })
+        .map(|body| parse_profile_actions(&body))
+        .unwrap_or_default();
+    AccountStatus {
+        properties,
+        actions,
+    }
+}
+
 /// The JoinMinecraftServerRequest body; `selectedProfile` is the undashed UUID.
 pub fn join_request(session: &AuthSession, server_hash: &str) -> String {
     serde_json::json!({

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

@@ -0,0 +1,373 @@
+//! The ban notices `Gui.addInitialScreens` queues before the title screen:
+//! `Minecraft.multiplayerBan()` (the account's MULTIPLAYER ban from the services
+//! attributes call), the forced name change and the banned skin
+//! (`ProfileResult.actions()`), and the text `BanNoticeScreens` shows for each.
+//! The network calls are in `auth.rs`; this file parses what they return.
+use crate::text::Text;
+
+/// `CommonLinks.SUSPENSION_HELP`.
+pub const SUSPENSION_HELP: &str = "https://aka.ms/mcjavamoderation";
+
+/// authlib's `BanDetails` (the id is never shown).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct BanDetails {
+    /// Epoch milliseconds the ban ends; `None` is permanent.
+    pub expires_ms: Option<i64>,
+    pub reason: Option<String>,
+    pub reason_message: Option<String>,
+}
+
+/// authlib's `UserProperties`, as far as the title screen reads it.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct UserProperties {
+    /// `UserFlag.SERVERS_ALLOWED` (`privileges.multiplayerServer.enabled`).
+    pub servers_allowed: bool,
+    /// `bannedScopes.get("MULTIPLAYER")`.
+    pub multiplayer_ban: Option<BanDetails>,
+}
+impl Default for UserProperties {
+    /// `UserApiService.OFFLINE_PROPERTIES`: what a failed fetch falls back to.
+    fn default() -> Self {
+        Self {
+            servers_allowed: true,
+            multiplayer_ban: None,
+        }
+    }
+}
+
+/// authlib's `ProfileResult.actions()`.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ProfileActions {
+    pub forced_name_change: bool,
+    pub using_banned_skin: bool,
+}
+
+/// What the title screen learns about the account.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct AccountStatus {
+    pub properties: UserProperties,
+    pub actions: ProfileActions,
+}
+impl AccountStatus {
+    /// `Minecraft.allowsMultiplayer` (without the `--disableMultiplayer` flag).
+    pub fn allows_multiplayer(&self) -> bool {
+        self.properties.servers_allowed
+            && self.properties.multiplayer_ban.is_none()
+            && !self.actions.forced_name_change
+    }
+}
+
+/// One of the screens `Gui.addInitialScreens` adds.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Notice {
+    /// `BanNoticeScreens.create`.
+    Multiplayer(BanDetails),
+    /// `BanNoticeScreens.createNameBan` with the profile's name.
+    Name(String),
+    /// `BanNoticeScreens.createSkinBan`.
+    Skin,
+}
+
+/// `Gui.addInitialScreens`' ban part, in its order: the multiplayer ban, the
+/// name ban, the skin ban.
+pub fn initial_notices(status: &AccountStatus, profile_name: &str) -> Vec<Notice> {
+    let mut notices = Vec::new();
+    if let Some(ban) = &status.properties.multiplayer_ban {
+        notices.push(Notice::Multiplayer(ban.clone()));
+    }
+    if status.actions.forced_name_change {
+        notices.push(Notice::Name(profile_name.to_owned()));
+    }
+    if status.actions.using_banned_skin {
+        notices.push(Notice::Skin);
+    }
+    notices
+}
+
+impl Notice {
+    /// The screen's title (bold).
+    pub fn title(&self) -> Text {
+        let key = match self {
+            Self::Multiplayer(ban) if ban.expires_ms.is_some() => "gui.banned.title.temporary",
+            Self::Multiplayer(_) => "gui.banned.title.permanent",
+            Self::Name(_) => "gui.banned.name.title",
+            Self::Skin => "gui.banned.skin.title",
+        };
+        Text::translate(key, &[]).bold()
+    }
+    /// The screen's message; `now_ms` is `Instant.now()`.
+    pub fn message(&self, now_ms: i64) -> Text {
+        let link = || Text::literal(SUSPENSION_HELP);
+        match self {
+            Self::Multiplayer(ban) => Text::translate(
+                "gui.banned.description",
+                &[reason_text(ban), status_text(ban, now_ms), link()],
+            ),
+            Self::Name(name) => Text::translate(
+                "gui.banned.name.description",
+                &[Text::colored(name.clone(), YELLOW), link()],
+            ),
+            Self::Skin => Text::translate("gui.banned.skin.description", &[link()]),
+        }
+    }
+}
+
+/// `ChatFormatting.YELLOW`.
+const YELLOW: u32 = 0xFFFF55;
+
+/// `BanReason.byId`: the translation key suffix.
+fn ban_reason(id: i32) -> Option<&'static str> {
+    Some(match id {
+        2 => "false_reporting",
+        5 => "hate_speech",
+        16 | 25 => "hate_terrorism_notorious_figure",
+        17 | 19 | 23 | 31 => "generic_violation",
+        21 => "harassment_or_bullying",
+        27 => "defamation_impersonation_false_information",
+        28 => "drugs",
+        29 => "fraud",
+        30 => "spam_or_advertising",
+        32 => "nudity_or_pornography",
+        33 | 35 | 36 => "sexually_inappropriate",
+        34 => "extreme_violence_or_gore",
+        53 => "imminent_harm_to_person_or_property",
+        _ => return None,
+    })
+}
+
+/// `BanNoticeScreens.getBanReasonText`.
+fn reason_text(ban: &BanDetails) -> Text {
+    let numeric = ban
+        .reason
+        .as_deref()
+        .filter(|r| !r.is_empty() && r.bytes().all(|b| b.is_ascii_digit()));
+    let Some(reason) = numeric else {
+        return Text::translate("gui.banned.description.unknownreason", &[]);
+    };
+    // Integer.parseInt: past i32 the vanilla screen would throw; show the code as is.
+    let id = reason.parse::<i32>().ok();
+    let text = if let Some(key) = id.and_then(ban_reason) {
+        Text::translate(&format!("gui.banned.reason.{key}"), &[]).bold()
+    } else if let Some(message) = &ban.reason_message {
+        Text::translate(
+            "gui.banned.description.reason_id_message",
+            &[Text::literal(reason), Text::literal(message.clone())],
+        )
+        .bold()
+    } else {
+        Text::translate("gui.banned.description.reason_id", &[Text::literal(reason)]).bold()
+    };
+    Text::translate("gui.banned.description.reason", &[text])
+}
+
+/// `BanNoticeScreens.getBanStatusText`.
+fn status_text(ban: &BanDetails, now_ms: i64) -> Text {
+    match ban.expires_ms {
+        Some(expires) => {
+            let duration = Text::translate(
+                "gui.banned.description.temporary.duration",
+                &[duration_text(expires - now_ms)],
+            )
+            .bold();
+            Text::translate("gui.banned.description.temporary", &[duration])
+        }
+        None => Text::translate("gui.banned.description.permanent", &[]).bold(),
+    }
+}
+
+/// `BanNoticeScreens.getBanDurationText`: days past 72 hours, else hours,
+/// else minutes (`Duration.toHours` and friends truncate toward zero).
+fn duration_text(millis: i64) -> Text {
+    let count = |n: i64| Text::literal(n.to_string());
+    let hours = millis / 3_600_000;
+    if hours > 72 {
+        Text::translate("gui.days", &[count(millis / 86_400_000)])
+    } else if hours < 1 {
+        Text::translate("gui.minutes", &[count(millis / 60_000)])
+    } else {
+        Text::translate("gui.hours", &[count(hours)])
+    }
+}
+
+/// `Instant` as authlib's gson adapter reads it: an ISO-8601 string, or epoch milliseconds.
+fn parse_instant(value: &serde_json::Value) -> Option<i64> {
+    match value {
+        serde_json::Value::Number(n) => n.as_i64(),
+        serde_json::Value::String(s) => chrono::DateTime::parse_from_rfc3339(s)
+            .ok()
+            .map(|t| t.timestamp_millis())
+            .or_else(|| s.parse().ok()),
+        _ => None,
+    }
+}
+
+/// `UserAttributesResponse` into `UserProperties` (`fetchProperties`). Bad JSON
+/// is an error, which vanilla answers with the offline properties.
+pub fn parse_properties(body: &str) -> Option<UserProperties> {
+    let v: serde_json::Value = serde_json::from_str(body).ok()?;
+    let servers_allowed = v
+        .pointer("/privileges/multiplayerServer/enabled")
+        .and_then(|e| e.as_bool())
+        .unwrap_or(false);
+    let multiplayer_ban = v
+        .pointer("/banStatus/bannedScopes/MULTIPLAYER")
+        .filter(|b| b.is_object())
+        .map(|b| {
+            let text = |k: &str| b.get(k).and_then(|s| s.as_str()).map(str::to_owned);
+            BanDetails {
+                expires_ms: b.get("expires").and_then(parse_instant),
+                reason: text("reason"),
+                reason_message: text("reasonMessage"),
+            }
+        });
+    Some(UserProperties {
+        servers_allowed,
+        multiplayer_ban,
+    })
+}
+
+/// `MinecraftProfilePropertiesResponse.profileActions` into `ProfileActionType`s.
+pub fn parse_profile_actions(body: &str) -> ProfileActions {
+    let mut actions = ProfileActions::default();
+    let v: serde_json::Value = serde_json::from_str(body).unwrap_or_default();
+    for action in v
+        .get("profileActions")
+        .and_then(|a| a.as_array())
+        .into_iter()
+        .flatten()
+    {
+        match action.get("type").and_then(|t| t.as_str()) {
+            Some("FORCED_NAME_CHANGE") => actions.forced_name_change = true,
+            Some("USING_BANNED_SKIN") => actions.using_banned_skin = true,
+            _ => {}
+        }
+    }
+    actions
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const HOUR: i64 = 3_600_000;
+    /// 2026-11-01T00:00:00Z.
+    const EXPIRES: i64 = 1_793_491_200_000;
+
+    #[test]
+    fn parses_a_multiplayer_ban() {
+        let body = r#"{"privileges":{"multiplayerServer":{"enabled":false}},
+            "banStatus":{"bannedScopes":{"MULTIPLAYER":{"banId":"6b0f0a0e-0000-4000-8000-000000000000",
+            "expires":"2026-11-01T00:00:00Z","reason":"21","reasonMessage":"x"}}}}"#;
+        let p = parse_properties(body).unwrap();
+        assert!(!p.servers_allowed);
+        let ban = p.multiplayer_ban.unwrap();
+        assert_eq!(ban.expires_ms, Some(EXPIRES));
+        assert_eq!(ban.reason.as_deref(), Some("21"));
+        let numeric =
+            parse_properties(r#"{"banStatus":{"bannedScopes":{"MULTIPLAYER":{"expires":5}}}}"#)
+                .unwrap();
+        assert_eq!(numeric.multiplayer_ban.unwrap().expires_ms, Some(5));
+        assert!(parse_properties("nope").is_none());
+        let clean = parse_properties(
+            r#"{"privileges":{"multiplayerServer":{"enabled":true}},"banStatus":{"bannedScopes":{}}}"#,
+        )
+        .unwrap();
+        assert!(clean.servers_allowed && clean.multiplayer_ban.is_none());
+    }
+
+    #[test]
+    fn parses_profile_actions() {
+        let a = parse_profile_actions(
+            r#"{"id":"x","profileActions":[{"type":"FORCED_NAME_CHANGE"},{"type":"OTHER"}]}"#,
+        );
+        assert!(a.forced_name_change && !a.using_banned_skin);
+        let a = parse_profile_actions(r#"{"profileActions":[{"type":"USING_BANNED_SKIN"}]}"#);
+        assert!(!a.forced_name_change && a.using_banned_skin);
+        assert_eq!(parse_profile_actions("{}"), ProfileActions::default());
+    }
+
+    #[test]
+    fn queues_in_vanilla_order() {
+        let ban = BanDetails {
+            expires_ms: None,
+            reason: None,
+            reason_message: None,
+        };
+        let status = AccountStatus {
+            properties: UserProperties {
+                servers_allowed: true,
+                multiplayer_ban: Some(ban.clone()),
+            },
+            actions: ProfileActions {
+                forced_name_change: true,
+                using_banned_skin: true,
+            },
+        };
+        assert_eq!(
+            initial_notices(&status, "Steve"),
+            vec![
+                Notice::Multiplayer(ban),
+                Notice::Name("Steve".into()),
+                Notice::Skin
+            ]
+        );
+        assert!(!status.allows_multiplayer());
+        assert!(initial_notices(&AccountStatus::default(), "Steve").is_empty());
+        assert!(AccountStatus::default().allows_multiplayer());
+        let no_servers = AccountStatus {
+            properties: UserProperties {
+                servers_allowed: false,
+                multiplayer_ban: None,
+            },
+            ..Default::default()
+        };
+        assert!(!no_servers.allows_multiplayer());
+    }
+
+    /// The message's component JSON: the keys and arguments, whatever language is loaded.
+    fn json(notice: &Notice, now: i64) -> String {
+        notice.message(now).component().to_string()
+    }
+
+    #[test]
+    fn ban_text_follows_banned_screens() {
+        let temp = |reason: Option<&str>, message: Option<&str>| {
+            Notice::Multiplayer(BanDetails {
+                expires_ms: Some(100 * HOUR),
+                reason: reason.map(str::to_owned),
+                reason_message: message.map(str::to_owned),
+            })
+        };
+        assert_eq!(
+            temp(None, None).title().translation_key(),
+            Some("gui.banned.title.temporary")
+        );
+        let perm = Notice::Multiplayer(BanDetails {
+            expires_ms: None,
+            reason: Some("5".into()),
+            reason_message: None,
+        });
+        assert_eq!(
+            perm.title().translation_key(),
+            Some("gui.banned.title.permanent")
+        );
+        let text = json(&perm, 0);
+        assert!(text.contains("gui.banned.reason.hate_speech"));
+        assert!(text.contains("gui.banned.description.permanent"));
+        assert!(text.contains(SUSPENSION_HELP));
+        // Unknown ids show their code, with the message when there is one.
+        let with_message = json(&temp(Some("999"), Some("why")), 0);
+        assert!(with_message.contains("gui.banned.description.reason_id_message"));
+        assert!(with_message.contains("why"));
+        assert!(json(&temp(Some("999"), None), 0).contains("gui.banned.description.reason_id\""));
+        assert!(json(&temp(Some("abc"), None), 0).contains("gui.banned.description.unknownreason"));
+        // 100 hours left is past 72: days (4); less is hours; under an hour is minutes.
+        let duration = |now| json(&temp(None, None), now);
+        assert!(duration(0).contains("gui.days") && duration(0).contains("[4]"));
+        assert!(duration(60 * HOUR).contains("gui.hours") && duration(60 * HOUR).contains("[40]"));
+        let minutes = duration(100 * HOUR - 90_000);
+        assert!(minutes.contains("gui.minutes") && minutes.contains("[1]"));
+        assert!(json(&Notice::Name("Bob".into()), 0).contains("Bob"));
+        assert!(json(&Notice::Skin, 0).contains(SUSPENSION_HELP));
+    }
+}

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

@@ -789,6 +789,8 @@ pub struct Scene<'a> {
     pub glyphs: u64,
 }
 
+/// Empty by default (a dedicated server): no state has a block entity model.
+#[derive(Default)]
 pub struct BlockEntityRenderer {
     models: HashMap<&'static str, ModelPart>,
     kinds: Vec<Kind>,
@@ -1490,6 +1492,7 @@ impl BlockEntityRenderer {
                 } else {
                     None
                 };
+                let has_profile = skin.is_some();
                 let texture = skin.as_deref().unwrap_or(texture);
                 let (Some(model), Some(paint)) =
                     (self.models.get(model), paint(texture, 0xFFFFFF, packed))
@@ -1524,7 +1527,13 @@ impl BlockEntityRenderer {
                     "right_ear" => p[5] = (f64::from(t * PI * 0.2).cos() + 2.5) as f32 * 0.2,
                     _ => {}
                 };
+                let start = out.len();
                 draw_part(model, "root", m, &anim, paint, out);
+                // `SkullBlockRenderer.resolveSkullRenderType`: a head with a profile takes
+                // the player skin's `entityTranslucent` render type.
+                if has_profile {
+                    crate::gfx::mark_oit(&mut out[start..]);
+                }
             }
             Kind::Bell => {
                 let (Some(model), Some(paint)) = (

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

@@ -24,6 +24,9 @@ struct Out {
     return out;
 }
 @fragment fn fs_border(in: Out) -> @location(0) vec4<f32> {
+    return border_color(in);
+}
+fn border_color(in: Out) -> vec4<f32> {
     let color = textureSample(forcefield, forcefield_sampler, in.uv);
     if color.a == 0.0 {
         discard;

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

@@ -12,8 +12,8 @@ use serde_json::Value;
 use std::{collections::HashSet, fs, path::Path};
 
 pub use horizon_client_core::potions::{
-    BASE_POTION_COLOR, Category, EFFECTS, EffectDef, POTIONS, PotionDef, effect, namespaced,
-    potion, potion_color,
+    BASE_POTION_COLOR, Category, EFFECTS, EffectDef, POTIONS, PotionDef, all_effects,
+    description_id, effect, mod_effects, namespaced, potion, potion_color, register_mod_effects,
 };
 /// `MobEffectUtil.formatDuration` at 20 TPS.
 pub fn format_duration(ticks: i32) -> String {
@@ -80,8 +80,7 @@ pub fn effect_lines<'a>(
         .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());
+            let mut line = translate(&description_id(e)).unwrap_or_else(|| e.to_owned());
             if amp > 0 {
                 line.push(' ');
                 line.push_str(

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

@@ -21,6 +21,8 @@ const COMMAND_HISTORY_FILE: &str = "command_history.txt";
 const MAX_PERSISTED_COMMAND_HISTORY: usize = 50;
 /// GuiMessageTag.systemSinglePlayer's indicator colour.
 pub const SYSTEM_INDICATOR: u32 = 0xD0D0D0;
+/// `GuiMessageTag.CHAT_MODIFIED_INDICATOR_COLOR`.
+const MODIFIED_INDICATOR: u32 = 0x60_6060;
 /// A player message's signature (MessageSignature), which names it to a
 /// server's deletion.
 pub type Signature = horizon_protocol::secure_chat::Signature;
@@ -169,7 +171,7 @@ impl ChatOptions {
 struct Message {
     added: u64,
     content: Text,
-    indicator: Option<u32>,
+    tag: Option<std::sync::Arc<Tag>>,
     source: ChatSource,
     /// `GuiMessage.signature`: a signed player message's, for deletion.
     signature: Option<Box<Signature>>,
@@ -179,7 +181,46 @@ struct Message {
 struct Line {
     added: u64,
     content: Text,
-    indicator: Option<u32>,
+    tag: Option<std::sync::Arc<Tag>>,
+}
+
+/// `GuiMessageTag`: the bar at the left of a message's lines, the tooltip
+/// over it, and for a modified message the icon after each line.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Tag {
+    pub color: u32,
+    /// `GuiMessageTag.Icon.CHAT_MODIFIED`.
+    pub icon: bool,
+    pub text: Text,
+}
+impl Tag {
+    /// `GuiMessageTag.systemSinglePlayer`, in `color`.
+    pub fn system_single_player(color: u32) -> Self {
+        Self {
+            color,
+            icon: false,
+            text: Text::translate("chat.tag.system_single_player", &[]),
+        }
+    }
+    /// `GuiMessageTag.chatNotSecure`.
+    pub fn not_secure() -> Self {
+        Self {
+            color: SYSTEM_INDICATOR,
+            icon: false,
+            text: Text::translate("chat.tag.not_secure", &[]),
+        }
+    }
+    /// `GuiMessageTag.chatModified`: the tooltip adds the original content in grey.
+    pub fn modified(original_content: &str) -> Self {
+        Self {
+            color: MODIFIED_INDICATOR,
+            icon: true,
+            text: Text::empty()
+                .append(Text::translate("chat.tag.modified", &[]))
+                .append(Text::literal("\n"))
+                .append(Text::literal(original_content).with_color(text::GRAY)),
+        }
+    }
 }
 
 /// `ChatComponent.AlphaCalculator.timeBased`: opaque for 180 ticks, then
@@ -236,7 +277,8 @@ impl Chat {
         ticks: u64,
         focused: bool,
     ) {
-        self.add_message(&atlas.font, content, indicator, source, ticks, focused);
+        let tag = indicator.map(|color| std::sync::Arc::new(Tag::system_single_player(color)));
+        self.add_message(&atlas.font, content, tag, source, ticks, focused);
     }
     /// `add` of a player message with its signature, which a server's
     /// deletion names it by (`GuiMessage.signature`).
@@ -245,11 +287,13 @@ impl Chat {
         atlas: &HudAtlas,
         content: Text,
         signature: Option<Signature>,
+        tag: Option<Tag>,
         ticks: u64,
         focused: bool,
     ) {
-        self.add_signed_message(&atlas.font, content, signature, ticks, focused);
+        self.add_player_message(&atlas.font, content, signature, tag, ticks, focused);
     }
+    #[cfg(test)]
     fn add_signed_message(
         &mut self,
         font: &crate::font::Font,
@@ -257,13 +301,25 @@ impl Chat {
         signature: Option<Signature>,
         ticks: u64,
         focused: bool,
+    ) {
+        self.add_player_message(font, content, signature, None, ticks, focused);
+    }
+    /// `ChatComponent.addPlayerMessage`: the tag the message's trust level made.
+    fn add_player_message(
+        &mut self,
+        font: &crate::font::Font,
+        content: Text,
+        signature: Option<Signature>,
+        tag: Option<Tag>,
+        ticks: u64,
+        focused: bool,
     ) {
         self.push_message(
             font,
             Message {
                 added: ticks,
                 content,
-                indicator: None,
+                tag: tag.map(std::sync::Arc::new),
                 source: ChatSource::Player,
                 signature: signature.map(Box::new),
             },
@@ -274,7 +330,7 @@ impl Chat {
         &mut self,
         font: &crate::font::Font,
         content: Text,
-        indicator: Option<u32>,
+        tag: Option<std::sync::Arc<Tag>>,
         source: ChatSource,
         ticks: u64,
         focused: bool,
@@ -284,7 +340,7 @@ impl Chat {
             Message {
                 added: ticks,
                 content,
-                indicator,
+                tag,
                 source,
                 signature: None,
             },
@@ -307,7 +363,13 @@ impl Chat {
         self.received += 1;
     }
     fn add_lines(&mut self, font: &crate::font::Font, message: &Message, focused: bool) {
-        let width = self.max_width();
+        // GuiMessage.splitLines: room for the tag's icon (its width, 4 before and 2 after).
+        let icon = if message.tag.as_ref().is_some_and(|tag| tag.icon) {
+            9 + 4 + 2
+        } else {
+            0
+        };
+        let width = self.max_width() - icon;
         let content = self.displayed(&message.content);
         for line in font.wrap_components(&content, width) {
             if focused && self.scroll > 0 {
@@ -319,7 +381,7 @@ impl Chat {
                 Line {
                     added: message.added,
                     content: line,
-                    indicator: message.indicator,
+                    tag: message.tag.clone(),
                 },
             );
         }
@@ -416,7 +478,9 @@ impl Chat {
         *message = Message {
             added: message.added,
             content: Self::deleted_marker(),
-            indicator: Some(SYSTEM_INDICATOR),
+            tag: Some(std::sync::Arc::new(Tag::system_single_player(
+                SYSTEM_INDICATOR,
+            ))),
             source: ChatSource::Server,
             signature: None,
         };
@@ -540,8 +604,8 @@ impl Chat {
                     shadow: true,
                 });
             }
-            if let Some(indicator) = line.indicator {
-                let color = hud_layout::as8(opacity) << 24 | indicator & 0xFF_FFFF;
+            if let Some(tag) = &line.tag {
+                let color = hud_layout::as8(opacity) << 24 | tag.color & 0xFF_FFFF;
                 out.push(hud_layout::fill(
                     -4,
                     bottom - entry_height,
@@ -702,12 +766,91 @@ impl Chat {
         }
         None
     }
-    /// Whether the cursor is on a line's indicator bar while chat is focused
-    /// (`DrawingFocusedGraphicsAccess.handleTag`), whose tooltip is the
-    /// message tag's text.
-    pub fn indicator_at(&self, height: i32, x: f64, y: f64) -> bool {
-        self.line_at(height, x, y)
-            .is_some_and(|(line, x)| line.indicator.is_some() && (-4.0..-2.0).contains(&x))
+    /// `DrawingFocusedGraphicsAccess.handleTag` and `handleTagIcon` with the
+    /// cursor at GUI position `(x, y)` while chat is focused: the tooltip of
+    /// the tag under it (its bar, or its icon) and the icons to draw, those
+    /// under the cursor and those of the message the cursor is over.
+    pub fn focused_tags(
+        &self,
+        font: &crate::font::Font,
+        height: i32,
+        x: f64,
+        y: f64,
+    ) -> (Option<Text>, Vec<GuiDraw>) {
+        let o = &self.options;
+        let scale = o.scale as f32;
+        let chat_bottom = hud_layout::floor((height - 40) as f32 / scale);
+        let entry_height = o.line_height();
+        let bottom_to_text =
+            (8.0 * (o.line_spacing + 1.0) - 4.0 * o.line_spacing + 0.5).floor() as i32;
+        let (mouse_x, mouse_y) = (x / f64::from(scale) - 4.0, y / f64::from(scale));
+        let inside = |left: i32, top: i32, right: i32, bottom: i32| {
+            mouse_x >= f64::from(left)
+                && mouse_x < f64::from(right)
+                && mouse_y >= f64::from(top)
+                && mouse_y < f64::from(bottom)
+        };
+        let visible = self
+            .lines
+            .len()
+            .saturating_sub(self.scroll)
+            .min(self.lines_per_page(true));
+        let mut tooltip = None;
+        let mut icons = Vec::new();
+        let mut hovered_message = false;
+        for i in (0..visible).rev() {
+            let index = i + self.scroll;
+            let line = &self.lines[index];
+            let bottom = chat_bottom - i as i32 * entry_height;
+            let top = bottom - entry_height;
+            let width = font.width_text(&line.content).ceil() as i32;
+            hovered_message |= inside(0, top, width, bottom);
+            // GuiMessage.Line.endOfEntry: the next newer line is another message's.
+            let end_of_entry = index == 0
+                || match (&line.tag, &self.lines[index - 1].tag) {
+                    (Some(a), Some(b)) => !std::sync::Arc::ptr_eq(a, b),
+                    (None, None) => false,
+                    _ => true,
+                };
+            let force_icon = end_of_entry && hovered_message;
+            if end_of_entry {
+                hovered_message = false;
+            }
+            let Some(tag) = &line.tag else { continue };
+            if inside(-4, top, -2, bottom) {
+                tooltip = Some(tag.text.clone());
+            }
+            if tag.icon {
+                let (left, text_bottom) = (width + 4, bottom - bottom_to_text + 9);
+                let icon_top = text_bottom - 9 - 1;
+                let over = inside(left, icon_top, left + 9, text_bottom);
+                if over {
+                    tooltip = Some(tag.text.clone());
+                }
+                if force_icon || over {
+                    icons.push(GuiDraw::Sprite {
+                        sprite: "icon/chat_modified".into(),
+                        x: left,
+                        y: icon_top,
+                        w: 9,
+                        h: 9,
+                        region: None,
+                        color: hud_layout::WHITE,
+                        blend: hud_layout::Blend::Textured,
+                    });
+                }
+            }
+        }
+        if icons.is_empty() {
+            return (tooltip, icons);
+        }
+        let mut draws = vec![GuiDraw::Push(vec![
+            PoseOp::Scale(scale, scale),
+            PoseOp::Translate(4.0, 0.0),
+        ])];
+        draws.extend(icons);
+        draws.push(GuiDraw::Pop);
+        (tooltip, draws)
     }
     /// Plain text of the newest messages (for tests and the control socket).
     pub fn recent_lines(&self, n: usize) -> Vec<String> {

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

@@ -33,7 +33,7 @@ fn add(chat: &mut Chat, font: &Font, content: Text) {
             Line {
                 added: 0,
                 content,
-                indicator: None,
+                tag: None,
             },
         );
     }
@@ -557,7 +557,7 @@ fn a_deleted_message_shows_60_ticks_then_becomes_the_marker() {
     assert_eq!(lines(&chat), ["<Alex> hi".to_owned(), marker.clone()]);
     assert!(chat.deletions.is_empty());
     let line = &chat.lines[1];
-    assert_eq!(line.indicator, Some(SYSTEM_INDICATOR));
+    assert_eq!(line.tag.as_ref().map(|t| t.color), Some(SYSTEM_INDICATOR));
     assert_eq!(line.added, 100, "the marker keeps the message's time");
     assert!(
         line.content

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

@@ -223,6 +223,35 @@ pub fn install(dir: &Path, world: &Path, selected: &[String]) -> Result<(), Stri
     let file = world.join("datapacks.json");
     std::fs::write(&file, json.to_string()).map_err(|e| err(&file, e))
 }
+/// Re-Create World's packs from a saved world: a new folder holding a copy of
+/// its `datapacks` (`CreateWorldScreen.createTempDataPackDirFromExistingWorld`; `None` when the
+/// world has none), and the selection its `datapacks.json` makes, lowest
+/// priority first (`WorldOpenFlows.recreateWorldData` keeps the world's `DataConfiguration`).
+/// The built-in pack is selected unless the world turned it off.
+pub fn for_recreate(world: &Path) -> (Option<PathBuf>, Vec<String>) {
+    let packs = discover(world);
+    let mut selected = enabled_ids(world, &packs);
+    let vanilla_off = std::fs::read(world.join("datapacks.json"))
+        .ok()
+        .and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).ok())
+        .and_then(|v| v["disabled"].as_array().cloned())
+        .is_some_and(|a| a.iter().any(|id| id.as_str() == Some("vanilla")));
+    if !vanilla_off {
+        selected.insert(0, "vanilla".into());
+    }
+    if packs.is_empty() {
+        return (None, selected);
+    }
+    let dir = temp_folder().ok().and_then(|dir| {
+        if copy(&world.join("datapacks"), &dir).is_ok() {
+            Some(dir)
+        } else {
+            let _ = std::fs::remove_dir_all(&dir);
+            None
+        }
+    });
+    (dir, selected)
+}
 /// A file, or a folder and everything in it.
 fn copy(from: &Path, to: &Path) -> Result<(), String> {
     let err = |e: std::io::Error| format!("{} -> {}: {e}", from.display(), to.display());

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

@@ -6,7 +6,8 @@ use horizon_client_core::potions;
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct EffectInstance {
-    /// Effect id without namespace (`speed`, `poison`, ...).
+    /// Effect id: vanilla's without namespace (`speed`, `poison`, ...), a
+    /// content mod's `<ns>:<path>`.
     pub id: &'static str,
     /// Remaining ticks; -1 is infinite.
     pub duration: i32,
@@ -219,7 +220,7 @@ impl PlayerEffects {
             .iter()
             .map(|e| {
                 (
-                    format!("minecraft:{}", e.id),
+                    potions::namespaced(e.id).to_owned(),
                     e.duration,
                     e.amplifier,
                     e.ambient,
@@ -525,6 +526,30 @@ mod tests {
         assert_eq!(fx.get("speed").unwrap().duration, 49);
         assert_eq!(fx.get("raid_omen").unwrap().amplifier, 1);
     }
+    /// The only test here that registers mod effects (once per process).
+    #[test]
+    fn a_mod_effect_saves_under_its_namespace() {
+        potions::register_mod_effects([(
+            "ruby:glow".to_owned(),
+            0xFF0000,
+            potions::Category::Neutral,
+        )]);
+        let mut fx = PlayerEffects::default();
+        fx.add(EffectInstance::new(
+            potions::effect("ruby:glow").unwrap().id,
+            600,
+            1,
+        ));
+        let saved = fx.saved();
+        assert_eq!(saved, [("ruby:glow".to_owned(), 600, 1, false, true)]);
+        assert_eq!(PlayerEffects::from_saved(&saved).list, fx.list);
+        // Without its mod the saved effect is dropped, as an unknown id is.
+        assert!(
+            PlayerEffects::from_saved(&[("gone:glow".into(), 600, 1, false, true)])
+                .list
+                .is_empty()
+        );
+    }
     #[test]
     fn raid_omen_acts_on_its_last_tick() {
         let mut fx = PlayerEffects::default();

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

@@ -23,6 +23,7 @@ struct Globals {
     // Horizon Extras' dynamic lights: camera-relative position and level (dynamic_light.rs).
     dynamic_lights: array<vec4<f32>, 16>,
     sunrise_fan: array<vec4<f32>, 32>,
+    filtering: vec4<f32>,
 }
 @group(0) @binding(0) var<uniform> globals: Globals;
 @group(0) @binding(1) var atlas: texture_2d<f32>;
@@ -131,7 +132,7 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
     @location(5) normal: vec4<f32>, @location(6) glint_uv: vec2<f32>) -> Out {
     var out = entity_vertex(position, uv, overlay & 0xffffu, color, light, normal);
     out.glint_uv = glint_uv;
-    out.tier = overlay >> 16u;
+    out.tier = (overlay >> 16u) & 0xffu;
     return out;
 }
 // Retained bolt-local geometry, translated using the same f64 camera
@@ -224,6 +225,9 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
 }
 // CRUMBLING_UV_END
 @fragment fn fs_entity(in: Out, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {
+    return entity_color(in, front);
+}
+fn entity_color(in: Out, front: bool) -> vec4<f32> {
     var uv = in.uv;
     if in.overlay == 6u { uv.y = in.wrap.x + fract(in.uv.y) * in.wrap.y; }
     if in.overlay == 11u || in.overlay == 12u {
@@ -271,6 +275,9 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
 // rendertype_entity_shadow.fsh: the shadow texture times the vertex colour,
 // then fog, with no alpha cutout, so a faint shadow in dim light still draws.
 @fragment fn fs_entity_shadow(in: Out) -> @location(0) vec4<f32> {
+    return shadow_color(in);
+}
+fn shadow_color(in: Out) -> vec4<f32> {
     var color = textureSample(atlas, atlas_sampler, in.uv) * in.color;
     color *= in.light_color;
     let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
@@ -306,21 +313,33 @@ fn celestial_color(in: Out) -> vec4<f32> {
 @fragment fn fs_sky_celestial(in: Out) -> @location(0) vec4<f32> {
     let color = celestial_color(in);
     let added = color.rgb * color.a;
-    return vec4(added, smoothstep(0.1, 0.3, max(added.r, max(added.g, added.b))));
+    // The sky under the disc keeps alpha 1 less this: 0 for the brightest tier
+    // (the sun), terrain.wgsl's mark for the lower ones (the moon). Tier 0 is
+    // geometry that sets none (the End sky, the End flash): it stays brightest.
+    let tier = select(4u, min(in.tier, 4u), in.tier > 0u);
+    let mark = 1.0 - 0.7 * f32(4u - tier) / 4.0;
+    return vec4(added, mark * smoothstep(0.1, 0.3, max(added.r, max(added.g, added.b))));
 }
 
 // RenderPipelines.ENERGY_SWIRL (entity.fsh with EMISSIVE and NO_OVERLAY): the sprite, scrolled by
 // the UV and repeated within itself, times the layer colour 0xFF808080, unlit; the pipeline adds
 // it to the frame. The light bytes carry the sprite's origin and the colour bytes its size, both
 // as breaking::stage_light packs them.
-@fragment fn fs_energy_swirl(in: Out) -> @location(0) vec4<f32> {
+fn energy_swirl_base(in: Out) -> vec4<f32> {
     let bytes = round(in.color * 255.0);
     let size = vec2(bytes.x + bytes.y * 256.0, bytes.z + bytes.w * 256.0) / 65535.0;
     let color = textureSample(atlas, atlas_sampler, crumbling_uv(in.uv, in.wrap, size, textureDimensions(atlas)));
     if color.a < 0.1 { discard; }
+    return vec4(color.rgb * (128.0 / 255.0), color.a);
+}
+fn energy_swirl_fog(in: Out) -> f32 {
     let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
                 linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
-    return vec4(mix(color.rgb * (128.0 / 255.0), globals.fog_color.rgb, f * globals.fog_color.a), color.a);
+    return f * globals.fog_color.a;
+}
+@fragment fn fs_energy_swirl(in: Out) -> @location(0) vec4<f32> {
+    let color = energy_swirl_base(in);
+    return vec4(mix(color.rgb, globals.fog_color.rgb, energy_swirl_fog(in)), color.a);
 }
 
 // RenderPipelines.WATER_MASK: depth only (the pipeline masks the colour off).
@@ -449,6 +468,9 @@ struct WeatherTime { values: vec4<f32> }
     return out;
 }
 @fragment fn fs_weather(in: Out) -> @location(0) vec4<f32> {
+    return weather_color(in);
+}
+fn weather_color(in: Out) -> vec4<f32> {
     // Repeat within this sprite, never across the atlas. The atlas uses nearest
     // filtering and no mipmaps, so fractional UVs have no seam derivatives.
     let texel = weather_texel(in.uv, in.weather_rect, textureDimensions(atlas));

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

@@ -40,9 +40,9 @@ mod entity_outline;
 mod weather;
 use entity_batch::EntityBatch;
 pub use entity_batch::{
-    ENERGY_SWIRL_OVERLAY, SHADOW_OVERLAY, TEXT_POLYGON_OFFSET_OVERLAY,
+    ENERGY_SWIRL_OVERLAY, OIT_ENTITY, SHADOW_OVERLAY, TEXT_POLYGON_OFFSET_OVERLAY,
     TRANSLUCENT_GLINT_ITEM_OVERLAY, TRANSLUCENT_ITEM_OVERLAY, TRANSLUCENT_PARTICLE_OVERLAY,
-    WATER_MASK_OVERLAY,
+    WATER_MASK_OVERLAY, mark_oit,
 };
 pub use view::{View, ViewSet};
 
@@ -84,6 +84,8 @@ mod native_pack;
 mod native_post;
 mod native_sky;
 mod occlusion;
+mod oit;
+mod oit_features;
 mod pack_atlas;
 pub mod pack_draw;
 mod pack_entities;
@@ -224,6 +226,8 @@ struct Globals {
     dynamic_lights: [[f32; 4]; crate::dynamic_light::MAX],
     /// The sunrise fan's triangles as the sky shader tests them (`sunrise_fan::normals`).
     sunrise_fan: [[f32; 4]; 2 * sunrise_fan::TRIANGLES],
+    /// x: `Options.textureFiltering` (0 none, 1 RGSS, 2 anisotropic); y: the sprite arrays' width.
+    filtering: [f32; 4],
 }
 pub type SectionKey = (i32, i32, i32);
 struct SectionGpu {
@@ -542,6 +546,10 @@ pub struct Renderer {
     /// terrain.wgsl's `SPRITE_ARRAYS` and `SPRITE_SPLIT`, for a shader pack's terrain.
     terrain_sprites: [f64; 2],
     sprite_sampler: wgpu::Sampler,
+    /// `Options.textureFiltering`: 0 none, 1 RGSS, 2 anisotropic.
+    texture_filtering: u32,
+    /// The anisotropic sampler's clamp (`Options.maxAnisotropyValue`); 1 unless anisotropic.
+    max_anisotropy: u16,
     lightmap_view: wgpu::TextureView,
     lightmap_sampler: wgpu::Sampler,
     animations: animate::SpriteAnimator,
@@ -672,6 +680,10 @@ pub struct Renderer {
     pub gamma: f32,
     /// Optional full-light lightmap (Horizon Extras).
     pub fullbright: bool,
+    /// The Improved transparency option (`GameRenderer.useImprovedTransparency`).
+    pub improved_transparency: bool,
+    /// Its passes and targets, made when first drawn with.
+    oit: Option<oit::Oit>,
     /// Advance animated block textures (Horizon setting; vanilla always does).
     pub animated_textures: bool,
     present_modes: Vec<wgpu::PresentMode>,
@@ -723,6 +735,36 @@ fn sprite_views(
         })
         .collect()
 }
+/// The terrain sprites' sampler for a Texture Filtering mode. None keeps the nearest sampler;
+/// RGSS and anisotropic take LevelRenderer.chunkLayerSampler's linear one (clamped to the edge),
+/// with `anisotropy` samples when it is above 1 (wgpu then needs a linear mipmap filter too).
+fn sprite_sampler_descriptor(filtering: u32, anisotropy: u16) -> wgpu::SamplerDescriptor<'static> {
+    if filtering == 0 {
+        return wgpu::SamplerDescriptor {
+            label: Some("Block sprites"),
+            address_mode_u: wgpu::AddressMode::Repeat,
+            address_mode_v: wgpu::AddressMode::Repeat,
+            mag_filter: wgpu::FilterMode::Nearest,
+            min_filter: wgpu::FilterMode::Nearest,
+            mipmap_filter: wgpu::MipmapFilterMode::Nearest,
+            ..Default::default()
+        };
+    }
+    wgpu::SamplerDescriptor {
+        label: Some("Block sprites (filtered)"),
+        address_mode_u: wgpu::AddressMode::ClampToEdge,
+        address_mode_v: wgpu::AddressMode::ClampToEdge,
+        mag_filter: wgpu::FilterMode::Linear,
+        min_filter: wgpu::FilterMode::Linear,
+        mipmap_filter: wgpu::MipmapFilterMode::Linear,
+        anisotropy_clamp: anisotropy,
+        ..Default::default()
+    }
+}
+/// `Options.maxAnisotropyValue` for a `maxAnisotropyBit`: `1 << bit`, at most wgpu's 16.
+fn sampler_anisotropy(bit: i32) -> u16 {
+    1u16 << bit.clamp(0, 4)
+}
 /// terrain.wgsl's group 0.
 #[allow(clippy::too_many_arguments)]
 fn terrain_group(
@@ -1119,6 +1161,7 @@ async fn open_backend(
     // stand-in neither clamps nor drops NaN.
     let features = timing::GpuTimer::features(&adapter)
         | cull::Cull::features(&adapter)
+        | oit::features(&adapter)
         | (adapter.features()
             & (wgpu::Features::INDIRECT_FIRST_INSTANCE
                 | wgpu::Features::MAPPABLE_PRIMARY_BUFFERS
@@ -1701,15 +1744,7 @@ impl Renderer {
                 ..Default::default()
             });
         let sprite_views = sprite_views(&sprite_textures, &sprite_unused, None);
-        let sprite_sampler = device.create_sampler(&wgpu::SamplerDescriptor {
-            label: Some("Block sprites"),
-            address_mode_u: wgpu::AddressMode::Repeat,
-            address_mode_v: wgpu::AddressMode::Repeat,
-            mag_filter: wgpu::FilterMode::Nearest,
-            min_filter: wgpu::FilterMode::Nearest,
-            mipmap_filter: wgpu::MipmapFilterMode::Nearest,
-            ..Default::default()
-        });
+        let sprite_sampler = device.create_sampler(&sprite_sampler_descriptor(0, 1));
         let lightmap = device.create_texture(&wgpu::TextureDescriptor {
             label: Some("Lightmap"),
             size: wgpu::Extent3d {
@@ -2728,7 +2763,7 @@ impl Renderer {
                 }
                 cull
             });
-        let depth = Self::depth(&device, &config, cull.as_ref());
+        let depth = Self::depth(&device, &config);
         let world_post = world_post::Post::new(&device, config.format.remove_srgb_suffix());
         let uploads = upload::Uploads::new(&device);
         let section_uploads = upload::Uploads::with_chunk(&device, SECTION_UPLOAD_CHUNK);
@@ -2840,6 +2875,8 @@ impl Renderer {
             terrain_layout: bindings,
             terrain_sprites: sprite_constants.map(|(_, v)| v),
             sprite_sampler,
+            texture_filtering: 0,
+            max_anisotropy: 1,
             lightmap_view,
             lightmap_sampler,
             animations,
@@ -2914,6 +2951,8 @@ impl Renderer {
             screenshot: None,
             screenshot_result: None,
             gamma: 0.5,
+            improved_transparency: false,
+            oit: None,
             fullbright: false,
             animated_textures: true,
             present_modes,
@@ -2998,13 +3037,8 @@ impl Renderer {
         self.surface = Some(surface);
         Ok(())
     }
-    /// The world's depth, which occlusion culling's test may read.
-    fn depth(
-        device: &wgpu::Device,
-        config: &wgpu::SurfaceConfiguration,
-        cull: Option<&cull::Cull>,
-    ) -> wgpu::TextureView {
-        let read = cull.is_some_and(|c| c.depth_test() == cull::DepthTest::InShader);
+    /// The world's depth, which occlusion culling's test and post effects may read.
+    fn depth(device: &wgpu::Device, config: &wgpu::SurfaceConfiguration) -> wgpu::TextureView {
         device
             .create_texture(&wgpu::TextureDescriptor {
                 label: Some("Horizon depth"),
@@ -3017,11 +3051,11 @@ impl Renderer {
                 sample_count: 1,
                 dimension: wgpu::TextureDimension::D2,
                 format: wgpu::TextureFormat::Depth32Float,
-                usage: if read {
-                    wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING
-                } else {
-                    wgpu::TextureUsages::RENDER_ATTACHMENT
-                },
+                // TEXTURE_BINDING: a post effect may read the depth buffer.
+                // COPY_SRC: improved transparency copies it.
+                usage: wgpu::TextureUsages::RENDER_ATTACHMENT
+                    | wgpu::TextureUsages::TEXTURE_BINDING
+                    | wgpu::TextureUsages::COPY_SRC,
                 view_formats: &[],
             })
             .create_view(&Default::default())
@@ -3085,7 +3119,7 @@ impl Renderer {
         } else {
             self.offscreen = Some(Self::offscreen_target(&self.device, &self.config));
         }
-        self.depth = Self::depth(&self.device, &self.config, self.cull.as_ref());
+        self.depth = Self::depth(&self.device, &self.config);
     }
     /// Whether sections are drawn as one index list per frame (`flat`).
     pub fn flat_draws(&self) -> bool {
@@ -3184,7 +3218,7 @@ impl Renderer {
             section.is_some() || (mesh.solid.is_empty() && mesh.translucent.is_empty()),
         );
         if let Some(section) = section {
-            self.sections.insert(key, section);
+            self.sections.insert_with_bounds(key, section, mesh.bounds);
         }
     }
     fn upload_mesh(&mut self, mesh: &SectionMesh) -> Option<SectionGpu> {
@@ -3583,7 +3617,8 @@ impl Renderer {
             // Only HDR output asks the system about the display, so with HDR off the
             // game never waits on the compositor for it.
             self.display = if output.is_some() {
-                let (watch, now) = DisplayWatch::new(&self.window);
+                let (watch, now) =
+                    DisplayWatch::new(&self.window, self.surface.as_ref(), &self.adapter);
                 crate::graphics::report(now);
                 self.display_fresh = true;
                 watch
@@ -3622,7 +3657,7 @@ impl Renderer {
         if std::mem::take(&mut self.display_fresh) {
             return true;
         }
-        let Some(now) = self.display.changed() else {
+        let Some(now) = self.display.changed(self.surface.as_ref(), &self.adapter) else {
             return false;
         };
         crate::graphics::report(now);
@@ -3805,6 +3840,44 @@ impl Renderer {
     pub fn shader_pack_dimension(&self) -> Option<i32> {
         self.pack_post.as_ref().map(|p| p.0)
     }
+    /// The Texture Filtering and Max Anisotropy options (`filtering`: 0 none, 1 RGSS, 2
+    /// anisotropic; `bit`: `maxAnisotropyBit`). None is the nearest sampler terrain always used;
+    /// the others take LevelRenderer's chunk layer sampler (linear, clamped, `bit` anisotropy
+    /// when anisotropic) and terrain.wgsl's sampleNearest / sampleRGSS.
+    pub fn set_texture_filtering(&mut self, filtering: i32, bit: i32) {
+        let filtering = filtering.clamp(0, 2) as u32;
+        let anisotropy = if filtering == 2 {
+            sampler_anisotropy(bit)
+        } else {
+            1
+        };
+        if filtering == self.texture_filtering && anisotropy == self.max_anisotropy {
+            return;
+        }
+        self.texture_filtering = filtering;
+        self.max_anisotropy = anisotropy;
+        self.sprite_sampler = self
+            .device
+            .create_sampler(&sprite_sampler_descriptor(filtering, anisotropy));
+        self.rebuild_terrain_group();
+    }
+    fn rebuild_terrain_group(&mut self) {
+        let views = sprite_views(
+            &self.sprite_textures,
+            &self.sprite_unused,
+            Some(self.mipmaps + 1),
+        );
+        self.group = terrain_group(
+            &self.device,
+            "Horizon terrain resources",
+            &self.terrain_layout,
+            &self.globals,
+            &views,
+            &self.sprite_sampler,
+            &self.lightmap_view,
+            &self.lightmap_sampler,
+        );
+    }
     /// The Mipmap Levels option: block textures sample at most `levels`
     /// reduced copies (0: none).
     pub fn set_mipmap_levels(&mut self, levels: u32) {
@@ -3818,17 +3891,7 @@ impl Renderer {
             return;
         }
         self.mipmaps = levels;
-        let views = sprite_views(&self.sprite_textures, &self.sprite_unused, Some(levels + 1));
-        self.group = terrain_group(
-            &self.device,
-            "Horizon terrain resources",
-            &self.terrain_layout,
-            &self.globals,
-            &views,
-            &self.sprite_sampler,
-            &self.lightmap_view,
-            &self.lightmap_sampler,
-        );
+        self.rebuild_terrain_group();
     }
     /// The views `render` draws `frame` from.
     pub fn views(&self, frame: &Frame) -> ViewSet {
@@ -4148,6 +4211,12 @@ impl Renderer {
                 lights
             },
             sunrise_fan: sunrise_fan::normals(frame.sky.sunrise_color[3], sun),
+            filtering: [
+                self.texture_filtering as f32,
+                self.sprite_textures[0].width() as f32,
+                0.0,
+                0.0,
+            ],
         };
         self.uploads
             .buffer(&mut encoder, &self.globals, 0, bytemuck::bytes_of(&globals));
@@ -4700,6 +4769,13 @@ impl Renderer {
             );
             entities = &self.pack_entity_rest;
         }
+        // GameRenderer.useImprovedTransparency. A shader pack keeps its own
+        // path.
+        let oit_on = self.improved_transparency
+            && !frame.title
+            && self.pack_post.as_ref().is_none_or(|p| p.1.is_none())
+            && self.native.is_none()
+            && oit::supported(&self.device);
         let [
             entity_quads,
             text_quads,
@@ -4710,9 +4786,14 @@ impl Renderer {
             shadow_quads,
             translucent_particle_quads,
             translucent_item_quads,
-        ] = self
-            .entity_batch
-            .update(entities, frame.additive, frame.hand, frame.see_through);
+            oit_entity_quads,
+        ] = self.entity_batch.update(
+            entities,
+            frame.additive,
+            frame.hand,
+            frame.see_through,
+            oit_on,
+        );
         let weather_quads = frame.weather.len() as u32 / 4;
         let world_quads = entity_quads
             + text_quads
@@ -4722,7 +4803,11 @@ impl Renderer {
             + swirl_quads
             + shadow_quads
             + translucent_particle_quads
-            + translucent_item_quads;
+            + translucent_item_quads
+            + oit_entity_quads;
+        // Where the tail of materials the classic and the improved passes
+        // both draw ends: the shadows, particles and items count back from it.
+        let base_quads = world_quads - oit_entity_quads;
         let cloud_quads = if let Some(input) = &frame.clouds {
             let (rebuilt, uniform) =
                 crate::spans::time("clouds", || self.cloud_mesh.prepare(input));
@@ -4763,7 +4848,7 @@ impl Renderer {
         );
         let all_entities = &self.entity_batch.combined;
         let hand_quads = (frame.hand.len() / 4) as u32;
-        let additive_quads = (frame.additive.len() / 4) as u32;
+        let additive_quads = (frame.additive.len() / 4) as u32 - self.entity_batch.moved_additive;
         let see_through_quads = (frame.see_through.len() / 4) as u32;
         let entity_vertices = all_entities.len() as u64;
         if entity_vertices > self.entity_capacity {
@@ -4972,7 +5057,7 @@ impl Renderer {
         }
         let pack_reads_world = pack_post || native_post;
         // Phase 2 of occlusion culling draws over the depth, and a shader pack or TAA reads it.
-        let keep_depth = pack_reads_world || (taa && self.world_post.taa);
+        let keep_depth = pack_reads_world || (taa && self.world_post.taa) || oit_on;
         // The pack's program reads the vertices this frame's draws bind.
         let pack_draws_terrain = pack_terrain && flat_frame == self.pack_terrain_flat;
         // The shadow camera's lists, drawn by the pack's shadow programs.
@@ -5025,6 +5110,46 @@ impl Renderer {
         if culling && let Some(cull) = &mut self.cull {
             cull.bind_depth(&self.device, world_depth);
         }
+        if oit_on {
+            let size = self
+                .world_post
+                .size()
+                .filter(|_| scaled.is_some())
+                .unwrap_or([self.config.width, self.config.height]);
+            let (device, layout, sprites) =
+                (&self.device, &self.terrain_layout, self.terrain_sprites);
+            let clouds = [0, 1].map(|i| self.cloud_pipeline.get_bind_group_layout(i));
+            let format = self.config.format.remove_srgb_suffix();
+            let flat = self
+                .flat
+                .as_ref()
+                .map(|f| f.translucent.get_bind_group_layout(1));
+            let features = [
+                self.entity_pipeline.get_bind_group_layout(0),
+                self.weather.pipeline().get_bind_group_layout(1),
+                self.border_pipeline.get_bind_group_layout(0),
+            ];
+            self.oit
+                .get_or_insert_with(|| {
+                    oit::Oit::new(
+                        device,
+                        layout,
+                        flat.as_ref(),
+                        [&features[0], &features[1], &features[2]],
+                        [&clouds[0], &clouds[1]],
+                        sprites,
+                        format,
+                    )
+                })
+                .prepare(
+                    &self.device,
+                    &self.queue,
+                    size,
+                    &views.primary().projection,
+                    [water_mask_quads > 0, cloud_quads > 0],
+                );
+        }
+        let oit = self.oit.as_ref().filter(|_| oit_on);
         let cull = self.cull.as_ref().filter(|_| culling && solid_draws > 0);
         let clear = if frame.title || (frame.end_sky && !frame.underwater && sky_open(frame)) {
             wgpu::Color::BLACK
@@ -5262,29 +5387,29 @@ impl Renderer {
                 }
                 pass.set_bind_group(0, &self.group, &[]);
             }
-            if text_quads > 0 {
+            if text_quads > 0 && !oit_on {
                 pass.set_pipeline(&self.text_polygon_offset_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                 pass.draw_indexed(0..text_quads * 6, (entity_quads * 4) as i32, 0..1);
                 pass.set_bind_group(0, &self.group, &[]);
             }
-            if translucent_item_quads > 0 {
+            if translucent_item_quads > 0 && !oit_on {
                 pass.set_pipeline(&self.translucent_item_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                 pass.draw_indexed(
                     0..translucent_item_quads * 6,
-                    ((world_quads - translucent_item_quads) * 4) as i32,
+                    ((base_quads - translucent_item_quads) * 4) as i32,
                     0..1,
                 );
                 pass.set_bind_group(0, &self.group, &[]);
             }
-            if !pack_draws_weather {
+            if !pack_draws_weather && !oit_on {
                 self.weather.draw(&mut pass, &self.entity_group);
             }
             pass.set_bind_group(0, &self.group, &[]);
-            if crumbling_quads > 0 {
+            if crumbling_quads > 0 && !oit_on {
                 pass.set_pipeline(&self.crumbling_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -5295,13 +5420,13 @@ impl Renderer {
                 );
                 pass.set_bind_group(0, &self.group, &[]);
             }
-            if shadow_quads > 0 {
+            if shadow_quads > 0 && !oit_on {
                 pass.set_pipeline(&self.shadow_blob_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                 pass.draw_indexed(
                     0..shadow_quads * 6,
-                    ((world_quads
+                    ((base_quads
                         - translucent_item_quads
                         - translucent_particle_quads
                         - shadow_quads)
@@ -5312,7 +5437,7 @@ impl Renderer {
             }
             // BoatRenderer's water patch (RenderTypes.waterMask): depth only,
             // before translucent terrain, so no water shows inside the boat.
-            if water_mask_quads > 0 {
+            if water_mask_quads > 0 && !oit_on {
                 pass.set_pipeline(&self.water_mask_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -5324,13 +5449,13 @@ impl Renderer {
                 );
                 pass.set_bind_group(0, &self.group, &[]);
             }
-            if !frame.lightning.bolts.is_empty() {
+            if !frame.lightning.bolts.is_empty() && !oit_on {
                 pass.set_pipeline(&self.lightning_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 self.lightning.draw(&mut pass, &frame.lightning);
                 pass.set_bind_group(0, &self.group, &[]);
             }
-            if swirl_quads > 0 {
+            if swirl_quads > 0 && !oit_on {
                 pass.set_pipeline(&self.energy_swirl_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -5346,7 +5471,7 @@ impl Renderer {
                 );
                 pass.set_bind_group(0, &self.group, &[]);
             }
-            if additive_quads > 0 {
+            if additive_quads > 0 && !oit_on {
                 pass.set_pipeline(&self.additive_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -5369,6 +5494,168 @@ impl Renderer {
             match self.flat.as_ref().filter(|_| flat_frame) {
                 // The pack draws translucent terrain after its deferred programs.
                 _ if pack_draws_water => {}
+                // LevelRenderer.executeOit in place of the classic blend; what
+                // follows draws over its composite in a pass of its own.
+                flat if let Some(oit) = oit => {
+                    drop(pass);
+                    // LevelRenderer.executeOitWaterMask and CloudRenderer.renderOit.
+                    let mask = |pass: &mut wgpu::RenderPass<'_>| {
+                        pass.set_pipeline(&self.water_mask_pipeline);
+                        pass.set_bind_group(0, &self.entity_group, &[]);
+                        pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
+                        pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
+                        pass.draw_indexed(
+                            0..water_mask_quads * 6,
+                            ((entity_quads
+                                + text_quads
+                                + crumbling_quads
+                                + translucent_crumbling_quads)
+                                * 4) as i32,
+                            0..1,
+                        );
+                    };
+                    let clouds =
+                        |pass: &mut wgpu::RenderPass<'_>, pipeline: &wgpu::RenderPipeline| {
+                            pass.set_pipeline(pipeline);
+                            pass.set_bind_group(0, &self.entity_group, &[]);
+                            pass.set_bind_group(1, &self.cloud_group, &[]);
+                            pass.set_index_buffer(
+                                self.indices.slice(..),
+                                wgpu::IndexFormat::Uint32,
+                            );
+                            pass.set_vertex_buffer(0, self.cloud_buffer.slice(..));
+                            pass.draw_indexed(0..cloud_quads * 6, 0, 0..1);
+                        };
+                    // "Features, World Border, Weather": what follows the opaque
+                    // world in the classic pass, one stage at a time.
+                    let features = |pass: &mut wgpu::RenderPass<'_>, stage: oit::Stage| {
+                        let f = oit.features();
+                        let s = stage as usize;
+                        pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
+                        pass.set_bind_group(0, &self.entity_group, &[]);
+                        pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
+                        // Quads of a material, `first` quads into the buffer.
+                        let quads = |pass: &mut wgpu::RenderPass<'_>,
+                                     pipeline: &wgpu::RenderPipeline,
+                                     count: u32,
+                                     first: u32| {
+                            if count > 0 {
+                                pass.set_pipeline(pipeline);
+                                pass.draw_indexed(0..count * 6, (first * 4) as i32, 0..1);
+                            }
+                        };
+                        quads(pass, &f.text[s], text_quads, entity_quads);
+                        quads(
+                            pass,
+                            &f.crumbling[s],
+                            crumbling_quads,
+                            entity_quads + text_quads,
+                        );
+                        quads(
+                            pass,
+                            &f.crumbling[s],
+                            translucent_crumbling_quads,
+                            entity_quads + text_quads + crumbling_quads,
+                        );
+                        quads(
+                            pass,
+                            &f.swirl[s],
+                            swirl_quads,
+                            entity_quads
+                                + text_quads
+                                + crumbling_quads
+                                + translucent_crumbling_quads
+                                + water_mask_quads,
+                        );
+                        quads(
+                            pass,
+                            &f.shadow[s],
+                            shadow_quads,
+                            base_quads
+                                - translucent_item_quads
+                                - translucent_particle_quads
+                                - shadow_quads,
+                        );
+                        quads(
+                            pass,
+                            &f.entity[s],
+                            translucent_particle_quads,
+                            base_quads - translucent_item_quads - translucent_particle_quads,
+                        );
+                        quads(
+                            pass,
+                            &f.entity[s],
+                            translucent_item_quads,
+                            base_quads - translucent_item_quads,
+                        );
+                        // Translucent, emissive, eyes and breeze wind models:
+                        // the same fragment, their light and shading are in
+                        // the vertices.
+                        quads(pass, &f.entity[s], oit_entity_quads, base_quads);
+                        if !frame.lightning.bolts.is_empty() {
+                            pass.set_pipeline(&f.lightning[s]);
+                            self.lightning.draw(pass, &frame.lightning);
+                            pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
+                        }
+                        quads(pass, &f.additive[s], additive_quads, world_quads);
+                        self.weather
+                            .draw_with(pass, &f.weather[s], &self.entity_group);
+                        if let Some(b) = frame.border.as_ref().filter(|_| !frame.title) {
+                            pass.set_pipeline(&f.border[s]);
+                            pass.set_bind_group(0, &self.border_group, &[]);
+                            pass.set_vertex_buffer(0, self.border_vertices.slice(..));
+                            for &side in &b.sides {
+                                let first = side as u32 * 6;
+                                pass.draw_indexed(first..first + 6, 0, 0..1);
+                            }
+                        }
+                    };
+                    let extras = oit::Extras {
+                        water_mask: (water_mask_quads > 0).then_some(&mask as _),
+                        clouds: (cloud_quads > 0).then_some(&clouds as _),
+                        features: Some(&features),
+                    };
+                    oit.run(
+                        &mut encoder,
+                        world_view,
+                        world_depth,
+                        &|pass, stage| {
+                            pass.set_bind_group(0, &self.group, &[]);
+                            // Flat section draws take the flat pipelines.
+                            if let Some((flat, pipeline)) = flat.zip(oit.flat(stage)) {
+                                pass.set_pipeline(pipeline);
+                                flat.draw(pass, flat.translucent_calls(), |p| self.arena.buffer(p));
+                                return;
+                            }
+                            pass.set_pipeline(oit.terrain(stage));
+                            pass.set_index_buffer(
+                                self.indices.slice(..),
+                                wgpu::IndexFormat::Uint32,
+                            );
+                            pass.set_vertex_buffer(1, self.instances.slice(..));
+                            self.draw_sections(
+                                pass,
+                                &self.indirect,
+                                0,
+                                solid_draws,
+                                translucent_draws,
+                            );
+                        },
+                        &extras,
+                    );
+                    pass = world_pass_after_culling(&mut encoder, world_view, world_depth, true);
+                    pass.set_bind_group(0, &self.group, &[]);
+                    pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
+                    // HDR output's mark on the eyes drawn in the stages, as the
+                    // classic pass marks them after the entities.
+                    if oit_entity_quads > 0 && self.hdr.is_some() {
+                        pass.set_pipeline(&self.hdr_mark_pipeline);
+                        pass.set_bind_group(0, &self.entity_group, &[]);
+                        pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
+                        pass.draw_indexed(0..oit_entity_quads * 6, (base_quads * 4) as i32, 0..1);
+                        pass.set_bind_group(0, &self.group, &[]);
+                    }
+                }
                 Some(flat) => {
                     pass.set_pipeline(pack_flat.map_or(&flat.translucent, |p| &p.1));
                     flat.draw(&mut pass, flat.translucent_calls(), |p| {
@@ -5394,15 +5681,14 @@ impl Renderer {
             // translucent particle layer draws after translucent terrain —
             // the quads write depth, so before it they would hide the glass
             // or water behind them.
-            if translucent_particle_quads > 0 {
+            if translucent_particle_quads > 0 && !oit_on {
                 pass.set_pipeline(&self.entity_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                 pass.draw_indexed(
                     0..translucent_particle_quads * 6,
-                    ((world_quads - translucent_item_quads - translucent_particle_quads) * 4)
-                        as i32,
+                    ((base_quads - translucent_item_quads - translucent_particle_quads) * 4) as i32,
                     0..1,
                 );
                 pass.set_bind_group(0, &self.group, &[]);
@@ -5414,7 +5700,7 @@ impl Renderer {
             }
             pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
             // LevelRenderer: the world border after translucent terrain and weather.
-            if let Some(b) = frame.border.as_ref().filter(|_| !frame.title) {
+            if let Some(b) = frame.border.as_ref().filter(|_| !frame.title && !oit_on) {
                 pass.set_pipeline(&self.border_pipeline);
                 pass.set_bind_group(0, &self.border_group, &[]);
                 pass.set_index_buffer(self.indices.slice(..), wgpu::IndexFormat::Uint32);
@@ -5425,7 +5711,7 @@ impl Renderer {
                 }
                 pass.set_bind_group(0, &self.group, &[]);
             }
-            if translucent_crumbling_quads > 0 {
+            if translucent_crumbling_quads > 0 && !oit_on {
                 pass.set_pipeline(&self.crumbling_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
@@ -5435,7 +5721,7 @@ impl Renderer {
                     0..1,
                 );
             }
-            if cloud_quads > 0 && !pack_draws_clouds {
+            if cloud_quads > 0 && !pack_draws_clouds && !oit_on {
                 pass.set_pipeline(&self.cloud_pipeline);
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_bind_group(1, &self.cloud_group, &[]);
@@ -5633,6 +5919,8 @@ impl Renderer {
                     &target_texture,
                     &view_target,
                     [self.config.width, self.config.height],
+                    // The scaled world pass drew its own depth buffer.
+                    scaled.is_none().then_some(&self.depth),
                     &frame.post_effects,
                 );
         }
@@ -6153,6 +6441,46 @@ mod tests {
         assert!(!drawable_size(984, 65496, 32768));
         assert!(!drawable_size(984, u32::MAX, 32768));
     }
+
+    #[test]
+    fn os_luminances_become_auto_values() {
+        use super::os_reported;
+        use crate::graphics::Reported;
+        let info = |max, white| wgpu::DisplayHdrInfo {
+            luminance: Some(wgpu::DisplayLuminance {
+                max_nits: max,
+                sdr_white_nits: white,
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        // Windows' SDR content brightness slider runs 80..480 nits.
+        assert_eq!(
+            os_reported(&info(Some(998.4), Some(240.0))),
+            Some(Reported {
+                paper_white: 240,
+                peak: 998
+            })
+        );
+        assert_eq!(
+            os_reported(&info(Some(120.0), Some(1000.0))),
+            Some(Reported {
+                paper_white: 480,
+                peak: 480
+            })
+        );
+        // White above the calibrated peak (a Samsung QD-OLED's 380, the slider at 456).
+        assert_eq!(
+            os_reported(&info(Some(380.0), Some(456.0))),
+            Some(Reported {
+                paper_white: 456,
+                peak: 456
+            })
+        );
+        assert_eq!(os_reported(&info(Some(1000.0), None)), None);
+        assert_eq!(os_reported(&info(Some(f32::NAN), Some(80.0))), None);
+        assert_eq!(os_reported(&wgpu::DisplayHdrInfo::default()), None);
+    }
     #[test]
     fn surface_is_8_bit_and_not_srgb() {
         use super::surface_format;
@@ -6225,9 +6553,9 @@ mod tests {
         .flat_map(|(layer, id)| quad(layer, id))
         .collect();
         let mut batch = super::EntityBatch::default();
-        let counts = batch.update(&entities, &quad(3, 5), &quad(0, 6), &quad(0, 8));
+        let counts = batch.update(&entities, &quad(3, 5), &quad(0, 6), &quad(0, 8), false);
         let vertices = &batch.combined;
-        assert_eq!(counts, [4, 1, 1, 1, 0, 0, 1, 1, 0]);
+        assert_eq!(counts, [4, 1, 1, 1, 0, 0, 1, 1, 0, 0]);
         assert_eq!(
             vertices
                 .as_chunks::<4>()
@@ -6299,8 +6627,31 @@ mod tests {
             &mut files,
         );
         assert!(files.len() >= 10, "{files:?}");
+        // Improved transparency's files are appended to terrain.wgsl and entity.wgsl.
+        let mut sources: Vec<(std::path::PathBuf, String)> = Vec::new();
         for path in files {
             let text = std::fs::read_to_string(&path).unwrap();
+            let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
+            if name == "oit.wgsl" {
+                // The shared maths: it needs the file it is appended to.
+                continue;
+            } else if name == "oit_world.wgsl" {
+                let base = include_str!("terrain.wgsl").to_owned() + include_str!("oit.wgsl");
+                sources.push((path, base + &text));
+            } else if name == "oit_features.wgsl" {
+                let base = super::entity_shader() + include_str!("oit.wgsl");
+                sources.push((path, base + &text));
+            } else if name == "oit_border.wgsl" {
+                let base = include_str!("border.wgsl").to_owned() + include_str!("oit.wgsl");
+                sources.push((path, base + &text));
+            } else if name == "oit_clouds.wgsl" {
+                let base = super::entity_shader() + include_str!("oit.wgsl");
+                sources.push((path, base + &text));
+            } else {
+                sources.push((path, text));
+            }
+        }
+        for (path, text) in sources {
             // entity.wgsl comes after the overlay's constants (entity_shader).
             let module = naga::front::wgsl::parse_str(&text)
                 .or_else(|_| {
@@ -6419,6 +6770,30 @@ mod tests {
         );
     }
     #[test]
+    fn texture_filtering_samplers() {
+        use super::{sampler_anisotropy, sprite_sampler_descriptor};
+        // None is the sampler terrain always used.
+        let none = sprite_sampler_descriptor(0, 1);
+        assert_eq!(none.mag_filter, wgpu::FilterMode::Nearest);
+        assert_eq!(none.min_filter, wgpu::FilterMode::Nearest);
+        assert_eq!(none.address_mode_u, wgpu::AddressMode::Repeat);
+        assert_eq!(none.anisotropy_clamp, 1);
+        // LevelRenderer.chunkLayerSampler: linear both ways, clamped.
+        for (mode, aniso) in [(1, 1), (2, 8)] {
+            let d = sprite_sampler_descriptor(mode, aniso);
+            assert_eq!(d.mag_filter, wgpu::FilterMode::Linear);
+            assert_eq!(d.min_filter, wgpu::FilterMode::Linear);
+            assert_eq!(d.mipmap_filter, wgpu::MipmapFilterMode::Linear);
+            assert_eq!(d.address_mode_v, wgpu::AddressMode::ClampToEdge);
+            assert_eq!(d.anisotropy_clamp, aniso);
+        }
+        assert_eq!(
+            [1, 2, 3].map(sampler_anisotropy),
+            [2, 4, 8],
+            "Options.maxAnisotropyValue is 1 << bit"
+        );
+    }
+    #[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> {
@@ -6635,32 +7010,65 @@ mod sprite_upload_tests {
 }
 
 /// What the system says about the window's display, kept up to date: on Wayland, the
-/// compositor's preferred image description of the surface.
+/// compositor's preferred image description of the surface; elsewhere what wgpu reads
+/// from the OS (on Windows, DXGI's luminances and the SDR white level).
 #[derive(Default)]
 struct DisplayWatch {
     #[cfg(target_os = "linux")]
     wayland: Option<horizon_hdr::wayland::Watch>,
+    /// Without Wayland's event, what wgpu last read and when to read it again: the OS
+    /// sends no event for a moved window or a changed SDR brightness slider.
+    polled: Option<(Option<crate::graphics::Reported>, std::time::Instant)>,
 }
+/// How often [`DisplayWatch`] reads the OS's values again where no event says they changed.
+const DISPLAY_POLL: std::time::Duration = std::time::Duration::from_secs(2);
 impl DisplayWatch {
     /// Starts watching, with what the system reports now.
-    fn new(window: &Window) -> (Self, Option<crate::graphics::Reported>) {
+    fn new(
+        window: &Window,
+        surface: Option<&wgpu::Surface>,
+        adapter: &wgpu::Adapter,
+    ) -> (Self, Option<crate::graphics::Reported>) {
         #[cfg(target_os = "linux")]
         if let Some((wayland, now)) = horizon_hdr::wayland::Watch::new(window) {
             let watch = Self {
                 wayland: Some(wayland),
+                polled: None,
             };
             return (watch, now.map(reported));
         }
         let _ = window;
-        (Self::default(), None)
+        let now = surface.and_then(|surface| os_reported(&surface.display_hdr_info(adapter)));
+        log_os_reported(now);
+        let watch = Self {
+            #[cfg(target_os = "linux")]
+            wayland: None,
+            polled: Some((now, std::time::Instant::now() + DISPLAY_POLL)),
+        };
+        (watch, now)
     }
     /// What the system reports, if that changed since the last call.
-    fn changed(&mut self) -> Option<Option<crate::graphics::Reported>> {
+    fn changed(
+        &mut self,
+        surface: Option<&wgpu::Surface>,
+        adapter: &wgpu::Adapter,
+    ) -> Option<Option<crate::graphics::Reported>> {
         #[cfg(target_os = "linux")]
         if let Some(wayland) = &mut self.wayland {
             return wayland.changed().map(|now| now.map(reported));
         }
-        None
+        let (last, next) = self.polled.as_mut()?;
+        let time = std::time::Instant::now();
+        if time < *next {
+            return None;
+        }
+        *next = time + DISPLAY_POLL;
+        let now = surface.and_then(|surface| os_reported(&surface.display_hdr_info(adapter)));
+        (now != *last).then(|| {
+            log_os_reported(now);
+            *last = now;
+            now
+        })
     }
 }
 
@@ -6680,8 +7088,6 @@ 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
@@ -6711,6 +7117,33 @@ fn flush_display_log() {
         (log.last, log.at) = (line, Some(now));
     }
 }
+fn log_os_reported(reported: Option<crate::graphics::Reported>) {
+    log_display(match reported {
+        Some(r) => format!(
+            "Horizon renderer: the system reports SDR white at {} nits and a peak of {} nits",
+            r.paper_white, r.peak
+        ),
+        None => "Horizon renderer: the system doesn't report the display's luminance".into(),
+    });
+}
+/// What the OS reports in absolute nits (Windows: DXGI's `MaxLuminance` and the SDR
+/// white level the brightness slider sets), which is HDR output's scale there: SDR
+/// white is Paper White, the display's peak is Peak Brightness. Both are kept within
+/// the settings' ranges. The OS's figures often come from the display's EDID and may
+/// run optimistic; the player's own value always wins.
+fn os_reported(info: &wgpu::DisplayHdrInfo) -> Option<crate::graphics::Reported> {
+    let luminance = info.luminance?;
+    let usable = |n: f32| n.is_finite() && n > 0.0;
+    let peak = luminance.max_nits.filter(|&n| usable(n))?;
+    let white = luminance.sdr_white_nits.filter(|&n| usable(n))?;
+    let paper_white = (white.round() as u32).clamp(80, 480);
+    Some(crate::graphics::Reported {
+        paper_white,
+        // Windows' SDR brightness slider can set white above the reported peak (480 against
+        // a calibrated 380): the highlights then stay at white instead of dropping below it.
+        peak: (peak.round() as u32).clamp(200, 10_000).max(paper_white),
+    })
+}
 
 /// What a compositor's luminances mean in HDR output's scale.
 ///

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

@@ -491,10 +491,6 @@ impl Cull {
         }
     }
 
-    pub fn depth_test(&self) -> DepthTest {
-        self.depth_test
-    }
-
     /// In the world pass after phase 1 (`Early`): draw the tested boxes
     /// against its depth. Leaves the pass's pipeline and group 0 changed.
     pub fn test(&self, pass: &mut wgpu::RenderPass<'_>) {

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

@@ -9,7 +9,24 @@ use super::Vertex;
 /// `RenderPipelines.ENTITY_SHADOW`), translucent-layer particles (15, drawn
 /// after translucent terrain: `SubmitNodeCollection.submitQuadParticleGroup`)
 /// and translucent item quads (32, drawn without depth writes).
-const MATERIALS: usize = 9;
+///
+/// With improved transparency on, quads tagged `OIT_ENTITY` are a tenth
+/// material at the end: the render types vanilla gives an `OitPipelineSet`
+/// (translucent, emissive, eyes and breeze wind entity models). Off, the tag is
+/// ignored and they stay in the first one, in their order.
+const MATERIALS: usize = 10;
+/// A bit of `Vertex::layer`, above the overlay (low 16 bits) and the HDR tier
+/// (bits 16 to 23): the quad's render type has an `OitPipelineSet`
+/// (`RenderTypes.entityTranslucent`, `entityTranslucentEmissive`, `eyes`,
+/// `breezeWind`). Only the improved transparency path reads it.
+pub const OIT_ENTITY: u32 = 1 << 24;
+/// Tags quads as drawn by a render type vanilla gives an `OitPipelineSet`
+/// (`OIT_ENTITY`): improved transparency draws them in its stages.
+pub fn mark_oit(quads: &mut [Vertex]) {
+    for vertex in quads {
+        vertex.layer |= OIT_ENTITY;
+    }
+}
 /// The overlay of depth-only quads that hide water (`RenderTypes.waterMask`).
 pub const WATER_MASK_OVERLAY: u32 = 13;
 /// The overlay of energy swirl quads (`RenderTypes.energySwirl`: the charged creeper's and the
@@ -30,7 +47,10 @@ pub const TRANSLUCENT_GLINT_ITEM_OVERLAY: u32 = 33;
 pub const TEXT_POLYGON_OFFSET_OVERLAY: u32 = 35;
 
 /// The material of a quad by its overlay (`MATERIALS` order).
-fn material(layer: u32) -> usize {
+fn material(layer: u32, oit: bool) -> usize {
+    if oit && layer & OIT_ENTITY != 0 {
+        return 9;
+    }
     match layer {
         TEXT_POLYGON_OFFSET_OVERLAY => 1,
         11 => 2,
@@ -51,6 +71,10 @@ pub(super) struct EntityBatch {
     // frame, keeping their storage.
     runs: [Vec<(usize, usize)>; MATERIALS],
     pub(super) combined: Vec<Vertex>,
+    /// Additive quads tagged `OIT_ENTITY` that the last `update` moved into the
+    /// last material (improved transparency on): the dragon's eyes, which share
+    /// the additive buffer with its rays.
+    pub(super) moved_additive: u32,
 }
 
 impl EntityBatch {
@@ -60,6 +84,7 @@ impl EntityBatch {
         additive: &[Vertex],
         hand: &[Vertex],
         see_through: &[Vertex],
+        oit: bool,
     ) -> [u32; MATERIALS] {
         let quads = entities.as_chunks::<4>().0;
         for runs in &mut self.runs {
@@ -68,10 +93,10 @@ impl EntityBatch {
         let mut counts = [0usize; MATERIALS];
         let mut start = 0;
         while start < quads.len() {
-            let kind = material(quads[start][0].layer);
+            let kind = material(quads[start][0].layer, oit);
             let end = quads[start + 1..]
                 .iter()
-                .position(|quad| material(quad[0].layer) != kind)
+                .position(|quad| material(quad[0].layer, oit) != kind)
                 .map_or(quads.len(), |n| start + 1 + n);
             self.runs[kind].push((start, end - start));
             counts[kind] += end - start;
@@ -87,7 +112,32 @@ impl EntityBatch {
                     .extend_from_slice(&entities[first * 4..(first + count) * 4]);
             }
         }
-        self.combined.extend_from_slice(additive);
+        // `RenderTypes.eyes` is blended like the other entities, not added: with
+        // improved transparency on, tagged additive quads join the last
+        // material, drawn without the additive overlay and the baked shading.
+        self.moved_additive = 0;
+        if oit {
+            for quad in additive.as_chunks::<4>().0 {
+                if quad[0].layer & OIT_ENTITY != 0 {
+                    self.combined.extend(quad.iter().map(|v| Vertex {
+                        layer: v.layer & !0xffff,
+                        normal: [0; 4],
+                        ..*v
+                    }));
+                    counts[9] += 1;
+                    self.moved_additive += 1;
+                }
+            }
+        }
+        if self.moved_additive == 0 {
+            self.combined.extend_from_slice(additive);
+        } else {
+            for quad in additive.as_chunks::<4>().0 {
+                if quad[0].layer & OIT_ENTITY == 0 {
+                    self.combined.extend_from_slice(quad);
+                }
+            }
+        }
         self.combined.extend_from_slice(hand);
         self.combined.extend_from_slice(see_through);
         counts.map(|count| count as u32)
@@ -156,13 +206,78 @@ mod tests {
         hand: &[Vertex],
     ) {
         let (expected, counts) = baseline(entities, additive, hand);
-        assert_eq!(batch.update(entities, additive, hand, &[]), counts);
+        assert_eq!(batch.update(entities, additive, hand, &[], false), counts);
         assert_eq!(
             bytemuck::cast_slice::<_, u8>(&batch.combined),
             bytemuck::cast_slice::<_, u8>(&expected)
         );
     }
 
+    #[test]
+    fn oit_entity_quads_are_a_last_material_only_when_on() {
+        let quad = |layer: u32, x: f32| {
+            (0..4).map(move |_| Vertex {
+                pos: [x, 0.0, 0.0],
+                layer,
+                ..geometry(1, false)[0]
+            })
+        };
+        // Plain, tagged, plain, shadow, tagged with a hurt overlay.
+        let entities: Vec<Vertex> = [
+            (0, 0.0),
+            (OIT_ENTITY | 3 << 16, 1.0),
+            (1, 2.0),
+            (SHADOW_OVERLAY, 3.0),
+            (OIT_ENTITY | 1, 4.0),
+        ]
+        .into_iter()
+        .flat_map(|(layer, x)| quad(layer, x))
+        .collect();
+        let mut batch = EntityBatch::default();
+        // Off: the tag changes nothing, the quads keep their place.
+        let counts = batch.update(&entities, &[], &[], &[], false);
+        assert_eq!(counts, [4, 0, 0, 0, 0, 0, 1, 0, 0, 0]);
+        let xs: Vec<f32> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
+        assert_eq!(xs, [0.0, 1.0, 2.0, 4.0, 3.0]);
+        // On: the tagged quads come last, in order.
+        let counts = batch.update(&entities, &[], &[], &[], true);
+        assert_eq!(counts, [2, 0, 0, 0, 0, 0, 1, 0, 0, 2]);
+        let xs: Vec<f32> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
+        assert_eq!(xs, [0.0, 2.0, 3.0, 1.0, 4.0]);
+    }
+
+    #[test]
+    fn tagged_additive_quads_join_the_last_material_only_when_on() {
+        let quad = |layer: u32, x: f32| {
+            (0..4).map(move |_| Vertex {
+                pos: [x, 0.0, 0.0],
+                layer,
+                normal: [1, 2, 3, 4],
+                ..geometry(1, false)[0]
+            })
+        };
+        // The dragon's eyes (tagged, overlay 2) and a ray (plain).
+        let additive: Vec<Vertex> = [(2 | OIT_ENTITY | 3 << 16, 1.0), (2, 2.0)]
+            .into_iter()
+            .flat_map(|(layer, x)| quad(layer, x))
+            .collect();
+        let entities: Vec<Vertex> = quad(0, 0.0).collect();
+        let mut batch = EntityBatch::default();
+        // Off: untouched.
+        let counts = batch.update(&entities, &additive, &[], &[], false);
+        assert_eq!((counts[9], batch.moved_additive), (0, 0));
+        assert_eq!(batch.combined.len(), 12);
+        assert_eq!(batch.combined[4].layer, 2 | OIT_ENTITY | 3 << 16);
+        // On: the eyes are an entity quad without the additive overlay, the ray stays.
+        let counts = batch.update(&entities, &additive, &[], &[], true);
+        assert_eq!((counts[0], counts[9], batch.moved_additive), (1, 1, 1));
+        let xs: Vec<f32> = batch.combined.iter().step_by(4).map(|v| v.pos[0]).collect();
+        assert_eq!(xs, [0.0, 1.0, 2.0]);
+        assert_eq!(batch.combined[4].layer, OIT_ENTITY | 3 << 16);
+        assert_eq!(batch.combined[4].normal, [0; 4]);
+        assert_eq!(batch.combined[8].layer, 2);
+    }
+
     #[test]
     fn stable_material_order_tails_and_reuse() {
         let mut batch = EntityBatch::default();
@@ -227,7 +342,7 @@ mod tests {
             equivalent(&mut batch, &entities, &additive, &hand);
             for _ in 0..50 {
                 black_box(baseline(black_box(&entities), &additive, &hand));
-                black_box(batch.update(black_box(&entities), &additive, &hand, &[]));
+                black_box(batch.update(black_box(&entities), &additive, &hand, &[], false));
                 black_box(&batch.combined);
             }
             let mut before = Vec::new();
@@ -240,7 +355,7 @@ mod tests {
                 before.push(start.elapsed().as_nanos() / 100);
                 let start = Instant::now();
                 for _ in 0..100 {
-                    black_box(batch.update(black_box(&entities), &additive, &hand, &[]));
+                    black_box(batch.update(black_box(&entities), &additive, &hand, &[], false));
                     black_box(&batch.combined);
                 }
                 after.push(start.elapsed().as_nanos() / 100);

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

@@ -0,0 +1,968 @@
+//! Improved transparency: vanilla 26.3's order-independent transparency
+//! (`LevelRenderer.executeOit`). The translucent layer is drawn three times
+//! against the opaque world's depth, without writing it, into targets the
+//! next stage reads (`oit.wgsl` says what each holds), then a full-screen pass
+//! composites the sum. With the option off none of this exists and the world
+//! draws as before.
+
+use super::oit_features::Features;
+use glam::Mat4;
+
+/// The depth bounds' clear: `LevelRenderer.DEPTH_BOUNDS_CLEAR_COLOR`.
+const BOUNDS_CLEAR: wgpu::Color = wgpu::Color {
+    r: -(f32::MAX as f64),
+    g: 0.0,
+    b: 0.0,
+    a: 0.0,
+};
+const BOUNDS_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba32Float;
+const COEFFICIENT_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;
+/// The shader's bind group: `terrain.wgsl` holds groups 0 and 1.
+const GROUP: u32 = 2;
+
+/// `OitStage`.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Stage {
+    DepthBounds,
+    Transmittance,
+    Accumulate,
+}
+
+/// What the device must support: max blending on 32-bit float targets.
+pub fn features(adapter: &wgpu::Adapter) -> wgpu::Features {
+    adapter.features() & wgpu::Features::FLOAT32_BLENDABLE
+}
+
+pub fn supported(device: &wgpu::Device) -> bool {
+    device
+        .features()
+        .contains(wgpu::Features::FLOAT32_BLENDABLE)
+}
+
+/// What a stage's pipelines write: `OIT_*_SNIPPET`'s colour targets.
+pub(super) fn stage_targets(stage: Stage) -> Vec<Option<wgpu::ColorTargetState>> {
+    let blend = |operation| wgpu::BlendComponent {
+        src_factor: wgpu::BlendFactor::One,
+        dst_factor: wgpu::BlendFactor::One,
+        operation,
+    };
+    let target = |format, operation| {
+        Some(wgpu::ColorTargetState {
+            format,
+            blend: Some(wgpu::BlendState {
+                color: blend(operation),
+                alpha: blend(operation),
+            }),
+            write_mask: wgpu::ColorWrites::ALL,
+        })
+    };
+    let add = wgpu::BlendOperation::Add;
+    match stage {
+        Stage::DepthBounds => vec![target(BOUNDS_FORMAT, wgpu::BlendOperation::Max)],
+        Stage::Transmittance => vec![
+            target(COEFFICIENT_FORMAT, add),
+            target(COEFFICIENT_FORMAT, add),
+        ],
+        Stage::Accumulate => vec![target(COEFFICIENT_FORMAT, add)],
+    }
+}
+
+/// `ProjMat[2][2]` and `ProjMat[3][2]`: a device depth `d` is `y / (d + x)`
+/// blocks along the view axis (`oit_linear_depth`).
+fn projection_terms(projection: &Mat4) -> [f32; 2] {
+    [projection.z_axis.z, projection.w_axis.z]
+}
+
+struct Targets {
+    size: [u32; 2],
+    bounds: wgpu::Texture,
+    culled: wgpu::Texture,
+    views: Views,
+    /// The uniform alone, with the culled bounds, with those and the
+    /// coefficients, for the cull with the unculled bounds, and the composite.
+    alone: wgpu::BindGroup,
+    sampled: wgpu::BindGroup,
+    accumulate: wgpu::BindGroup,
+    cull: wgpu::BindGroup,
+    composite: wgpu::BindGroup,
+    /// The depth the terrain's stages test against while a water mask is
+    /// drawn (a copy of the world's, plus the masks), and the clouds' own.
+    terrain_depth: Option<Depth>,
+    cloud_depth: Option<Depth>,
+}
+
+struct Depth {
+    texture: wgpu::Texture,
+    view: wgpu::TextureView,
+}
+
+impl Depth {
+    fn new(device: &wgpu::Device, label: &str, size: [u32; 2]) -> Self {
+        let texture = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some(label),
+            size: extent(size),
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::Depth32Float,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_DST,
+            view_formats: &[],
+        });
+        Self {
+            view: texture.create_view(&Default::default()),
+            texture,
+        }
+    }
+}
+
+fn extent(size: [u32; 2]) -> wgpu::Extent3d {
+    wgpu::Extent3d {
+        width: size[0].max(1),
+        height: size[1].max(1),
+        depth_or_array_layers: 1,
+    }
+}
+
+/// What the translucent layer's other drawers add to a frame: each draws with
+/// a pipeline per stage where it has one.
+#[derive(Default)]
+pub struct Extras<'a> {
+    /// `executeOitWaterMask`: the boats' water patches, depth only.
+    pub water_mask: Option<&'a dyn Fn(&mut wgpu::RenderPass<'_>)>,
+    /// `CloudRenderer.renderOit`: draws the clouds with the pipeline given.
+    pub clouds: Option<&'a dyn Fn(&mut wgpu::RenderPass<'_>, &wgpu::RenderPipeline)>,
+    /// "Features, World Border, Weather": draws what the entity, weather and
+    /// border shaders put after the opaque world, with `Oit::features`'s
+    /// pipelines of the stage.
+    pub features: Option<&'a dyn Fn(&mut wgpu::RenderPass<'_>, Stage)>,
+}
+
+struct Views {
+    bounds: wgpu::TextureView,
+    culled: wgpu::TextureView,
+    coefficients: [wgpu::TextureView; 2],
+    accumulated: wgpu::TextureView,
+}
+
+pub struct Oit {
+    uniform: wgpu::Buffer,
+    /// Layouts of the groups at `GROUP`: the uniform; with the bounds; with the
+    /// coefficients; and with the accumulation too.
+    layouts: [wgpu::BindGroupLayout; 4],
+    /// One per `Stage`.
+    terrain: [wgpu::RenderPipeline; 3],
+    /// The terrain's flat section draws (`Flat`), where the device has them.
+    flat: Option<[wgpu::RenderPipeline; 3]>,
+    features: Features,
+    clouds: [wgpu::RenderPipeline; 3],
+    cull: wgpu::RenderPipeline,
+    composite: wgpu::RenderPipeline,
+    targets: Option<Targets>,
+}
+
+impl Oit {
+    /// `terrain`: the terrain bind group layout that `vs_terrain` reads,
+    /// `flat` the flat draws' second group, `features` the entity, weather
+    /// and world border layouts,
+    /// `clouds` the cloud pipeline's two, `sprites` the terrain's override
+    /// constants, `format` the world target's.
+    pub fn new(
+        device: &wgpu::Device,
+        terrain: &wgpu::BindGroupLayout,
+        flat: Option<&wgpu::BindGroupLayout>,
+        features: [&wgpu::BindGroupLayout; 3],
+        clouds: [&wgpu::BindGroupLayout; 2],
+        sprites: [f64; 2],
+        format: wgpu::TextureFormat,
+    ) -> Self {
+        let instance = wgpu::vertex_attr_array![5=>Float32x4];
+        let buffers = [
+            Some(wgpu::VertexBufferLayout {
+                array_stride: std::mem::size_of::<super::TerrainVertex>() as u64,
+                step_mode: wgpu::VertexStepMode::Vertex,
+                attributes: &super::TERRAIN_ATTRIBUTES,
+            }),
+            Some(wgpu::VertexBufferLayout {
+                array_stride: 16,
+                step_mode: wgpu::VertexStepMode::Instance,
+                attributes: &instance,
+            }),
+        ];
+        let buffers = &buffers[..];
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Horizon improved transparency"),
+            source: wgpu::ShaderSource::Wgsl(
+                (include_str!("../terrain.wgsl").to_owned()
+                    + include_str!("../oit.wgsl")
+                    + include_str!("../oit_world.wgsl"))
+                .into(),
+            ),
+        });
+        let uniform = device.create_buffer(&wgpu::BufferDescriptor {
+            label: Some("Improved transparency"),
+            size: 16,
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+        let entry = |binding: u32, ty| wgpu::BindGroupLayoutEntry {
+            binding,
+            visibility: wgpu::ShaderStages::FRAGMENT,
+            ty,
+            count: None,
+        };
+        let texture = |binding| {
+            entry(
+                binding,
+                wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Float { filterable: false },
+                    view_dimension: wgpu::TextureViewDimension::D2,
+                    multisampled: false,
+                },
+            )
+        };
+        let params = entry(
+            0,
+            wgpu::BindingType::Buffer {
+                ty: wgpu::BufferBindingType::Uniform,
+                has_dynamic_offset: false,
+                min_binding_size: None,
+            },
+        );
+        let layout = |label, entries: &[wgpu::BindGroupLayoutEntry]| {
+            device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+                label: Some(label),
+                entries,
+            })
+        };
+        let layouts = [
+            layout("Improved transparency", &[params]),
+            layout("Improved transparency bounds", &[params, texture(1)]),
+            layout(
+                "Improved transparency coefficients",
+                &[params, texture(1), texture(2), texture(3)],
+            ),
+            layout(
+                "Improved transparency composite",
+                &[params, texture(1), texture(2), texture(3), texture(4)],
+            ),
+        ];
+        let pipeline_layout = |first: Option<&wgpu::BindGroupLayout>, group: usize| {
+            device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                label: Some("Improved transparency"),
+                bind_group_layouts: &[first, None, Some(&layouts[group])],
+                ..Default::default()
+            })
+        };
+        let constants = [("SPRITE_ARRAYS", sprites[0]), ("SPRITE_SPLIT", sprites[1])];
+        let add = wgpu::BlendOperation::Add;
+        let depth = |write| {
+            Some(wgpu::DepthStencilState {
+                format: wgpu::TextureFormat::Depth32Float,
+                depth_write_enabled: Some(write),
+                depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
+                stencil: Default::default(),
+                bias: Default::default(),
+            })
+        };
+        let pipeline = |label,
+                        layout: &wgpu::PipelineLayout,
+                        vertex: &str,
+                        fragment: &str,
+                        buffers: &[Option<wgpu::VertexBufferLayout<'_>>],
+                        targets: &[Option<wgpu::ColorTargetState>],
+                        depth_stencil| {
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some(label),
+                layout: Some(layout),
+                vertex: wgpu::VertexState {
+                    module: &shader,
+                    entry_point: Some(vertex),
+                    compilation_options: wgpu::PipelineCompilationOptions {
+                        constants: &constants,
+                        ..Default::default()
+                    },
+                    buffers,
+                },
+                primitive: wgpu::PrimitiveState {
+                    cull_mode: vertex.starts_with("vs_terrain").then_some(wgpu::Face::Back),
+                    ..Default::default()
+                },
+                depth_stencil,
+                multisample: Default::default(),
+                fragment: Some(wgpu::FragmentState {
+                    module: &shader,
+                    entry_point: Some(fragment),
+                    compilation_options: wgpu::PipelineCompilationOptions {
+                        constants: &constants,
+                        ..Default::default()
+                    },
+                    targets,
+                }),
+                multiview_mask: None,
+                cache: None,
+            })
+        };
+        let terrain_pipeline = |label, fragment, stage| {
+            pipeline(
+                label,
+                &pipeline_layout(Some(terrain), stage as usize),
+                "vs_terrain",
+                fragment,
+                buffers,
+                &stage_targets(stage),
+                depth(false),
+            )
+        };
+        let terrain_pipelines = [
+            terrain_pipeline("OIT depth bounds", "fs_oit_bounds", Stage::DepthBounds),
+            terrain_pipeline(
+                "OIT transmittance",
+                "fs_oit_transmittance",
+                Stage::Transmittance,
+            ),
+            terrain_pipeline("OIT accumulate", "fs_oit_accumulate", Stage::Accumulate),
+        ];
+        // The same fragments over `vs_terrain_flat`: one vertex buffer, and
+        // the draw table at group 1.
+        let flat_pipelines = flat.map(|draw| {
+            let flat_buffers = &buffers[..1];
+            [
+                (
+                    "OIT depth bounds (flat)",
+                    "fs_oit_bounds",
+                    Stage::DepthBounds,
+                ),
+                (
+                    "OIT transmittance (flat)",
+                    "fs_oit_transmittance",
+                    Stage::Transmittance,
+                ),
+                (
+                    "OIT accumulate (flat)",
+                    "fs_oit_accumulate",
+                    Stage::Accumulate,
+                ),
+            ]
+            .map(|(label, fragment, stage)| {
+                let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                    label: Some("Improved transparency flat terrain"),
+                    bind_group_layouts: &[
+                        Some(terrain),
+                        Some(draw),
+                        Some(&layouts[stage as usize]),
+                    ],
+                    ..Default::default()
+                });
+                pipeline(
+                    label,
+                    &layout,
+                    "vs_terrain_flat",
+                    fragment,
+                    flat_buffers,
+                    &stage_targets(stage),
+                    depth(false),
+                )
+            })
+        });
+        let screen = |label, fragment, group, targets: &[_], depth_stencil| {
+            pipeline(
+                label,
+                &pipeline_layout(None, group),
+                "vs_sky",
+                fragment,
+                &[],
+                targets,
+                depth_stencil,
+            )
+        };
+        let replace = |format| {
+            Some(wgpu::ColorTargetState {
+                format,
+                blend: None,
+                write_mask: wgpu::ColorWrites::ALL,
+            })
+        };
+        let cull = screen(
+            "OIT cull depth bounds",
+            "fs_oit_cull",
+            1,
+            &[replace(BOUNDS_FORMAT)],
+            depth(true),
+        );
+        // `RenderPipelines.OIT_COMPOSITE`: premultiplied alpha over the world,
+        // the nearest see-through depth written.
+        let premultiplied = wgpu::BlendComponent {
+            src_factor: wgpu::BlendFactor::One,
+            dst_factor: wgpu::BlendFactor::OneMinusSrcAlpha,
+            operation: add,
+        };
+        let composite = screen(
+            "OIT composite",
+            "fs_oit_composite",
+            3,
+            &[Some(wgpu::ColorTargetState {
+                format,
+                blend: Some(wgpu::BlendState {
+                    color: premultiplied,
+                    alpha: premultiplied,
+                }),
+                write_mask: wgpu::ColorWrites::ALL,
+            })],
+            Some(wgpu::DepthStencilState {
+                format: wgpu::TextureFormat::Depth32Float,
+                depth_write_enabled: Some(true),
+                depth_compare: Some(wgpu::CompareFunction::Always),
+                stencil: Default::default(),
+                bias: Default::default(),
+            }),
+        );
+        // The clouds: entity.wgsl's vertex shader and vertex format, with the
+        // stages' fragments.
+        let cloud_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Horizon improved transparency clouds"),
+            source: wgpu::ShaderSource::Wgsl(
+                (super::entity_shader()
+                    + include_str!("../oit.wgsl")
+                    + include_str!("../oit_clouds.wgsl"))
+                .into(),
+            ),
+        });
+        let cloud_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2];
+        let cloud_buffers = [Some(wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<super::Vertex>() as u64,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &cloud_attributes,
+        })];
+        let cloud_pipeline = |label, fragment, stage: Stage| {
+            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                label: Some(label),
+                layout: Some(
+                    &device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                        label: Some("Improved transparency clouds"),
+                        bind_group_layouts: &[
+                            Some(clouds[0]),
+                            Some(clouds[1]),
+                            Some(&layouts[stage as usize]),
+                        ],
+                        ..Default::default()
+                    }),
+                ),
+                vertex: wgpu::VertexState {
+                    module: &cloud_shader,
+                    entry_point: Some("vs_cloud"),
+                    compilation_options: Default::default(),
+                    buffers: &cloud_buffers,
+                },
+                primitive: wgpu::PrimitiveState {
+                    cull_mode: Some(wgpu::Face::Back),
+                    ..Default::default()
+                },
+                // `OIT_CLOUDS`: only the bounds stage writes the cloud depth,
+                // so the later stages keep the nearest face of each cloud.
+                depth_stencil: depth(stage == Stage::DepthBounds),
+                multisample: Default::default(),
+                fragment: Some(wgpu::FragmentState {
+                    module: &cloud_shader,
+                    entry_point: Some(fragment),
+                    compilation_options: Default::default(),
+                    targets: &stage_targets(stage),
+                }),
+                multiview_mask: None,
+                cache: None,
+            })
+        };
+        let cloud_pipelines = [
+            cloud_pipeline(
+                "OIT cloud depth bounds",
+                "fs_oit_cloud_bounds",
+                Stage::DepthBounds,
+            ),
+            cloud_pipeline(
+                "OIT cloud transmittance",
+                "fs_oit_cloud_transmittance",
+                Stage::Transmittance,
+            ),
+            cloud_pipeline(
+                "OIT cloud accumulate",
+                "fs_oit_cloud_accumulate",
+                Stage::Accumulate,
+            ),
+        ];
+        let features = Features::new(device, &layouts, features[0], features[1], features[2]);
+        Self {
+            uniform,
+            layouts,
+            terrain: terrain_pipelines,
+            flat: flat_pipelines,
+            features,
+            clouds: cloud_pipelines,
+            cull,
+            composite,
+            targets: None,
+        }
+    }
+
+    /// The pipeline the terrain's translucent layer draws with in `stage`.
+    pub fn terrain(&self, stage: Stage) -> &wgpu::RenderPipeline {
+        &self.terrain[stage as usize]
+    }
+
+    /// The pipeline the terrain's translucent layer draws with in `stage`
+    /// as flat section draws, where they run.
+    pub fn flat(&self, stage: Stage) -> Option<&wgpu::RenderPipeline> {
+        self.flat.as_ref().map(|f| &f[stage as usize])
+    }
+
+    pub fn features(&self) -> &Features {
+        &self.features
+    }
+
+    /// Sizes the targets to the world's and writes this frame's projection.
+    pub fn prepare(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        size: [u32; 2],
+        projection: &Mat4,
+        wants: [bool; 2],
+    ) {
+        queue.write_buffer(
+            &self.uniform,
+            0,
+            bytemuck::cast_slice(&[projection_terms(projection), [0.0; 2]].concat()),
+        );
+        let [mask, clouds] = wants;
+        if let Some(t) = self.targets.as_mut().filter(|t| t.size == size) {
+            if mask && t.terrain_depth.is_none() {
+                t.terrain_depth = Some(Depth::new(device, "OIT terrain depth", size));
+            }
+            if clouds && t.cloud_depth.is_none() {
+                t.cloud_depth = Some(Depth::new(device, "OIT cloud depth", size));
+            }
+            return;
+        }
+        let make = |label, format, usage| {
+            device.create_texture(&wgpu::TextureDescriptor {
+                label: Some(label),
+                size: extent(size),
+                mip_level_count: 1,
+                sample_count: 1,
+                dimension: wgpu::TextureDimension::D2,
+                format,
+                usage,
+                view_formats: &[],
+            })
+        };
+        let attachment =
+            wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING;
+        let bounds = make(
+            "OIT depth bounds",
+            BOUNDS_FORMAT,
+            attachment | wgpu::TextureUsages::COPY_SRC,
+        );
+        let culled = make(
+            "OIT culled depth bounds",
+            BOUNDS_FORMAT,
+            attachment | wgpu::TextureUsages::COPY_DST,
+        );
+        let coefficients =
+            [0, 1].map(|_| make("OIT transmittance", COEFFICIENT_FORMAT, attachment));
+        let accumulated = make("OIT accumulate", COEFFICIENT_FORMAT, attachment);
+        let views = Views {
+            bounds: bounds.create_view(&Default::default()),
+            culled: culled.create_view(&Default::default()),
+            coefficients: coefficients.map(|t| t.create_view(&Default::default())),
+            accumulated: accumulated.create_view(&Default::default()),
+        };
+        let group = |layout: &wgpu::BindGroupLayout, views: &[&wgpu::TextureView]| {
+            let mut entries = vec![wgpu::BindGroupEntry {
+                binding: 0,
+                resource: self.uniform.as_entire_binding(),
+            }];
+            entries.extend(views.iter().enumerate().map(|(i, v)| wgpu::BindGroupEntry {
+                binding: i as u32 + 1,
+                resource: wgpu::BindingResource::TextureView(v),
+            }));
+            device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: Some("Improved transparency"),
+                layout,
+                entries: &entries,
+            })
+        };
+        let [c0, c1] = &views.coefficients;
+        self.targets = Some(Targets {
+            size,
+            alone: group(&self.layouts[0], &[]),
+            sampled: group(&self.layouts[1], &[&views.culled]),
+            accumulate: group(&self.layouts[2], &[&views.culled, c0, c1]),
+            cull: group(&self.layouts[1], &[&views.bounds]),
+            composite: group(
+                &self.layouts[3],
+                &[&views.bounds, c0, c1, &views.accumulated],
+            ),
+            terrain_depth: mask.then(|| Depth::new(device, "OIT terrain depth", size)),
+            cloud_depth: clouds.then(|| Depth::new(device, "OIT cloud depth", size)),
+            bounds,
+            culled,
+            views,
+        });
+    }
+
+    /// `LevelRenderer.executeOit`: `draw` records the terrain's translucent
+    /// layer into each stage's pass with that stage's pipeline, `extras` the
+    /// water masks and clouds, then the composite goes over `color`. `depth`
+    /// is the opaque world's: the stages only read it; the cull and the
+    /// composite write it.
+    pub fn run(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        color: &wgpu::TextureView,
+        depth: &wgpu::TextureView,
+        draw: &dyn Fn(&mut wgpu::RenderPass<'_>, Stage),
+        extras: &Extras<'_>,
+    ) {
+        let Some(t) = &self.targets else { return };
+        let attachment = |view, load| {
+            Some(wgpu::RenderPassColorAttachment {
+                view,
+                resolve_target: None,
+                depth_slice: None,
+                ops: wgpu::Operations {
+                    load,
+                    store: wgpu::StoreOp::Store,
+                },
+            })
+        };
+        let clear = wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT);
+        let load = wgpu::LoadOp::Load;
+        let read_only = |view| {
+            Some(wgpu::RenderPassDepthStencilAttachment {
+                view,
+                depth_ops: None,
+                stencil_ops: None,
+            })
+        };
+        let water_mask = extras.water_mask.zip(t.terrain_depth.as_ref());
+        let cloud_depth = extras.clouds.zip(t.cloud_depth.as_ref());
+        if let Some((mask, _)) = water_mask {
+            self.execute_water_mask(encoder, t, color, depth, mask);
+        }
+        let terrain_depth = water_mask.map_or(depth, |(_, d)| &d.view);
+        let [c0, c1] = &t.views.coefficients;
+        let culled = &t.views.culled;
+        for (stage, label, group, first, then) in [
+            (
+                Stage::DepthBounds,
+                "OIT depth bounds",
+                &t.alone,
+                vec![attachment(
+                    &t.views.bounds,
+                    wgpu::LoadOp::Clear(BOUNDS_CLEAR),
+                )],
+                // The clouds' bounds join the culled ones.
+                vec![attachment(culled, load)],
+            ),
+            (
+                Stage::Transmittance,
+                "OIT transmittance",
+                &t.sampled,
+                vec![attachment(c0, clear), attachment(c1, clear)],
+                vec![attachment(c0, load), attachment(c1, load)],
+            ),
+            (
+                Stage::Accumulate,
+                "OIT accumulate",
+                &t.accumulate,
+                vec![attachment(&t.views.accumulated, clear)],
+                vec![attachment(&t.views.accumulated, load)],
+            ),
+        ] {
+            {
+                let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                    label: Some(label),
+                    color_attachments: &first,
+                    depth_stencil_attachment: read_only(terrain_depth),
+                    ..Default::default()
+                });
+                pass.set_bind_group(GROUP, group, &[]);
+                draw(&mut pass, stage);
+            }
+            if let Some(features) = extras.features {
+                // Over the world's own depth, even where a water mask patched
+                // the terrain's: the masks only hide water.
+                let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                    label: Some(label),
+                    color_attachments: &[attachment(
+                        match stage {
+                            Stage::DepthBounds => &t.views.bounds,
+                            Stage::Transmittance => c0,
+                            Stage::Accumulate => &t.views.accumulated,
+                        },
+                        load,
+                    )]
+                    .into_iter()
+                    .chain((stage == Stage::Transmittance).then(|| attachment(c1, load)))
+                    .collect::<Vec<_>>(),
+                    depth_stencil_attachment: read_only(depth),
+                    ..Default::default()
+                });
+                pass.set_bind_group(GROUP, group, &[]);
+                features(&mut pass, stage);
+            }
+            if stage == Stage::DepthBounds {
+                self.execute_depth_bounds_cull(encoder, t, depth);
+            }
+            if let Some((clouds, cloud_depth)) = cloud_depth {
+                self.render_clouds(
+                    encoder,
+                    t,
+                    stage,
+                    depth,
+                    (label, group, &then),
+                    (clouds, cloud_depth),
+                );
+            }
+            if stage == Stage::DepthBounds
+                && let Some((mask, _)) = water_mask
+            {
+                self.execute_water_mask(encoder, t, color, depth, mask);
+            }
+        }
+        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some("OIT composite"),
+            color_attachments: &[attachment(color, wgpu::LoadOp::Load)],
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: depth,
+                depth_ops: Some(wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: wgpu::StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            ..Default::default()
+        });
+        pass.set_pipeline(&self.composite);
+        pass.set_bind_group(GROUP, &t.composite, &[]);
+        pass.draw(0..3, 0..1);
+    }
+
+    /// `CloudRenderer.renderOit` for one stage. The bounds stage first copies
+    /// the world's depth (after the cull) and draws into it, so the later
+    /// stages, which only read it, keep each pixel's nearest cloud face.
+    fn render_clouds(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        t: &Targets,
+        stage: Stage,
+        depth: &wgpu::TextureView,
+        (label, group, targets): (
+            &str,
+            &wgpu::BindGroup,
+            &[Option<wgpu::RenderPassColorAttachment<'_>>],
+        ),
+        (draw, cloud_depth): (
+            &dyn Fn(&mut wgpu::RenderPass<'_>, &wgpu::RenderPipeline),
+            &Depth,
+        ),
+    ) {
+        if stage == Stage::DepthBounds {
+            encoder.copy_texture_to_texture(
+                depth.texture().as_image_copy(),
+                cloud_depth.texture.as_image_copy(),
+                extent(t.size),
+            );
+        }
+        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some(label),
+            color_attachments: targets,
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: &cloud_depth.view,
+                depth_ops: (stage == Stage::DepthBounds).then_some(wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: wgpu::StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            ..Default::default()
+        });
+        pass.set_bind_group(GROUP, group, &[]);
+        draw(&mut pass, &self.clouds[stage as usize]);
+    }
+
+    /// `LevelRenderer.executeOitWaterMask`: the terrain's depth is the world's
+    /// again, with the boats' water patches on top.
+    fn execute_water_mask(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        t: &Targets,
+        color: &wgpu::TextureView,
+        depth: &wgpu::TextureView,
+        mask: &dyn Fn(&mut wgpu::RenderPass<'_>),
+    ) {
+        let Some(terrain) = &t.terrain_depth else {
+            return;
+        };
+        encoder.copy_texture_to_texture(
+            depth.texture().as_image_copy(),
+            terrain.texture.as_image_copy(),
+            extent(t.size),
+        );
+        // The mask pipeline writes depth only but has a colour target.
+        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some("OIT water mask"),
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                view: color,
+                resolve_target: None,
+                depth_slice: None,
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: wgpu::StoreOp::Store,
+                },
+            })],
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: &terrain.view,
+                depth_ops: Some(wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: wgpu::StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            ..Default::default()
+        });
+        mask(&mut pass);
+    }
+
+    /// `LevelRenderer.executeDepthBoundsCull`: the bounds are copied, then where
+    /// the nearest fully opaque see-through fragment is in front of the world,
+    /// the far bound stops there and its depth replaces the world's.
+    fn execute_depth_bounds_cull(
+        &self,
+        encoder: &mut wgpu::CommandEncoder,
+        t: &Targets,
+        depth: &wgpu::TextureView,
+    ) {
+        encoder.copy_texture_to_texture(
+            t.bounds.as_image_copy(),
+            t.culled.as_image_copy(),
+            wgpu::Extent3d {
+                width: t.size[0].max(1),
+                height: t.size[1].max(1),
+                depth_or_array_layers: 1,
+            },
+        );
+        let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: Some("OIT cull depth bounds"),
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                view: &t.views.culled,
+                resolve_target: None,
+                depth_slice: None,
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: wgpu::StoreOp::Store,
+                },
+            })],
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: depth,
+                depth_ops: Some(wgpu::Operations {
+                    load: wgpu::LoadOp::Load,
+                    store: wgpu::StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            ..Default::default()
+        });
+        pass.set_pipeline(&self.cull);
+        pass.set_bind_group(GROUP, &t.cull, &[]);
+        pass.draw(0..3, 0..1);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn validate(source: &str, entries: &[&str]) {
+        let module = naga::front::wgsl::parse_str(source).unwrap();
+        naga::valid::Validator::new(
+            naga::valid::ValidationFlags::all(),
+            naga::valid::Capabilities::all(),
+        )
+        .validate(&module)
+        .unwrap();
+        for entry in entries {
+            assert!(
+                module.entry_points.iter().any(|e| e.name == *entry),
+                "{entry}"
+            );
+        }
+    }
+
+    #[test]
+    fn the_terrain_shader_validates() {
+        validate(
+            &(include_str!("../terrain.wgsl").to_owned()
+                + include_str!("../oit.wgsl")
+                + include_str!("../oit_world.wgsl")),
+            &[
+                "fs_oit_bounds",
+                "fs_oit_transmittance",
+                "fs_oit_accumulate",
+                "fs_oit_cull",
+                "fs_oit_composite",
+            ],
+        );
+    }
+
+    #[test]
+    fn the_cloud_shader_validates() {
+        validate(
+            &(super::super::entity_shader()
+                + include_str!("../oit.wgsl")
+                + include_str!("../oit_clouds.wgsl")),
+            &[
+                "fs_oit_cloud_bounds",
+                "fs_oit_cloud_transmittance",
+                "fs_oit_cloud_accumulate",
+            ],
+        );
+    }
+
+    #[test]
+    fn the_feature_shaders_validate() {
+        let stages = |name: &str| {
+            ["bounds", "transmittance", "accumulate"].map(|s| format!("fs_oit_{name}_{s}"))
+        };
+        let entity = ["entity", "shadow", "weather", "swirl"]
+            .map(stages)
+            .concat();
+        validate(
+            &(super::super::entity_shader()
+                + include_str!("../oit.wgsl")
+                + include_str!("../oit_features.wgsl")),
+            &entity.iter().map(String::as_str).collect::<Vec<_>>(),
+        );
+        let border = stages("border");
+        validate(
+            &(include_str!("../border.wgsl").to_owned()
+                + include_str!("../oit.wgsl")
+                + include_str!("../oit_border.wgsl")),
+            &border.iter().map(String::as_str).collect::<Vec<_>>(),
+        );
+    }
+
+    #[test]
+    fn a_device_depth_gives_the_distance_along_the_view_axis() {
+        // The world's reversed-Z projection: near plane at depth 1.
+        let projection = super::super::world_projection(70.0, 16.0 / 9.0, 512.0);
+        let [x, y] = projection_terms(&projection);
+        for distance in [0.1_f32, 1.0, 7.5, 64.0, 500.0] {
+            let clip = projection * glam::Vec4::new(0.0, 0.0, -distance, 1.0);
+            let device = clip.z / clip.w;
+            let linear = y / (device + x);
+            assert!(
+                (linear - distance).abs() < distance * 2e-3,
+                "{distance}: {linear}"
+            );
+        }
+    }
+}

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

@@ -0,0 +1,248 @@
+//! Improved transparency for what is drawn after the opaque world besides the
+//! terrain and the clouds: `LevelRenderer.executeOit`'s "Features, World
+//! Border, Weather" pass. Each kind keeps its classic vertex shader, vertex
+//! format and depth state (minus the depth writes, as every `OIT_*` pipeline),
+//! with the three stages' fragments (`oit_features.wgsl`, `oit_border.wgsl`).
+
+use super::oit::{Stage, stage_targets};
+
+/// One pipeline per stage.
+type Set = [wgpu::RenderPipeline; 3];
+
+pub struct Features {
+    /// `OIT_ENTITY`/`OIT_ITEM`: translucent items and particles.
+    pub entity: Set,
+    /// `OIT_TEXT_POLYGON_OFFSET`.
+    pub text: Set,
+    /// `OIT_CRUMBLING`.
+    pub crumbling: Set,
+    /// `OIT_ENTITY_SHADOW`.
+    pub shadow: Set,
+    /// `OIT_ENERGY_SWIRL`.
+    pub swirl: Set,
+    /// `OIT_LIGHTNING`: the retained bolts.
+    pub lightning: Set,
+    /// `OIT_DRAGON_RAYS`: the additive geometry after the bolts.
+    pub additive: Set,
+    /// `OIT_WEATHER`.
+    pub weather: Set,
+    /// `OIT_WORLD_BORDER`.
+    pub border: Set,
+}
+
+/// What a kind differs in.
+struct Kind<'a> {
+    label: &'a str,
+    /// The entry points' common prefix: `fs_oit_<name>_<stage>`.
+    name: &'a str,
+    vertex: &'a str,
+    cull: Option<wgpu::Face>,
+    bias: wgpu::DepthBiasState,
+}
+
+const PLAIN: wgpu::DepthBiasState = wgpu::DepthBiasState {
+    constant: 0,
+    slope_scale: 0.0,
+    clamp: 0.0,
+};
+
+impl Features {
+    /// `layouts`: `Oit`'s stage groups (at group 2); `entity`, `weather` and
+    /// `border` the bind group layouts of the classic pipelines.
+    pub fn new(
+        device: &wgpu::Device,
+        layouts: &[wgpu::BindGroupLayout; 4],
+        entity: &wgpu::BindGroupLayout,
+        weather: &wgpu::BindGroupLayout,
+        border: &wgpu::BindGroupLayout,
+    ) -> Self {
+        let entity_module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Horizon improved transparency features"),
+            source: wgpu::ShaderSource::Wgsl(
+                (super::entity_shader()
+                    + include_str!("../oit.wgsl")
+                    + include_str!("../oit_features.wgsl"))
+                .into(),
+            ),
+        });
+        let border_module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Horizon improved transparency world border"),
+            source: wgpu::ShaderSource::Wgsl(
+                (include_str!("../border.wgsl").to_owned()
+                    + include_str!("../oit.wgsl")
+                    + include_str!("../oit_border.wgsl"))
+                .into(),
+            ),
+        });
+        let entity_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Uint32,3=>Unorm8x4,4=>Uint8x4,5=>Snorm8x4,6=>Float32x2];
+        let weather_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2,2=>Float32x4,
+            3=>Float32x4,4=>Uint32x4,5=>Unorm8x4,6=>Uint8x4,7=>Uint32];
+        let border_attributes = wgpu::vertex_attr_array![0=>Float32x3,1=>Float32x2];
+        let entity_buffers = [Some(wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<super::Vertex>() as u64,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &entity_attributes,
+        })];
+        let weather_buffers = [Some(wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<crate::weather::Vertex>() as u64,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &weather_attributes,
+        })];
+        let border_buffers = [Some(wgpu::VertexBufferLayout {
+            array_stride: std::mem::size_of::<crate::border_render::BorderVertex>() as u64,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &border_attributes,
+        })];
+        let lightning_attributes = wgpu::vertex_attr_array![7=>Float32x3];
+        let lightning_buffers = [
+            entity_buffers[0].clone(),
+            Some(wgpu::VertexBufferLayout {
+                array_stride: std::mem::size_of::<[f32; 3]>() as u64,
+                step_mode: wgpu::VertexStepMode::Instance,
+                attributes: &lightning_attributes,
+            }),
+        ];
+        let set = |module: &wgpu::ShaderModule,
+                   groups: [Option<&wgpu::BindGroupLayout>; 2],
+                   buffers: &[Option<wgpu::VertexBufferLayout<'_>>],
+                   kind: Kind<'_>| {
+            [Stage::DepthBounds, Stage::Transmittance, Stage::Accumulate].map(|stage| {
+                let suffix = ["bounds", "transmittance", "accumulate"][stage as usize];
+                let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+                    label: Some("Improved transparency features"),
+                    bind_group_layouts: &[groups[0], groups[1], Some(&layouts[stage as usize])],
+                    ..Default::default()
+                });
+                device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+                    label: Some(&format!("OIT {} {suffix}", kind.label)),
+                    layout: Some(&layout),
+                    vertex: wgpu::VertexState {
+                        module,
+                        entry_point: Some(kind.vertex),
+                        compilation_options: Default::default(),
+                        buffers,
+                    },
+                    primitive: wgpu::PrimitiveState {
+                        cull_mode: kind.cull,
+                        ..Default::default()
+                    },
+                    depth_stencil: Some(wgpu::DepthStencilState {
+                        format: wgpu::TextureFormat::Depth32Float,
+                        depth_write_enabled: Some(false),
+                        depth_compare: Some(wgpu::CompareFunction::GreaterEqual),
+                        stencil: Default::default(),
+                        bias: kind.bias,
+                    }),
+                    multisample: Default::default(),
+                    fragment: Some(wgpu::FragmentState {
+                        module,
+                        entry_point: Some(&format!("fs_oit_{}_{suffix}", kind.name)),
+                        compilation_options: Default::default(),
+                        targets: &stage_targets(stage),
+                    }),
+                    multiview_mask: None,
+                    cache: None,
+                })
+            })
+        };
+        let entities = [Some(entity), None];
+        let kind = |label, name, cull, bias| Kind {
+            label,
+            name,
+            vertex: "vs_entity",
+            cull,
+            bias,
+        };
+        // The classic pipelines' biases: text and cracks (10, 1), shadows
+        // (128 ulps and a slope, over the block tops they lie on).
+        let offset = wgpu::DepthBiasState {
+            constant: 10,
+            slope_scale: 1.0,
+            clamp: 0.0,
+        };
+        let shadow_bias = wgpu::DepthBiasState {
+            constant: 128,
+            slope_scale: 0.015,
+            clamp: 0.0,
+        };
+        Self {
+            entity: set(
+                &entity_module,
+                entities,
+                &entity_buffers,
+                kind("entities", "entity", None, PLAIN),
+            ),
+            text: set(
+                &entity_module,
+                entities,
+                &entity_buffers,
+                kind("text", "entity", None, offset),
+            ),
+            crumbling: set(
+                &entity_module,
+                entities,
+                &entity_buffers,
+                kind("breaking cracks", "entity", Some(wgpu::Face::Back), offset),
+            ),
+            shadow: set(
+                &entity_module,
+                entities,
+                &entity_buffers,
+                kind("entity shadows", "shadow", None, shadow_bias),
+            ),
+            swirl: set(
+                &entity_module,
+                entities,
+                &entity_buffers,
+                kind("energy swirls", "swirl", None, PLAIN),
+            ),
+            lightning: set(
+                &entity_module,
+                entities,
+                &lightning_buffers,
+                Kind {
+                    label: "lightning",
+                    name: "lightning",
+                    vertex: "vs_lightning",
+                    cull: None,
+                    bias: PLAIN,
+                },
+            ),
+            additive: set(
+                &entity_module,
+                entities,
+                &entity_buffers,
+                kind("additive entities", "lightning", None, PLAIN),
+            ),
+            weather: set(
+                &entity_module,
+                [Some(entity), Some(weather)],
+                &weather_buffers,
+                Kind {
+                    label: "weather",
+                    name: "weather",
+                    vertex: "vs_weather",
+                    cull: None,
+                    bias: PLAIN,
+                },
+            ),
+            // `OIT_WORLD_BORDER`: a polygon offset of 3 towards the camera.
+            border: set(
+                &border_module,
+                [Some(border), None],
+                &border_buffers,
+                Kind {
+                    label: "world border",
+                    name: "border",
+                    vertex: "vs_border",
+                    cull: None,
+                    bias: wgpu::DepthBiasState {
+                        constant: 3,
+                        slope_scale: 3.0,
+                        clamp: 0.0,
+                    },
+                },
+            ),
+        }
+    }
+}

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

@@ -349,7 +349,10 @@ impl PackEntities {
             bytes[0..4].copy_from_slice(&(span.stage as i32).to_le_bytes());
             bytes[4..8].copy_from_slice(&entity_id.to_le_bytes());
             bytes[8..12].copy_from_slice(&block_id.to_le_bytes());
-            for (i, c) in entity_color(run[0].layer).iter().enumerate() {
+            for (i, c) in entity_color(run[0].layer & !super::entity_batch::OIT_ENTITY)
+                .iter()
+                .enumerate()
+            {
                 bytes[16 + 4 * i..20 + 4 * i].copy_from_slice(&c.to_le_bytes());
             }
             self.uniforms.extend_from_slice(&bytes);
@@ -408,9 +411,12 @@ pub(super) fn quad_indices(device: &wgpu::Device, quads: u32) -> wgpu::Buffer {
 /// celestial body, cloud, beam, End portal, crack or energy swirl (overlay codes Horizon's entity
 /// shader draws in its own way; entity.wgsl).
 fn plain(run: &[Vertex]) -> bool {
-    run.iter()
-        .step_by(4)
-        .all(|v| !matches!(v.layer, 2 | 4 | 6 | 9 | 10 | 11 | 12 | 34))
+    run.iter().step_by(4).all(|v| {
+        !matches!(
+            v.layer & !super::entity_batch::OIT_ENTITY,
+            2 | 4 | 6 | 9 | 10 | 11 | 12 | 34
+        )
+    })
 }
 
 /// The programs of entity runs, in the order they draw.

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

@@ -203,9 +203,9 @@ fn body(angle: f32, tilt: f32) -> Vec3 {
 }
 
 /// `sunPathRotation`'s turn of the sky's bodies: `tilt` degrees about the world's X axis, so a
-/// positive angle moves the noon sun toward +Z (south).
+/// positive angle moves the noon sun toward -Z (north), as Iris does.
 pub fn tilt_matrix(tilt: f32) -> Mat4 {
-    Mat4::from_rotation_x(tilt.to_radians())
+    Mat4::from_rotation_x(-tilt.to_radians())
 }
 
 /// The world direction of the shadow light (7.1): the sun by day, the moon by night.
@@ -232,38 +232,39 @@ pub fn shadow_culling(frame: &Frame, shadow: &Shadow) -> Mat4 {
     depth * gl * view
 }
 
-/// Distance from the snapped point to the shadow camera, toward the light: the middle of the
-/// default near and far planes (OQ-6).
-const SHADOW_EYE: f64 = 128.0;
+/// How far toward the light the shadow projection starts, in blocks: part of the projection,
+/// not of `shadowModelView` (Iris's matrices, measured).
+const SHADOW_EYE: f32 = 100.0;
 
-/// The shadow camera (7.1; OQ-6, impl-plan.md): its view (player space to shadow view space)
-/// and GL projection. The camera looks from the light, world +Z up (+Y when the light is near
-/// Z); the point it centres moves in steps of `shadowIntervalSize` along the shadow view's
-/// own axes, and it sits `SHADOW_EYE` blocks toward the light from it. Orthographic over
-/// `shadowDistance` each side, or perspective with `shadowMapFov`.
+/// The shadow camera as Iris places it (7.1; measured from the outside): its view (player
+/// space to shadow view space) and GL projection. The view undoes `sunPathRotation`, turns the
+/// light's path about Z by the light's angle from the zenith, then X by 90 degrees, so the
+/// light lies on the view's +Z. Its origin is `shadowIntervalSize / 2 - camera % interval`
+/// (the remainder takes the camera's sign) from the player on each world axis, so the map moves
+/// in whole steps. The orthographic projection covers `shadowDistance` each side and depths
+/// from `-near` to `far`, counted from `SHADOW_EYE` blocks toward the light; or perspective
+/// with `shadowMapFov`.
 pub fn shadow_camera(light: Vec3, camera: DVec3, shadow: &Shadow) -> (Mat4, Mat4) {
-    let light = light.as_dvec3();
-    let up = if light.z.abs() > 0.99 {
-        DVec3::Y
-    } else {
-        DVec3::Z
-    };
-    let rotation = DMat4::look_to_rh(DVec3::ZERO, -light, up);
-    let at = rotation.transform_vector3(camera);
+    let tilt = f64::from(shadow.sun_path_rotation).to_radians();
+    let untilted = DMat4::from_rotation_x(tilt).transform_vector3(light.as_dvec3());
+    let zenith = untilted.x.atan2(untilted.y);
+    let rotation = DMat4::from_rotation_x(std::f64::consts::FRAC_PI_2)
+        * DMat4::from_rotation_z(zenith)
+        * DMat4::from_rotation_x(tilt);
     let step = f64::from(shadow.interval);
-    let snapped = if step > 0.0 {
-        (at / step).floor() * step
+    let origin = if step > 0.0 {
+        DVec3::splat(step / 2.0) - camera % step
     } else {
-        at
+        DVec3::ZERO
     };
-    let offset = at - snapped - DVec3::new(0.0, 0.0, SHADOW_EYE);
-    let view = (DMat4::from_translation(offset) * rotation).as_mat4();
+    let view = (rotation * DMat4::from_translation(-origin)).as_mat4();
     let (near, far) = (shadow.near, shadow.far);
+    let eye = Mat4::from_translation(Vec3::new(0.0, 0.0, -SHADOW_EYE));
     let projection = match shadow.fov {
-        Some(fov) => Mat4::perspective_rh_gl(fov.to_radians(), 1.0, near, far),
+        Some(fov) => Mat4::perspective_rh_gl(fov.to_radians(), 1.0, near, far) * eye,
         None => {
             let d = shadow.distance;
-            Mat4::orthographic_rh_gl(-d, d, -d, d, near, far)
+            Mat4::orthographic_rh_gl(-d, d, -d, d, -near, far) * eye
         }
     };
     (view, projection)
@@ -360,7 +361,8 @@ impl FrameUniforms {
                 "viewHeight" => Value::f(&[size[1] as f32]),
                 "aspectRatio" => Value::f(&[aspect]),
                 "near" => Value::f(&[0.05]),
-                "far" => Value::f(&[frame.distance]),
+                // The chunk render distance, not the distant terrain's reach.
+                "far" => Value::f(&[frame.detail_distance]),
                 "rainStrength" => Value::f(&[inputs.rain]),
                 "wetness" => Value::f(&[self.wetness]),
                 "thunderStrength" => Value::f(&[inputs.thunder]),
@@ -486,8 +488,8 @@ mod tests {
     fn noon_is_straight_up_and_the_sun_sets_in_the_west() {
         assert!(body(0.0, 0.0).abs_diff_eq(Vec3::new(0.0, 100.0, 0.0), 1e-3));
         assert!(body(90.0, 0.0).abs_diff_eq(Vec3::new(-100.0, 0.0, 0.0), 1e-3));
-        // sunPathRotation tilts noon toward +Z and leaves sunset on the horizon.
-        assert!(body(0.0, 30.0).abs_diff_eq(Vec3::new(0.0, 86.60254, 50.0), 1e-3));
+        // sunPathRotation tilts noon toward -Z and leaves sunset on the horizon.
+        assert!(body(0.0, 30.0).abs_diff_eq(Vec3::new(0.0, 86.60254, -50.0), 1e-3));
         assert!(body(90.0, 30.0).abs_diff_eq(Vec3::new(-100.0, 0.0, 0.0), 1e-3));
     }
 
@@ -500,10 +502,13 @@ mod tests {
         let at = |p: Vec3| view.transform_point3(p);
         // Straight down: a block below the player is farther from the light.
         assert!(at(Vec3::new(0.0, -1.0, 0.0)).z < at(Vec3::ZERO).z);
-        // The player is less than a step from the centre, 128 blocks from the light.
-        let centre = at(Vec3::ZERO);
-        assert!(centre.x.abs() <= 2.0 && centre.y.abs() <= 2.0, "{centre}");
-        assert!((centre.z + 128.0).abs() < 1e-3, "{centre}");
+        // The view's origin is interval / 2 - camera % interval from the player on each axis,
+        // the remainder with the camera's sign: up to a step and a half on negative axes.
+        let origin = view.inverse().w_axis.truncate();
+        assert!(
+            origin.abs_diff_eq(Vec3::new(0.7, 1.0, 1.7), 1e-3),
+            "{origin}"
+        );
         // Moving within a step keeps the world where it was in the map.
         camera.x = 1000.6;
         let (moved, _) = shadow_camera(Vec3::Y, camera, &shadow);
@@ -515,7 +520,38 @@ mod tests {
                 .abs_diff_eq(at(world), 1e-3)
         );
         // shadowDistance blocks reach the map's edge.
-        let edge = projection.project_point3(Vec3::new(160.0, 0.0, -128.0));
+        let edge = projection.project_point3(Vec3::new(160.0, 0.0, 0.0));
         assert!((edge.x.abs() - 1.0).abs() < 1e-4, "{edge}");
     }
+
+    /// Iris's matrices at 3000 ticks with `sunPathRotation = 30` and the camera at
+    /// (0.5, -58.38, 0.5), read from its uniforms by a probe pack.
+    #[test]
+    fn the_shadow_camera_matches_iris() {
+        let shadow = Shadow {
+            sun_path_rotation: 30.0,
+            ..Shadow::default()
+        };
+        let light = Vec3::new(0.56782, 0.71287, -0.41158).normalize();
+        let (view, projection) = shadow_camera(light, DVec3::new(0.5, -58.38, 0.5), &shadow);
+        let iris_view = Mat4::from_cols_array_2d(&[
+            [0.82315, 0.0, 0.56782, 0.0],
+            [-0.49175, -0.5, 0.71287, 0.0],
+            [0.28391, -0.86603, -0.41158, 0.0],
+            [0.12508, 1.12301, -1.06188, 1.0],
+        ]);
+        assert!(view.abs_diff_eq(iris_view, 2e-4), "{view}");
+        assert!(
+            (projection.z_axis.z + 0.0078110).abs() < 1e-6,
+            "{projection}"
+        );
+        assert!((projection.w_axis.z + 0.21851).abs() < 1e-4, "{projection}");
+        // Elsewhere the origin keeps to the steps: Iris put it at (-0.5, 1.38, 2.5) here.
+        let (view, _) = shadow_camera(light, DVec3::new(3.5, -58.38, -1.5), &shadow);
+        let origin = view.inverse().w_axis.truncate();
+        assert!(
+            origin.abs_diff_eq(Vec3::new(-0.5, 1.38, 2.5), 1e-3),
+            "{origin}"
+        );
+    }
 }

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

@@ -30,6 +30,7 @@ pub struct Resident<T> {
     /// The minimum Y of section index 0 (the level's column).
     min_y: i32,
     items: Vec<(SectionKey, T)>,
+    bounds: Vec<Option<[Vec3; 2]>>,
     slots: FxHashMap<SectionKey, u32>,
     columns: Vec<Column>,
     column_index: FxHashMap<(i32, i32), u32>,
@@ -40,6 +41,7 @@ impl<T> Default for Resident<T> {
         Self {
             min_y: crate::chunk::MIN_Y,
             items: Vec::new(),
+            bounds: Vec::new(),
             slots: FxHashMap::default(),
             columns: Vec::new(),
             column_index: FxHashMap::default(),
@@ -78,18 +80,26 @@ impl<T> Resident<T> {
     }
     pub fn clear(&mut self) {
         self.items.clear();
+        self.bounds.clear();
         self.slots.clear();
         self.columns.clear();
         self.column_index.clear();
     }
-    /// Adds or replaces `key`'s value.
+    /// Adds or replaces `key`'s value with default 16x16x16 bounds.
+    #[cfg(test)]
     pub fn insert(&mut self, key: SectionKey, value: T) {
+        self.insert_with_bounds(key, value, None);
+    }
+    /// Adds or replaces `key`'s value with optional tight geometry bounds.
+    pub fn insert_with_bounds(&mut self, key: SectionKey, value: T, bounds: Option<[Vec3; 2]>) {
         if let Some(&slot) = self.slots.get(&key) {
             self.items[slot as usize].1 = value;
+            self.bounds[slot as usize] = bounds;
             return;
         }
         let slot = self.items.len() as u32;
         self.items.push((key, value));
+        self.bounds.push(bounds);
         self.slots.insert(key, slot);
         let column = match self.column_index.get(&(key.0, key.2)) {
             Some(&c) => &mut self.columns[c as usize],
@@ -129,6 +139,7 @@ impl<T> Resident<T> {
         } else {
             column.bounds();
         }
+        let _ = self.bounds.swap_remove(slot as usize);
         let (_, value) = self.items.swap_remove(slot as usize);
         // The last item now sits in `slot`: point its key and column at it.
         if let Some(&(moved, _)) = self.items.get(slot as usize) {
@@ -175,31 +186,57 @@ fn camera_column(camera: DVec3) -> (i32, i32) {
     )
 }
 
+/// The world AABB (min, max) of a section from its origin and optional tight bounds.
+#[inline]
+fn section_box(min: Vec3, bounds: Option<[Vec3; 2]>) -> (Vec3, Vec3) {
+    match bounds {
+        Some([bmin, bmax]) => (min + bmin, min + bmax),
+        None => (min, min + Vec3::splat(16.0)),
+    }
+}
+
 /// Whether the section at `key` is drawn: its column within the render
 /// distance of the camera's (`SectionOcclusionGraph.isInViewDistance`), and
 /// partly inside the frustum. `None` when it is not, else its squared centre
 /// distance and origin. `Resident::visible` walks columns instead.
 #[cfg(test)]
 fn in_view(key: SectionKey, camera: DVec3, radius: i32, frustum: &Frustum) -> Option<(f64, Vec3)> {
+    in_view_with_bounds(key, camera, radius, frustum, None)
+}
+
+/// `in_view` with optional tight bounds.
+#[cfg(test)]
+fn in_view_with_bounds(
+    key: SectionKey,
+    camera: DVec3,
+    radius: i32,
+    frustum: &Frustum,
+    bounds: Option<[Vec3; 2]>,
+) -> Option<(f64, Vec3)> {
     if !in_view_distance(camera_column(camera), radius, key.0, key.2) {
         return None;
     }
-    in_frustum(key, crate::chunk::MIN_Y, camera, frustum, false)
+    in_frustum(key, crate::chunk::MIN_Y, camera, frustum, false, bounds)
 }
 
 /// `in_view` without the distance test; `inside`: the section's column is
 /// entirely inside the frustum, so the section is too.
+#[cfg(test)]
 fn in_frustum(
     key: SectionKey,
     min_y: i32,
     camera: DVec3,
     frustum: &Frustum,
     inside: bool,
+    bounds: Option<[Vec3; 2]>,
 ) -> Option<(f64, Vec3)> {
     let origin = origin(key, min_y, camera);
     let min = origin.as_vec3();
-    if !inside && !frustum.intersects(min, min + Vec3::splat(16.0)) {
-        return None;
+    if !inside {
+        let (bmin, bmax) = section_box(min, bounds);
+        if !frustum.intersects(bmin, bmax) {
+            return None;
+        }
     }
     Some(((origin + DVec3::splat(8.0)).length_squared(), min))
 }
@@ -239,17 +276,50 @@ impl<T> Resident<T> {
             if !inside && !frustum.intersects(min, max) {
                 continue;
             }
-            for &(y, slot) in &column.sections {
-                let key = (column.x, y, column.z);
-                if near && !reachable(key) {
-                    continue;
-                }
-                if let Some((d, o)) = in_frustum(key, self.min_y, camera, frustum, inside) {
+            let ox = f64::from(column.x * 16) - camera.x;
+            let oz = f64::from(column.z * 16) - camera.z;
+            let min_x = ox as f32;
+            let min_z = oz as f32;
+            let dx8 = ox + 8.0;
+            let dz8 = oz + 8.0;
+            let xz_sq = dx8 * dx8 + dz8 * dz8;
+
+            if inside {
+                for &(y, slot) in &column.sections {
+                    let key = (column.x, y, column.z);
+                    if near && !reachable(key) {
+                        continue;
+                    }
+                    let oy = f64::from(self.min_y + y * 16) - camera.y;
+                    let min = Vec3::new(min_x, oy as f32, min_z);
+                    let dy8 = oy + 8.0;
+                    let distance = xz_sq + dy8 * dy8;
                     out.push(Visible {
-                        distance: d.to_bits(),
+                        distance: distance.to_bits(),
                         key,
                         slot,
-                        origin: o.to_array(),
+                        origin: min.to_array(),
+                    });
+                }
+            } else {
+                for &(y, slot) in &column.sections {
+                    let key = (column.x, y, column.z);
+                    if near && !reachable(key) {
+                        continue;
+                    }
+                    let oy = f64::from(self.min_y + y * 16) - camera.y;
+                    let min = Vec3::new(min_x, oy as f32, min_z);
+                    let (bmin, bmax) = section_box(min, self.bounds[slot as usize]);
+                    if !frustum.intersects(bmin, bmax) {
+                        continue;
+                    }
+                    let dy8 = oy + 8.0;
+                    let distance = xz_sq + dy8 * dy8;
+                    out.push(Visible {
+                        distance: distance.to_bits(),
+                        key,
+                        slot,
+                        origin: min.to_array(),
                     });
                 }
             }
@@ -271,7 +341,15 @@ mod tests {
                 for y in 0..24 {
                     // Leave holes so columns have uneven bounds.
                     if (x * 7 + y * 3 + z * 5).rem_euclid(4) != 0 {
-                        r.insert((x, y, z), ());
+                        // Mix of sections with fallback None and randomized tight bounds.
+                        let bounds = if (x + y + z).rem_euclid(2) == 0 {
+                            let y_min = ((x + z).rem_euclid(4)) as f32;
+                            let y_max = y_min + 2.0 + ((y.rem_euclid(5)) as f32);
+                            Some([Vec3::new(0.0, y_min, 0.0), Vec3::new(16.0, y_max, 16.0)])
+                        } else {
+                            None
+                        };
+                        r.insert_with_bounds((x, y, z), (), bounds);
                     }
                 }
             }
@@ -297,12 +375,21 @@ mod tests {
                 let mut slow: Vec<(SectionKey, f64, [f32; 3])> = r
                     .items
                     .iter()
-                    .filter_map(|&(k, _)| {
+                    .enumerate()
+                    .filter_map(|(slot, &(k, _))| {
                         let near = in_view_distance(camera_column(camera), radius, k.0, k.2);
                         if near {
-                            in_view(k, camera, radius, &frustum).filter(|_| reachable(k))
+                            in_view_with_bounds(k, camera, radius, &frustum, r.bounds[slot])
+                                .filter(|_| reachable(k))
                         } else if beyond(k.0, k.2) {
-                            in_frustum(k, crate::chunk::MIN_Y, camera, &frustum, false)
+                            in_frustum(
+                                k,
+                                crate::chunk::MIN_Y,
+                                camera,
+                                &frustum,
+                                false,
+                                r.bounds[slot],
+                            )
                         } else {
                             None
                         }
@@ -471,4 +558,152 @@ mod tests {
             list.len()
         );
     }
+
+    #[test]
+    fn tight_mesh_bounds_culls_section_outside_frustum() {
+        let mut r = Resident::default();
+        let key = (0, 0, 0);
+        // Section geometry only occupies local Y in [0.0, 2.0]
+        let tight = Some([Vec3::new(0.0, 0.0, 0.0), Vec3::new(16.0, 2.0, 16.0)]);
+        r.insert_with_bounds(key, (), tight);
+
+        let camera = DVec3::new(8.0, f64::from(crate::chunk::MIN_Y + 15), -2.0);
+        let projection = super::super::world_projection(70.0, 16.0 / 9.0, 512.0);
+        let view = crate::camera::view_matrix(0.0, -60.0);
+        let frustum = Frustum {
+            planes: super::super::frustum(projection * view),
+        };
+
+        // Tight bounds culls the section whose geometry is entirely outside the frustum
+        let mut out = Vec::new();
+        r.visible(camera, 4, &frustum, |_| true, |_, _| false, &mut out);
+        assert!(
+            out.is_empty(),
+            "tight bounds should cull section whose geometry is below frustum"
+        );
+
+        // With fallback 16x16x16 bounds, the section intersects the frustum and is visible
+        r.insert_with_bounds(key, (), None);
+        out.clear();
+        r.visible(camera, 4, &frustum, |_| true, |_, _| false, &mut out);
+        assert_eq!(
+            out.len(),
+            1,
+            "full 16x16x16 bounds intersect frustum and are accepted"
+        );
+    }
+
+    #[test]
+    #[ignore = "benchmark"]
+    fn tight_bounds_benchmark() {
+        use std::time::Instant;
+
+        let mut r_fallback = Resident::default();
+        let mut r_tight = Resident::default();
+
+        let radius = 16;
+        for x in -radius..=radius {
+            for z in -radius..=radius {
+                // Section 0..4: underground rock
+                for y in 0..4 {
+                    r_fallback.insert((x, y, z), ());
+                    r_tight.insert_with_bounds((x, y, z), (), None);
+                }
+                // Section 4: surface terrain with grass / hills (e.g. Y in [0, 4] or [0, 6])
+                let height = 2.0 + (((x * 3 + z * 5).rem_euclid(5)) as f32) * 1.5;
+                let surface_bounds =
+                    Some([Vec3::new(0.0, 0.0, 0.0), Vec3::new(16.0, height, 16.0)]);
+                r_fallback.insert((x, 4, z), ());
+                r_tight.insert_with_bounds((x, 4, z), (), surface_bounds);
+            }
+        }
+
+        println!("\n=== Tight Bounds Culling Benchmark ===");
+        println!("Total Resident Sections: {}", r_tight.len());
+
+        let test_views = [
+            ("Looking level across terrain (pitch 0°)", 0.0, 0.0),
+            ("Looking slightly up (pitch -15°)", 45.0, -15.0),
+            ("Looking up towards sky (pitch -35°)", 90.0, -35.0),
+            ("Looking down at ground (pitch 25°)", 180.0, 25.0),
+            ("Diagonal view (yaw 135°, pitch -10°)", 135.0, -10.0),
+        ];
+
+        let camera = DVec3::new(8.0, f64::from(crate::chunk::MIN_Y + 4 * 16 + 10), 8.0);
+        let projection = super::super::world_projection(70.0, 16.0 / 9.0, 512.0);
+
+        for (desc, yaw, pitch) in test_views {
+            let view = crate::camera::view_matrix(yaw, pitch);
+            let frustum = Frustum {
+                planes: super::super::frustum(projection * view),
+            };
+
+            let mut out_fallback = Vec::new();
+            let mut out_tight = Vec::new();
+
+            r_fallback.visible(
+                camera,
+                radius,
+                &frustum,
+                |_| true,
+                |_, _| false,
+                &mut out_fallback,
+            );
+            r_tight.visible(
+                camera,
+                radius,
+                &frustum,
+                |_| true,
+                |_, _| false,
+                &mut out_tight,
+            );
+
+            let culled_extra = out_fallback.len().saturating_sub(out_tight.len());
+            let pct_saved = if !out_fallback.is_empty() {
+                (culled_extra as f64 / out_fallback.len() as f64) * 100.0
+            } else {
+                0.0
+            };
+
+            // Timing over 1,000 passes
+            let iters = 1_000;
+            let t0 = Instant::now();
+            for _ in 0..iters {
+                out_fallback.clear();
+                r_fallback.visible(
+                    camera,
+                    radius,
+                    &frustum,
+                    |_| true,
+                    |_, _| false,
+                    &mut out_fallback,
+                );
+            }
+            let dur_fallback = t0.elapsed();
+
+            let t1 = Instant::now();
+            for _ in 0..iters {
+                out_tight.clear();
+                r_tight.visible(
+                    camera,
+                    radius,
+                    &frustum,
+                    |_| true,
+                    |_, _| false,
+                    &mut out_tight,
+                );
+            }
+            let dur_tight = t1.elapsed();
+
+            println!(
+                "{desc}\n  Fallback 16x16: {} sections | {:?}\n  Tight Bounds:   {} sections | {:?}\n  Reduction:      -{} sections ({:.1}% culled)\n",
+                out_fallback.len(),
+                dur_fallback / iters,
+                out_tight.len(),
+                dur_tight / iters,
+                culled_extra,
+                pct_saved
+            );
+        }
+    }
 }

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

@@ -55,9 +55,9 @@ mod tests {
         let n = |i: usize| Vec3::from_slice(&normals[i][..3]);
         let mut best = 0.0f32;
         let mut k0 = d.dot(n(TRIANGLES));
-        for i in 0..TRIANGLES {
+        for (i, triangle) in normals.iter().take(TRIANGLES).enumerate() {
             let k1 = d.dot(n(TRIANGLES + (i + 1) % TRIANGLES));
-            let w = normals[i][3];
+            let w = triangle[3];
             if k0 * w <= 0.0 && k1 * w >= 0.0 {
                 let apex = d.dot(n(i));
                 let s = apex + k1 - k0;
@@ -75,6 +75,115 @@ mod tests {
         best
     }
 
+    // Projecting the fan onto the YZ plane leaves uniformly spaced rim
+    // angles after undoing its Y squash. Test both ray directions because
+    // the projection plane goes through the camera.
+    fn sector_weight(alpha: f32, sun: Vec3, d: Vec3) -> f32 {
+        let normals = normals(alpha, sun);
+        if d.y * d.y + d.z * d.z < 1e-10 {
+            return weight(&normals, d);
+        }
+        let n = |i: usize| Vec3::from_slice(&normals[i][..3]);
+        let apex = d.dot(n(0));
+        if apex * normals[0][3] < -1e-4 {
+            return 0.0;
+        }
+        let y = d.dot(n(16));
+        let x = -d.dot(n(20));
+        let ax = x.abs();
+        let ay = y.abs();
+        let t = std::f32::consts::SQRT_2 - 1.0;
+        let q = if ay > ax {
+            if ax < ay * t { 3 } else { 2 }
+        } else if ay > ax * t {
+            1
+        } else {
+            0
+        };
+        let sector = if x >= 0.0 {
+            if y >= 0.0 { q } else { 15 - q }
+        } else if y >= 0.0 {
+            7 - q
+        } else {
+            8 + q
+        };
+        let mut best = 0.0f32;
+        let k0 = d.dot(n(16 + sector as usize));
+        let k1 = d.dot(n(16 + ((sector + 1) % 16) as usize));
+        let offsets: &[i32] = if k0.abs().min(k1.abs()) < ax.max(ay) * 0.001 {
+            &[0, 8, -1, 1, 7, 9]
+        } else {
+            &[0, 8]
+        };
+        for &offset in offsets {
+            let i = (sector + offset).rem_euclid(16) as usize;
+            let k0 = d.dot(n(16 + i));
+            let k1 = d.dot(n(16 + (i + 1) % 16));
+            let w = normals[i][3];
+            let apex = d.dot(n(i));
+            let sum = apex + k1 - k0;
+            if sum.abs() >= 1e-6
+                && sum * w > 0.0
+                && apex * sum >= 0.0
+                && k1 * sum >= 0.0
+                && k0 * sum <= 0.0
+            {
+                best = best.max(apex / sum);
+            }
+        }
+        best
+    }
+    #[test]
+    fn angular_sector_matches_random_and_exact_rim_directions() {
+        let mut state = 19u32;
+        let mut random = || {
+            state = state.wrapping_mul(1664525).wrapping_add(1013904223);
+            (state >> 8) as f32 / 16777216.0
+        };
+        for _ in 0..1000 {
+            let alpha = 0.0011 + random() * 0.9989;
+            let z = if random() > 0.5 { 0.3 } else { -0.2 };
+            let sun = Vec3::new(0.0, (1.0f32 - z * z).sqrt(), z);
+            let normals = normals(alpha, sun);
+            let (_, rim) = vertices(alpha, sun);
+            let random_ray = Vec3::new(
+                random() * 2.0 - 1.0,
+                random() * 2.0 - 1.0,
+                random() * 2.0 - 1.0,
+            )
+            .normalize();
+            for ray in rim.into_iter().chain([random_ray]) {
+                let d = ray.normalize();
+                let (got, want) = (sector_weight(alpha, sun, d), weight(&normals, d));
+                assert!(
+                    (got - want).abs() < 1e-4,
+                    "{alpha} {sun} {d}: {got} != {want}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn angular_sector_matches_all_triangle_search() {
+        for alpha in [0.0011f32, 0.05, 0.6, 1.0] {
+            for z in [-0.2f32, 0.3] {
+                let sun = Vec3::new(0.0, (1.0 - z * z).sqrt(), z);
+                let normals = normals(alpha, sun);
+                for yaw in 0..360 {
+                    for pitch in -89..90 {
+                        let (y, p) = ((yaw as f32).to_radians(), (pitch as f32).to_radians());
+                        let d = Vec3::new(y.cos() * p.cos(), p.sin(), y.sin() * p.cos());
+                        let (got, want) = (sector_weight(alpha, sun, d), weight(&normals, d));
+                        assert!(
+                            (got - want).abs() < 1e-4,
+                            "alpha={alpha} z={z} d={d} {got} != {want}"
+                        );
+                    }
+                }
+            }
+        }
+    }
+
     /// The shader's former per-pixel Möller-Trumbore over the same vertices.
     fn reference(alpha: f32, sun: Vec3, d: Vec3) -> f32 {
         let (apex, rim) = vertices(alpha, sun);

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

@@ -124,6 +124,26 @@ impl Weather {
         uploads.buffer(encoder, &self.vertices, 0, bytemuck::cast_slice(vertices));
         uploads.buffer(encoder, &self.uniform, 0, bytemuck::bytes_of(&time));
     }
+    /// The classic pipeline, for its layouts.
+    pub fn pipeline(&self) -> &wgpu::RenderPipeline {
+        &self.pipeline
+    }
+    /// `draw` with another pipeline of the same layouts and vertex format.
+    pub fn draw_with(
+        &self,
+        pass: &mut wgpu::RenderPass<'_>,
+        pipeline: &wgpu::RenderPipeline,
+        entities: &wgpu::BindGroup,
+    ) {
+        if self.count == 0 {
+            return;
+        }
+        pass.set_pipeline(pipeline);
+        pass.set_bind_group(0, entities, &[]);
+        pass.set_bind_group(1, &self.group, &[]);
+        pass.set_vertex_buffer(0, self.vertices.slice(..));
+        pass.draw_indexed(0..self.count / 4 * 6, 0, 0..1);
+    }
     pub fn draw(&self, pass: &mut wgpu::RenderPass<'_>, entities: &wgpu::BindGroup) {
         if self.count == 0 {
             return;

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

@@ -344,7 +344,7 @@ impl Post {
                 "Scaled world depth",
                 size,
                 wgpu::TextureFormat::Depth32Float,
-                sampled,
+                sampled | wgpu::TextureUsages::COPY_SRC,
             )
             .create_view(&Default::default());
             let group = self.bind(device, &color);

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

@@ -311,6 +311,8 @@ pub fn reduced_far_detail_suggested() -> bool {
     REDUCED_SUGGESTED.load(std::sync::atomic::Ordering::Relaxed)
 }
 
+/// The name the options screen waits on to bind `Graphics::hdr_key`.
+pub const HDR_KEY: &str = "horizon.hdrSettings";
 static HDR_OFFERED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
 /// Whether the display path offers HDR output (HDR10 or scRGB): set when the renderer
 /// opens its surface; the settings open HDR's screen only then.
@@ -391,6 +393,8 @@ pub struct Graphics {
     /// HDR brightness of the HUD and menus, in percent of paper white (25..=100); the
     /// first-person hand stays at the world's.
     pub hdr_ui_brightness: u32,
+    /// A vanilla key name (`HDR_KEY`): opens HDR's settings from the game. Unbound by default.
+    pub hdr_key: String,
     /// Battery mode: at most 60 frames per second in a world and 30 in menus
     /// or behind other windows, and half the worker threads. Off by default;
     /// it changes when frames are drawn, never what they show or the ticks.
@@ -429,6 +433,7 @@ impl Default for Graphics {
             hdr_peak: 0,
             hdr_black_level: 0,
             hdr_ui_brightness: 100,
+            hdr_key: "key.keyboard.unknown".into(),
             battery: false,
             api: GraphicsApi::Auto,
             shader_pack: String::new(),
@@ -507,6 +512,7 @@ impl Graphics {
                 "hdrUiBrightness" => {
                     g.hdr_ui_brightness = number(g.hdr_ui_brightness).clamp(25, 100)
                 }
+                "hdrKey" if value.starts_with("key.") => g.hdr_key = value.to_owned(),
                 "batteryMode" => g.battery = flag(g.battery),
                 "graphicsApi" => g.api = GraphicsApi::from_name(value).unwrap_or_default(),
                 "pickedShaderPack" => g.shader_pack = value.to_owned(),
@@ -524,7 +530,7 @@ impl Graphics {
     }
     pub fn serialize(&self) -> String {
         format!(
-            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nbatteryMode:{}\ngraphicsApi:{}\npickedShaderPack:{}\n",
+            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\ngraphicsApi:{}\npickedShaderPack:{}\n",
             self.preset.name(),
             self.lod_distance,
             self.far_detail.name(),
@@ -556,11 +562,20 @@ impl Graphics {
             self.hdr_peak,
             self.hdr_black_level,
             self.hdr_ui_brightness,
+            self.hdr_key,
             bool_text(self.battery),
             self.api.name(),
             self.shader_pack,
         )
     }
+    /// Binds Horizon's graphics key `name` (`HDR_KEY`); false for another name.
+    pub fn set_key(&mut self, name: &str, value: String) -> bool {
+        match name {
+            HDR_KEY => self.hdr_key = value,
+            _ => return false,
+        }
+        true
+    }
     pub fn save(&self, dir: &Path) {
         let _ = fs::write(dir.join(FILE), self.serialize());
     }
@@ -691,6 +706,7 @@ mod tests {
             hdr_peak: 1400,
             hdr_black_level: 12,
             hdr_ui_brightness: 60,
+            hdr_key: "key.keyboard.h".into(),
             battery: true,
             api: GraphicsApi::Dx12,
             shader_pack: "Golden Hour".into(),

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

@@ -3,6 +3,7 @@
 //! lay out rows and handle input; a menu theme replaces this module.
 use crate::{
     hud::{HudAtlas, HudBatch},
+    lang,
     text::Text,
     ui,
 };
@@ -156,10 +157,11 @@ impl Style {
         cost: Cost,
         text: &str,
     ) {
-        let tag = Text::literal(cost.label());
+        let tag = Text::literal(lang::get(cost.label()));
         batch.text_styled(atlas, &tag, x, y, self.cost_colors[cost as usize], true);
         let indent = atlas.font.width_text(&tag) + 4.0;
-        let lines = wrap(atlas, text, self.text_width(batch.width), indent);
+        let text = lang::get(text);
+        let lines = wrap(atlas, &text, self.text_width(batch.width), indent);
         for (i, line) in lines.iter().take(2).enumerate() {
             let lx = if i == 0 { x + indent } else { x };
             batch.text_styled(

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

@@ -5,6 +5,7 @@ use crate::{
     graphics::{FarDetail, GraphicsApi, Overlay, Pacing, PresentMode, Preset, Upscaling},
     graphics_style::{Cost, STYLE},
     hud::{HudAtlas, HudBatch},
+    lang,
     settings::{Opt, Settings},
     text::Text,
     ui,
@@ -43,6 +44,8 @@ pub enum H {
     /// Opens `Level::Hdr`.
     HdrSettings,
     HdrBlackLevel,
+    /// Binds `Graphics::hdr_key`.
+    HdrKey,
     HdrPeak,
     HdrPaperWhite,
     HdrUiBrightness,
@@ -153,6 +156,11 @@ pub fn rows(level: Level) -> Vec<Row> {
                 None,
                 "How bright the HUD and menus are, against paper white.",
             ),
+            h(
+                H::HdrKey,
+                None,
+                "A key that opens this screen from the game. Not bound at first.",
+            ),
         ],
         Level::Advanced => vec![
             Row::Header("Rendering"),
@@ -354,11 +362,14 @@ fn extra_rows(level: Level, settings: &Settings) -> Vec<Row> {
     rows
 }
 
-fn on_off(on: bool) -> &'static str {
-    if on { "On" } else { "Off" }
+fn on_off(on: bool) -> String {
+    lang::get(if on { "On" } else { "Off" })
 }
+/// A control's caption and its value, both through the language table: Horizon's captions are
+/// English sentences, and some of the values ("Off", "12 chunks") are words too.
 fn labelled(caption: &str, value: impl std::fmt::Display) -> Text {
-    Text::literal(format!("{caption}: {value}"))
+    let value = value.to_string();
+    Text::literal(format!("{}: {}", lang::get(caption), lang::get(&value)))
 }
 
 impl H {
@@ -396,19 +407,21 @@ impl H {
             H::Preset => labelled("Preset", g.preset.label()),
             H::LodDistance => match g.lod_distance {
                 0 => labelled("LOD Distance", "Off"),
-                n => labelled("LOD Distance", format!("{n} chunks")),
+                n => labelled("LOD Distance", lang::tr("%s chunks", &[&n])),
             },
             H::FarDetail => labelled("Far Detail", g.far_detail.label()),
             H::CaveCulling => labelled("Cave Culling", on_off(g.cave_culling)),
             H::EntityCulling => labelled("Entity Culling", on_off(g.entity_culling)),
             H::ChunkUpdates => match g.chunk_updates {
                 0 => labelled("Chunk Updates", "Unlimited"),
-                n => labelled("Chunk Updates", format!("{n} per frame")),
+                n => labelled("Chunk Updates", lang::tr("%s per frame", &[&n])),
             },
             H::UploadBudget => match g.upload_budget_kib {
                 0 => labelled("Upload Budget", "Unlimited"),
-                k if k >= 1024 => labelled("Upload Budget", format!("{} MiB/frame", k / 1024)),
-                k => labelled("Upload Budget", format!("{k} KiB/frame")),
+                k if k >= 1024 => {
+                    labelled("Upload Budget", lang::tr("%s MiB/frame", &[&(k / 1024)]))
+                }
+                k => labelled("Upload Budget", lang::tr("%s KiB/frame", &[&k])),
             },
             H::Sky => labelled("Sky", on_off(g.sky)),
             H::Fog => labelled("Fog", on_off(g.fog)),
@@ -423,7 +436,10 @@ impl H {
                 },
             ),
             H::Workers => match g.workers {
-                0 => labelled("Worker Threads", format!("Auto ({})", g.worker_threads())),
+                0 => labelled(
+                    "Worker Threads",
+                    lang::tr("Auto (%s)", &[&g.worker_threads()]),
+                ),
                 n => labelled("Worker Threads", n),
             },
             H::ResolutionScale => labelled("Resolution Scale", format!("{}%", g.resolution_scale)),
@@ -437,23 +453,32 @@ impl H {
             ),
             H::Upscaling => labelled("Upscaling", g.upscaling.label()),
             H::Hdr => labelled("HDR", on_off(g.hdr)),
-            H::HdrSettings => Text::literal("HDR Settings..."),
+            H::HdrSettings => Text::literal(lang::get("HDR Settings...")),
             H::HdrPaperWhite => match g.hdr_paper_white {
                 0 => labelled(
                     "Paper White",
-                    format!("Auto ({} nits)", g.paper_white_nits()),
+                    lang::tr("Auto (%s nits)", &[&g.paper_white_nits()]),
                 ),
-                n => labelled("Paper White", format!("{n} nits")),
+                n => labelled("Paper White", lang::tr("%s nits", &[&n])),
             },
             H::HdrPeak => match g.hdr_peak {
-                0 => labelled("Peak Brightness", format!("Auto ({} nits)", g.peak_nits())),
-                n => labelled("Peak Brightness", format!("{n} nits")),
+                0 => labelled(
+                    "Peak Brightness",
+                    lang::tr("Auto (%s nits)", &[&g.peak_nits()]),
+                ),
+                n => labelled("Peak Brightness", lang::tr("%s nits", &[&n])),
             },
             H::HdrBlackLevel => labelled(
                 "Black Level",
-                format!("{:.2} nits", g.hdr_black_level as f32 / 100.0),
+                lang::tr(
+                    "%s nits",
+                    &[&format!("{:.2}", g.hdr_black_level as f32 / 100.0)],
+                ),
             ),
             H::HdrUiBrightness => labelled("UI Brightness", format!("{}%", g.hdr_ui_brightness)),
+            H::HdrKey => {
+                Text::literal("Shortcut: ").append(crate::keybinds::display_name(&g.hdr_key))
+            }
             H::BatteryMode => labelled("Battery Mode", on_off(g.battery)),
             H::GraphicsApi => labelled("Graphics API", g.api.label()),
             H::Overlay => labelled(
@@ -618,7 +643,7 @@ impl Item {
         match self {
             Item::Vanilla(Opt::RenderDistance) if s.horizon.lod_distance > 0 => labelled(
                 "Full Detail Distance",
-                format!("{} chunks", s.render_distance),
+                lang::tr("%s chunks", &[&s.render_distance]),
             ),
             Item::Vanilla(o) => o.label(s),
             Item::Horizon(h) => h.label(s),
@@ -686,6 +711,8 @@ pub enum Action {
     OpenAdvanced,
     OpenSimple,
     OpenHdr,
+    /// Wait for a key or mouse button to bind to this name.
+    BindKey(&'static str),
     Done,
 }
 
@@ -708,6 +735,8 @@ pub struct GraphicsUi {
     /// The list's scroll amount and its held scrollbar (`AbstractScrollArea`).
     scroll: ui::Scroll,
     dragging: Option<Item>,
+    /// The key binding the options screen is waiting on (`Action::BindKey`).
+    pub binding: Option<&'static str>,
 }
 
 impl GraphicsUi {
@@ -818,7 +847,7 @@ impl GraphicsUi {
         let x = STYLE.row_x(w);
         for (y, name) in headers {
             if shown(y, STYLE.header_height) {
-                STYLE.header(batch, atlas, &Text::literal(name), x, y);
+                STYLE.header(batch, atlas, &Text::literal(lang::get(name)), x, y);
             }
         }
         let descriptions: Vec<(Cost, &'static str)> = extra_rows(level, s)
@@ -840,11 +869,17 @@ impl GraphicsUi {
                     if !shown(wd.y, 20.0) {
                         continue;
                     }
-                    let label = item.label(s);
+                    let mut label = item.label(s);
+                    if item == Item::Horizon(H::HdrKey) && self.binding.is_some() {
+                        // KeyBindsScreen: "> key <" while it waits.
+                        label = Text::literal("Shortcut: > ")
+                            .append(crate::keybinds::display_name(&s.horizon.hdr_key))
+                            .append(" <");
+                    }
                     let blocked = item.blocked(s);
                     let live = blocked.is_none();
                     if hover && let Some(why) = blocked {
-                        tooltip = Some(atlas.font.split(&Text::literal(why), 170.0));
+                        tooltip = Some(atlas.font.split(&Text::literal(lang::get(why)), 170.0));
                     }
                     match item.slider(s) {
                         Some(value) => STYLE.slider(
@@ -885,7 +920,7 @@ impl GraphicsUi {
                         batch,
                         atlas,
                         (wd.x, wd.y, wd.w),
-                        &Text::literal(label),
+                        &Text::literal(lang::get(label)),
                         hover,
                         true,
                     );
@@ -907,7 +942,7 @@ impl GraphicsUi {
             Level::Advanced => "Graphics: Advanced",
             Level::Hdr => "Graphics: HDR",
         };
-        STYLE.title(batch, atlas, &Text::literal(title));
+        STYLE.title(batch, atlas, &Text::literal(lang::get(title)));
         if let Some(lines) = tooltip {
             ui::tooltip(batch, atlas, &lines, cursor);
         }
@@ -965,6 +1000,12 @@ impl GraphicsUi {
                 Target::Item(Item::Horizon(H::HdrSettings)) => {
                     vec![Action::ButtonClick, Action::OpenHdr]
                 }
+                Target::Item(Item::Horizon(H::HdrKey)) => {
+                    vec![
+                        Action::ButtonClick,
+                        Action::BindKey(crate::graphics::HDR_KEY),
+                    ]
+                }
                 Target::Item(item) => {
                     if item.slider(s).is_some() {
                         self.dragging = Some(item);

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

@@ -93,7 +93,7 @@ pub fn java_sort<T>(a: &mut [T], cmp: impl Fn(&T, &T) -> Ordering) {
 /// A `MobEffectInstance` as `extractEffects` sees it.
 #[derive(Clone, Debug, PartialEq)]
 pub struct EffectIcon {
-    /// The effect id without namespace (`speed`): the sprite is `mob_effect/<id>`.
+    /// The effect id: vanilla's without namespace (`speed`), a mod's `<ns>:<path>`.
     pub id: String,
     /// `MobEffect.isBeneficial`.
     pub beneficial: bool,

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

@@ -47,7 +47,7 @@ pub fn panels(
         .into_iter()
         .enumerate()
         .map(|(i, (effect, icon))| {
-            let mut name = translate(&format!("effect.minecraft.{}", effect.id))
+            let mut name = translate(&horizon_client_core::potions::description_id(effect.id))
                 .unwrap_or_else(|| effect.id.to_owned());
             if (1..=9).contains(&effect.amplifier) {
                 let level = effect.amplifier + 1;

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

@@ -321,10 +321,25 @@ pub fn smooth(smoothed: f32, progress: f32) -> f32 {
 }
 
 /// `ARGB.opaque` as the batch's RGBA.
-fn opaque(rgb: u32) -> u32 {
+pub const fn opaque(rgb: u32) -> u32 {
     0xFF00_0000 | (rgb & 0xFF) << 16 | (rgb & 0xFF00) | (rgb >> 16 & 0xFF)
 }
 
+/// `LoadingOverlay.LOGO_BACKGROUND_COLOR` (RGB: 239, 50, 61).
+pub const LOGO_BACKGROUND_COLOR: u32 = opaque(0xEF323D);
+/// `LoadingOverlay.LOGO_BACKGROUND_COLOR_DARK` (black).
+pub const LOGO_BACKGROUND_COLOR_DARK: u32 = opaque(0x000000);
+
+/// `LoadingOverlay.BRAND_BACKGROUND`: black when `darkMojangStudiosBackground` is set,
+/// Mojang red otherwise.
+pub fn brand_background(dark: bool) -> u32 {
+    if dark {
+        LOGO_BACKGROUND_COLOR_DARK
+    } else {
+        LOGO_BACKGROUND_COLOR
+    }
+}
+
 /// `LevelLoadingScreen.extractRenderState` over its background: the text,
 /// the progress bar and the chunk map, `status(x, z)` for x and z in
 /// `0..=2 * STATUS_RADIUS` from the map's north-west corner.
@@ -370,6 +385,27 @@ pub fn draw(
     }
 }
 
+/// `LoadingOverlay.extractRenderState`: fills the frame with `BRAND_BACKGROUND`
+/// (Mojang red, or black when `darkMojangStudiosBackground` is set) and draws the
+/// progress line and bar.
+pub fn draw_loading_overlay(
+    batch: &mut HudBatch,
+    atlas: &HudAtlas,
+    line: &str,
+    progress: f32,
+    dark: bool,
+) {
+    batch.fill(
+        atlas,
+        0.0,
+        0.0,
+        batch.width,
+        batch.height,
+        brand_background(dark),
+    );
+    draw_progress(batch, atlas, line, progress);
+}
+
 /// The startup loading screen: the stage's line and a progress bar, centred
 /// like `LevelLoadingScreen`'s text and bar.
 pub fn draw_progress(batch: &mut HudBatch, atlas: &HudAtlas, line: &str, progress: f32) {
@@ -546,6 +582,14 @@ mod tests {
         assert!((smooth(eased, 1.0) - 0.36).abs() < 1e-6);
     }
 
+    #[test]
+    fn brand_background_matches_dark_mojang_studios_setting() {
+        assert_eq!(brand_background(true), LOGO_BACKGROUND_COLOR_DARK);
+        assert_eq!(brand_background(false), LOGO_BACKGROUND_COLOR);
+        assert_eq!(LOGO_BACKGROUND_COLOR_DARK, 0xFF00_0000);
+        assert_eq!(LOGO_BACKGROUND_COLOR, crate::hud::rgba(239, 50, 61, 255));
+    }
+
     #[test]
     fn file_fixer_cancel_sits_below_the_centre() {
         assert_eq!(file_fixer_cancel(427.0, 240.0), (113.0, 220.0));

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

@@ -5,6 +5,7 @@ pub mod assets;
 pub mod atlas_sources;
 pub mod audio;
 pub mod auth;
+pub mod ban_notice;
 pub mod bidi;
 pub mod biome;
 pub mod block_entities;
@@ -62,7 +63,9 @@ pub mod par;
 pub mod particles;
 pub mod poi_sections;
 pub mod post_chain;
+pub mod post_glsl;
 pub mod potent_sulfur;
+pub mod preedit;
 pub mod providers;
 pub mod screen_draw;
 pub mod screen_effects;

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

@@ -22,6 +22,7 @@ use crate::{
 use horizon_core::geometry::{Direction, ShapeOp, VoxelShape};
 use horizon_world::registry::{BlockRegistry, BlockStateId};
 use std::{
+    cell::RefCell,
     collections::{HashMap, VecDeque},
     path::Path,
     sync::Arc,
@@ -240,7 +241,8 @@ impl LightTables {
     /// `edge_occluded` for two packed cells.
     #[inline]
     fn packed_edge_occluded(&self, top: u16, bottom: u16) -> bool {
-        bottom & 0xF != 0 || self.packed_blocked(top, bottom, Direction::Down as usize)
+        bottom & 0xF != 0
+            || ((top | bottom) != 0 && self.packed_blocked(top, bottom, Direction::Down as usize))
     }
     pub fn emission(&self, state: u32) -> u8 {
         self.cells[state as usize].emission
@@ -266,12 +268,64 @@ const OFFSETS: [(i32, i32, i32); 6] = [
     (1, 0, 0),
 ];
 
+struct LightScratch {
+    states: Vec<u16>,
+    sky: Vec<u8>,
+    block: Vec<u8>,
+    queue: Vec<u32>,
+    sky_queue: Vec<u32>,
+    present: Vec<bool>,
+    lowest: Vec<i32>,
+    ids: Box<[u32; 4096]>,
+}
+
+impl LightScratch {
+    fn new() -> Self {
+        Self {
+            states: Vec::new(),
+            sky: Vec::new(),
+            block: Vec::new(),
+            queue: Vec::new(),
+            sky_queue: Vec::new(),
+            present: vec![false; W * W],
+            lowest: vec![0; W * W],
+            ids: Box::new([0u32; 4096]),
+        }
+    }
+
+    /// Clear queues and shrink them if capacity exceeds the retention cap.
+    fn clear_queues(&mut self) {
+        const MAX_QUEUE_CAPACITY: usize = 65_536;
+        self.queue.clear();
+        if self.queue.capacity() > MAX_QUEUE_CAPACITY {
+            self.queue.shrink_to(MAX_QUEUE_CAPACITY);
+        }
+        self.sky_queue.clear();
+        if self.sky_queue.capacity() > MAX_QUEUE_CAPACITY {
+            self.sky_queue.shrink_to(MAX_QUEUE_CAPACITY);
+        }
+    }
+}
+
+thread_local! {
+    static SCRATCH: RefCell<LightScratch> = RefCell::new(LightScratch::new());
+}
+
 /// `region[dz][dx]` holds the chunks around the centre (index 1,1).
 /// `sky` is false in dimensions without skylight (the Nether).
 pub fn light_chunk(
     region: &[[Option<&Chunk>; 3]; 3],
     tables: &LightTables,
     sky_light: bool,
+) -> Vec<Light> {
+    SCRATCH.with_borrow_mut(|scratch| light_chunk_with_scratch(region, tables, sky_light, scratch))
+}
+
+fn light_chunk_with_scratch(
+    region: &[[Option<&Chunk>; 3]; 3],
+    tables: &LightTables,
+    sky_light: bool,
+    scratch: &mut LightScratch,
 ) -> Vec<Light> {
     let sections = region[1][1].expect("centre chunk").sections.len();
     // Highest occupied section in the region bounds the work.
@@ -287,142 +341,194 @@ 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(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.
-    let mut states = vec![0u16; W * W * h];
-    let mut sky = vec![0u8; W * W * h];
-    let mut block = vec![0u8; W * W * h];
-    let mut queue = VecDeque::new();
-    let mut sky_queue = VecDeque::new();
-    let mut ids = Box::new([0u32; 4096]);
+    let total = W * W * h;
+
+    scratch.states.resize(total, 0);
+    scratch.states.fill(0);
+    scratch.sky.resize(total, 0);
+    scratch.sky.fill(0);
+    scratch.block.resize(total, 0);
+    scratch.block.fill(0);
+    scratch.clear_queues();
+
+    let states = &mut scratch.states[..total];
+    let sky = &mut scratch.sky[..total];
+    let block = &mut scratch.block[..total];
+    let queue = &mut scratch.queue;
+    let sky_queue = &mut scratch.sky_queue;
+    let ids = &mut scratch.ids;
+
     for (dz, row) in region.iter().enumerate() {
+        let z_base = dz * 16;
         for (dx, chunk) in row.iter().enumerate() {
             let Some(chunk) = chunk else { continue };
+            let x_base = dx * 16;
             for (si, section) in chunk.sections.iter().enumerate().take(top_section) {
                 if section.is_uniform(0) {
                     continue;
                 }
-                section.unpack(&mut ids);
-                for (i, &id) in ids.iter().enumerate() {
-                    let (lx, lz, ly) = (i & 15, (i >> 4) & 15, i >> 8);
-                    let p = at(dx * 16 + lx, si * 16 + ly, dz * 16 + lz);
-                    let info = tables.info[id as usize];
-                    states[p] = info as u16;
-                    let emission = info >> 16;
-                    if emission > 0 {
-                        block[p] = emission as u8;
-                        queue.push_back(p as u32);
+                section.unpack(ids);
+                let y_base = si * 16;
+                for ly in 0..16 {
+                    let y = y_base + ly;
+                    let y_offset = y * (W * W);
+                    for lz in 0..16 {
+                        let z = z_base + lz;
+                        let p_row = y_offset + z * W + x_base;
+                        let i_row = (ly << 8) | (lz << 4);
+                        for lx in 0..16 {
+                            let id = ids[i_row + lx];
+                            if id == 0 {
+                                continue;
+                            }
+                            let p = p_row + lx;
+                            let info = tables.info[id as usize];
+                            states[p] = info as u16;
+                            let emission = info >> 16;
+                            if emission > 0 {
+                                block[p] = emission as u8;
+                                queue.push(p as u32);
+                            }
+                        }
                     }
                 }
             }
         }
     }
+
     // Columns of missing neighbour chunks neither hold nor pass light.
-    let mut present = vec![false; W * W];
+    scratch.present.resize(W * W, false);
     for z in 0..W {
         for x in 0..W {
-            present[z * W + x] = region[z / 16][x / 16].is_some();
+            scratch.present[z * W + x] = region[z / 16][x / 16].is_some();
         }
     }
-    let mut lowest = vec![h as i32; W * W];
+    let present = &scratch.present[..W * W];
+
+    scratch.lowest.resize(W * W, h as i32);
+    let lowest = &mut scratch.lowest[..W * W];
+
     for z in 0..W {
         for x in 0..W {
-            if !present[z * W + x] || !sky_light {
+            let col = z * W + x;
+            if !present[col] || !sky_light {
+                lowest[col] = h as i32;
                 continue;
             }
             // The top layer (above the occupied range) is always open sky.
             let mut y = h as i32 - 1;
-            sky[at(x, y as usize, z)] = 15;
-            while y > 0
-                && !tables.packed_edge_occluded(
-                    states[at(x, y as usize, z)],
-                    states[at(x, y as usize - 1, z)],
-                )
-            {
+            let mut p = (h - 1) * (W * W) + col;
+            sky[p] = 15;
+            while y > 0 {
+                let next_p = p - (W * W);
+                if tables.packed_edge_occluded(states[p], states[next_p]) {
+                    break;
+                }
                 y -= 1;
-                sky[at(x, y as usize, z)] = 15;
+                p = next_p;
+                sky[p] = 15;
             }
-            lowest[z * W + x] = y;
+            lowest[col] = y;
         }
     }
-    for z in 0..W {
-        for x in 0..W {
-            if !present[z * W + x] || !sky_light {
-                continue;
-            }
-            let own = lowest[z * W + x];
-            let mut deepest = own;
-            for (nx, nz) in [
-                (x.wrapping_sub(1), z),
-                (x + 1, z),
-                (x, z.wrapping_sub(1)),
-                (x, z + 1),
-            ] {
-                if nx < W && nz < W && present[nz * W + nx] {
-                    deepest = deepest.max(lowest[nz * W + nx]);
+
+    if sky_light {
+        for z in 0..W {
+            for x in 0..W {
+                let col = z * W + x;
+                if !present[col] {
+                    continue;
                 }
-            }
-            // Seed propagation from the source cells that border darker cells.
-            let from = own.max(0) as usize;
-            let to = (deepest as usize).min(h - 1);
-            for y in from..=to {
-                if sky[at(x, y, z)] == 15 {
-                    sky_queue.push_back(at(x, y, z) as u32);
+                let own = lowest[col];
+                let mut deepest = own;
+                for (nx, nz) in [
+                    (x.wrapping_sub(1), z),
+                    (x + 1, z),
+                    (x, z.wrapping_sub(1)),
+                    (x, z + 1),
+                ] {
+                    if nx < W && nz < W && present[nz * W + nx] {
+                        deepest = deepest.max(lowest[nz * W + nx]);
+                    }
+                }
+                // Seed propagation from the source cells that border darker cells.
+                let from = own.max(0) as usize;
+                let to = (deepest as usize).min(h.saturating_sub(1));
+                if from <= to {
+                    let mut p = from * (W * W) + col;
+                    for _ in from..=to {
+                        if sky[p] == 15 {
+                            sky_queue.push(p as u32);
+                        }
+                        p += W * W;
+                    }
                 }
             }
         }
     }
-    let spread = |light: &mut [u8], queue: &mut VecDeque<u32>| {
-        while let Some(p) = queue.pop_front() {
-            let p = p as usize;
+
+    let block_masks = &tables.block_masks;
+    let types = tables.types;
+
+    let spread = |light: &mut [u8], queue: &mut Vec<u32>| {
+        let mut head = 0;
+        while head < queue.len() {
+            let p = queue[head] as usize;
+            head += 1;
             let level = light[p];
             if level <= 1 {
                 continue;
             }
-            let x = p % W;
-            let z = (p / W) % W;
+            let min_threshold = level - 1;
             let y = p / (W * W);
+            let col = p % (W * W);
+            let z = col / W;
+            let x = col % W;
             let from = states[p];
-            let col = z * W + x;
+            let from_row = (from >> 4) as usize * types;
+
             // Neighbours by linear offset; `present` only depends on the
             // column, and the axis bounds rule out wrapping.
-            macro_rules! neighbour {
-                ($d:expr, $q:expr, $ncol:expr) => {{
-                    if present[$ncol] {
-                        let q = $q;
+            macro_rules! step_neighbour {
+                ($d:expr, $q:expr) => {{
+                    let q = $q;
+                    if light[q] < min_threshold {
                         let to = states[q];
-                        let next = level.saturating_sub((to & 0xF).max(1) as u8);
-                        if next > light[q] && !tables.packed_blocked(from, to, $d) {
-                            light[q] = next;
-                            queue.push_back(q as u32);
+                        let damp = (to & 0xF).max(1) as u8;
+                        if level > light[q] + damp {
+                            if block_masks[from_row + (to >> 4) as usize] & (1 << $d) == 0 {
+                                light[q] = level - damp;
+                                queue.push(q as u32);
+                            }
                         }
                     }
                 }};
             }
             if y > 0 {
-                neighbour!(0, p - W * W, col);
+                step_neighbour!(0, p - W * W);
             }
             if y + 1 < h {
-                neighbour!(1, p + W * W, col);
+                step_neighbour!(1, p + W * W);
             }
-            if z > 0 {
-                neighbour!(2, p - W, col - W);
+            if z > 0 && present[col - W] {
+                step_neighbour!(2, p - W);
             }
-            if z + 1 < W {
-                neighbour!(3, p + W, col + W);
+            if z + 1 < W && present[col + W] {
+                step_neighbour!(3, p + W);
             }
-            if x > 0 {
-                neighbour!(4, p - 1, col - 1);
+            if x > 0 && present[col - 1] {
+                step_neighbour!(4, p - 1);
             }
-            if x + 1 < W {
-                neighbour!(5, p + 1, col + 1);
+            if x + 1 < W && present[col + 1] {
+                step_neighbour!(5, p + 1);
             }
         }
     };
-    spread(&mut sky, &mut sky_queue);
-    spread(&mut block, &mut queue);
-    pack_lighting(sections, h, &sky, &block, sky_light)
+    spread(sky, sky_queue);
+    spread(block, queue);
+    let result = pack_lighting(sections, h, sky, block, sky_light);
+    scratch.clear_queues();
+    result
 }
 
 /// Extract just the centre column's light (`sections` of it); never copy
@@ -434,7 +540,6 @@ fn pack_lighting(
     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)
         .map(|si| {
@@ -447,10 +552,13 @@ fn pack_lighting(
                 if y >= h {
                     continue;
                 }
+                let y_offset = y * (W * W);
                 for lz in 0..16 {
+                    let p_row = y_offset + (16 + lz) * W + 16;
+                    let out_row = (ly << 8) | (lz << 4);
                     for lx in 0..16 {
-                        let p = at(16 + lx, y, 16 + lz);
-                        data[index(lx as i32, ly as i32, lz as i32)] = sky[p] << 4 | block[p];
+                        let p = p_row + lx;
+                        data[out_row + lx] = sky[p] << 4 | block[p];
                     }
                 }
             }
@@ -1832,4 +1940,336 @@ mod tests {
             changed.sections().count()
         );
     }
+
+    #[test]
+    #[ignore = "benchmark"]
+    fn benchmark_light_chunk() {
+        use std::time::Instant;
+        let t = tables();
+        let layout = ColumnLayout::VANILLA;
+        let mut chunks = Vec::new();
+        for cz in -1..=1 {
+            for cx in -1..=1 {
+                let mut c = Chunk::with_layout(cx, cz, layout);
+                for y in layout.min_y()..64 {
+                    for i in 0..256 {
+                        c.set(i & 15, y, i >> 4, STONE);
+                    }
+                }
+                for x in 2..14 {
+                    for z in 2..14 {
+                        c.set(x, 64, z, SLAB);
+                    }
+                }
+                c.set(8, 65, 8, TORCH);
+                c.set(4, 30, 4, TORCH);
+                chunks.push(c);
+            }
+        }
+        let region = [
+            [Some(&chunks[0]), Some(&chunks[1]), Some(&chunks[2])],
+            [Some(&chunks[3]), Some(&chunks[4]), Some(&chunks[5])],
+            [Some(&chunks[6]), Some(&chunks[7]), Some(&chunks[8])],
+        ];
+
+        for _ in 0..5 {
+            let _ = light_chunk(&region, &t, true);
+        }
+
+        let start = Instant::now();
+        let iters = 200;
+        for _ in 0..iters {
+            let _ = std::hint::black_box(light_chunk(std::hint::black_box(&region), &t, true));
+        }
+        let elapsed = start.elapsed();
+        println!(
+            "benchmark_light_chunk: {:?} total, {:.2} µs/chunk",
+            elapsed,
+            elapsed.as_micros() as f64 / iters as f64
+        );
+    }
+
+    #[test]
+    fn scratch_queues_shrink_above_capacity_cap() {
+        let mut scratch = LightScratch::new();
+        scratch.queue.resize(100_000, 0);
+        scratch.sky_queue.resize(100_000, 0);
+        assert!(scratch.queue.capacity() >= 100_000);
+        assert!(scratch.sky_queue.capacity() >= 100_000);
+        scratch.clear_queues();
+        assert_eq!(scratch.queue.len(), 0);
+        assert_eq!(scratch.sky_queue.len(), 0);
+        assert!(scratch.queue.capacity() < 100_000);
+        assert!(scratch.sky_queue.capacity() < 100_000);
+    }
+
+    /// The baseline flood-fill lighting algorithm before the scratch and wavefront optimizations.
+    fn old_light_chunk(
+        region: &[[Option<&Chunk>; 3]; 3],
+        tables: &LightTables,
+        sky_light: bool,
+    ) -> Vec<Light> {
+        let sections = region[1][1].expect("centre chunk").sections.len();
+        let mut top_section = 0;
+        for chunk in region.iter().flatten().flatten() {
+            for (i, s) in chunk.sections.iter().enumerate().rev() {
+                if !s.is_uniform(0) {
+                    top_section = top_section.max(i + 1);
+                    break;
+                }
+            }
+        }
+        let h = ((top_section + 1) * 16).min(sections * 16);
+        let at = |x: usize, y: usize, z: usize| (y * W + z) * W + x;
+        let mut states = vec![0u16; W * W * h];
+        let mut sky = vec![0u8; W * W * h];
+        let mut block = vec![0u8; W * W * h];
+        let mut queue = VecDeque::new();
+        let mut sky_queue = VecDeque::new();
+        let mut ids = Box::new([0u32; 4096]);
+        for (dz, row) in region.iter().enumerate() {
+            for (dx, chunk) in row.iter().enumerate() {
+                let Some(chunk) = chunk else { continue };
+                for (si, section) in chunk.sections.iter().enumerate().take(top_section) {
+                    if section.is_uniform(0) {
+                        continue;
+                    }
+                    section.unpack(&mut ids);
+                    for (i, &id) in ids.iter().enumerate() {
+                        let (lx, lz, ly) = (i & 15, (i >> 4) & 15, i >> 8);
+                        let p = at(dx * 16 + lx, si * 16 + ly, dz * 16 + lz);
+                        let info = tables.info[id as usize];
+                        states[p] = info as u16;
+                        let emission = info >> 16;
+                        if emission > 0 {
+                            block[p] = emission as u8;
+                            queue.push_back(p as u32);
+                        }
+                    }
+                }
+            }
+        }
+        let mut present = vec![false; W * W];
+        for z in 0..W {
+            for x in 0..W {
+                present[z * W + x] = region[z / 16][x / 16].is_some();
+            }
+        }
+        let mut lowest = vec![h as i32; W * W];
+        let old_packed_edge_occluded = |top: u16, bottom: u16| -> bool {
+            bottom & 0xF != 0 || tables.packed_blocked(top, bottom, Direction::Down as usize)
+        };
+        for z in 0..W {
+            for x in 0..W {
+                if !present[z * W + x] || !sky_light {
+                    continue;
+                }
+                let mut y = h as i32 - 1;
+                sky[at(x, y as usize, z)] = 15;
+                while y > 0
+                    && !old_packed_edge_occluded(
+                        states[at(x, y as usize, z)],
+                        states[at(x, y as usize - 1, z)],
+                    )
+                {
+                    y -= 1;
+                    sky[at(x, y as usize, z)] = 15;
+                }
+                lowest[z * W + x] = y;
+            }
+        }
+        for z in 0..W {
+            for x in 0..W {
+                if !present[z * W + x] || !sky_light {
+                    continue;
+                }
+                let own = lowest[z * W + x];
+                let mut deepest = own;
+                for (nx, nz) in [
+                    (x.wrapping_sub(1), z),
+                    (x + 1, z),
+                    (x, z.wrapping_sub(1)),
+                    (x, z + 1),
+                ] {
+                    if nx < W && nz < W && present[nz * W + nx] {
+                        deepest = deepest.max(lowest[nz * W + nx]);
+                    }
+                }
+                let from = own.max(0) as usize;
+                let to = (deepest as usize).min(h.saturating_sub(1));
+                for y in from..=to {
+                    if sky[at(x, y, z)] == 15 {
+                        sky_queue.push_back(at(x, y, z) as u32);
+                    }
+                }
+            }
+        }
+        let spread = |light: &mut [u8], queue: &mut VecDeque<u32>| {
+            while let Some(p) = queue.pop_front() {
+                let p = p as usize;
+                let level = light[p];
+                if level <= 1 {
+                    continue;
+                }
+                let x = p % W;
+                let z = (p / W) % W;
+                let y = p / (W * W);
+                let from = states[p];
+                let col = z * W + x;
+                macro_rules! neighbour {
+                    ($d:expr, $q:expr, $ncol:expr) => {{
+                        if present[$ncol] {
+                            let q = $q;
+                            let to = states[q];
+                            let next = level.saturating_sub((to & 0xF).max(1) as u8);
+                            if next > light[q] && !tables.packed_blocked(from, to, $d) {
+                                light[q] = next;
+                                queue.push_back(q as u32);
+                            }
+                        }
+                    }};
+                }
+                if y > 0 {
+                    neighbour!(0, p - W * W, col);
+                }
+                if y + 1 < h {
+                    neighbour!(1, p + W * W, col);
+                }
+                if z > 0 {
+                    neighbour!(2, p - W, col - W);
+                }
+                if z + 1 < W {
+                    neighbour!(3, p + W, col + W);
+                }
+                if x > 0 {
+                    neighbour!(4, p - 1, col - 1);
+                }
+                if x + 1 < W {
+                    neighbour!(5, p + 1, col + 1);
+                }
+            }
+        };
+        spread(&mut sky, &mut sky_queue);
+        spread(&mut block, &mut queue);
+        pack_lighting(sections, h, &sky, &block, sky_light)
+    }
+
+    #[test]
+    fn light_chunk_matches_old_algorithm() {
+        let t = tables();
+        let layout = ColumnLayout::VANILLA;
+
+        let mut rng = 0x1234_5678_u64;
+        let mut next = |max: usize| -> usize {
+            rng = rng.wrapping_mul(6364136223846793005).wrapping_add(1);
+            ((rng >> 32) as usize) % max
+        };
+
+        let cases = [
+            // (sky_light, missing_pattern)
+            // 0 = full 3x3
+            // 1 = missing corners
+            // 2 = missing edges
+            // 3 = random missing neighbours
+            // 4 = only centre and single neighbour
+            (true, 0),
+            (false, 0),
+            (true, 1),
+            (false, 1),
+            (true, 2),
+            (false, 2),
+            (true, 3),
+            (false, 3),
+            (true, 4),
+            (false, 4),
+        ];
+
+        for (round, &(sky_light, pattern)) in cases.iter().enumerate() {
+            let mut chunks = Vec::new();
+            for cz in -1..=1 {
+                for cx in -1..=1 {
+                    let mut c = Chunk::with_layout(cx, cz, layout);
+                    let base_y = -64 + next(64) as i32;
+                    for y in layout.min_y()..base_y {
+                        for i in 0..256 {
+                            c.set(i & 15, y, i >> 4, STONE);
+                        }
+                    }
+                    let features = 10 + next(20);
+                    for _ in 0..features {
+                        let fx = next(16) as i32;
+                        let fz = next(16) as i32;
+                        let fy = base_y + next(32) as i32;
+                        let block_type = match next(4) {
+                            0 => AIR,
+                            1 => STONE,
+                            2 => TORCH,
+                            _ => SLAB,
+                        };
+                        c.set(fx, fy, fz, block_type);
+                    }
+                    let roof_y = base_y + 10 + next(10) as i32;
+                    for rx in 4..12 {
+                        for rz in 4..12 {
+                            if next(3) != 0 {
+                                c.set(rx, roof_y, rz, SLAB);
+                            }
+                        }
+                    }
+                    c.set(8, roof_y - 1, 8, TORCH);
+                    c.set(next(16) as i32, roof_y + 2, next(16) as i32, TORCH);
+                    c.set(0, base_y + 1, 0, TORCH);
+                    c.set(15, base_y + 1, 15, TORCH);
+
+                    chunks.push(c);
+                }
+            }
+
+            let mut region: [[Option<&Chunk>; 3]; 3] = [[None; 3]; 3];
+            for dz in 0..3 {
+                for dx in 0..3 {
+                    let is_centre = dz == 1 && dx == 1;
+                    let chunk_ref = &chunks[dz * 3 + dx];
+                    let include = if is_centre {
+                        true
+                    } else {
+                        match pattern {
+                            0 => true,
+                            1 => (dz + dx) % 2 == 1,
+                            2 => (dz + dx) % 2 == 0,
+                            3 => next(10) < 6,
+                            4 => dz == 1 && dx == 2,
+                            _ => true,
+                        }
+                    };
+                    if include {
+                        region[dz][dx] = Some(chunk_ref);
+                    }
+                }
+            }
+
+            let old = old_light_chunk(&region, &t, sky_light);
+            let new = light_chunk(&region, &t, sky_light);
+
+            assert_eq!(
+                old.len(),
+                new.len(),
+                "round {round}: section count mismatch"
+            );
+            for si in 0..old.len() {
+                for i in 0..4096 {
+                    assert_eq!(
+                        new[si].get(i),
+                        old[si].get(i),
+                        "mismatch at round {round} (sky_light={sky_light}, pattern={pattern}), section {si}, index {i} (lx={}, ly={}, lz={}): new={:#04x}, old={:#04x}",
+                        i & 15,
+                        i >> 8,
+                        (i >> 4) & 15,
+                        new[si].get(i),
+                        old[si].get(i)
+                    );
+                }
+            }
+        }
+    }
 }

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

@@ -130,6 +130,12 @@ impl Mesher {
                 let tint = match name.strip_prefix("minecraft:").unwrap_or(name) {
                     "spruce_leaves" => Tint::Constant(0x61_9961),
                     "birch_leaves" => Tint::Constant(0x80_A755),
+                    // Cherry (and other pre-coloured) leaves: the texture is
+                    // already pink; biome foliage tint turns a grove yellow (#4688).
+                    "cherry_leaves"
+                    | "azalea_leaves"
+                    | "flowering_azalea_leaves"
+                    | "pale_oak_leaves" => Tint::None,
                     "leaf_litter" => Tint::Dry,
                     _ if leaves => Tint::Foliage,
                     _ => Tint::Grass,

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

@@ -139,11 +139,50 @@ mod vertex_tests {
         assert_eq!(hdr_tier("red_candle", 3), LOW);
         assert_eq!(hdr_tier("glow_lichen", 7), 0);
         assert_eq!(hdr_tier("stone", 0), 0);
+        assert_eq!(hdr_tier("ochre_froglight", 15), LOW);
+        assert_eq!(hdr_tier("respawn_anchor", 3), INCANDESCENT);
+        assert_eq!(hdr_tier("waxed_copper_bulb", 15), LOW);
+        assert_eq!(hdr_tier("sea_pickle", 15), 0);
         // Unlisted ones by their light level.
-        assert_eq!(hdr_tier("ochre_froglight", 15), INCANDESCENT);
+        assert_eq!(hdr_tier("vault", 12), INCANDESCENT);
         assert_eq!(hdr_tier("sculk_sensor", 1), LOW);
     }
 }
+
+#[cfg(test)]
+mod section_mesh_tests {
+    use super::*;
+
+    #[test]
+    fn compute_bounds_empty_solid_and_translucent() {
+        let mut mesh = SectionMesh::default();
+        assert_eq!(mesh.compute_bounds(), None);
+
+        let v1 = TerrainVertex::new([1.0, 2.0, 3.0], [0.0, 0.0], 0, 0, 0);
+        let v2 = TerrainVertex::new([4.0, 5.0, 6.0], [0.0, 0.0], 0, 0, 0);
+        mesh.solid.push(v1);
+        mesh.solid.push(v2);
+
+        let pad = glam::Vec3::splat(SectionMesh::BOUNDS_PAD);
+        assert_eq!(
+            mesh.compute_bounds(),
+            Some([
+                glam::Vec3::new(1.0, 2.0, 3.0) - pad,
+                glam::Vec3::new(4.0, 5.0, 6.0) + pad,
+            ])
+        );
+
+        let v3 = TerrainVertex::new([0.5, 7.0, 8.0], [0.0, 0.0], 0, 0, 0);
+        mesh.translucent.push(v3);
+        assert_eq!(
+            mesh.compute_bounds(),
+            Some([
+                glam::Vec3::new(0.5, 2.0, 3.0) - pad,
+                glam::Vec3::new(4.0, 7.0, 8.0) + pad,
+            ])
+        );
+    }
+}
 pub struct SectionMesh {
     pub solid: Vec<TerrainVertex>,
     /// The buckets `solid` is sorted in by the side its quads face: empty
@@ -158,6 +197,8 @@ pub struct SectionMesh {
     /// each frame by `block_entity_render` like vanilla's per-section
     /// `SectionCompiler.Results.blockEntities`.
     pub block_entities: Vec<([i32; 3], u32)>,
+    /// Axis-aligned bounding box [min, max] of actual terrain mesh vertices in section-local space [0, 16].
+    pub bounds: Option<[glam::Vec3; 2]>,
 }
 impl Default for SectionMesh {
     fn default() -> Self {
@@ -167,19 +208,66 @@ impl Default for SectionMesh {
             translucent: Vec::new(),
             visibility: ALL_VISIBLE,
             block_entities: Vec::new(),
+            bounds: None,
         }
     }
 }
 impl SectionMesh {
+    /// Padding applied to mesh vertex bounds to prevent clipping at the frustum
+    /// boundary when shader packs with vertex displacement (e.g. waving foliage, water) are active.
+    pub const BOUNDS_PAD: f32 = 0.5;
+
+    /// Retain geometry capacity after an upload, but none of its old contents.
+    pub(crate) fn clear(&mut self) {
+        self.solid.clear();
+        self.translucent.clear();
+        self.block_entities.clear();
+        self.sides = Sides::default();
+        self.visibility = ALL_VISIBLE;
+        self.bounds = None;
+    }
+    pub(crate) fn capacity_bytes(&self) -> usize {
+        self.solid.capacity() * std::mem::size_of::<TerrainVertex>()
+            + self.translucent.capacity() * std::mem::size_of::<TerrainVertex>()
+            + self.block_entities.capacity() * std::mem::size_of::<([i32; 3], u32)>()
+    }
     /// Sorts the solid quads by the side they face, for the renderer to
     /// leave out those facing away from the eye (`sides`).
     pub fn sort_solid(&mut self) {
         self.sides = sides::sort(&mut self.solid);
+        self.bounds = self.compute_bounds();
+    }
+
+    /// Computes the tight axis-aligned bounding box [min, max] of actual terrain geometry vertices.
+    pub fn compute_bounds(&self) -> Option<[glam::Vec3; 2]> {
+        if self.solid.is_empty() && self.translucent.is_empty() {
+            return None;
+        }
+        let mut min = glam::Vec3::splat(f32::INFINITY);
+        let mut max = glam::Vec3::splat(f32::NEG_INFINITY);
+        for v in &self.solid {
+            let p = glam::Vec3::from(v.pos);
+            min = min.min(p);
+            max = max.max(p);
+        }
+        for v in &self.translucent {
+            let p = glam::Vec3::from(v.pos);
+            min = min.min(p);
+            max = max.max(p);
+        }
+        let pad = glam::Vec3::splat(Self::BOUNDS_PAD);
+        Some([min - pad, max + pad])
     }
 }
 pub const ALL_VISIBLE: u64 = (1 << 36) - 1;
 /// VisGraph.resolve: flood fill non-opaque cells and connect the faces each region touches.
+#[cfg(test)]
 fn visibility(pad: &Padded, info: &[Info]) -> u64 {
+    visibility_reusing(pad, info, &mut Vec::new())
+}
+fn visibility_reusing(pad: &Padded, info: &[Info], stack: &mut Vec<usize>) -> u64 {
+    // The all-visible shortcut can leave a partially filled stack behind.
+    stack.clear();
     // Opaque cells are already visited: resolve each state's opacity once,
     // then reuse this map for the flood fill and the uniform-section shortcuts.
     let mut seen = [false; 4096];
@@ -201,7 +289,6 @@ fn visibility(pad: &Padded, info: &[Info]) -> u64 {
         return 0;
     }
     let mut result = 0u64;
-    let mut stack = Vec::new();
     for start in 0..4096usize {
         if seen[start] {
             continue;
@@ -458,7 +545,12 @@ impl MeshTables {
             });
             let mut face = [0u8; 6];
             let mut cover = [0f32; 6];
-            for d in Direction::ALL {
+            // A server's visibility knows no state (`FaceVisibility::empty`):
+            // it meshes no fluid, so these stay unset.
+            for d in Direction::ALL
+                .into_iter()
+                .filter(|_| !visibility.is_empty())
+            {
                 let (face_id, shape) = visibility
                     .occlusion_face(BlockStateId(id as u32), d)
                     .ok_or("missing occlusion face")?;
@@ -631,21 +723,30 @@ fn pi(x: i32, y: i32, z: i32) -> usize {
     ((y + B) as usize * P + (z + B) as usize) * P + (x + B) as usize
 }
 /// Blocks and light of one section plus a `B`-block border.
+#[derive(Default)]
 struct Padded {
     blocks: Vec<u32>,
     light: Vec<u8>,
 }
 impl Padded {
+    #[cfg(test)]
     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 mut pad = Self::default();
+        pad.fill(region, sy, &mut Box::new([0; 4096]));
+        pad
+    }
+    fn fill(&mut self, region: &[[Option<&Chunk>; 3]; 3], sy: i32, own: &mut [u32; 4096]) {
+        self.blocks.resize(P * P * P, 0);
+        self.blocks.fill(0);
+        self.light.resize(P * P * P, 0);
+        let (blocks, light) = (&mut self.blocks, &mut self.light);
         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]);
+        own.fill(0);
         let center = region[1][1].map(|c| &c.sections[sy as usize]);
         if let Some(section) = center {
-            section.unpack(&mut own);
+            section.unpack(own);
         }
         for y in -B..16 + B {
             let wy = base_y + y;
@@ -677,9 +778,18 @@ impl Padded {
                 }
             }
         }
-        Self { blocks, light }
     }
 }
+/// Per-worker temporary arrays. They never hold resource-pack references or
+/// geometry still owned by the renderer, and total about 88 KiB per worker.
+#[derive(Default)]
+pub(crate) struct MeshScratch {
+    padded: Padded,
+    own: Option<Box<[u32; 4096]>>,
+    visibility: Vec<usize>,
+}
+#[cfg(test)]
+mod reuse_tests;
 /// 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 how brightly its face shines
@@ -702,14 +812,25 @@ 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,
+        | "soul_torch" | "soul_wall_torch" | "soul_fire" | "beacon" | "end_rod" | "furnace"
+        | "redstone_lamp" => BRIGHT,
         "torch" | "wall_torch" | "lantern" | "lava" | "crying_obsidian" | "fire"
         | "sea_lantern" => INCANDESCENT,
-        "redstone_torch" | "redstone_wall_torch" | "magma_block" => LOW,
+        // Glowing at every charge, not only the brighter ones.
+        "respawn_anchor" => INCANDESCENT,
+        "redstone_torch"
+        | "redstone_wall_torch"
+        | "magma_block"
+        | "ochre_froglight"
+        | "verdant_froglight"
+        | "pearlescent_froglight"
+        | "shroomlight" => LOW,
         // Its flame is a particle.
         _ if name.ends_with("candle") || name.ends_with("candle_cake") => LOW,
+        // One tier at every oxidation stage, waxed or not.
+        _ if name.ends_with("copper_bulb") => LOW,
         // A faint glow in the dark, as in SDR.
-        "glow_lichen" => 0,
+        "glow_lichen" | "sea_pickle" | "brown_mushroom" | "dragon_egg" | "end_portal_frame" => 0,
         _ if level >= 10 => INCANDESCENT,
         _ => LOW,
     }
@@ -849,14 +970,30 @@ pub struct Mesher<'a> {
 impl Mesher<'_> {
     /// `region[dz][dx]` are the chunks around the meshed column (centre 1,1).
     pub fn mesh(&mut self, region: &[[Option<&Chunk>; 3]; 3], sy: i32) -> SectionMesh {
-        let mut out = SectionMesh::default();
+        self.mesh_reusing(
+            region,
+            sy,
+            SectionMesh::default(),
+            &mut MeshScratch::default(),
+        )
+    }
+    pub(crate) fn mesh_reusing(
+        &mut self,
+        region: &[[Option<&Chunk>; 3]; 3],
+        sy: i32,
+        mut out: SectionMesh,
+        scratch: &mut MeshScratch,
+    ) -> SectionMesh {
+        out.clear();
         let center = region[1][1].expect("centre chunk");
         let section = &center.sections[sy as usize];
         if section.is_uniform(0) {
             return out;
         }
-        let pad = Padded::new(region, sy);
-        out.visibility = visibility(&pad, &self.tables.info);
+        let own = scratch.own.get_or_insert_with(|| Box::new([0; 4096]));
+        scratch.padded.fill(region, sy, own);
+        let pad = &scratch.padded;
+        out.visibility = visibility_reusing(pad, &self.tables.info, &mut scratch.visibility);
         let base_y = center.min_y() + sy * 16;
         let mut tints = Tints::new(
             region,
@@ -891,7 +1028,7 @@ impl Mesher<'_> {
                     if state.fluid.kind() != FluidKind::Empty {
                         let water = tints.get(Resolver::Water, x, y, z);
                         let nether = self.nether_shading;
-                        fluid::tesselate(self.tables, nether, &pad, water, &mut out, [x, y, z]);
+                        fluid::tesselate(self.tables, nether, pad, water, &mut out, [x, y, z]);
                     }
                     if !state.model {
                         continue;
@@ -941,7 +1078,7 @@ impl Mesher<'_> {
                                 continue;
                             }
                             self.face(
-                                &pad,
+                                pad,
                                 &mut tints,
                                 &mut out,
                                 [x, y, z],

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

@@ -0,0 +1,208 @@
+use super::*;
+
+#[test]
+fn padded_reuse_resets_missing_neighbors_and_matches_chunk_reads_across_layouts() {
+    let mut pad = Padded::default();
+    let mut own = Box::new([u32::MAX; 4096]);
+    for min_y in [MIN_Y, -256, 0, 256] {
+        let layout = crate::chunk::ColumnLayout::new(min_y, 32).unwrap();
+        let base_y = min_y + 16;
+        let mut center = Chunk::with_layout(0, 0, layout);
+        center.set(0, base_y, 0, 7);
+        center.set(15, base_y + 15, 15, 9);
+        let mut neighbor = Chunk::with_layout(1, 0, layout);
+        neighbor.set(0, base_y + 2, 3, 11);
+        let mut region = [[None; 3]; 3];
+        region[1][1] = Some(&center);
+        region[1][2] = Some(&neighbor);
+        pad.fill(&region, 1, &mut own);
+        let buffers = (pad.blocks.as_ptr(), pad.light.as_ptr());
+        for current in [region, [[None; 3]; 3], region] {
+            pad.fill(&current, 1, &mut own);
+            for y in -B..16 + B {
+                for z in -B..16 + B {
+                    for x in -B..16 + B {
+                        let chunk = current[((z + 16) >> 4) as usize][((x + 16) >> 4) as usize];
+                        // A missing neighbour continues the centre's edge column.
+                        let (block, light) = match (chunk, current[1][1]) {
+                            (Some(c), _) => (
+                                c.get(x & 15, base_y + y, z & 15),
+                                c.light(x & 15, base_y + y, z & 15),
+                            ),
+                            (None, Some(c)) => {
+                                let (ex, ez) = (x.clamp(0, 15), z.clamp(0, 15));
+                                (c.get(ex, base_y + y, ez), c.light(ex, base_y + y, ez))
+                            }
+                            (None, None) => (0, 0xF0),
+                        };
+                        assert_eq!(pad.blocks[pi(x, y, z)], block);
+                        assert_eq!(pad.light[pi(x, y, z)], light);
+                    }
+                }
+            }
+            assert_eq!(buffers, (pad.blocks.as_ptr(), pad.light.as_ptr()));
+        }
+    }
+}
+
+/// Run explicitly with prepared assets; never silently pass without exercising geometry.
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn reused_mesh_matches_fresh_geometry_across_sections_and_resource_reload() {
+    let root = std::env::var_os("HORIZON_MESH_TEST_RESOURCES")
+        .map(std::path::PathBuf::from)
+        .unwrap_or_else(|| {
+            std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+                .join("../../.local/horizon-client/26.3")
+        });
+    let assets = Assets::load(&root).unwrap();
+    let facts = BlockFacts::load(&root, assets.registry).unwrap();
+    let biomes = Biomes::load(&root).unwrap();
+    let state = |name| assets.registry.default_state(name).unwrap().0;
+    let names = [
+        "minecraft:stone",
+        "minecraft:glass",
+        "minecraft:grass_block",
+        "minecraft:oak_leaves",
+        "minecraft:water",
+        "minecraft:chest",
+    ];
+    let mut dense = Chunk::empty(0, 0);
+    for z in 0..16 {
+        for x in 0..16 {
+            dense.set(
+                x,
+                MIN_Y + 4,
+                z,
+                state(names[((x + z) as usize) % names.len()]),
+            );
+        }
+    }
+    let mut sparse = Chunk::empty(-3, 5);
+    sparse.set(0, MIN_Y + 15, 0, state("minecraft:short_grass"));
+    sparse.set(15, MIN_Y + 1, 15, state("minecraft:lava"));
+    let empty = Chunk::empty(0, 0);
+    let mut neighbor = Chunk::empty(1, 0);
+    neighbor.set(0, MIN_Y + 4, 0, state("minecraft:stone"));
+    let mut custom = Chunk::with_layout(2, -4, crate::chunk::ColumnLayout::new(-256, 64).unwrap());
+    custom.set(1, -252, 2, state("minecraft:chest"));
+    let mut scratch = MeshScratch::default();
+    let mut recycled = SectionMesh::default();
+    // The same scratch and output buffers survive a resource reload. They must
+    // contain no references into the previous RenderAssets or MeshTables.
+    for reload in 0..2 {
+        let render = assets.reload(&root).unwrap();
+        let visibility = crate::models::load_visibility(&root, assets.registry).unwrap();
+        let tables = MeshTables::new(&assets, &render, &facts, visibility.clone()).unwrap();
+        let mut mesher = Mesher {
+            nether_shading: false,
+            assets: &assets,
+            render: &render,
+            tables: &tables,
+            biomes: &biomes,
+            visibility,
+            zoom: BiomeZoom::new(42),
+            blend_radius: 2,
+            smooth_lighting: reload == 0,
+            cutout_leaves: reload == 0,
+        };
+        for (case, (center, east)) in [
+            (&empty, None),
+            (&dense, Some(&neighbor)),
+            (&sparse, None),
+            (&empty, None),
+            (&dense, None),
+            (&custom, None),
+        ]
+        .into_iter()
+        .enumerate()
+        {
+            let mut region = [[None; 3]; 3];
+            region[1][1] = Some(center);
+            region[1][2] = east;
+            let mut fresh = mesher.mesh(&region, 0);
+            recycled = mesher.mesh_reusing(&region, 0, recycled, &mut scratch);
+            if reload == 0 && case == 0 {
+                assert!(scratch.own.is_none());
+                assert_eq!(scratch.padded.blocks.capacity(), 0);
+                assert_eq!(scratch.padded.light.capacity(), 0);
+                assert_eq!(scratch.visibility.capacity(), 0);
+            }
+            fresh.sort_solid();
+            recycled.sort_solid();
+            assert_eq!(
+                bytemuck::cast_slice::<TerrainVertex, u8>(&fresh.solid),
+                bytemuck::cast_slice::<TerrainVertex, u8>(&recycled.solid)
+            );
+            assert_eq!(
+                bytemuck::cast_slice::<TerrainVertex, u8>(&fresh.translucent),
+                bytemuck::cast_slice::<TerrainVertex, u8>(&recycled.translucent)
+            );
+            assert_eq!(fresh.block_entities, recycled.block_entities);
+            assert_eq!(fresh.visibility, recycled.visibility);
+            assert_eq!(fresh.sides, recycled.sides);
+            assert_eq!(fresh.bounds, recycled.bounds);
+            if std::ptr::eq(center, &dense) {
+                assert!(!fresh.solid.is_empty());
+                assert!(!fresh.translucent.is_empty());
+                assert!(!fresh.block_entities.is_empty());
+            }
+            if std::ptr::eq(center, &custom) {
+                assert_eq!(
+                    fresh.block_entities,
+                    [([33, -252, -62], state("minecraft:chest"))]
+                );
+            }
+        }
+    }
+}
+
+/// An isolated scratch-stage comparison, not a whole-mesher or FPS benchmark.
+/// Output each sample so the caller can retain the observations and spread.
+#[test]
+#[ignore = "opt-in scratch microbenchmark; run with --nocapture --test-threads=1"]
+fn benchmark_padded_reuse() {
+    const ITERATIONS: usize = 4096;
+    let mut chunk = Chunk::empty(0, 0);
+    for y in 0..16 {
+        for z in 0..16 {
+            for x in 0..16 {
+                chunk.set(x, MIN_Y + y, z, 1 + ((x + y + z) % 7) as u32);
+            }
+        }
+    }
+    let mut region = [[None; 3]; 3];
+    region[1][1] = Some(&chunk);
+    let mut pad = Padded::new(&region, 0);
+    let mut own = Box::new([0; 4096]);
+    let pointers = (pad.blocks.as_ptr(), pad.light.as_ptr(), own.as_ptr());
+    let bytes = pad.blocks.capacity() * 4 + pad.light.capacity() + 4096 * 4;
+    // Warm both code paths and the process allocator before recording samples.
+    for _ in 0..1024 {
+        std::hint::black_box(Padded::new(std::hint::black_box(&region), 0));
+        pad.fill(std::hint::black_box(&region), 0, &mut own);
+        std::hint::black_box(&pad);
+    }
+    for sample in 0..9 {
+        // Alternate execution order to expose, rather than hide, order effects.
+        for reused in [sample % 2 == 0, sample % 2 != 0] {
+            let start = std::time::Instant::now();
+            for _ in 0..ITERATIONS {
+                if reused {
+                    pad.fill(std::hint::black_box(&region), 0, &mut own);
+                    std::hint::black_box(&pad);
+                } else {
+                    std::hint::black_box(Padded::new(std::hint::black_box(&region), 0));
+                }
+            }
+            println!(
+                "{{\"sample\":{sample},\"reused\":{reused},\"iterations\":{ITERATIONS},\"elapsed_ms\":{:.6},\"scratch_bytes\":{bytes}}}",
+                start.elapsed().as_secs_f64() * 1000.0
+            );
+            assert_eq!(
+                pointers,
+                (pad.blocks.as_ptr(), pad.light.as_ptr(), own.as_ptr())
+            );
+        }
+    }
+}

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

@@ -187,6 +187,21 @@ fn visibility_matches_reference() {
     }
 }
 
+#[test]
+fn visibility_scratch_reuse_keeps_shortcuts_and_subsequent_fills_exact() {
+    let info = [info(false), info(true), info(false), info(true)];
+    let mut stack = vec![usize::MAX];
+    for _ in 0..3 {
+        for (name, pad) in cases() {
+            assert_eq!(
+                visibility_reusing(&pad, &info, &mut stack),
+                reference(&pad, &info),
+                "{name}"
+            );
+        }
+    }
+}
+
 #[test]
 fn visibility_preserves_every_face_pair() {
     let info = [info(false), info(true), info(false), info(true)];

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

@@ -12,6 +12,11 @@ use std::{
 pub const FILE: &str = "horizon-mods.txt";
 /// The folder holding `.hmod` files, beside `options.txt`.
 pub const DIR: &str = "horizon-mods";
+/// Where the launcher installs native mods (`<id>.hnmod`), beside [`DIR`]. They run only in a
+/// game the launcher built with them.
+pub const NATIVE_DIR: &str = "horizon-native-mods";
+/// Why a native mod installed in [`NATIVE_DIR`] doesn't run in this game.
+pub const NOT_BUILT: &str = "Installed, not built into this game: build the game with it in the launcher (Settings > Native mods), then play the instance that build is in.";
 
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct ModList {

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

@@ -579,6 +579,9 @@ impl MultiLineEdit {
         if show_cursor && !insert_cursor && self.within(cursor_y + shift, cursor_y + shift + LINE) {
             batch.text(atlas, "_", cursor_x, cursor_y, cursor_color, true);
         }
+        if self.focused {
+            crate::preedit::report_caret(cursor_x, cursor_y, 10.0);
+        }
         if self.has_selection() {
             let (sel_begin, sel_end) = self.selected();
             let draw_x = inner_left;

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

@@ -0,0 +1,166 @@
+// Improved transparency (the options screen's order-independent transparency),
+// appended to terrain.wgsl. Vanilla 26.3 draws its translucent layer three
+// times: once to find each pixel's nearest and furthest see-through depth (the
+// depth bounds), once to add each fragment's absorbance into a small wavelet
+// transform over that range (the transmittance), and once to weight every
+// fragment's colour by what the transform says lies in front of it (the
+// accumulation). A last full-screen pass puts the sum over the opaque world.
+//
+// Eight coefficients in two RGBA16F targets: [0] is the mean absorbance, [1]
+// the widest wavelet, [2..4] the next level, [4..8] the finest, one per depth
+// bin pair.
+struct OitParams {
+    // x, y: the projection's [2][2] and [3][2], which turn a device depth into
+    // a distance along the view axis: y / (depth + x).
+    projection: vec4<f32>,
+}
+@group(2) @binding(0) var<uniform> oit: OitParams;
+@group(2) @binding(1) var oit_bounds: texture_2d<f32>;
+@group(2) @binding(2) var oit_coeff0: texture_2d<f32>;
+@group(2) @binding(3) var oit_coeff1: texture_2d<f32>;
+@group(2) @binding(4) var oit_accumulated: texture_2d<f32>;
+
+const OIT_FULLY_OPAQUE_ALPHA: f32 = 0.99;
+const OIT_FULLY_OPAQUE_TRANSMITTANCE: f32 = 0.02;
+const OIT_BINS: i32 = 8;
+const OIT_LOW_PRECISION_BINS: f32 = 2.0;
+const OIT_HIGH_PRECISION_RANGE: f32 = 10.0;
+const OIT_ALPHA_CUTOUT: f32 = 0.1;
+
+fn oit_linear_depth(device_depth: f32) -> f32 {
+    return oit.projection.y / (device_depth + oit.projection.x);
+}
+fn oit_absorbance(transmittance: f32) -> f32 {
+    return clamp(-log(max(transmittance, 0.0001)), 0.0, 4.0);
+}
+fn oit_transmittance(absorbance: f32) -> f32 {
+    return clamp(exp(-absorbance), 0.0001, 1.0);
+}
+
+// Where a fragment sits in its pixel's depth range, 0 to 1. The last
+// OIT_LOW_PRECISION_BINS bins stretch over whatever is past the first ten
+// blocks, so a thin pane near the eye keeps its resolution in a deep range.
+fn oit_normalize_depth(device_depth: f32, pixel: vec2<f32>) -> f32 {
+    let bounds = textureLoad(oit_bounds, vec2<i32>(pixel), 0);
+    let nearest = -bounds.r;
+    let furthest = bounds.g;
+    let linear = oit_linear_depth(device_depth);
+    let range = max(furthest - nearest, 0.0001);
+    let within = clamp(linear - nearest, 0.0, range);
+    let fine_share = (f32(OIT_BINS) - OIT_LOW_PRECISION_BINS) / f32(OIT_BINS);
+    let fine_range = fine_share * range;
+    if fine_range <= OIT_HIGH_PRECISION_RANGE {
+        return within / range;
+    }
+    if within <= OIT_HIGH_PRECISION_RANGE {
+        return within / OIT_HIGH_PRECISION_RANGE * fine_share;
+    }
+    return fine_share + (within - OIT_HIGH_PRECISION_RANGE)
+        / (range - OIT_HIGH_PRECISION_RANGE) * (1.0 - fine_share);
+}
+
+struct OitCoefficients {
+    @location(0) first: vec4<f32>,
+    @location(1) second: vec4<f32>,
+}
+// One fragment's contribution to the transform (summed by additive blending).
+fn oit_add_transmittance(transmittance: f32, frag_depth: f32, pixel: vec2<f32>) -> OitCoefficients {
+    var c: array<f32, 8>;
+    let absorbance = oit_absorbance(transmittance);
+    let original = oit_normalize_depth(frag_depth, pixel);
+    let depth = original * f32(OIT_BINS - 1) / f32(OIT_BINS);
+    c[0] = absorbance * (1.0 - depth);
+    // The wavelet tree's leaves start at index 8.
+    var tree = i32(floor(original * f32(OIT_BINS - 1))) + OIT_BINS;
+    for (var level = 0; level <= 2; level++) {
+        let power = 2 - level;
+        let parent = tree >> 1u;
+        let index_at_parent = f32(parent & ((1 << u32(power)) - 1));
+        let right = tree & 1;
+        let side = 1 - (right << 1u);
+        let width = exp2(-f32(power));
+        let height = exp2(f32(power) * 0.5);
+        let offset = depth - width * index_at_parent;
+        c[parent] = (f32(right) * width + f32(side) * offset) * height * absorbance;
+        tree = parent;
+    }
+    return OitCoefficients(vec4(c[0], c[1], c[2], c[3]), vec4(c[4], c[5], c[6], c[7]));
+}
+
+// The absorbance in front of `original` (a normalized depth), without the
+// fragment's own contribution `current` that the transform already holds.
+fn oit_sample_absorbance(coefficients: array<f32, 8>, original: f32, current: f32) -> f32 {
+    var c = coefficients;
+    var average = c[0];
+    if average == 0.0 {
+        return 0.0;
+    }
+    let in_bins = original * f32(OIT_BINS - 1);
+    let depth = in_bins / f32(OIT_BINS);
+    average -= current * (1.0 - depth);
+    // B: the bin the fragment is in; A: the one before it.
+    var tree_b = clamp(i32(floor(in_bins)), 0, OIT_BINS - 1);
+    let sample_a_too = tree_b >= 1;
+    var tree_a = select(tree_b, tree_b - 1, sample_a_too);
+    tree_b += OIT_BINS;
+    tree_a += OIT_BINS;
+    var sample_b = average;
+    var sample_a = select(0.0, average, sample_a_too);
+    for (var level = 0; level <= 2; level++) {
+        let power = 2 - level;
+        let width = exp2(-f32(power));
+        let height = exp2(f32(power) * 0.5);
+        let parent_b = tree_b >> 1u;
+        let right_b = tree_b & 1;
+        let side_b = 1 - (right_b << 1u);
+        let index_at_parent = f32(parent_b & ((1 << u32(power)) - 1));
+        let offset = depth - width * index_at_parent;
+        let own = (f32(right_b) * width + f32(side_b) * offset) * height * current;
+        let difference_b = c[parent_b] - own;
+        sample_b -= height * difference_b * f32(side_b);
+        tree_b = parent_b;
+        if sample_a_too {
+            let parent_a = tree_a >> 1u;
+            let difference_a = select(c[parent_a], difference_b, parent_a == parent_b);
+            let side_a = 1 - ((tree_a & 1) << 1u);
+            sample_a -= height * difference_a * f32(side_a);
+            tree_a = parent_a;
+        }
+    }
+    let blend = select(fract(in_bins), 1.0, in_bins >= f32(OIT_BINS));
+    return mix(sample_a, sample_b, blend);
+}
+fn oit_sample_transmittance(pixel: vec2<i32>, depth: f32, current: f32) -> f32 {
+    let a = textureLoad(oit_coeff0, pixel, 0);
+    let b = textureLoad(oit_coeff1, pixel, 0);
+    let c = array<f32, 8>(a.x, a.y, a.z, a.w, b.x, b.y, b.z, b.w);
+    return oit_transmittance(oit_sample_absorbance(c, depth, oit_absorbance(current)));
+}
+
+// The three stages' ends for a pipeline whose fragment colour is computed as
+// it is without improved transparency (vanilla's `executeAlphaOnlyPhase` and
+// `sampleColorForAccumulation`). `color` is the classic result, fogged:
+// weighting a fogged colour equals fogging the weighted one, since the fog
+// is a mix and vanilla premultiplies the fog colour by the same alpha.
+fn oit_bounds_fragment(alpha: f32, clip: vec4<f32>) -> vec4<f32> {
+    if alpha < 0.01 { discard; }
+    let linear = oit_linear_depth(clip.z);
+    let opaque = select(0.0, clip.z, alpha > OIT_FULLY_OPAQUE_ALPHA);
+    return vec4(-linear, linear, clip.z, opaque);
+}
+fn oit_transmittance_fragment(alpha: f32, clip: vec4<f32>) -> OitCoefficients {
+    return oit_add_transmittance(1.0 - alpha, clip.z, clip.xy);
+}
+fn oit_accumulate_fragment(color: vec4<f32>, clip: vec4<f32>) -> vec4<f32> {
+    let seen = oit_sample_transmittance(vec2<i32>(clip.xy),
+        oit_normalize_depth(clip.z, clip.xy), 1.0 - color.a);
+    return vec4(color.rgb * color.a, color.a) * seen;
+}
+// `OIT_ADDITIVE`: no coverage and nothing in the transmittance. The colour
+// is not fogged yet: the fog colour is premultiplied by the alpha, which is
+// zero, so the fog fades it out instead of tinting it.
+fn oit_accumulate_additive(color: vec4<f32>, fog: f32, clip: vec4<f32>) -> vec4<f32> {
+    let seen = oit_sample_transmittance(vec2<i32>(clip.xy),
+        oit_normalize_depth(clip.z, clip.xy), 1.0);
+    return vec4(color.rgb * color.a * (1.0 - fog), 0.0) * seen;
+}

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

@@ -0,0 +1,13 @@
+// Improved transparency's stages for the world border (`OIT_WORLD_BORDER`:
+// `world_border.fsh` with `OIT_ADDITIVE`), appended to border.wgsl after
+// oit.wgsl.
+@fragment fn fs_oit_border_bounds(in: Out) -> @location(0) vec4<f32> {
+    return oit_bounds_fragment(border_color(in).a, in.clip);
+}
+@fragment fn fs_oit_border_transmittance(in: Out) -> OitCoefficients {
+    discard;
+    return OitCoefficients(vec4(0.0), vec4(0.0));
+}
+@fragment fn fs_oit_border_accumulate(in: Out) -> @location(0) vec4<f32> {
+    return oit_accumulate_additive(border_color(in), 0.0, in.clip);
+}

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

@@ -0,0 +1,28 @@
+// Improved transparency's cloud stages (`clouds.fsh` under OIT_*), appended to
+// entity.wgsl after oit.wgsl. The clouds' vertex shader and draw are the
+// classic ones; only the fragment colour goes through the three stages.
+
+// The cloud's colour; it fades out towards the cloud fog end everywhere but in
+// the depth bounds stage, which sees the unfaded alpha.
+fn oit_cloud_color(in: Out, front: bool, fade: bool) -> vec4<f32> {
+    let color = textureSample(atlas, atlas_sampler, in.uv) * select(in.back_color, in.color, front);
+    let faded = 1.0 - linear_fog(in.spherical, 0.0, globals.fog_ends.y);
+    return vec4(color.rgb, color.a * select(1.0, faded, fade));
+}
+@fragment fn fs_oit_cloud_bounds(in: Out, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {
+    let color = oit_cloud_color(in, front, false);
+    if color.a < 0.01 { discard; }
+    let linear = oit_linear_depth(in.clip.z);
+    let opaque = select(0.0, in.clip.z, color.a > OIT_FULLY_OPAQUE_ALPHA);
+    return vec4(-linear, linear, in.clip.z, opaque);
+}
+@fragment fn fs_oit_cloud_transmittance(in: Out, @builtin(front_facing) front: bool) -> OitCoefficients {
+    let color = oit_cloud_color(in, front, true);
+    return oit_add_transmittance(1.0 - color.a, in.clip.z, in.clip.xy);
+}
+@fragment fn fs_oit_cloud_accumulate(in: Out, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {
+    let color = oit_cloud_color(in, front, true);
+    let seen = oit_sample_transmittance(vec2<i32>(in.clip.xy),
+        oit_normalize_depth(in.clip.z, in.clip.xy), 1.0 - color.a);
+    return vec4(color.rgb * color.a, color.a) * seen;
+}

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

@@ -0,0 +1,61 @@
+// Improved transparency's stages for what the entity shader draws after the
+// opaque world (`LevelRenderer.executeOit`'s "Features, World Border,
+// Weather" pass), appended to entity.wgsl after oit.wgsl. The colour of each
+// is the classic fragment's, so the shaders cannot drift apart.
+
+// Items, particles, text, breaking cracks (`RenderPipelines.OIT_ENTITY` and
+// the others on entity.fsh).
+@fragment fn fs_oit_entity_bounds(in: Out, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {
+    return oit_bounds_fragment(entity_color(in, front).a, in.clip);
+}
+@fragment fn fs_oit_entity_transmittance(in: Out, @builtin(front_facing) front: bool) -> OitCoefficients {
+    return oit_transmittance_fragment(entity_color(in, front).a, in.clip);
+}
+@fragment fn fs_oit_entity_accumulate(in: Out, @builtin(front_facing) front: bool) -> @location(0) vec4<f32> {
+    return oit_accumulate_fragment(entity_color(in, front), in.clip);
+}
+// `OIT_ENTITY_SHADOW`.
+@fragment fn fs_oit_shadow_bounds(in: Out) -> @location(0) vec4<f32> {
+    return oit_bounds_fragment(shadow_color(in).a, in.clip);
+}
+@fragment fn fs_oit_shadow_transmittance(in: Out) -> OitCoefficients {
+    return oit_transmittance_fragment(shadow_color(in).a, in.clip);
+}
+@fragment fn fs_oit_shadow_accumulate(in: Out) -> @location(0) vec4<f32> {
+    return oit_accumulate_fragment(shadow_color(in), in.clip);
+}
+// `OIT_WEATHER` (the particle shader).
+@fragment fn fs_oit_weather_bounds(in: Out) -> @location(0) vec4<f32> {
+    return oit_bounds_fragment(weather_color(in).a, in.clip);
+}
+@fragment fn fs_oit_weather_transmittance(in: Out) -> OitCoefficients {
+    return oit_transmittance_fragment(weather_color(in).a, in.clip);
+}
+@fragment fn fs_oit_weather_accumulate(in: Out) -> @location(0) vec4<f32> {
+    return oit_accumulate_fragment(weather_color(in), in.clip);
+}
+// `OIT_ENERGY_SWIRL`: entity.fsh with `OIT_ADDITIVE`, which caps the alpha.
+@fragment fn fs_oit_swirl_bounds(in: Out) -> @location(0) vec4<f32> {
+    return oit_bounds_fragment(min(0.99, energy_swirl_base(in).a), in.clip);
+}
+@fragment fn fs_oit_swirl_transmittance(in: Out) -> OitCoefficients {
+    discard;
+    return OitCoefficients(vec4(0.0), vec4(0.0));
+}
+@fragment fn fs_oit_swirl_accumulate(in: Out) -> @location(0) vec4<f32> {
+    let color = energy_swirl_base(in);
+    return oit_accumulate_additive(vec4(color.rgb, min(0.99, color.a)), energy_swirl_fog(in), in.clip);
+}
+// `OIT_LIGHTNING` and `OIT_DRAGON_RAYS`: additive (`OIT_ADDITIVE`), the
+// classic fragment's colour (fs_celestial) with the alpha capped.
+@fragment fn fs_oit_lightning_bounds(in: Out) -> @location(0) vec4<f32> {
+    return oit_bounds_fragment(min(0.99, celestial_color(in).a), in.clip);
+}
+@fragment fn fs_oit_lightning_transmittance(in: Out) -> OitCoefficients {
+    discard;
+    return OitCoefficients(vec4(0.0), vec4(0.0));
+}
+@fragment fn fs_oit_lightning_accumulate(in: Out) -> @location(0) vec4<f32> {
+    let color = celestial_color(in);
+    return oit_accumulate_additive(vec4(color.rgb, min(0.99, color.a)), 0.0, in.clip);
+}

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

@@ -0,0 +1,57 @@
+// Improved transparency's terrain stages and its screen passes (oit.wgsl
+// has the shared maths), appended to terrain.wgsl after oit.wgsl.
+// The terrain's translucent layer, once per stage.
+fn oit_terrain_color(in: TerrainOut) -> vec4<f32> {
+    var color = sprite(in.uv, in.layer & 0x7fffu) * in.color;
+    color = mix(globals.fog_color * vec4(1.0, 1.0, 1.0, color.a), color, in.visibility);
+    if color.a < OIT_ALPHA_CUTOUT { discard; }
+    return color;
+}
+// Stage 1: (-nearest, furthest, nearest device depth, nearest opaque device
+// depth), combined by max blending.
+@fragment fn fs_oit_bounds(in: TerrainOut) -> @location(0) vec4<f32> {
+    let color = oit_terrain_color(in);
+    let linear = oit_linear_depth(in.clip.z);
+    let opaque = select(0.0, in.clip.z, color.a > OIT_FULLY_OPAQUE_ALPHA);
+    return vec4(-linear, linear, in.clip.z, opaque);
+}
+// Stage 2.
+@fragment fn fs_oit_transmittance(in: TerrainOut) -> OitCoefficients {
+    let color = oit_terrain_color(in);
+    return oit_add_transmittance(1.0 - color.a, in.clip.z, in.clip.xy);
+}
+// Stage 3: premultiplied colour, weighted by the transmittance in front.
+@fragment fn fs_oit_accumulate(in: TerrainOut) -> @location(0) vec4<f32> {
+    let color = oit_terrain_color(in);
+    let seen = oit_sample_transmittance(vec2<i32>(in.clip.xy),
+        oit_normalize_depth(in.clip.z, in.clip.xy), 1.0 - color.a);
+    let weighted = vec4(color.rgb * color.a, color.a) * seen;
+    let f = max(linear_fog(in.spherical, globals.fog.x, globals.fog.y),
+                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
+    // The fog colour is premultiplied by the same weight.
+    let rgb = mix(weighted.rgb, globals.fog_color.rgb * weighted.a, f * globals.fog_color.a);
+    return vec4(rgb, weighted.a);
+}
+
+struct OitFragment {
+    @location(0) color: vec4<f32>,
+    @builtin(frag_depth) depth: f32,
+}
+// After the bounds stage: a fully opaque fragment hides what is behind it, so
+// the far bound stops there and its depth goes into the depth buffer.
+@fragment fn fs_oit_cull(@builtin(position) pos: vec4<f32>) -> OitFragment {
+    let b = textureLoad(oit_bounds, vec2<i32>(pos.xy), 0);
+    let opaque = oit_linear_depth(b.a);
+    return OitFragment(vec4(b.r, min(b.g, opaque), b.b, b.a), b.a);
+}
+// The sum over the world, renormalized to the coverage the transform gives.
+@fragment fn fs_oit_composite(@builtin(position) pos: vec4<f32>) -> OitFragment {
+    let p = vec2<i32>(pos.xy);
+    let accumulated = textureLoad(oit_accumulated, p, 0);
+    let seen = oit_sample_transmittance(p, 100000.0, 1.0);
+    let coverage = 1.0 - select(seen, 0.0, seen < OIT_FULLY_OPAQUE_TRANSMITTANCE);
+    // Additive surfaces add light but no coverage.
+    if coverage < 0.00001 && dot(accumulated.rgb, vec3(1.0)) < 0.00001 { discard; }
+    let scale = select(1.0, coverage / accumulated.a, accumulated.a > 0.00001);
+    return OitFragment(vec4(accumulated.rgb * scale, coverage), textureLoad(oit_bounds, p, 0).b);
+}

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

@@ -128,7 +128,6 @@ impl Opt {
                 | Opt::HideMatchedNames
                 | Opt::OnlySecureChat
                 | Opt::SaveChatDrafts
-                | Opt::MonochromeLogo
                 | Opt::RotateWithMinecarts
                 // Saved, but no Horizon system reads them yet: no Realms, no
                 // friends list, no directional audio, no now-playing toast.
@@ -141,9 +140,6 @@ impl Opt {
                 | Opt::ChunkFade
                 | Opt::ImprovedTransparency
                 | Opt::ChunkBuilder
-                // Saved, but the terrain sampler has no RGSS or anisotropic filtering yet.
-                | Opt::TextureFiltering
-                | Opt::MaxAnisotropy
                 // Saved, but the mouse doesn't read it yet.
                 | Opt::CtrlClickEmulatesRightClick
         )
@@ -876,6 +872,7 @@ impl Opt {
             | Opt::HideLightningFlashes
             | Opt::HideSplashTexts
             | Opt::HighContrastBlockOutlines
+            | Opt::MonochromeLogo
             | Opt::HideMatchedNames
             | Opt::OnlySecureChat
             | Opt::SaveChatDrafts
@@ -1352,6 +1349,9 @@ pub struct OptionsUi {
     pub resource_error: Option<String>,
     /// When the pack screen's search box took the focus (its cursor blink).
     pack_focus: Instant,
+    /// The selection carried over from a pack screen made again over a changed pack list
+    /// (`update_pack_infos`) differs from the settings'.
+    pack_reselected: bool,
     pub in_world: bool,
     /// Scroll the selected language into the middle on the next layout.
     center_language: bool,
@@ -1387,6 +1387,7 @@ impl Default for OptionsUi {
             data_pack_stamp: (Vec::new(), Instant::now()),
             resource_error: None,
             pack_focus: Instant::now(),
+            pack_reselected: false,
             in_world: false,
             center_language: false,
             graphics: Default::default(),
@@ -1418,6 +1419,10 @@ fn option_widget(s: &Settings, opt: Opt, x: f32, y: f32, w: f32) -> Widget {
     if !opt.available() {
         return inactive(button(x, y, w, opt.label(s), Act::Cycle(opt)));
     }
+    // VideoSettingsScreen.tick: Max Anisotropy only works with Anisotropic filtering.
+    if opt == Opt::MaxAnisotropy && s.file.int("textureFiltering") != 2 {
+        return inactive(button(x, y, w, opt.label(s), Act::Cycle(opt)));
+    }
     match opt.kind(s) {
         Kind::Slider(v) => Widget {
             x,
@@ -1472,6 +1477,23 @@ impl OptionsUi {
         self.settings_search.focused
             && matches!(self.page(), Page::Video | Page::Controls | Page::KeyBinds)
     }
+    /// Whether the resource pack screen is open (not Create World's data packs on the same
+    /// page).
+    pub fn resource_packs_open(&self) -> bool {
+        self.page() == Page::Packs && self.data_pack_dir.is_none()
+    }
+    /// The packs in `resourcepacks/` changed while the pack screen is open
+    /// (`PackSelectionScreen`'s directory watcher): the screen is made again over
+    /// `infos`, keeping the selection made on it so far.
+    pub fn update_pack_infos(&mut self, infos: Vec<crate::pack_screen::PackInfo>) {
+        if let Some(p) = self.pack_screen.take()
+            && p.changed
+        {
+            self.pack_selection = p.commit();
+            self.pack_reselected = true;
+        }
+        self.pack_infos = infos;
+    }
     pub fn page(&self) -> Page {
         *self.stack.last().unwrap_or(&Page::Main)
     }
@@ -1966,7 +1988,9 @@ impl OptionsUi {
                     .map(|(i, installed)| {
                         let mut label = Text::literal(format!("{}: ", installed.title))
                             .append(on_off(s.mods.is_on(i)));
-                        if installed.problem.is_some() {
+                        if installed.problem.as_deref() == Some(crate::mod_list::NOT_BUILT) {
+                            label = label.append(tr("horizon.mods.not_built"));
+                        } else if installed.problem.is_some() {
                             label = label.append(tr("horizon.mods.stopped"));
                         } else if installed.dev {
                             label = label.append(tr("horizon.mods.dev"));
@@ -2588,6 +2612,7 @@ impl OptionsUi {
             return;
         }
         if let Some(level) = Self::graphics_level(self.page()) {
+            self.graphics.binding = self.selected_key;
             self.graphics
                 .draw(level, s, batch, atlas, cursor, self.in_world);
             return;
@@ -2847,6 +2872,15 @@ impl OptionsUi {
         }
         if let Some(level) = Self::graphics_level(self.page()) {
             use crate::graphics_ui::Action;
+            // Waiting on a key: a mouse button binds, as on Key Binds.
+            if self.selected_key.is_some() && !drag {
+                let button = if right {
+                    winit::event::MouseButton::Right
+                } else {
+                    winit::event::MouseButton::Left
+                };
+                return self.bind_mouse(s, button);
+            }
             let mut events = Vec::new();
             for action in self
                 .graphics
@@ -2858,6 +2892,7 @@ impl OptionsUi {
                     Action::SliderDrag => events.push(Event::SliderDrag),
                     Action::OpenAdvanced => self.push(Page::GraphicsAdvanced),
                     Action::OpenHdr => self.push(Page::GraphicsHdr),
+                    Action::BindKey(name) => self.selected_key = Some(name),
                     Action::OpenSimple => {
                         if self.stack.len() >= 2
                             && self.stack[self.stack.len() - 2] == Page::Graphics
@@ -3226,7 +3261,7 @@ impl OptionsUi {
                 } else {
                     "resourcePack.title"
                 };
-                self.pack_screen = Some(crate::pack_screen::PackScreen::new(
+                let mut screen = crate::pack_screen::PackScreen::new(
                     &m,
                     crate::text::Text::translate(title, &[]),
                     w,
@@ -3234,7 +3269,9 @@ impl OptionsUi {
                     self.in_world,
                     self.pack_infos.clone(),
                     &self.pack_selection,
-                ));
+                );
+                screen.changed = std::mem::take(&mut self.pack_reselected);
+                self.pack_screen = Some(screen);
             }
         }
         self.pack_screen.as_mut().expect("made above")
@@ -3348,7 +3385,7 @@ impl OptionsUi {
             keys.insert(key.clone(), value);
             return vec![Event::Changed];
         }
-        if !s.extras.set_key(name, value.clone()) {
+        if !s.extras.set_key(name, value.clone()) && !s.horizon.set_key(name, value.clone()) {
             s.keys.set(name, &value);
         }
         vec![Event::Changed]
@@ -3465,10 +3502,12 @@ mod tests {
                 assert_eq!(loaded.file.double(opt.file_key().unwrap()), expected);
             }
         }
+        assert!(Opt::MonochromeLogo.available());
         for opt in [
             Opt::TextBackground,
             Opt::HideLightningFlashes,
             Opt::HideSplashTexts,
+            Opt::MonochromeLogo,
         ] {
             let key = opt.file_key().unwrap();
             let before = s.file.bool(key);
@@ -4024,9 +4063,21 @@ mod tests {
             assert_eq!(s.file.int("maxAnisotropyBit"), bit, "{preset}");
             assert_eq!(s.file.int("textureFiltering"), filtering, "{preset}");
         }
-        // Nothing samples the terrain atlas with them yet, so the buttons stay greyed out.
-        assert!(!Opt::TextureFiltering.available());
-        assert!(!Opt::MaxAnisotropy.available());
+        assert!(Opt::TextureFiltering.available());
+        assert!(Opt::MaxAnisotropy.available());
+        // The anisotropy slider only works with Anisotropic filtering (VideoSettingsScreen.tick).
+        let grey = |s: &Settings| {
+            matches!(
+                option_widget(s, Opt::MaxAnisotropy, 0.0, 0.0, 150.0).kind,
+                WKind::Button { active: false, .. }
+            )
+        };
+        s.file
+            .set("textureFiltering", crate::options_file::V::Int(1));
+        assert!(grey(&s));
+        s.file
+            .set("textureFiltering", crate::options_file::V::Int(2));
+        assert!(!grey(&s));
     }
 
     #[test]
@@ -4928,7 +4979,7 @@ mod tests {
             MouseButton::Back,
             MouseButton::Forward,
         ] {
-            for name in [SORT_KEY, "key.jump"] {
+            for name in [SORT_KEY, crate::graphics::HDR_KEY, "key.jump"] {
                 let mut ui = OptionsUi::default();
                 let mut s = Settings::default();
                 ui.selected_key = Some(name);
@@ -4937,6 +4988,7 @@ mod tests {
                 let value = keybinds::mouse_name(button);
                 match name {
                     SORT_KEY => assert_eq!(s.extras.sort_key, value),
+                    crate::graphics::HDR_KEY => assert_eq!(s.horizon.hdr_key, value),
                     _ => assert_eq!(s.keys.get(name), value),
                 }
                 assert_eq!(Extras::parse(&s.extras.serialize()), s.extras);

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

@@ -414,6 +414,13 @@ fn overlays_of(meta: &serde_json::Value) -> Vec<String> {
         .flatten()
         .filter(|e| overlay_applies(e))
         .filter_map(|e| e["directory"].as_str().map(str::to_owned))
+        // OverlayMetadataSection's DIR_VALIDATOR: one folder of the pack, `[-_a-zA-Z0-9.]+`.
+        .filter(|d| {
+            stays_inside(d)
+                && !d.contains('/')
+                && d.bytes()
+                    .all(|b| b.is_ascii_alphanumeric() || b"-_.".contains(&b))
+        })
         .collect()
 }
 fn filter_of(meta: &serde_json::Value) -> Vec<Filter> {
@@ -539,7 +546,7 @@ fn pack_files(pack: &Pack) -> io::Result<BTreeMap<String, Provided>> {
             let zip = Zip::open(z)?;
             for root in &roots {
                 let prefix = format!("{root}assets/");
-                for name in zip.names() {
+                for name in zip.names().filter(|name| stays_inside(name)) {
                     if let Some(rest) = name.strip_prefix(&prefix) {
                         out.insert(format!("assets/{rest}"), (None, name.to_owned()));
                     }
@@ -549,6 +556,15 @@ fn pack_files(pack: &Pack) -> io::Result<BTreeMap<String, Provided>> {
     }
     Ok(out)
 }
+/// Whether a zip entry's name, joined to the overlay folder, stays in it: `/`-separated parts
+/// (zip.rs turns `\` into `/`), none empty, `.` or `..`, and no `:` (a drive or a stream on
+/// Windows). A pack, a server's too, may name entries anything.
+fn stays_inside(name: &str) -> bool {
+    !name.contains([':', '\0'])
+        && name
+            .split('/')
+            .all(|part| !part.is_empty() && part != "." && part != "..")
+}
 #[cfg(unix)]
 fn link(target: &Path, at: &Path) -> io::Result<()> {
     // Relative sources are relative to the process, not the overlay directory.
@@ -566,31 +582,11 @@ fn link(target: &Path, at: &Path) -> io::Result<()> {
         fs::hard_link(target, at).or_else(|_| fs::copy(target, at).map(|_| ()))
     }
 }
-/// A directory junction, which Windows creates without privileges (a directory symlink needs
-/// developer mode). The mirror falls back to copying the tree when it fails.
+/// A directory junction (`horizon_threads::junction`); the mirror falls back to copying the
+/// tree when it fails.
 #[cfg(windows)]
 fn junction(target: &Path, at: &Path) -> io::Result<()> {
-    use std::os::windows::process::CommandExt;
-    // cmd parses its own line: Rust quotes only paths with spaces, so `&` or `^` in an
-    // unquoted path would split or change the command. A Windows path cannot hold `"`.
-    let quoted = |path: &Path| -> io::Result<std::ffi::OsString> {
-        let mut quoted = std::ffi::OsString::from("\"");
-        quoted.push(std::path::absolute(path)?);
-        quoted.push("\"");
-        Ok(quoted)
-    };
-    let status = std::process::Command::new("cmd")
-        .args(["/C", "mklink", "/J"])
-        .raw_arg(quoted(at)?)
-        .raw_arg(quoted(target)?)
-        .creation_flags(0x0800_0000) // CREATE_NO_WINDOW
-        .stdout(std::process::Stdio::null())
-        .stderr(std::process::Stdio::null())
-        .status()?;
-    status
-        .success()
-        .then_some(())
-        .ok_or_else(|| io::Error::other("mklink /J failed"))
+    horizon_threads::junction(target, at)
 }
 #[cfg(not(windows))]
 fn junction(_: &Path, _: &Path) -> io::Result<()> {
@@ -1422,6 +1418,56 @@ mod tests {
         let _ = fs::remove_dir_all(base);
     }
     #[test]
+    fn zip_entries_never_leave_the_overlay() {
+        use std::io::Write as _;
+        let base = std::env::temp_dir().join(format!("horizon-pack-escape-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&base);
+        let vanilla = base.join("vanilla");
+        fs::create_dir_all(vanilla.join("assets/minecraft/textures/block")).unwrap();
+        fs::write(
+            vanilla.join("assets/minecraft/textures/block/stone.png"),
+            b"vanilla",
+        )
+        .unwrap();
+        fs::create_dir_all(base.join("packs")).unwrap();
+        let mut zip = zip::ZipWriter::new(fs::File::create(base.join("packs/evil.zip")).unwrap());
+        for (name, data) in [
+            (
+                "pack.mcmeta",
+                &br#"{"pack":{"description":"d","pack_format":97}}"#[..],
+            ),
+            ("assets/minecraft/textures/block/stone.png", b"pack"),
+            ("assets/../../escaped.txt", b"out"),
+            ("assets/minecraft/../../../escaped_lang.json", b"{}"),
+            ("assets\\..\\..\\escaped_backslash.txt", b"out"),
+            ("assets/./minecraft/dot.txt", b"in"),
+        ] {
+            zip.start_file(name, zip::write::SimpleFileOptions::default())
+                .unwrap();
+            zip.write_all(data).unwrap();
+        }
+        zip.finish().unwrap();
+        let packs = discover(&vanilla, &base.join("packs"));
+        assert_eq!(packs.len(), 1);
+        let out = base.join("work/overlay");
+        build_overlay(&vanilla, &packs, &out).unwrap();
+        assert_eq!(
+            fs::read(out.join("assets/minecraft/textures/block/stone.png")).unwrap(),
+            b"pack"
+        );
+        for escaped in [
+            "escaped.txt",
+            "escaped_lang.json",
+            "escaped_backslash.txt",
+            "work/escaped.txt",
+            "work/escaped_lang.json",
+            "work/escaped_backslash.txt",
+        ] {
+            assert!(!base.join(escaped).exists(), "{escaped} was written");
+        }
+        let _ = fs::remove_dir_all(base);
+    }
+    #[test]
     fn built_in_and_folder_packs_give_their_pack_png() {
         use std::io::Write as _;
         let base = std::env::temp_dir().join(format!("horizon-pack-icons-{}", std::process::id()));
@@ -1469,6 +1515,15 @@ mod tests {
             {"min_format":97,"max_format":[97,5],"directory":"also"},
             {"formats":50,"directory":"no"}]}}"#);
         assert_eq!(overlays_of(&meta), ["new", "also"]);
+        // Only one plain folder of the pack, as vanilla's DIR_VALIDATOR has it.
+        let meta = v(r#"{"overlays":{"entries":[
+            {"formats":97,"directory":".."},
+            {"formats":97,"directory":"../outside"},
+            {"formats":97,"directory":"/etc"},
+            {"formats":97,"directory":"a/b"},
+            {"formats":97,"directory":"C:"},
+            {"formats":97,"directory":"ok_1.21-x"}]}}"#);
+        assert_eq!(overlays_of(&meta), ["ok_1.21-x"]);
         let base = std::env::temp_dir().join(format!("horizon-packs-ov-{}", std::process::id()));
         let _ = fs::remove_dir_all(&base);
         let vanilla = base.join("vanilla");

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

@@ -9,7 +9,9 @@ use std::{collections::BTreeSet, fs, io, path::Path, path::PathBuf};
 // Bump when overlay/merge semantics change. Markers are disposable cache data.
 // Version 4 mirrored every untouched directory file by file on Windows.
 // Version 3 could omit untouched vanilla directories on Windows (#1649, #1688).
-const VERSION: u32 = 5;
+// Version 5 read every vanilla file to stamp it on Windows.
+// Version 6 stamps vanilla's files by their metadata on Windows too.
+const VERSION: u32 = 6;
 
 #[derive(Default, Serialize, Deserialize)]
 pub(super) struct Dependencies {
@@ -18,13 +20,16 @@ pub(super) struct Dependencies {
     failed: bool,
     #[serde(skip)]
     tracking: bool,
+    /// The vanilla root (absolute): its files are stamped without reading them.
+    #[serde(skip)]
+    vanilla: PathBuf,
 }
 impl Dependencies {
     fn record(&mut self, path: &Path, directory: bool) {
         if !self.tracking {
             return;
         }
-        match dependency_signature(path, directory) {
+        match dependency_signature(path, directory, &self.vanilla) {
             Ok(signature) => self.entries.push((path.into(), directory, signature)),
             Err(_) => self.failed = true,
         }
@@ -38,7 +43,7 @@ impl Dependencies {
     fn valid(&self) -> bool {
         !self.failed
             && self.entries.iter().all(|(path, directory, signature)| {
-                dependency_signature(path, *directory).is_ok_and(|s| s == *signature)
+                dependency_signature(path, *directory, &self.vanilla).is_ok_and(|s| s == *signature)
             })
     }
 }
@@ -72,13 +77,16 @@ fn content(hash: &mut Sha256, path: &Path) -> io::Result<()> {
     }
     Ok(())
 }
-fn stamp(hash: &mut Sha256, path: &Path) -> io::Result<()> {
+/// `path`'s stamp; `read` lets platforms without a change timestamp hash a file's bytes.
+fn stamp(hash: &mut Sha256, path: &Path, read: bool) -> io::Result<()> {
     let meta = fs::metadata(path)?;
     hash.update(meta.len().to_le_bytes());
     field(hash, format!("{:?}", meta.modified()?).as_bytes());
     #[cfg(unix)]
     {
         use std::os::unix::fs::MetadataExt;
+        // The change time stands in for the bytes here.
+        let _ = read;
         hash.update(meta.dev().to_le_bytes());
         hash.update(meta.ino().to_le_bytes());
         hash.update(meta.ctime().to_le_bytes());
@@ -87,8 +95,11 @@ fn stamp(hash: &mut Sha256, path: &Path) -> io::Result<()> {
     #[cfg(not(unix))]
     {
         // Portable metadata lacks a change timestamp. Preserve content-based
-        // validation for materialized files on those platforms.
-        if meta.is_file() {
+        // validation for the packs' materialized files on those platforms;
+        // vanilla's (the launcher's, tens of thousands) keep to the size and
+        // the write and creation times: reading each costs minutes on Windows,
+        // where every open is scanned by the antivirus.
+        if read && meta.is_file() {
             return content(hash, path);
         }
         if let Ok(created) = meta.created() {
@@ -104,17 +115,18 @@ fn entries(path: &Path) -> io::Result<Vec<PathBuf>> {
     entries.sort();
     Ok(entries)
 }
-fn dependency_signature(path: &Path, directory: bool) -> io::Result<String> {
+fn dependency_signature(path: &Path, directory: bool, vanilla: &Path) -> io::Result<String> {
     let mut hash = Sha256::new();
+    let read = !(path.starts_with(vanilla) || absolute(path).is_ok_and(|p| p.starts_with(vanilla)));
     match fs::metadata(path) {
         Err(e) if e.kind() == io::ErrorKind::NotFound => field(&mut hash, b"missing"),
         Err(e) => return Err(e),
         Ok(meta) if directory && meta.is_dir() => {
             field(&mut hash, b"directory");
-            stamp(&mut hash, path)?;
+            stamp(&mut hash, path, read)?;
         }
         Ok(_) if directory => field(&mut hash, b"not-directory"),
-        Ok(_) => stamp(&mut hash, path)?,
+        Ok(_) => stamp(&mut hash, path, read)?,
     }
     Ok(finish(hash))
 }
@@ -190,7 +202,7 @@ fn tree_inner(
             if pack.is_none() {
                 return content(hash, path);
             }
-            stamp(hash, path)?;
+            stamp(hash, path, true)?;
         }
     }
     Ok(())
@@ -283,11 +295,14 @@ pub(super) fn build(vanilla: &Path, packs: &[Pack], out: &Path) -> io::Result<()
     let signature = pack_signature(packs);
     if let Ok(signature) = &signature
         && let Ok(bytes) = fs::read(&marker_path)
-        && let Ok(marker) = serde_json::from_slice::<Marker>(&bytes)
+        && let Ok(mut marker) = serde_json::from_slice::<Marker>(&bytes)
         && marker.version == VERSION
         && marker.vanilla == vanilla_key
         && marker.packs == *signature
-        && marker.dependencies.valid()
+        && {
+            marker.dependencies.vanilla = vanilla_key.clone();
+            marker.dependencies.valid()
+        }
         && out.is_dir()
     {
         return Ok(());
@@ -300,6 +315,7 @@ pub(super) fn build(vanilla: &Path, packs: &[Pack], out: &Path) -> io::Result<()
     }
     let mut dependencies = Dependencies {
         tracking: signature.is_ok(),
+        vanilla: vanilla_key.clone(),
         ..Dependencies::default()
     };
     build_overlay_uncached(vanilla, packs, out, &mut dependencies)?;

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

@@ -1064,8 +1064,9 @@ pub struct ParticleEngine {
     pub particle_level: u8,
     /// FireworkParticles.Starter instances.
     starters: Vec<Starter>,
-    /// Local sounds requested by particles (dripstone drips): (event, position, volume, pitch).
-    pub sounds: Vec<(&'static str, [f64; 3], f32, f32)>,
+    /// Local sounds requested by particles (dripstone drips, firework bursts):
+    /// (event, position, volume, pitch, distanceDelay).
+    pub sounds: Vec<(&'static str, [f64; 3], f32, f32, bool)>,
     /// How many of each type were made, for `horizon-ctl status`.
     made: std::collections::BTreeMap<&'static str, u64>,
     /// The item particles' sprites (`BreakingItemParticle`'s slime ball, snowball
@@ -3059,7 +3060,7 @@ impl ParticleEngine {
                     (false, false) => "minecraft:entity.firework_rocket.blast",
                 };
                 let pitch = 0.95 + self.random.next_float() * 0.1;
-                self.sounds.push((sound, s.at, 20.0, pitch));
+                self.sounds.push((sound, s.at, 20.0, pitch, true));
             }
             if s.life % 2 == 0 && ((s.life / 2) as usize) < s.explosions.len() {
                 let e = s.explosions[(s.life / 2) as usize].clone();
@@ -3110,7 +3111,7 @@ impl ParticleEngine {
                         "minecraft:entity.firework_rocket.twinkle"
                     };
                     let pitch = 0.9 + self.random.next_float() * 0.15;
-                    self.sounds.push((sound, s.at, 20.0, pitch));
+                    self.sounds.push((sound, s.at, 20.0, pitch, true));
                 }
                 continue;
             }
@@ -3305,7 +3306,7 @@ impl ParticleEngine {
                         }
                         if let Some(sound) = sound {
                             let volume = p.random.next_float() * 0.7 + 0.3;
-                            self.sounds.push((sound, p.position, volume, 1.0));
+                            self.sounds.push((sound, p.position, volume, 1.0, false));
                         }
                     }
                     _ => {}

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

@@ -1,8 +1,9 @@
 // The built-in stand-ins for the vanilla post shaders a `post_effect` chain can
 // name (`core/screenquad`, `post/rotscale`, `post/invert`, `post/blit`,
 // `post/bits`, `post/color_convolve`, `post/box_blur`, `post/spiderclip`).
-// Coordinates stay in the chain's own convention (v up from the bottom edge) and
-// are flipped only where a texture is read.
+// Targets keep GL's rows (row 0 is the bottom edge): the passes draw with clip y
+// negated (`vs_quad_gl`, `vs_rotscale`) and read their textures as they are;
+// `vs_quad` with `fs_blit` is the flip between the frame and a chain's `main`.
 
 // OutSize, InSize | BlurSize, menu blur radius.
 @group(0) @binding(0) var<uniform> info: array<vec4<f32>, 2>;
@@ -27,10 +28,10 @@ fn fcf(i: u32) -> f32 {
     return fs_cfg[i / 4u][i % 4u];
 }
 fn read_in(uv: vec2<f32>) -> vec4<f32> {
-    return textureSampleLevel(in_tex, in_smp, vec2(uv.x, 1.0 - uv.y), 0.0);
+    return textureSampleLevel(in_tex, in_smp, uv, 0.0);
 }
 fn read_blur(uv: vec2<f32>) -> vec4<f32> {
-    return textureSampleLevel(blur_tex, blur_smp, vec2(uv.x, 1.0 - uv.y), 0.0);
+    return textureSampleLevel(blur_tex, blur_smp, uv, 0.0);
 }
 
 fn corner(i: u32) -> vec2<f32> {
@@ -46,10 +47,19 @@ fn corner(i: u32) -> vec2<f32> {
     return out;
 }
 
+@vertex fn vs_quad_gl(@builtin(vertex_index) i: u32) -> Out {
+    let p = corner(i);
+    var out: Out;
+    out.clip = vec4(p.x * 2.0 - 1.0, 1.0 - p.y * 2.0, 0.0, 1.0);
+    out.uv = p;
+    out.scaled = p;
+    return out;
+}
+
 @vertex fn vs_rotscale(@builtin(vertex_index) i: u32) -> Out {
     let p = corner(i);
     var out: Out;
-    out.clip = vec4(p * 2.0 - 1.0, 0.0, 1.0);
+    out.clip = vec4(p.x * 2.0 - 1.0, 1.0 - p.y * 2.0, 0.0, 1.0);
     out.uv = p;
     let radians = vcf(4u) * 0.0174532925;
     let c = cos(radians);

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

@@ -0,0 +1,316 @@
+//! Vanilla's post-processing GLSL (`#version 330` with `layout(std140)` uniform blocks
+//! and `uniform sampler2D`s, Vulkan-style `gl_VertexIndex`) turned into naga modules at
+//! run time, from whichever resource root is active, the way Horizon's shader packs turn
+//! their GLSL into naga (`horizon-shaders`' translator, which handles the compatibility
+//! dialect; the post shaders need only the block and sampler binding rewrite below).
+//!
+//! `ShaderManager`/`GlslPreprocessor` read `assets/<ns>/shaders/<path>.{vsh,fsh}` and
+//! resolve `#include <ns:path>` to `assets/<ns>/shaders/include/<path>`.
+//!
+//! The rewrite gives every uniform block a binding of bind group 0, shared by both
+//! stages, and splits each `uniform sampler2D NameSampler;` into a texture and a sampler
+//! object at the next two bindings, `NameSampler` becoming the combined
+//! `sampler2D(texture, sampler)` again where it is used. The vertex stage's `main` is
+//! wrapped so that clip y is negated: targets keep GL's rows (row 0 is the bottom edge),
+//! so `texCoord` reads the texel it would in vanilla.
+use naga::ShaderStage;
+use naga::front::glsl::{Frontend, Options};
+use naga::valid::{Capabilities, ValidationFlags, Validator};
+use std::path::Path;
+
+/// One program, ready for wgpu.
+pub struct Program {
+    pub vertex: naga::Module,
+    pub fragment: naga::Module,
+    /// Every uniform block either stage declares, with its binding.
+    pub blocks: Vec<(String, u32)>,
+    /// Every sampler (`NameSampler`): the texture's binding; the sampler object is the next.
+    pub samplers: Vec<(String, u32)>,
+}
+
+fn is_ident(c: u8) -> bool {
+    c.is_ascii_alphanumeric() || c == b'_'
+}
+
+/// The source with its comments blanked (same length, so offsets stay valid).
+fn blank_comments(src: &str) -> String {
+    let b = src.as_bytes();
+    let mut out = b.to_vec();
+    let mut i = 0;
+    while i < b.len() {
+        if b[i] == b'/' && b.get(i + 1) == Some(&b'/') {
+            while i < b.len() && b[i] != b'\n' {
+                out[i] = b' ';
+                i += 1;
+            }
+        } else if b[i] == b'/' && b.get(i + 1) == Some(&b'*') {
+            while i < b.len() && !(b[i] == b'*' && b.get(i + 1) == Some(&b'/')) {
+                if b[i] != b'\n' {
+                    out[i] = b' ';
+                }
+                i += 1;
+            }
+            for slot in out.iter_mut().take((i + 2).min(b.len())).skip(i) {
+                *slot = b' ';
+            }
+            i += 2;
+        } else {
+            i += 1;
+        }
+    }
+    String::from_utf8(out).unwrap_or_default()
+}
+
+/// `GlslPreprocessor`'s `#include <ns:path>`.
+fn read_source(root: &Path, id: &str, ext: &str) -> Result<String, String> {
+    let (ns, path) = id.split_once(':').unwrap_or(("minecraft", id));
+    let file = root
+        .join("assets")
+        .join(ns)
+        .join("shaders")
+        .join(format!("{path}.{ext}"));
+    std::fs::read_to_string(&file).map_err(|e| format!("{}: {e}", file.display()))
+}
+
+fn include(root: &Path, src: &str, depth: u32) -> Result<String, String> {
+    if depth > 8 {
+        return Err("#include nested too deep".into());
+    }
+    let mut out = String::new();
+    for line in src.lines() {
+        let t = line.trim_start();
+        if let Some(rest) = t.strip_prefix("#include") {
+            let name = rest
+                .trim()
+                .trim_start_matches(['<', '"'])
+                .trim_end_matches(['>', '"'])
+                .trim();
+            let (ns, path) = name.split_once(':').unwrap_or(("minecraft", name));
+            let file = root
+                .join("assets")
+                .join(ns)
+                .join("shaders")
+                .join("include")
+                .join(path);
+            let text = std::fs::read_to_string(&file)
+                .map_err(|e| format!("#include <{name}>: {}: {e}", file.display()))?;
+            out.push_str(&include(root, &text, depth + 1)?);
+        } else if t.starts_with("#version") || t.starts_with("#extension") {
+            // Re-added below, for the translator.
+            out.push('\n');
+            continue;
+        } else {
+            out.push_str(line);
+        }
+        out.push('\n');
+    }
+    Ok(out)
+}
+
+/// Every `uniform` declaration of a source: (start of the declaration including a
+/// `layout(...)` before it, end of the type or of the whole `;`, type, name, is a sampler).
+fn declarations(src: &str) -> Vec<(usize, usize, String, String, bool)> {
+    let plain = blank_comments(src);
+    let b = plain.as_bytes();
+    let mut out = Vec::new();
+    let mut at = 0;
+    while let Some(found) = plain[at..].find("uniform") {
+        let start = at + found;
+        at = start + 7;
+        if (start > 0 && is_ident(b[start - 1])) || b.get(start + 7).is_some_and(|c| is_ident(*c)) {
+            continue;
+        }
+        let word = |from: usize| -> Option<(usize, usize)> {
+            let mut s = from;
+            while s < b.len() && b[s].is_ascii_whitespace() {
+                s += 1;
+            }
+            let mut e = s;
+            while e < b.len() && is_ident(b[e]) {
+                e += 1;
+            }
+            (e > s).then_some((s, e))
+        };
+        let Some((ts, te)) = word(start + 7) else {
+            continue;
+        };
+        let ty = plain[ts..te].to_owned();
+        // The `layout(...)` right before `uniform`, if any.
+        let before = plain[..start].trim_end();
+        let decl_start = before
+            .ends_with(')')
+            .then(|| before.rfind("layout"))
+            .flatten()
+            .filter(|l| {
+                before[*l + 6..].trim_start().starts_with('(') && !before[*l..].contains(';')
+            })
+            .unwrap_or(start);
+        if ty.starts_with("sampler") {
+            let Some((ns, ne)) = word(te) else { continue };
+            let end = plain[ne..].find(';').map_or(ne, |p| ne + p + 1);
+            out.push((decl_start, end, ty, plain[ns..ne].to_owned(), true));
+        } else {
+            let mut s = te;
+            while s < b.len() && b[s].is_ascii_whitespace() {
+                s += 1;
+            }
+            if b.get(s) == Some(&b'{') {
+                out.push((decl_start, te, String::new(), ty, false));
+            }
+        }
+    }
+    out
+}
+
+/// The source with each declaration given its binding from the shared tables.
+fn rewrite(src: &str, blocks: &[(String, u32)], samplers: &[(String, u32)]) -> String {
+    let mut out = String::new();
+    let mut pos = 0;
+    for (start, end, ty, name, sampler) in declarations(src) {
+        out.push_str(&src[pos..start]);
+        pos = end;
+        if sampler {
+            let tex = samplers.iter().find(|(n, _)| *n == name).map_or(0, |s| s.1);
+            let kind = if ty == "sampler2D" { "texture2D" } else { &ty };
+            out.push_str(&format!(
+                "layout(set = 0, binding = {tex}) uniform {kind} {name}_hz_tex; \
+                 layout(set = 0, binding = {}) uniform sampler {name}_hz_smp;\n\
+                 #define {name} sampler2D({name}_hz_tex, {name}_hz_smp)\n",
+                tex + 1
+            ));
+        } else {
+            let binding = blocks.iter().find(|(n, _)| *n == name).map_or(0, |s| s.1);
+            out.push_str(&format!(
+                "layout(std140, set = 0, binding = {binding}) uniform {name}"
+            ));
+        }
+    }
+    out.push_str(&src[pos..]);
+    out
+}
+
+/// Replaces the word `main` of `void main(` with `hz_main`.
+fn wrap_main(src: &str) -> Result<String, String> {
+    let plain = blank_comments(src);
+    let mut at = 0;
+    while let Some(found) = plain[at..].find("main") {
+        let p = at + found;
+        at = p + 4;
+        let b = plain.as_bytes();
+        if (p > 0 && is_ident(b[p - 1])) || b.get(p + 4).is_some_and(|c| is_ident(*c)) {
+            continue;
+        }
+        if plain[..p].trim_end().ends_with("void") && plain[p + 4..].trim_start().starts_with('(') {
+            let mut out = String::with_capacity(src.len() + 80);
+            out.push_str(&src[..p]);
+            out.push_str("hz_main");
+            out.push_str(&src[p + 4..]);
+            out.push_str("\nvoid main() { hz_main(); gl_Position.y = -gl_Position.y; }\n");
+            return Ok(out);
+        }
+    }
+    Err("no main".into())
+}
+
+fn parse(stage: ShaderStage, text: &str) -> Result<naga::Module, String> {
+    let module = Frontend::default()
+        .parse(&Options::from(stage), text)
+        .map_err(|e| {
+            e.errors
+                .iter()
+                .map(|e| e.kind.to_string())
+                .collect::<Vec<_>>()
+                .join("; ")
+        })?;
+    Validator::new(ValidationFlags::all(), Capabilities::empty())
+        .validate(&module)
+        .map_err(|e| format!("{:?}", e.into_inner()))?;
+    Ok(module)
+}
+
+/// Translates the vertex and fragment shader a pass names (`minecraft:post/invert`).
+pub fn translate(root: &Path, vertex: &str, fragment: &str) -> Result<Program, String> {
+    let vs = include(root, &read_source(root, vertex, "vsh")?, 0)?;
+    let fs = include(root, &read_source(root, fragment, "fsh")?, 0)?;
+    // Blocks and samplers are shared by name across the stages, so both agree on a binding.
+    let mut blocks: Vec<(String, u32)> = Vec::new();
+    let mut names: Vec<String> = Vec::new();
+    for src in [&vs, &fs] {
+        for (_, _, _, name, sampler) in declarations(src) {
+            if sampler {
+                if !names.contains(&name) {
+                    names.push(name);
+                }
+            } else if !blocks.iter().any(|(n, _)| *n == name) {
+                blocks.push((name, blocks.len() as u32));
+            }
+        }
+    }
+    let first = blocks.len() as u32;
+    let samplers: Vec<(String, u32)> = names.into_iter().zip((first..).step_by(2)).collect();
+    let vs = wrap_main(&rewrite(&vs, &blocks, &samplers))?;
+    let fs = rewrite(&fs, &blocks, &samplers);
+    let vertex_module = parse(ShaderStage::Vertex, &format!("#version 450\n{vs}"))
+        .map_err(|e| format!("{vertex}: {e}"))?;
+    let fragment_module = parse(ShaderStage::Fragment, &format!("#version 450\n{fs}"))
+        .map_err(|e| format!("{fragment}: {e}"))?;
+    Ok(Program {
+        vertex: vertex_module,
+        fragment: fragment_module,
+        blocks,
+        samplers,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn root() -> Option<std::path::PathBuf> {
+        let dir = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .ancestors()
+            .nth(2)?
+            .join(".local/horizon-client/26.3");
+        dir.join("assets/minecraft/shaders/post/blit.fsh")
+            .exists()
+            .then_some(dir)
+    }
+
+    #[test]
+    fn vanilla_post_shaders_translate() {
+        let Some(root) = root() else { return };
+        let vs = ["minecraft:core/screenquad", "minecraft:post/rotscale"];
+        let fs = [
+            "bits",
+            "blit",
+            "box_blur",
+            "color_convolve",
+            "entity_outline_box_blur",
+            "entity_sobel",
+            "invert",
+            "spiderclip",
+        ];
+        for f in fs {
+            for v in vs {
+                let name = format!("minecraft:post/{f}");
+                let p = translate(&root, v, &name);
+                // rotscale's outputs only match spiderclip, but each stage translates alone.
+                if let Err(e) = &p {
+                    panic!("{v} + {name}: {e}");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn sampler_and_block_bindings() {
+        let src = "layout(std140) uniform A {\n float x;\n};\nuniform sampler2D InSampler; // c\nvoid main(){}\n";
+        let d = declarations(src);
+        assert_eq!(d.len(), 2);
+        let out = rewrite(src, &[("A".into(), 0)], &[("InSampler".into(), 1)]);
+        assert!(out.contains("layout(std140, set = 0, binding = 0) uniform A {"));
+        assert!(out.contains("binding = 1) uniform texture2D InSampler_hz_tex;"));
+        assert!(out.contains("binding = 2) uniform sampler InSampler_hz_smp;"));
+        assert!(wrap_main("void main() {}").unwrap().contains("hz_main"));
+    }
+}

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

@@ -0,0 +1,304 @@
+//! Input method composition text (`PreeditEvent`, `IMEPreeditOverlay`,
+//! `TextInputManager`): the text an input method is still composing, shown
+//! under the focused text field's caret, and the area the system's candidate
+//! window is placed at.
+//!
+//! Vanilla hands each `PreeditEvent` to the focused widget, which keeps an
+//! overlay and reports its caret every frame. Horizon draws its fields from
+//! many places, so the event is kept here and every focused field calls
+//! [`report_caret`] where it draws its caret; the game draws the overlay last
+//! with [`draw_overlay`] and applies [`take_text_input_area`] to the window.
+use crate::{
+    hud::{HudAtlas, HudBatch},
+    text::{Style, Text},
+    ui::nine_slice,
+};
+use std::{sync::Mutex, time::Instant};
+
+/// `PreeditEvent`: the composition, its caret and the blocks of text the
+/// input method set apart (the one being converted is `focused_block`).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PreeditEvent {
+    pub full_text: String,
+    /// Byte offset of the caret in `full_text` (vanilla's UTF-16 offset).
+    pub caret_position: usize,
+    pub blocks: Vec<String>,
+    pub focused_block: usize,
+}
+
+impl PreeditEvent {
+    /// `PreeditEvent.fromSdlTextEditing`: `selection_start` and
+    /// `selection_length` are in code points; a negative start puts the caret
+    /// at the end. Empty text is no composition.
+    pub fn from_sdl_text_editing(
+        text: Option<&str>,
+        selection_start: i32,
+        selection_length: i32,
+    ) -> Option<Self> {
+        let text = text.filter(|t| !t.is_empty())?;
+        let total = text.chars().count();
+        let caret_codepoint = if selection_start < 0 {
+            total
+        } else {
+            (selection_start as usize).min(total)
+        };
+        let caret_char = offset_by_codepoints(text, caret_codepoint);
+        let single = |caret| Self {
+            full_text: text.to_owned(),
+            caret_position: caret,
+            blocks: vec![text.to_owned()],
+            focused_block: 0,
+        };
+        if selection_length <= 0 {
+            return Some(single(caret_char));
+        }
+        let end_codepoint = (caret_codepoint + selection_length as usize).min(total);
+        let end_char = offset_by_codepoints(text, end_codepoint);
+        if end_char <= caret_char {
+            return Some(single(caret_char));
+        }
+        let mut blocks = Vec::new();
+        let mut focused_block = 0;
+        if caret_char > 0 {
+            blocks.push(text[..caret_char].to_owned());
+            focused_block = 1;
+        }
+        blocks.push(text[caret_char..end_char].to_owned());
+        if end_char < text.len() {
+            blocks.push(text[end_char..].to_owned());
+        }
+        Some(Self {
+            full_text: text.to_owned(),
+            caret_position: caret_char,
+            blocks,
+            focused_block,
+        })
+    }
+
+    /// winit's `Ime::Preedit`: `cursor` is the byte range of the part being
+    /// converted, `None` when the input method hides its cursor. SDL's
+    /// `TEXTEDITING` says the same in code points.
+    pub fn from_winit(text: &str, cursor: Option<(usize, usize)>) -> Option<Self> {
+        let (start, length) = match cursor {
+            Some((from, to)) => {
+                let from = from.min(text.len());
+                let to = to.clamp(from, text.len());
+                let start = text.get(..from).map_or(-1, |s| s.chars().count() as i32);
+                let length = text.get(from..to).map_or(0, |s| s.chars().count() as i32);
+                (start, length)
+            }
+            None => (-1, 0),
+        };
+        Self::from_sdl_text_editing(Some(text), start, length)
+    }
+
+    /// `PreeditEvent.toFormattedText`.
+    pub fn to_formatted_text(&self, focused_style: &Style) -> Text {
+        if self.blocks.len() == 1 {
+            return Text::literal(self.blocks[0].clone()).with_style(focused_style);
+        }
+        let mut result = Text::empty();
+        for (i, block) in self.blocks.iter().enumerate() {
+            let mut part = Text::literal(block.clone());
+            if i == self.focused_block {
+                part = part.with_style(focused_style);
+            }
+            result.push(part);
+        }
+        result
+    }
+}
+
+/// `String.offsetByCodePoints(0, n)`: the byte offset after `n` characters.
+fn offset_by_codepoints(text: &str, n: usize) -> usize {
+    text.char_indices().nth(n).map_or(text.len(), |(i, _)| i)
+}
+
+/// The caret a field reported this frame, in GUI pixels.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct Caret {
+    x: f32,
+    y: f32,
+    input_height: f32,
+}
+
+#[derive(Default)]
+struct State {
+    /// `KeyboardHandler.lastPreeditEvent`, with when the overlay was created.
+    preedit: Option<(PreeditEvent, Instant)>,
+    caret: Option<Caret>,
+    area: Option<[f32; 4]>,
+}
+
+static STATE: Mutex<State> = Mutex::new(State {
+    preedit: None,
+    caret: None,
+    area: None,
+});
+
+fn state() -> std::sync::MutexGuard<'static, State> {
+    STATE.lock().unwrap_or_else(|e| e.into_inner())
+}
+
+/// `KeyboardHandler.textEditing`: the input method's composition changed
+/// (`None`: it ended). A new `IMEPreeditOverlay` restarts the caret blink.
+pub fn set_preedit(event: Option<PreeditEvent>) {
+    let mut s = state();
+    s.preedit = event.map(|e| (e, Instant::now()));
+}
+
+/// Whether text is being composed.
+pub fn composing() -> bool {
+    state().preedit.is_some()
+}
+
+/// What the focused field's `extractRenderState` ends with: its caret is at
+/// (`x`, `y`) in GUI pixels and `input_height` tall (a line plus one).
+/// Without a composition that is the area for the candidate window; with one
+/// it is where the overlay goes ([`draw_overlay`]).
+pub fn report_caret(x: f32, y: f32, input_height: f32) {
+    state().caret = Some(Caret { x, y, input_height });
+}
+
+/// `IMEPreeditOverlay.extractRenderState` for the caret reported this frame,
+/// drawn on top of everything in `batch`. Without a composition the caret is
+/// the text input area (`TextInputManager.setTextInputArea`).
+pub fn draw_overlay(batch: &mut HudBatch, atlas: &HudAtlas) {
+    let mut s = state();
+    let Some(caret) = s.caret.take() else {
+        return;
+    };
+    let Some((event, init)) = s.preedit.as_ref() else {
+        s.area = Some([
+            caret.x,
+            caret.y,
+            caret.x + 1.0,
+            caret.y + caret.input_height,
+        ]);
+        return;
+    };
+    let font = &atlas.font;
+    let focused = Style {
+        underlined: Some(true),
+        ..Style::default()
+    };
+    let black = 0xFF00_0000;
+    let text = event.to_formatted_text(&focused).with_color(black);
+    let width = font.width_text(&text);
+    let caret_pos = font.width(&event.full_text[..event.caret_position]);
+    let blink_visible = (init.elapsed().as_millis() / 300).is_multiple_of(2);
+    let line = 9.0;
+    let (gui_w, gui_h) = (batch.width, batch.height);
+    let mut left = caret.x;
+    let mut right = left + width;
+    if right > gui_w {
+        left = gui_w - width;
+        right = left + width;
+    }
+    let input_bottom = caret.y + caret.input_height;
+    let mut bottom = input_bottom + 4.0 + line;
+    if bottom > gui_h {
+        bottom = caret.y - 4.0 - line;
+    }
+    let top = bottom - line;
+    s.area = Some([left, top, right, bottom]);
+    drop(s);
+    nine_slice(
+        batch,
+        atlas,
+        "gui/sprites/widget/preedit",
+        left - 5.0,
+        top - 5.0,
+        right - left + 10.0,
+        bottom - top + 10.0,
+        u32::MAX,
+    );
+    batch.text_styled(atlas, &text, left, top, black, false);
+    if blink_visible {
+        batch.fill(atlas, left + caret_pos, top - 1.0, 1.0, 11.0, black);
+    }
+}
+
+/// The text input area (`x0, y0, x1, y1` in GUI pixels) set since the last
+/// call, for `Window.set_ime_cursor_area`.
+pub fn take_text_input_area() -> Option<[f32; 4]> {
+    state().area.take()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_text_is_no_composition() {
+        assert_eq!(PreeditEvent::from_sdl_text_editing(None, 0, 0), None);
+        assert_eq!(PreeditEvent::from_sdl_text_editing(Some(""), 0, 0), None);
+    }
+
+    #[test]
+    fn a_negative_start_puts_the_caret_at_the_end() {
+        let e = PreeditEvent::from_sdl_text_editing(Some("abc"), -1, 0).unwrap();
+        assert_eq!(
+            (e.caret_position, e.blocks, e.focused_block),
+            (3, vec!["abc".into()], 0)
+        );
+    }
+
+    #[test]
+    fn the_caret_counts_code_points() {
+        // Two code points before the caret, the second outside the BMP.
+        let e = PreeditEvent::from_sdl_text_editing(Some("a\u{1F600}b"), 2, 0).unwrap();
+        assert_eq!(e.caret_position, "a\u{1F600}".len());
+        let past = PreeditEvent::from_sdl_text_editing(Some("ab"), 9, 0).unwrap();
+        assert_eq!(past.caret_position, 2);
+    }
+
+    #[test]
+    fn a_selection_splits_the_text_into_blocks() {
+        let e = PreeditEvent::from_sdl_text_editing(Some("abcdef"), 2, 2).unwrap();
+        assert_eq!(e.blocks, ["ab", "cd", "ef"]);
+        assert_eq!((e.focused_block, e.caret_position), (1, 2));
+        let first = PreeditEvent::from_sdl_text_editing(Some("abcdef"), 0, 3).unwrap();
+        assert_eq!(first.blocks, ["abc", "def"]);
+        assert_eq!(first.focused_block, 0);
+        let last = PreeditEvent::from_sdl_text_editing(Some("abcdef"), 3, 99).unwrap();
+        assert_eq!(last.blocks, ["abc", "def"]);
+        assert_eq!(last.focused_block, 1);
+    }
+
+    #[test]
+    fn winit_byte_ranges_become_code_points() {
+        let text = "\u{3042}\u{3044}\u{3046}";
+        // Converting the middle character (bytes 3..6).
+        let e = PreeditEvent::from_winit(text, Some((3, 6))).unwrap();
+        assert_eq!(e.blocks, ["\u{3042}", "\u{3044}", "\u{3046}"]);
+        assert_eq!(e.focused_block, 1);
+        // A hidden cursor sits at the end.
+        let hidden = PreeditEvent::from_winit(text, None).unwrap();
+        assert_eq!(hidden.caret_position, text.len());
+        assert_eq!(hidden.blocks.len(), 1);
+    }
+
+    #[test]
+    fn only_the_focused_block_is_underlined() {
+        let focused = Style {
+            underlined: Some(true),
+            ..Style::default()
+        };
+        let e = PreeditEvent::from_sdl_text_editing(Some("abcdef"), 2, 2).unwrap();
+        let styled: Vec<(char, bool)> = e
+            .to_formatted_text(&focused)
+            .chars()
+            .map(|(c, s)| (c, s.underlined == Some(true)))
+            .collect();
+        let underlined: String = styled.iter().filter(|x| x.1).map(|x| x.0).collect();
+        assert_eq!(underlined, "cd");
+        assert_eq!(styled.len(), 6);
+        let one = PreeditEvent::from_sdl_text_editing(Some("ab"), 0, 0).unwrap();
+        assert!(
+            one.to_formatted_text(&focused)
+                .chars()
+                .all(|(_, s)| s.underlined == Some(true))
+        );
+    }
+}

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

@@ -5,7 +5,7 @@
 //! dimension type allows.
 
 /// Section indexes of one column, 0 being the lowest.
-#[derive(Clone, Copy, Default, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct SectionMask([u64; 4]);
 
 impl SectionMask {

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

@@ -497,10 +497,13 @@ impl Settings {
     /// `Options.createInformation`: what the server learns about this player.
     pub fn client_information(&self, view_distance: i8) -> ClientInformation {
         ClientInformation {
+            language: self.language.clone(),
             chat_visibility: self.chat_visibility as i32,
+            chat_colors: self.chat_colors,
             model_customisation: self.file.model_customisation(),
             main_hand: i32::from(!self.main_hand_left),
             allows_listing: self.file.bool("allowServerListing"),
+            particle_status: i32::from(self.particles),
             ..ClientInformation::new(view_distance)
         }
     }

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

@@ -844,6 +844,12 @@ impl SkinSlots {
             kept: Default::default(),
         }
     }
+    /// The atlas was replaced (a resource pack reload): every slot is blank,
+    /// so no skin counts as stored and each uploads again.
+    pub fn forget(&mut self) {
+        self.slots.clear();
+        self.kept.clear();
+    }
     /// Whether `location` is in a slot.
     pub fn contains(&self, location: &str) -> bool {
         self.slots.iter().any(|(l, _)| l == location)
@@ -910,6 +916,23 @@ pub fn sha1(data: &[u8]) -> [u8; 20] {
 
 #[cfg(test)]
 mod tests {
+    /// A pack reload swaps the atlas: its skin slots are blank, so a forgotten
+    /// table holds nothing and hands out slots from the start again, even for
+    /// skins drawn in the last frame.
+    #[test]
+    fn a_new_atlas_forgets_every_skin_slot() {
+        use super::SkinSlots;
+        let mut slots = SkinSlots::new(2);
+        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.forget();
+        assert!(!slots.contains("skins/a"));
+        assert!(!slots.contains("skins/b"));
+        assert_eq!(slots.place("skins/c".into()), Some((0, None)));
+        assert_eq!(slots.place("skins/a".into()), Some((1, None)));
+    }
+
     /// The launcher's offline skin: a 64x64 or legacy 64x32 PNG laid out as
     /// a downloaded skin, slim only for the `slim` model; anything else is
     /// refused and the player keeps their default skin.

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

@@ -7,7 +7,7 @@ use crate::section_mask::SectionMask;
 use crate::{
     chunk::Chunk,
     light::{LightChanges, LightTables, apply_lighting, apply_relighting, light_chunk},
-    mesher::{MeshTables, Mesher, Region, SectionMesh, borrow},
+    mesher::{MeshScratch, MeshTables, Mesher, Region, SectionMesh, borrow},
     world::World,
 };
 use horizon_core::biome::BiomeZoom;
@@ -234,10 +234,39 @@ struct Shared {
     /// packs reload; each mesh job takes the current one.
     context: RwLock<Arc<WorkerContext>>,
     done: Mailbox,
+    /// Only workers use this pool; frames never wait for its lock. Retaining
+    /// cleared buffers avoids racing the renderer for the process heap.
+    meshes: Mutex<MeshPool>,
     /// 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,
 }
+#[derive(Default)]
+struct MeshPool {
+    meshes: Vec<SectionMesh>,
+    bytes: usize,
+}
+impl MeshPool {
+    const BYTES: usize = 16 << 20;
+    const COUNT: usize = 128;
+    fn take(&mut self) -> SectionMesh {
+        let mesh = self.meshes.pop().unwrap_or_default();
+        self.bytes -= mesh.capacity_bytes();
+        mesh
+    }
+    /// A rejected mesh is dropped by the caller, after releasing the lock.
+    fn put(&mut self, mut mesh: SectionMesh) -> Option<SectionMesh> {
+        let bytes = mesh.capacity_bytes();
+        if bytes == 0 || self.meshes.len() == Self::COUNT || bytes > Self::BYTES - self.bytes {
+            return Some(mesh);
+        }
+        mesh.clear();
+        self.bytes += bytes;
+        self.meshes.push(mesh);
+        None
+    }
+}
+
 /// 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
 /// half way through a send, and a worker descheduled there on a busy machine
@@ -536,6 +565,7 @@ impl Streaming {
             stop: AtomicBool::new(false),
             context: RwLock::new(context.clone()),
             done: Mailbox::default(),
+            meshes: Mutex::new(MeshPool::default()),
             released: AtomicUsize::new(0),
         });
         let workers = threads.max(1);
@@ -556,6 +586,7 @@ impl Streaming {
                         // the worker across mesh jobs, like vanilla's per-thread cache:
                         // cloning it per job copied every state and face shape.
                         let mut faces: Option<(Arc<MeshTables>, FaceVisibility)> = None;
+                        let mut mesh_scratch = MeshScratch::default();
                         loop {
                             let job = {
                                 let mut queue = shared.queue.lock().unwrap();
@@ -580,10 +611,12 @@ impl Streaming {
                                     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.
+                                        // face cache and scratch) until the next job
+                                        // needs them.
                                         drop(queue);
                                         generator.idle(&mut worker);
                                         faces = None;
+                                        mesh_scratch = MeshScratch::default();
                                         released = true;
                                         // The allocator keeps freed pages until memory
                                         // runs short: once every worker has freed its own,
@@ -591,6 +624,12 @@ impl Streaming {
                                         if shared.released.fetch_add(1, Ordering::Relaxed) + 1
                                             == workers
                                         {
+                                            // No worker needs retained mesh capacity now.
+                                            // Drop it outside the pool lock before asking
+                                            // the allocator to return freed pages.
+                                            let meshes =
+                                                std::mem::take(&mut *shared.meshes.lock().unwrap());
+                                            drop(meshes);
                                             horizon_threads::release_free_memory();
                                         }
                                         queue = shared.queue.lock().unwrap();
@@ -620,7 +659,10 @@ impl Streaming {
                                     Done::Saved(protos)
                                 }
                                 Job::Free(meshes) => {
-                                    drop(meshes);
+                                    for (_, mesh) in meshes {
+                                        let rejected = shared.meshes.lock().unwrap().put(mesh);
+                                        drop(rejected);
+                                    }
                                     continue;
                                 }
                                 Job::Light(x, z, region, seq, sky) => {
@@ -648,7 +690,13 @@ impl Streaming {
                                         biomes: &context.biomes,
                                         visibility,
                                     };
-                                    let mut mesh = mesher.mesh(&borrow(&region), sy);
+                                    let recycled = shared.meshes.lock().unwrap().take();
+                                    let mut mesh = mesher.mesh_reusing(
+                                        &borrow(&region),
+                                        sy,
+                                        recycled,
+                                        &mut mesh_scratch,
+                                    );
                                     mesh.sort_solid();
                                     faces = Some((context.tables.clone(), mesher.visibility));
                                     Done::Meshed(x, sy, z, mesh, seq)
@@ -958,6 +1006,21 @@ impl Streaming {
         }
         Some(Box::new(region))
     }
+    /// Whether `light_region` would find all nine columns: the same walk
+    /// without building the snapshot, so the scheduler can rank the ready
+    /// columns before any region is cloned. A proto neighbour whose light
+    /// view turns out empty is skipped when its region is built, and asked
+    /// for again, as `light_region` returning `None` always was.
+    fn light_region_ready(&self, world: &World, x: i32, z: i32) -> bool {
+        light_region_ready(
+            world,
+            |x, z| self.in_range(x, z, 1),
+            &self.decorated,
+            &self.protos,
+            x,
+            z,
+        )
+    }
     fn region(world: &World, x: i32, z: i32) -> Option<Box<Region>> {
         let mut region: Region = Default::default();
         for dz in 0..3 {
@@ -1357,13 +1420,29 @@ impl Streaming {
             }
         }
         self.schedule_generation(world, workers);
-        // Lighting once all neighbours exist.
-        let light: Vec<_> = world.dirty_light.iter().copied().collect();
-        for (x, z) in light {
+        // Lighting once all neighbours exist, nearest first and only as
+        // much of it as the workers can chew. Vanilla's light engine also
+        // hands a bounded queue to its workers and reschedules what did
+        // not fit by distance; submitted whole, the light jobs of every
+        // unlit column at once — each carrying a 3x3 region snapshot —
+        // grew with the render distance and outlived the columns they
+        // were queued for (#3629). What stays in `dirty_light` is asked
+        // for again, from the current centre, as capacity frees.
+        let mut light: Vec<(i64, i32, i32)> = Vec::new();
+        let mut gone: Vec<(i32, i32)> = Vec::new();
+        for &(x, z) in world.dirty_light.iter() {
             if !world.chunks.contains_key(&(x, z)) {
-                world.dirty_light.remove(&(x, z));
-                continue;
+                gone.push((x, z));
+            } else if self.light_region_ready(world, x, z) {
+                light.push((self.distance(x, z), x, z));
             }
+        }
+        for key in gone {
+            world.dirty_light.remove(&key);
+        }
+        let room = (self.threads.len() * 4).saturating_sub(self.lighting.len());
+        nearest_first(&mut light, room);
+        for (_, x, z) in light {
             let Some(region) = self.light_region(world, x, z) else {
                 continue;
             };
@@ -1409,6 +1488,7 @@ impl Streaming {
         }
         // Column by column: the checks below hold for all of a column's
         // sections, and columns waiting for light cost one look per frame.
+        let mut candidates: Vec<(i64, i32, i32, SectionMask)> = Vec::new();
         let columns: Vec<_> = world.dirty_sections.columns().collect();
         for ((x, z), sections) in columns {
             if !world.chunks.contains_key(&(x, z)) {
@@ -1437,6 +1517,18 @@ impl Streaming {
             if !ready {
                 continue;
             }
+            candidates.push((self.distance(x, z), x, z, sections));
+        }
+        // Nearest first, and only as many sections as the workers can chew.
+        // Every ready column used to be submitted at once, so at a wide
+        // render distance the queue — and `meshing`, and each job's 3x3
+        // region snapshot — grew with the number of loaded columns and the
+        // jobs went stale long before a worker reached them (#3629). What
+        // stays dirty is asked for again, from the current centre, as
+        // capacity frees; `requeue` then has a small queue to keep close.
+        let room = (self.threads.len() * 32).saturating_sub(self.meshing.len());
+        nearest_first(&mut candidates, room);
+        for (_, x, z, sections) in candidates {
             let Some(region) = Self::region(world, x, z) else {
                 continue;
             };
@@ -2051,10 +2143,112 @@ fn rank_again(queue: &mut BinaryHeap<Queued>, distance: impl Fn(i32, i32) -> i64
     }
     *queue = BinaryHeap::from(jobs);
 }
+/// Whether the 3x3 a light job for (x, z) reads is all there: every
+/// neighbour a finished column, or a decorated proto chunk past the area
+/// (the last FULL ring lights against neighbours at FEATURES, as
+/// `Streaming::light_region` reads them).
+fn light_region_ready(
+    world: &World,
+    in_range: impl Fn(i32, i32) -> bool,
+    decorated: &FxHashSet<(i32, i32)>,
+    protos: &FxHashMap<(i32, i32), Option<Proto>>,
+    x: i32,
+    z: i32,
+) -> bool {
+    for dz in 0..3 {
+        for dx in 0..3 {
+            let n = (x + dx - 1, z + dz - 1);
+            if world.chunks.contains_key(&n)
+                || (!in_range(n.0, n.1)
+                    && decorated.contains(&n)
+                    && matches!(protos.get(&n), Some(Some(_))))
+            {
+                continue;
+            }
+            return false;
+        }
+    }
+    true
+}
+/// The nearest `room` of the `candidates`, ordered: the light and mesh
+/// stages submit bounded work, chosen from everything that is ready each
+/// `update`, so what runs is always the nearest of what is left — chosen
+/// again, from the current centre, as capacity frees, the way vanilla's
+/// chunk task queues follow the current ticket levels. The selection is
+/// O(n); the sort orders only what is submitted.
+fn nearest_first<T: Ord>(candidates: &mut Vec<T>, room: usize) {
+    if candidates.len() > room {
+        candidates.select_nth_unstable(room);
+        candidates.truncate(room);
+    }
+    candidates.sort_unstable();
+}
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    #[test]
+    fn mesh_pool_reuses_capacity_with_clean_geometry_state() {
+        let mut mesh = SectionMesh::default();
+        mesh.solid.resize(64, bytemuck::Zeroable::zeroed());
+        mesh.translucent.resize(16, bytemuck::Zeroable::zeroed());
+        mesh.block_entities.push(([1, 2, 3], 7));
+        mesh.visibility = 0;
+        mesh.sides = crate::mesher::Sides::unsorted(16);
+        let capacities = mesh.capacity_bytes();
+        let pointers = (mesh.solid.as_ptr(), mesh.translucent.as_ptr());
+        let mut pool = MeshPool::default();
+        assert!(pool.put(mesh).is_none());
+        assert_eq!(pool.bytes, capacities);
+        let reused = pool.take();
+        assert_eq!(reused.capacity_bytes(), capacities);
+        assert_eq!(
+            pointers,
+            (reused.solid.as_ptr(), reused.translucent.as_ptr())
+        );
+        assert!(reused.solid.is_empty());
+        assert!(reused.translucent.is_empty());
+        assert!(reused.block_entities.is_empty());
+        assert_eq!(reused.visibility, crate::mesher::ALL_VISIBLE);
+        assert_eq!(reused.sides, crate::mesher::Sides::default());
+        assert_eq!(pool.bytes, 0);
+    }
+
+    #[test]
+    fn mesh_pool_caps_retained_count_and_bytes() {
+        let mut pool = MeshPool::default();
+        for _ in 0..MeshPool::COUNT {
+            let mut mesh = SectionMesh::default();
+            mesh.solid.reserve_exact(1);
+            assert!(pool.put(mesh).is_none());
+        }
+        let mut extra = SectionMesh::default();
+        extra.solid.reserve_exact(1);
+        assert!(pool.put(extra).is_some());
+        for _ in 0..MeshPool::COUNT {
+            pool.take();
+        }
+        assert_eq!(pool.bytes, 0);
+        for i in 0..2 {
+            let mut mesh = SectionMesh::default();
+            mesh.solid.reserve_exact(
+                MeshPool::BYTES / std::mem::size_of::<crate::mesher::TerrainVertex>() / 2 + 1,
+            );
+            assert_eq!(pool.put(mesh).is_some(), i == 1);
+            assert!(pool.bytes <= MeshPool::BYTES);
+            assert_eq!(pool.meshes.len(), 1);
+        }
+        pool.take();
+        assert_eq!(pool.bytes, 0);
+        let mut huge = SectionMesh::default();
+        huge.solid.reserve_exact(
+            MeshPool::BYTES / std::mem::size_of::<crate::mesher::TerrainVertex>() + 1,
+        );
+        assert!(pool.put(huge).is_some());
+        assert!(pool.meshes.is_empty());
+        assert_eq!(pool.bytes, 0);
+    }
+
     /// The frame never waits for a worker: while one holds the mailbox, the
     /// frame takes nothing and finds the results, in order, the next time.
     #[test]
@@ -2140,6 +2334,79 @@ mod tests {
         assert_eq!(queue.pop().and_then(|q| q.at), Some((20, 0)));
     }
 
+    /// The light and mesh stages submit bounded work, the nearest first:
+    /// what exceeds the room stays dirty, to be chosen again — from the
+    /// current centre — as capacity frees. Submitted whole, the queue once
+    /// held every ready column's jobs and grew with the render distance
+    /// (#3629); ties break by position, so the choice is deterministic.
+    #[test]
+    fn bounded_submission_takes_the_nearest_first() {
+        let candidates: Vec<(i64, i32, i32, u32)> = (0..40i32)
+            .map(|i| {
+                let (x, z) = (i / 8 - 2, i % 8 - 3);
+                (
+                    i64::from((x - 3).pow(2) + (z - 2).pow(2)),
+                    x,
+                    z,
+                    1 << (i % 24),
+                )
+            })
+            .collect();
+        let mut expected = candidates.clone();
+        expected.sort_unstable();
+        let mut none = candidates.clone();
+        nearest_first(&mut none, 0);
+        assert!(none.is_empty());
+        let mut nearest = candidates;
+        nearest_first(&mut nearest, 5);
+        assert_eq!(nearest, expected[..5]);
+        let mut past = expected.clone();
+        nearest_first(&mut past, expected.len() + 10);
+        assert_eq!(past, expected);
+    }
+
+    /// What the scheduler counts as ready to light: every neighbour a
+    /// finished column, or a decorated proto chunk past the area — the
+    /// walk `light_region` makes without its snapshot.
+    #[test]
+    fn light_readiness_follows_the_region_a_light_job_reads() {
+        let mut world = World::new(horizon_world::registry::BlockStateId(0), 0);
+        let chunk = Arc::new(Chunk::empty(0, 0));
+        let nine = (-1..=1).flat_map(|dz| (-1..=1).map(move |dx| (dx, dz)));
+        for key in nine {
+            world.chunks.insert(key, chunk.clone());
+        }
+        // The kept area is the cross around (0, 0); the corners of the
+        // 3x3 light reads lie past it.
+        let in_range = |x: i32, z: i32| x.abs() + z.abs() <= 1;
+        let none = FxHashSet::<(i32, i32)>::default();
+        let empty = FxHashMap::<(i32, i32), Option<Proto>>::default();
+        assert!(light_region_ready(&world, in_range, &none, &empty, 0, 0));
+        // A corner is missing, and nothing stands in for it yet.
+        world.chunks.remove(&(1, 1));
+        assert!(!light_region_ready(&world, in_range, &none, &empty, 0, 0));
+        // A decorated, checked-in proto chunk past the area lights against.
+        let decorated: FxHashSet<(i32, i32)> = [(1, 1)].into_iter().collect();
+        let mut protos: FxHashMap<(i32, i32), Option<Proto>> = Default::default();
+        protos.insert((1, 1), Some(Box::new(()) as Proto));
+        assert!(light_region_ready(
+            &world, in_range, &decorated, &protos, 0, 0
+        ));
+        // The proto is checked out to a job: it cannot be read.
+        protos.insert((1, 1), None);
+        assert!(!light_region_ready(
+            &world, in_range, &decorated, &protos, 0, 0
+        ));
+        // A neighbour inside the area waits for the chunk itself.
+        world.chunks.remove(&(1, 0));
+        let mut inside = decorated.clone();
+        inside.insert((1, 0));
+        protos.insert((1, 0), Some(Box::new(()) as Proto));
+        assert!(!light_region_ready(
+            &world, in_range, &inside, &protos, 0, 0
+        ));
+    }
+
     #[test]
     fn view_distance_is_vanillas_shape() {
         // ChunkTrackingView.isInViewDistance at render distance 12: a column

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

@@ -27,6 +27,9 @@ struct Globals {
     // The sunrise fan's 16 triangles (gfx/sunrise_fan.rs): xyz the apex weight's normal, w the
     // triangle's volume with the camera; then each rim vertex's normal against the apex.
     sunrise_fan: array<vec4<f32>, 32>,
+    // x: Options.textureFiltering (0 none, 1 RGSS, 2 anisotropic), y: the sprite arrays' width
+    // in texels (vanilla's TextureSize).
+    filtering: vec4<f32>,
 }
 @group(0) @binding(0) var<uniform> globals: Globals;
 @group(0) @binding(1) var sprites: texture_2d_array<f32>;
@@ -45,14 +48,12 @@ struct Globals {
 // which then samples exactly as before.
 override SPRITE_ARRAYS: u32 = 1u;
 override SPRITE_SPLIT: u32 = 2048u;
-fn sprite(uv: vec2<f32>, layer: u32) -> vec4<f32> {
-    if SPRITE_ARRAYS == 1u {
-        return textureSample(sprites, sprite_sampler, uv, i32(layer));
-    }
-    // The array is chosen per fragment: sample with the derivatives taken here.
-    let dx = dpdx(uv);
-    let dy = dpdy(uv);
+// A sprite sampled with the given gradients, from whichever array holds its layer.
+fn sprite_grad(uv: vec2<f32>, layer: u32, dx: vec2<f32>, dy: vec2<f32>) -> vec4<f32> {
     let l = i32(layer % SPRITE_SPLIT);
+    if SPRITE_ARRAYS == 1u {
+        return textureSampleGrad(sprites, sprite_sampler, uv, l, dx, dy);
+    }
     switch layer / SPRITE_SPLIT {
         case 0u: { return textureSampleGrad(sprites, sprite_sampler, uv, l, dx, dy); }
         case 1u: { return textureSampleGrad(sprites_1, sprite_sampler, uv, l, dx, dy); }
@@ -64,6 +65,78 @@ fn sprite(uv: vec2<f32>, layer: u32) -> vec4<f32> {
         default: { return textureSampleGrad(sprites_7, sprite_sampler, uv, l, dx, dy); }
     }
 }
+// The same at an explicit mip level.
+fn sprite_level(uv: vec2<f32>, layer: u32, lod: f32) -> vec4<f32> {
+    let l = i32(layer % SPRITE_SPLIT);
+    if SPRITE_ARRAYS == 1u {
+        return textureSampleLevel(sprites, sprite_sampler, uv, l, lod);
+    }
+    switch layer / SPRITE_SPLIT {
+        case 0u: { return textureSampleLevel(sprites, sprite_sampler, uv, l, lod); }
+        case 1u: { return textureSampleLevel(sprites_1, sprite_sampler, uv, l, lod); }
+        case 2u: { return textureSampleLevel(sprites_2, sprite_sampler, uv, l, lod); }
+        case 3u: { return textureSampleLevel(sprites_3, sprite_sampler, uv, l, lod); }
+        case 4u: { return textureSampleLevel(sprites_4, sprite_sampler, uv, l, lod); }
+        case 5u: { return textureSampleLevel(sprites_5, sprite_sampler, uv, l, lod); }
+        case 6u: { return textureSampleLevel(sprites_6, sprite_sampler, uv, l, lod); }
+        default: { return textureSampleLevel(sprites_7, sprite_sampler, uv, l, lod); }
+    }
+}
+// texture_sampling.glsl's sampleNearest: the sprite's texels stay square pixels, blending only
+// across the one screen pixel where two meet, so a linear (and anisotropic) sampler keeps them crisp.
+fn sample_nearest(uv: vec2<f32>, layer: u32, pixel: vec2<f32>, du: vec2<f32>, dv: vec2<f32>,
+                  texel_screen: vec2<f32>) -> vec4<f32> {
+    let texel_coords = uv / pixel;
+    let center = round(texel_coords) - 0.5;
+    var offset = texel_coords - center;
+    offset = (offset - 0.5) * pixel / max(texel_screen, vec2(1e-12)) + 0.5;
+    offset = clamp(offset, vec2(0.0), vec2(1.0));
+    return sprite_grad((center + offset) * pixel, layer, du, dv);
+}
+// sampleRGSS: four rotated-grid samples of the two nearest mip levels, faded in as the texels
+// shrink below two screen pixels, over sample_nearest.
+fn sample_rgss(uv: vec2<f32>, layer: u32, pixel: vec2<f32>, du: vec2<f32>, dv: vec2<f32>,
+               texel_screen: vec2<f32>) -> vec4<f32> {
+    let max_texel = max(texel_screen.x, texel_screen.y);
+    let min_pixel = min(pixel.x, pixel.y);
+    let blend = smoothstep(min_pixel, min_pixel * 2.0, max_texel);
+    let du_len = length(du);
+    let dv_len = length(dv);
+    let effective = sqrt(min(du_len, dv_len) * max(du_len, dv_len));
+    let exact = max(0.0, log2(effective / min_pixel));
+    let low = floor(exact);
+    let mip_blend = fract(exact);
+    var offsets = array<vec2<f32>, 4>(
+        vec2(0.125, 0.375), vec2(-0.125, -0.375), vec2(0.375, -0.125), vec2(-0.375, 0.125));
+    var sum_low = vec4(0.0);
+    var sum_high = vec4(0.0);
+    for (var i = 0; i < 4; i++) {
+        let p = uv + offsets[i] * pixel;
+        sum_low += sprite_level(p, layer, low);
+        sum_high += sprite_level(p, layer, low + 1.0);
+    }
+    let rgss = mix(sum_low * 0.25, sum_high * 0.25, mip_blend);
+    return mix(sample_nearest(uv, layer, pixel, du, dv, texel_screen), rgss, blend);
+}
+fn sprite(uv: vec2<f32>, layer: u32) -> vec4<f32> {
+    let mode = u32(globals.filtering.x);
+    if mode != 0u {
+        // Texture Filtering Anisotropic or RGSS: terrain.fsh's two sampling paths.
+        let du = dpdx(uv);
+        let dv = dpdy(uv);
+        let pixel = vec2(1.0 / globals.filtering.y);
+        let texel_screen = sqrt(du * du + dv * dv);
+        if mode == 1u {
+            return sample_rgss(uv, layer, pixel, du, dv, texel_screen);
+        }
+        return sample_nearest(uv, layer, pixel, du, dv, texel_screen);
+    }
+    if SPRITE_ARRAYS == 1u {
+        return textureSample(sprites, sprite_sampler, uv, i32(layer));
+    }
+    // The array is chosen per fragment: sample with the derivatives taken here.
+    return sprite_grad(uv, layer, dpdx(uv), dpdy(uv));
+}
 
 struct TerrainOut {
     @builtin(position) clip: vec4<f32>,
@@ -302,7 +375,7 @@ fn sky_fog(color: vec3<f32>, dist: vec2<f32>) -> vec3<f32> {
 // Weight of the fan centre where the ray crosses the sunrise fan (0 when missed):
 // Moller-Trumbore from the origin along d, over normals built once a frame
 // (gfx/sunrise_fan.rs). The barycentrics are apex/s, k1/s and -k0/s; s is -det.
-fn sunrise_weight(d: vec3<f32>) -> f32 {
+fn sunrise_weight_full(d: vec3<f32>) -> f32 {
     if globals.sunrise.a <= 0.001 { return 0.0; }
     var best = 0.0;
     var k0 = dot(d, globals.sunrise_fan[16].xyz);
@@ -322,6 +395,50 @@ fn sunrise_weight(d: vec3<f32>) -> f32 {
     }
     return best;
 }
+// The rim's YZ projection is an ellipse. Comparing its unsquashed X/Y
+// magnitudes with tan(PI/8) selects one of sixteen sectors without atan2.
+fn sunrise_triangle_weight(d: vec3<f32>, i: u32) -> f32 {
+    let k0 = dot(d, globals.sunrise_fan[16u+i].xyz);
+    let k1 = dot(d, globals.sunrise_fan[16u+(i+1u)%16u].xyz);
+    let triangle = globals.sunrise_fan[i];
+    let apex = dot(d, triangle.xyz);
+    let s = apex + k1 - k0;
+    if abs(s) >= 1e-6 && s * triangle.w > 0.0 && apex * s >= 0.0
+        && k1 * s >= 0.0 && k0 * s <= 0.0 {
+        return apex / s;
+    }
+    return 0.0;
+}
+fn sunrise_weight(d: vec3<f32>) -> f32 {
+    if globals.sunrise.a <= 0.001 { return 0.0; }
+    if dot(d.yz, d.yz) < 1e-10 { return sunrise_weight_full(d); }
+    // The camera lies in the rim plane. A forward ray can reach the fan
+    // only on the apex side. Keep a guard for rounded coplanar normals.
+    let apex = dot(d, globals.sunrise_fan[0].xyz);
+    if apex * globals.sunrise_fan[0].w < -1e-4 { return 0.0; }
+    let y = dot(d, globals.sunrise_fan[16].xyz);
+    let x = -dot(d, globals.sunrise_fan[20].xyz);
+    let ax = abs(x);
+    let ay = abs(y);
+    let tangent = 0.414213562373095;
+    let quadrant_sector = select(select(0u, 1u, ay > ax * tangent),
+        select(2u, 3u, ax < ay * tangent), ay > ax);
+    let sector = select(select(8u + quadrant_sector, 7u - quadrant_sector, y >= 0.0),
+        select(15u - quadrant_sector, quadrant_sector, y >= 0.0), x >= 0.0);
+    var best = max(sunrise_triangle_weight(d, sector),
+        sunrise_triangle_weight(d, (sector + 8u) % 16u));
+    // Test adjacent sectors only at a rounded boundary; their exact rim
+    // normals remain the authority for hit tests and interpolation weights.
+    let k0 = dot(d, globals.sunrise_fan[16u+sector].xyz);
+    let k1 = dot(d, globals.sunrise_fan[16u+(sector+1u)%16u].xyz);
+    if min(abs(k0), abs(k1)) < max(ax, ay) * 0.001 {
+        best = max(best, sunrise_triangle_weight(d, (sector + 15u) % 16u));
+        best = max(best, sunrise_triangle_weight(d, (sector + 1u) % 16u));
+        best = max(best, sunrise_triangle_weight(d, (sector + 7u) % 16u));
+        best = max(best, sunrise_triangle_weight(d, (sector + 9u) % 16u));
+    }
+    return best;
+}
 // The sky's colour along the view ray `d` (a shader pack's sky stage gets it as its input:
 // gfx/native_sky.rs builds that stage from this section).
 fn sky_along_ray(d: vec3<f32>) -> vec3<f32> {

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

@@ -1289,6 +1289,9 @@ impl EditBox {
                 batch.text(atlas, "_", cursor_x, ty, color, true);
             }
         }
+        if self.focused {
+            crate::preedit::report_caret(cursor_x, ty, 10.0);
+        }
     }
     /// Character index under GUI x (mouse click).
     pub fn index_at(&self, atlas: &HudAtlas, x: f32) -> usize {

crates/horizon-client-render/tests/sunrise_shader.rs

@@ -0,0 +1,189 @@
+#[path = "../src/gfx/sunrise_fan.rs"]
+mod sunrise_fan;
+
+#[path = "../src/gfx/wgsl_prefix.rs"]
+mod wgsl_prefix;
+
+fn sunrise_shader() -> String {
+    let terrain = include_str!("../src/terrain.wgsl");
+    let start = terrain.find("fn sunrise_weight_full").unwrap();
+    let end = terrain[start..].find("// The sky's colour").unwrap() + start;
+    let mut source = String::from(
+        "struct Globals { sunrise: vec4<f32>, sunrise_fan: array<vec4<f32>,32> }\n\
+         @group(0) @binding(0) var<uniform> globals: Globals;\n\
+         @group(0) @binding(1) var<storage,read> rays: array<vec4<f32>>;\n\
+         @group(0) @binding(2) var<storage,read_write> results: array<vec2<f32>>;\n",
+    );
+    source.push_str(&terrain[start..end]);
+    source.push_str(
+        "@compute @workgroup_size(64) fn main(@builtin(global_invocation_id) id: vec3<u32>) {\n\
+             if id.x < arrayLength(&rays) {\n\
+                 let d = rays[id.x].xyz;\n\
+                 results[id.x] = vec2(sunrise_weight_full(d), sunrise_weight(d));\n\
+             }\n\
+         }\n",
+    );
+    source
+}
+
+#[test]
+fn extracted_sunrise_shader_validates() {
+    let module = naga::front::wgsl::parse_str(&sunrise_shader()).unwrap();
+    naga::valid::Validator::new(
+        naga::valid::ValidationFlags::all(),
+        naga::valid::Capabilities::all(),
+    )
+    .validate(&module)
+    .unwrap();
+}
+
+// Execute the actual optimized and reference WGSL on a host GPU.
+// This opt-in test compares shipped WGSL with the full fan search, not FPS.
+#[test]
+#[ignore = "requires a host GPU; run with --ignored --nocapture"]
+fn sunrise_sectors_match_reference_on_real_gpu() {
+    use wgpu::util::DeviceExt;
+    let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+    let adapter = pollster::block_on(instance.request_adapter(&Default::default())).unwrap();
+    eprintln!("Sunrise GPU correctness: {}", adapter.get_info().name);
+    let (device, queue) = pollster::block_on(adapter.request_device(&Default::default())).unwrap();
+    let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        label: None,
+        source: wgpu::ShaderSource::Wgsl(sunrise_shader().into()),
+    });
+    let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+        label: None,
+        layout: None,
+        module: &module,
+        entry_point: Some("main"),
+        compilation_options: Default::default(),
+        cache: None,
+    });
+    let mut rays = Vec::<[f32; 4]>::new();
+    for yaw in 0..360 {
+        for pitch in -89..90 {
+            let (sy, cy) = (yaw as f32).to_radians().sin_cos();
+            let (sp, cp) = (pitch as f32).to_radians().sin_cos();
+            rays.push([sy * cp, sp, cy * cp, 0.]);
+        }
+    }
+    rays.extend([
+        [1., 0., 0., 0.],
+        [-1., 0., 0., 0.],
+        [0., 1., 0., 0.],
+        [0., -1., 0., 0.],
+    ]);
+    let input = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+        label: None,
+        contents: bytemuck::cast_slice(&rays),
+        usage: wgpu::BufferUsages::STORAGE,
+    });
+    let size = (rays.len() * 8) as u64;
+    let output = device.create_buffer(&wgpu::BufferDescriptor {
+        label: None,
+        size,
+        usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
+        mapped_at_creation: false,
+    });
+    let read = device.create_buffer(&wgpu::BufferDescriptor {
+        label: None,
+        size,
+        usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
+        mapped_at_creation: false,
+    });
+    for alpha in [0.01, 0.2, 0.65, 1.] {
+        for hemisphere in [-1., 1.] {
+            let mut globals = vec![[1., 1., 1., alpha]];
+            globals.extend(sunrise_fan::normals(
+                alpha,
+                glam::Vec3::new(0., 0., hemisphere),
+            ));
+            let uniform = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: None,
+                contents: bytemuck::cast_slice(&globals),
+                usage: wgpu::BufferUsages::UNIFORM,
+            });
+            let bindings = [&uniform, &input, &output];
+            let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: None,
+                layout: &pipeline.get_bind_group_layout(0),
+                entries: &bindings
+                    .iter()
+                    .enumerate()
+                    .map(|(i, b)| wgpu::BindGroupEntry {
+                        binding: i as u32,
+                        resource: b.as_entire_binding(),
+                    })
+                    .collect::<Vec<_>>(),
+            });
+            let mut encoder = device.create_command_encoder(&Default::default());
+            {
+                let mut pass = encoder.begin_compute_pass(&Default::default());
+                pass.set_pipeline(&pipeline);
+                pass.set_bind_group(0, &group, &[]);
+                pass.dispatch_workgroups((rays.len() as u32).div_ceil(64), 1, 1);
+            }
+            encoder.copy_buffer_to_buffer(&output, 0, &read, 0, size);
+            queue.submit([encoder.finish()]);
+            read.slice(..)
+                .map_async(wgpu::MapMode::Read, |r| r.unwrap());
+            device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+            {
+                let mapped = read.slice(..).get_mapped_range().unwrap();
+                let pairs: &[[f32; 2]] = bytemuck::cast_slice(&mapped);
+                for (i, pair) in pairs.iter().enumerate() {
+                    assert!(
+                        (pair[0] - pair[1]).abs() < 1e-4,
+                        "alpha={alpha} hemisphere={hemisphere} ray={:?} values={pair:?}",
+                        rays[i]
+                    );
+                }
+            }
+            read.unmap();
+        }
+    }
+}
+
+#[test]
+fn native_pack_sky_keeps_sunrise_helpers_private() {
+    use wgsl_prefix::{TERRAIN, prefixed, section};
+    // Use the same complete terrain sections and prefixer as native_sky.rs.
+    let sky = prefixed(
+        &[
+            section(TERRAIN, "struct Globals {", "@group(0) @binding(1)"),
+            section(TERRAIN, "fn linear_fog(", "fn apply_fog("),
+            section(TERRAIN, "struct SkyOut {", "// rendertype_lines"),
+        ]
+        .concat(),
+        "horizon_sky_",
+    );
+    for name in [
+        "sunrise_weight",
+        "sunrise_weight_full",
+        "sunrise_triangle_weight",
+    ] {
+        assert!(sky.contains(&format!("fn horizon_sky_{name}(")));
+    }
+    // A native pack may declare the same helper names as the renderer.
+    let own = "fn sunrise_weight(d: vec3<f32>) -> f32 { return d.x; }\n\
+               fn sunrise_weight_full(d: vec3<f32>) -> f32 { return d.y; }\n\
+               fn sunrise_triangle_weight(d: vec3<f32>, i: u32) -> f32 { return d.z + f32(i); }\n";
+    let module = naga::front::wgsl::parse_str(&format!("{own}\n{sky}")).unwrap();
+    naga::valid::Validator::new(
+        naga::valid::ValidationFlags::all(),
+        naga::valid::Capabilities::all(),
+    )
+    .validate(&module)
+    .unwrap();
+}
+
+#[test]
+fn complete_terrain_shader_still_validates_for_fallback_sky() {
+    let module = naga::front::wgsl::parse_str(wgsl_prefix::TERRAIN).unwrap();
+    naga::valid::Validator::new(
+        naga::valid::ValidationFlags::all(),
+        naga::valid::Capabilities::all(),
+    )
+    .validate(&module)
+    .unwrap();
+}

crates/horizon-client/Cargo.toml

@@ -64,10 +64,11 @@ horizon-dualsense = { path = "../horizon-dualsense", optional = true }
 # HTTPS to the Minecraft services (online-mode session join).
 ureq = { version = "2", default-features = false, features = ["tls"] }
 unicode-bidi = "0.3.18"
+# `LevelStorageAccess.estimateDiskSpace`: usable disk space, without unsafe code on Windows.
+fs4 = { version = "1.1.0", default-features = false, features = ["sync"] }
 
 [target.'cfg(unix)'.dependencies]
 # The server thread's CPU time per tick (`HORIZON_SPIKES`, spans.rs).
-# `LevelStorageAccess.estimateDiskSpace` (statvfs) too.
 rustix = { version = "1", default-features = false, features = ["std", "time", "process", "fs"] }
 
 [target.'cfg(windows)'.dependencies]
@@ -96,6 +97,10 @@ audio = ["horizon-client-render/audio"]
 controllers = ["dep:gilrs", "dep:horizon-dualsense", "horizon-client-input/controllers"]
 # Records the call sites of mob random draws (`mob_ai_probe` traces).
 rng-trace = ["horizon-core/rng-trace"]
+# Compatibility with earlier experiment commands: main already uses mimalloc.
+windows-mimalloc = []
+# Opt-in Windows heap experiment; see docs/windows-allocators.md.
+windows-segment-heap = []
 
 # Its own name, not `probe`: Cargo copies every crate's examples into one target/<profile>/examples.
 [[example]]

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

@@ -53,6 +53,7 @@
   "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.not_built": " (Not built)",
   "horizon.mods.dev": " (Dev)",
   "horizon.mods.settings": "Settings",
   "horizon.mods.open_folder": "Open Mod Folder",
@@ -63,5 +64,137 @@
   "horizon.multiplayer.cancel_reconnecting": "Cancel Reconnecting",
   "horizon.multiplayer.join_friend": "Join a Friend",
   "horizon.multiplayer.invite_code": "Invite Code",
-  "horizon.multiplayer.relay": "Relay (optional)"
+  "horizon.multiplayer.relay": "Relay (optional)",
+  "Preset": "Preset",
+  "LOD Distance": "LOD Distance",
+  "Far Detail": "Far Detail",
+  "Cave Culling": "Cave Culling",
+  "Entity Culling": "Entity Culling",
+  "Chunk Updates": "Chunk Updates",
+  "Upload Budget": "Upload Budget",
+  "Sky": "Sky",
+  "Fog": "Fog",
+  "Weather": "Weather",
+  "Animated Textures": "Animated Textures",
+  "Present Mode": "Present Mode",
+  "Frame Pacing": "Frame Pacing",
+  "Worker Threads": "Worker Threads",
+  "Resolution Scale": "Resolution Scale",
+  "Anti-aliasing": "Anti-aliasing",
+  "Upscaling": "Upscaling",
+  "HDR Settings...": "HDR Settings...",
+  "Paper White": "Paper White",
+  "Peak Brightness": "Peak Brightness",
+  "Black Level": "Black Level",
+  "UI Brightness": "UI Brightness",
+  "Battery Mode": "Battery Mode",
+  "Graphics API": "Graphics API",
+  "Performance Overlay": "Performance Overlay",
+  "Full Detail Distance": "Full Detail Distance",
+  "On": "On",
+  "Off": "Off",
+  "Unlimited": "Unlimited",
+  "Auto": "Auto",
+  "Custom": "Custom",
+  "Performance": "Performance",
+  "Balanced": "Balanced",
+  "Quality": "Quality",
+  "Ultra": "Ultra",
+  "Ultra Performance": "Ultra Performance",
+  "Native": "Native",
+  "Full": "Full",
+  "Reduced": "Reduced",
+  "Efficient": "Efficient",
+  "Precise": "Precise",
+  "Auto (VSync)": "Auto (VSync)",
+  "FIFO": "FIFO",
+  "Mailbox": "Mailbox",
+  "Immediate": "Immediate",
+  "Vulkan": "Vulkan",
+  "DirectX 12": "DirectX 12",
+  "OpenGL": "OpenGL",
+  "FPS and Graph": "FPS and Graph",
+  "FPS": "FPS",
+  "TAA": "TAA",
+  "FXAA": "FXAA",
+  "No cost": "No cost",
+  "Low cost": "Low cost",
+  "Medium cost": "Medium cost",
+  "High cost": "High cost",
+  "Saves time": "Saves time",
+  "Rendering": "Rendering",
+  "Display": "Display",
+  "Preferences": "Preferences",
+  "Overlay": "Overlay",
+  "HDR": "HDR",
+  "Graphics": "Graphics",
+  "Graphics: Advanced": "Graphics: Advanced",
+  "Graphics: HDR": "Graphics: HDR",
+  "Advanced...": "Advanced...",
+  "Simple...": "Simple...",
+  "Done": "Done",
+  "This feature is not yet available in Horizon.": "This feature is not yet available in Horizon.",
+  "Your display or system doesn't offer HDR output.": "Your display or system doesn't offer HDR output.",
+  "Turn HDR on to use it.": "Turn HDR on to use it.",
+  "%s chunks": "%s chunks",
+  "%s per frame": "%s per frame",
+  "%s MiB/frame": "%s MiB/frame",
+  "%s KiB/frame": "%s KiB/frame",
+  "%s nits": "%s nits",
+  "Auto (%s)": "Auto (%s)",
+  "Auto (%s nits)": "Auto (%s nits)",
+  "%.2f nits": "%.2f nits",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Full-detail terrain range. LOD Distance can extend local worlds farther.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Reduced draws far terrain coarser: faster on this integrated GPU.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Reduced draws far terrain coarser, for GPUs it slows down.",
+  "Field of view. Wider shows more terrain at once.": "Field of view. Wider shows more terrain at once.",
+  "Caps frames per second; a cap saves power and heat.": "Caps frames per second; a cap saves power and heat.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Waits for the display's refresh: no tearing, a little latency.",
+  "Size of menus and the HUD.": "Size of menus and the HUD.",
+  "Sets the options below together. Changing one makes it Custom.": "Sets the options below together. Changing one makes it Custom.",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Lava, fire and sunlight shine brighter than white. Needs an HDR display.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Your display's darkest black. 0 for OLED; LCDs glow a little.",
+  "How bright highlights get. Auto: the peak your system reports.": "How bright highlights get. Auto: the peak your system reports.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "How bright white paper and menus look. Auto: your desktop's white.",
+  "How bright the HUD and menus are, against paper white.": "How bright the HUD and menus are, against paper white.",
+  "How far mobs, crops and machines keep working. CPU time.": "How far mobs, crops and machines keep working. CPU time.",
+  "How far away mobs and items are drawn, as a share of normal.": "How far away mobs and items are drawn, as a share of normal.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Skips terrain hidden behind closed sections. Off costs a lot.",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Hides models behind opaque blocks. Entities update. Off with custom packs.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Meshed sections uploaded per frame. Lower is smoother while loading.",
+  "Soft shadows in corners. Costs chunk building time only.": "Soft shadows in corners. Costs chunk building time only.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Smaller copies of block textures for distant terrain: less shimmer.",
+  "Blends grass and water colours across biomes when building chunks.": "Blends grass and water colours across biomes when building chunks.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Cloud layer: off, flat (fast) or 3D (fancy).",
+  "How far clouds reach, in chunks.": "How far clouds reach, in chunks.",
+  "Draws the sky, sun, moon and stars.": "Draws the sky, sun, moon and stars.",
+  "Distance fog. Off shows the edge of the loaded world.": "Distance fog. Off shows the edge of the loaded world.",
+  "Draws rain and snow.": "Draws rain and snow.",
+  "How far rain and snow fall around you.": "How far rain and snow fall around you.",
+  "How many particles effects spawn.": "How many particles effects spawn.",
+  "Round shadows under mobs and items.": "Round shadows under mobs and items.",
+  "Leaves with see-through gaps. Off draws them solid.": "Leaves with see-through gaps. Off draws them solid.",
+  "Sorts water and glass more exactly behind each other.": "Sorts water and glass more exactly behind each other.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Which chunk rebuilds wait for the frame: none, nearby or yours.",
+  "Animates water, lava, fire and other moving textures.": "Animates water, lava, fire and other moving textures.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "World pixels per screen pixel. Below 100% is faster on the GPU.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Renders the world smaller and rebuilds it with TAA. Faster, softer.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "HDR output on an HDR display: lava, fire and sunlight shine brighter.",
+  "How frames reach the screen while VSync is off.": "How frames reach the screen while VSync is off.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Efficient sleeps until the next frame; Precise spins, like vanilla.",
+  "Fills the screen (borderless).": "Fills the screen (borderless).",
+  "Brightens dark places.": "Brightens dark places.",
+  "Lowers the frame rate when minimised, or idle too.": "Lowers the frame rate when minimised, or idle too.",
+  "Sways the view while walking.": "Sways the view while walking.",
+  "Fades newly loaded chunks in.": "Fades newly loaded chunks in.",
+  "Darkens the screen's edges.": "Darkens the screen's edges.",
+  "Shows when the world saves.": "Shows when the world saves.",
+  "Shows attack cooldown.": "Shows attack cooldown.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "60 FPS cap (30 in menus or unfocused), half the workers: less power.",
+  "Threads that generate, light and mesh chunks. Next start.": "Threads that generate, light and mesh chunks. Next start.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Mesh data sent to the GPU per frame. Lower is smoother while loading.",
+  "Frame rate and frame times over the game, with a graph.": "Frame rate and frame times over the game, with a graph."
 }

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

@@ -0,0 +1,15 @@
+{
+  "horizon.options.controller": "Mando",
+  "horizon.options.vibration": "Vibración",
+  "horizon.options.adaptive_triggers": "Gatillos adaptativos",
+  "horizon.options.lightbar": "Barra de luz",
+  "horizon.options.look_sensitivity": "Sensibilidad de vista",
+  "horizon.options.invert_x": "Invertir vista X",
+  "horizon.options.invert_y": "Invertir vista Y",
+  "horizon.options.sneak_button": "Botón de agacharse",
+  "horizon.options.move_deadzone": "Zona muerta de movimiento",
+  "horizon.options.look_deadzone": "Zona muerta de vista",
+  "horizon.options.button_glyphs": "Símbolos de botones",
+  "horizon.options.menu_navigation": "Navegación de menús",
+  "horizon.options.on_screen_keyboard": "Teclado en pantalla"
+}

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

@@ -63,5 +63,137 @@
   "horizon.multiplayer.cancel_reconnecting": "Отменить переподключение",
   "horizon.multiplayer.join_friend": "Играть с другом",
   "horizon.multiplayer.invite_code": "Код приглашения",
-  "horizon.multiplayer.relay": "Ретранслятор (необязательно)"
+  "horizon.multiplayer.relay": "Ретранслятор (необязательно)",
+  "Preset": "Пресет",
+  "LOD Distance": "Дистанция LOD",
+  "Far Detail": "Детализация вдали",
+  "Cave Culling": "Отсечение пещер",
+  "Entity Culling": "Отсечение сущностей",
+  "Chunk Updates": "Обновления чанков",
+  "Upload Budget": "Бюджет выгрузки",
+  "Sky": "Небо",
+  "Fog": "Туман",
+  "Weather": "Погода",
+  "Animated Textures": "Анимированные текстуры",
+  "Present Mode": "Режим вывода",
+  "Frame Pacing": "Ритм кадров",
+  "Worker Threads": "Рабочие потоки",
+  "Resolution Scale": "Масштаб разрешения",
+  "Anti-aliasing": "Сглаживание",
+  "Upscaling": "Апскейл",
+  "HDR Settings...": "Настройки HDR…",
+  "Paper White": "Белая точка",
+  "Peak Brightness": "Пиковая яркость",
+  "Black Level": "Уровень чёрного",
+  "UI Brightness": "Яркость интерфейса",
+  "Battery Mode": "Режим экономии",
+  "Graphics API": "Графический API",
+  "Performance Overlay": "Оверлей производительности",
+  "Full Detail Distance": "Дальность полной детализации",
+  "On": "Вкл.",
+  "Off": "Выкл.",
+  "Unlimited": "Без ограничения",
+  "Auto": "Авто",
+  "Custom": "Свои",
+  "Performance": "Производительность",
+  "Balanced": "Сбалансированный",
+  "Quality": "Качество",
+  "Ultra": "Ультра",
+  "Ultra Performance": "Максимальная производительность",
+  "Native": "Нативный",
+  "Full": "Полная",
+  "Reduced": "Снижена",
+  "Efficient": "Экономный",
+  "Precise": "Точный",
+  "Auto (VSync)": "Авто (верт. синхр.)",
+  "FIFO": "FIFO",
+  "Mailbox": "Mailbox",
+  "Immediate": "Immediate",
+  "Vulkan": "Vulkan",
+  "DirectX 12": "DirectX 12",
+  "OpenGL": "OpenGL",
+  "FPS and Graph": "FPS и график",
+  "FPS": "FPS",
+  "TAA": "TAA",
+  "FXAA": "FXAA",
+  "No cost": "Без затрат",
+  "Low cost": "Мало затрат",
+  "Medium cost": "Средние затраты",
+  "High cost": "Много затрат",
+  "Saves time": "Экономит время",
+  "Rendering": "Рендеринг",
+  "Display": "Изображение",
+  "Preferences": "Предпочтения",
+  "Overlay": "Оверлей",
+  "HDR": "HDR",
+  "Graphics": "Графика",
+  "Graphics: Advanced": "Графика: подробно",
+  "Graphics: HDR": "Графика: HDR",
+  "Advanced...": "Подробно…",
+  "Simple...": "Просто…",
+  "Done": "Готово",
+  "This feature is not yet available in Horizon.": "Эта функция в Horizon пока недоступна.",
+  "Your display or system doesn't offer HDR output.": "Ваш экран или система не поддерживает HDR-вывод.",
+  "Turn HDR on to use it.": "Включите HDR, чтобы пользоваться этим.",
+  "%s chunks": "%s чанков",
+  "%s per frame": "%s за кадр",
+  "%s MiB/frame": "%s МиБ/кадр",
+  "%s KiB/frame": "%s КиБ/кадр",
+  "%s nits": "%s нит",
+  "Auto (%s)": "Авто (%s)",
+  "Auto (%s nits)": "Авто (%s нит)",
+  "%.2f nits": "%.2f нит",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Дальность прорисованного рельефа в деталях. Дистанция LOD может продлить её для локальных миров.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Грубый дальний рельеф в локальных мирах. На встроенной графике — не дальше 128 чанков.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "«Снижено» рисует дальний рельеф грубее: на этой встроенной видеокарте быстрее.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "«Снижено» рисует дальний рельеф грубее — для карт, которым он мешает.",
+  "Field of view. Wider shows more terrain at once.": "Угол обзора. Шире — больше рельефа видно сразу.",
+  "Caps frames per second; a cap saves power and heat.": "Ограничивает кадры в секунду: предел экономит энергию и снижает нагрев.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Ждёт обновления экрана: без разрывов, с небольшой задержкой.",
+  "Size of menus and the HUD.": "Размер меню и интерфейса.",
+  "Sets the options below together. Changing one makes it Custom.": "Задаёт настройки ниже разом. Изменишь одну — станет «Свои».",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Лава, огонь и солнце светятся ярче белого. Нужен HDR-экран.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Самый тёмный чёрный вашего экрана. 0 для OLED; ЖК-панели светятся немного.",
+  "How bright highlights get. Auto: the peak your system reports.": "Насколько яркими будут блики. Авто: пик, который сообщает система.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Насколько ярким выглядит белый и меню. Авто: белый цвет рабочего стола.",
+  "How bright the HUD and menus are, against paper white.": "Яркость интерфейса и меню относительно белой точки.",
+  "How far mobs, crops and machines keep working. CPU time.": "Как далеко мобы, посевы и механизмы продолжают работать. Нагрузка на процессор.",
+  "How far away mobs and items are drawn, as a share of normal.": "С какой дистанции рисуются мобы и предметы, в долях от обычной.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Пропускает рельеф, скрытый за закрытыми секциями. Выключено — дорого.",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Прячет модели за непрозрачными блоками. Сущности тикают. Выключать со своими наборами.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Секций меша за кадр. Меньше — плавнее во время загрузки.",
+  "Soft shadows in corners. Costs chunk building time only.": "Мягкие тени по углам. Замедляет только построение чанков.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Уменьшенные копии текстур блоков для дали: меньше мерцания.",
+  "Blends grass and water colours across biomes when building chunks.": "Смешивает цвета травы и воды на границах биомов при построении чанков.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Слой облаков: выключен, плоский (быстро) или 3D (красиво).",
+  "How far clouds reach, in chunks.": "Как далеко простираются облака, в чанках.",
+  "Draws the sky, sun, moon and stars.": "Рисует небо, солнце, луну и звёзды.",
+  "Distance fog. Off shows the edge of the loaded world.": "Туман по дальности. Выключенный виден край прогруженного мира.",
+  "Draws rain and snow.": "Рисует дождь и снег.",
+  "How far rain and snow fall around you.": "Как далеко вокруг вас идёт дождь и снег.",
+  "How many particles effects spawn.": "Сколько частиц создают эффекты.",
+  "Round shadows under mobs and items.": "Круглые тени под мобами и предметами.",
+  "Leaves with see-through gaps. Off draws them solid.": "Листва с просветами. Выключено — рисуется сплошной.",
+  "Sorts water and glass more exactly behind each other.": "Точнее сортирует воду и стекло друг за другом.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Какие перестройки чанков ждут кадр: никакие, ближние или ваши.",
+  "Animates water, lava, fire and other moving textures.": "Анимирует воду, лаву, огонь и другие движущиеся текстуры.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Пикселей мира на пиксель экрана. Ниже 100% — быстрее для видеокарты.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Сглаживает рваные края. FXAA: мягче. TAA: глаже всего, но движущееся может шлейфить.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Рисует мир мельче и восстанавливает его через TAA. Быстрее, но мягче.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "HDR-вывод на HDR-экране: лава, огонь и солнце светятся ярче.",
+  "How frames reach the screen while VSync is off.": "Как кадры попадают на экран, когда вертикальная синхронизация выключена.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "«Экономный» спит до следующего кадра; «Точный» крутится, как в ванили.",
+  "Fills the screen (borderless).": "Занимает весь экран (без рамки).",
+  "Brightens dark places.": "Осветляет тёмные места.",
+  "Lowers the frame rate when minimised, or idle too.": "Снижает частоту кадров в свёрнутом окне, а также в простое.",
+  "Sways the view while walking.": "Покачивает вид при ходьбе.",
+  "Fades newly loaded chunks in.": "Плавно проявляет только что загруженные чанки.",
+  "Darkens the screen's edges.": "Затемняет края экрана.",
+  "Shows when the world saves.": "Показывает, когда мир сохраняется.",
+  "Shows attack cooldown.": "Показывает перезарядку удара.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "Предел 60 FPS (30 в меню и без фокуса) и половина потоков: меньше энергии.",
+  "Threads that generate, light and mesh chunks. Next start.": "Потоки, которые генерируют, освещают и строят чанки. Со следующего запуска.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, при сбое — DirectX 12 (Windows) или OpenGL (Linux). Со следующего запуска.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Данных меша в видеокарту за кадр. Меньше — плавнее во время загрузки.",
+  "Frame rate and frame times over the game, with a graph.": "Частота кадров и их время поверх игры, с графиком."
 }

crates/horizon-client/build.rs

@@ -1,5 +1,6 @@
 //! Embeds Horizon's icon (`packaging/icons/horizon.ico`) in the Windows executables, as icon
 //! resource 1: Explorer and the task bar show it, and the window takes it as its icon.
+//! The optional Segment Heap manifest is embedded in the same resource compilation.
 fn main() {
     let dir = std::env::var("CARGO_MANIFEST_DIR").unwrap_or_default();
     let ico = format!("{dir}/../../packaging/icons/horizon.ico");
@@ -8,8 +9,13 @@ fn main() {
     if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
         let mut resource = winresource::WindowsResource::new();
         resource.set_icon(&ico);
+        if std::env::var_os("CARGO_FEATURE_WINDOWS_SEGMENT_HEAP").is_some() {
+            let manifest = format!("{dir}/windows-segment-heap.manifest");
+            println!("cargo:rerun-if-changed={manifest}");
+            resource.set_manifest_file(&manifest);
+        }
         if let Err(e) = resource.compile() {
-            panic!("embedding {ico}: {e}");
+            panic!("embedding Windows resources: {e}");
         }
     }
 }

crates/horizon-client/examples/mod_port_probe.rs

@@ -46,6 +46,26 @@ fn tool(name: &str) -> Option<ItemStack> {
     }
 }
 
+/// An equipment asset's first humanoid layers as files under the root, as worn armour reads them.
+fn equipment_textures(root: &Path, asset: &str) -> Value {
+    let (ns, path) = asset.split_once(':').unwrap_or(("minecraft", asset));
+    let Ok(doc) = fs::read(root.join(format!("assets/{ns}/equipment/{path}.json"))) else {
+        return Value::Null;
+    };
+    let doc: Value = serde_json::from_slice(&doc).unwrap_or_default();
+    let mut out = Map::new();
+    for kind in ["humanoid", "humanoid_leggings"] {
+        if let Some(texture) = doc["layers"][kind][0]["texture"].as_str() {
+            let (tns, tpath) = texture.split_once(':').unwrap_or(("minecraft", texture));
+            let file = root.join(format!(
+                "assets/{tns}/textures/entity/equipment/{kind}/{tpath}.png"
+            ));
+            out.insert(kind.into(), json!(file.exists().then_some(file)));
+        }
+    }
+    Value::Object(out)
+}
+
 fn main() -> Result<()> {
     let args: Vec<String> = std::env::args().skip(1).collect();
     let [base, work, out, wanted @ ..] = args.as_slice() else {
@@ -226,6 +246,7 @@ fn main() -> Result<()> {
                         "repairable": repairable,
                         "equip_slot": i.equip_slot,
                         "equip_asset": i.equip_asset,
+                        "equipment": i.equip_asset.as_deref().map(|a| equipment_textures(&root, a)),
                         "food": i.food.map(|(nutrition, saturation)| json!({"nutrition": nutrition, "saturation": saturation})),
                     })
                 }

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

@@ -599,6 +599,8 @@ fn print_heart(
 fn player_damage(e: &MobEvent) -> f32 {
     match e {
         MobEvent::AttackPlayer(amount, _)
+        | MobEvent::CubeHurtPlayer { amount, .. }
+        | MobEvent::StingPlayer { amount, .. }
         | MobEvent::AttackPlayerWithEffect { amount, .. }
         | MobEvent::DamagePlayer { amount, .. } => *amount,
         MobEvent::SonicBoom {
@@ -616,6 +618,8 @@ fn player_hurt(player: Option<&PlayerView>, e: &MobEvent) -> bool {
     };
     match e {
         MobEvent::AttackPlayer(amount, _)
+        | MobEvent::CubeHurtPlayer { amount, .. }
+        | MobEvent::StingPlayer { amount, .. }
         | MobEvent::AttackPlayerWithEffect { amount, .. }
         | MobEvent::DamagePlayer { amount, .. } => *amount > 0.0,
         MobEvent::SonicBoom {
@@ -1027,6 +1031,10 @@ pub fn main() -> horizon_client::Result<()> {
                     "inlove" => m.extra.in_love = 600,
                     "nectar" => horizon_client::mobs::bee::set_has_nectar(&mut m, true),
                     "tame" => m.extra.tame = true,
+                    "owned" => {
+                        horizon_client::mobs::tame::set_tame(&mut m, true);
+                        m.extra.owner = Some(PLAYER_UUID);
+                    }
                     x if x.starts_with("age=") => m.extra.age = x[4..].parse().unwrap(),
                     x if x.starts_with("strength=") => m.extra.variant2 = x[9..].parse().unwrap(),
                     x if x.starts_with("hand=") => {

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

@@ -220,7 +220,7 @@ pub fn main() -> Result<()> {
                 }
                 writeln!(out)?;
             }
-            for (name, p, volume, pitch) in std::mem::take(&mut engine.sounds) {
+            for (name, p, volume, pitch, _) in std::mem::take(&mut engine.sounds) {
                 writeln!(
                     out,
                     "~ {name} {} {} {} {} {}",

crates/horizon-client/src/animate_tick.rs

@@ -301,7 +301,9 @@ fn candle_offsets(count: u8) -> &'static [[f64; 3]] {
     }
 }
 
-/// Per-state animate behaviour and the block tags it needs.
+/// Per-state animate behaviour and the block tags it needs. Empty by default
+/// (a dedicated server): every lookup finds nothing to animate.
+#[derive(Default)]
 pub struct AnimateTables {
     kinds: Vec<Animate>,
     impermeable: Vec<bool>,
@@ -536,7 +538,7 @@ fn add_visible(engine: &mut ParticleEngine, ty: T, p: [f64; 3], v: [f64; 3]) {
     engine.add_with(&ParticleOptions::simple(ty), p, v, false, true);
 }
 fn sound(engine: &mut ParticleEngine, name: &'static str, p: [f64; 3], volume: f32, pitch: f32) {
-    engine.sounds.push((name, p, volume, pitch));
+    engine.sounds.push((name, p, volume, pitch, false));
 }
 fn redstone(engine: &mut ParticleEngine, p: [f64; 3]) {
     engine.add(&ParticleOptions::dust([1.0, 0.0, 0.0], 1.0), p, [0.0; 3]);

crates/horizon-client/src/attribute_updates.rs

@@ -105,7 +105,7 @@ impl UpdateWorld<Key> for PlayerMotion {
     }
 }
 impl LiveAttributeWorld for PlayerMotion {
-    type Identity = Box<dyn FnMut() -> i32>;
+    type Identity = Box<dyn horizon_world::attributes::live::Identities>;
     fn get_attributes(&mut self) -> Result<()> {
         Ok(())
     }

crates/horizon-client/src/block_pattern.rs

@@ -1,6 +1,6 @@
 //! `BlockPattern`: a grid of block predicates found in the world in any of
 //! its 24 orientations (upright, upside down, lying flat, turned sideways).
-//! The wither is built from these.
+//! The wither and the golems are built from these.
 use horizon_core::geometry::Direction;
 
 /// A grid of predicate keys: `aisles[z][y]` is a row whose chars are the `x`
@@ -19,6 +19,25 @@ pub const WITHER_FULL: BlockPattern = BlockPattern {
 pub const WITHER_BASE: BlockPattern = BlockPattern {
     aisles: &[&["   ", "###", "~#~"]],
 };
+/// `CarvedPumpkinBlock.getOrCreateSnowGolemFull`: '^' a carved pumpkin or
+/// jack o'lantern, '#' a snow block.
+pub const SNOW_GOLEM_FULL: BlockPattern = BlockPattern {
+    aisles: &[&["^", "#", "#"]],
+};
+/// `CarvedPumpkinBlock.getOrCreateSnowGolemBase`: the same column with any
+/// block where the head will go.
+pub const SNOW_GOLEM_BASE: BlockPattern = BlockPattern {
+    aisles: &[&[" ", "#", "#"]],
+};
+/// `CarvedPumpkinBlock.getOrCreateIronGolemFull`: '^' the head, '#' an iron
+/// block, '~' air beside the arms and legs.
+pub const IRON_GOLEM_FULL: BlockPattern = BlockPattern {
+    aisles: &[&["~^~", "###", "~#~"]],
+};
+/// `CarvedPumpkinBlock.getOrCreateIronGolemBase`.
+pub const IRON_GOLEM_BASE: BlockPattern = BlockPattern {
+    aisles: &[&["~ ~", "###", "~#~"]],
+};
 /// `BlockPattern.BlockPatternMatch`: where a pattern was found and how it is turned.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct PatternMatch {

crates/horizon-client/src/content_identity.rs

@@ -1,7 +1,11 @@
-//! Identity of the ordered block-state registry used by chunk packets.
+//! Identity of the ordered block-state registry used by chunk packets, and of
+//! the mob effect registry once content mods add to it (effect packets carry
+//! its network ids).
+use serde::{Deserialize, Serialize, de::IgnoredAny};
 use sha2::{Digest, Sha256};
 use std::{
-    collections::HashMap,
+    collections::{BTreeMap, HashMap},
+    fmt, io,
     path::{Path, PathBuf},
     sync::{Mutex, OnceLock},
 };
@@ -9,47 +13,128 @@ use std::{
 pub const CHANNEL: &str = "horizon:block_registry";
 pub const MARKER: &str = "horizon-content-blocks";
 pub const MISMATCH: &str =
-    "Content block registry mismatch: install the same content blocks as the server.";
+    "Content registry mismatch: install the same content mods as the server.";
+
+#[derive(Debug)]
+pub enum IdentityError {
+    Read(io::Error),
+    Json(serde_json::Error),
+    Registries(String),
+}
+
+impl fmt::Display for IdentityError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Read(error) => write!(f, "cannot read facts.json: {error}"),
+            Self::Json(error) => write!(f, "invalid facts.json: {error}"),
+            Self::Registries(error) => write!(f, "invalid registries.json: {error}"),
+        }
+    }
+}
+
+impl std::error::Error for IdentityError {}
+
+#[derive(Deserialize)]
+struct Facts {
+    states: Vec<StateRow>,
+}
+
+#[derive(Deserialize)]
+struct StateRow(IgnoredAny, IgnoredAny, IgnoredAny, IgnoredAny, State);
+
+#[derive(Deserialize, Serialize)]
+#[serde(deny_unknown_fields)]
+struct State {
+    id: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    properties: Option<BTreeMap<String, String>>,
+}
 
 /// Hash the network order and each state's name and properties, not its gameplay facts.
-pub fn identity(root: &Path) -> Result<[u8; 32], String> {
+pub fn identity(root: &Path) -> Result<[u8; 32], IdentityError> {
+    // Keep each resource root stable and avoid reparsing its large facts file for every join.
     static IDENTITIES: OnceLock<Mutex<HashMap<PathBuf, [u8; 32]>>> = OnceLock::new();
     let mut identities = IDENTITIES.get_or_init(Default::default).lock().unwrap();
     if let Some(hash) = identities.get(root) {
         return Ok(*hash);
     }
-    let bytes = std::fs::read(root.join("facts.json")).map_err(|e| e.to_string())?;
-    let hash = hash_facts(&bytes)?;
+    let bytes = std::fs::read(root.join("facts.json")).map_err(IdentityError::Read)?;
+    let mut hash = hash_facts(&bytes)?;
+    let effects = match std::fs::read(root.join("registries.json")) {
+        Ok(registries) => mod_effects(&registries)?,
+        Err(_) => Vec::new(),
+    };
+    if !effects.is_empty() {
+        hash = hash_effects(hash, &effects);
+    }
     identities.insert(root.to_owned(), hash);
     Ok(hash)
 }
 
-fn hash_facts(bytes: &[u8]) -> Result<[u8; 32], String> {
-    let facts: serde_json::Value = serde_json::from_slice(bytes).map_err(|e| e.to_string())?;
-    let states = facts
-        .get("states")
-        .and_then(|s| s.as_array())
-        .ok_or("facts.json has no block states")?;
+fn hash_facts(bytes: &[u8]) -> Result<[u8; 32], IdentityError> {
+    let facts: Facts = serde_json::from_slice(bytes).map_err(IdentityError::Json)?;
     let mut hash = Sha256::new();
-    for row in states {
-        let state = row
-            .as_array()
-            .and_then(|r| r.get(4))
-            .ok_or("facts.json has an invalid block state")?;
-        let encoded = serde_json::to_vec(state).map_err(|e| e.to_string())?;
+    for row in facts.states {
+        let encoded = serde_json::to_vec(&row.4).map_err(IdentityError::Json)?;
         hash.update((encoded.len() as u64).to_le_bytes());
         hash.update(encoded);
     }
     Ok(hash.finalize().into())
 }
 
+/// The content mods' mob effects in `registries.json`, by network id.
+fn mod_effects(bytes: &[u8]) -> Result<Vec<(u64, String)>, IdentityError> {
+    let text = std::str::from_utf8(bytes).map_err(|e| IdentityError::Registries(e.to_string()))?;
+    let report = horizon_protocol::registry::Builtin::parse(text)
+        .map_err(|e| IdentityError::Registries(e.to_string()))?;
+    // Names come indexed by network id, so they are already in order.
+    Ok(report
+        .get("minecraft:mob_effect")
+        .into_iter()
+        .flat_map(|ids| ids.names.iter().enumerate())
+        .filter(|(_, name)| !name.is_empty() && !name.starts_with("minecraft:"))
+        .map(|(id, name)| (id as u64, name.clone()))
+        .collect())
+}
+
+/// The block identity extended with the mods' effects; a root without them
+/// keeps its block-only identity.
+fn hash_effects(blocks: [u8; 32], effects: &[(u64, String)]) -> [u8; 32] {
+    let mut hash = Sha256::new();
+    hash.update(blocks);
+    for (id, name) in effects {
+        hash.update(id.to_le_bytes());
+        hash.update((name.len() as u64).to_le_bytes());
+        hash.update(name);
+    }
+    hash.finalize().into()
+}
+
 #[cfg(test)]
 mod tests {
-    use super::hash_facts;
+    use super::{hash_effects, hash_facts, mod_effects};
+
+    #[test]
+    fn mod_effects_join_the_identity() {
+        let report = |extra: &str| {
+            format!(
+                r#"{{"minecraft:mob_effect":{{"entries":{{"minecraft:speed":{{"protocol_id":0}}{extra}}}}}}}"#
+            )
+        };
+        assert!(mod_effects(report("").as_bytes()).unwrap().is_empty());
+        let glow = mod_effects(report(r#","ruby:glow":{"protocol_id":40}"#).as_bytes()).unwrap();
+        assert_eq!(glow, [(40, "ruby:glow".to_owned())]);
+        let zap = mod_effects(report(r#","ruby:zap":{"protocol_id":40}"#).as_bytes()).unwrap();
+        let blocks = [7; 32];
+        assert_ne!(hash_effects(blocks, &glow), hash_effects(blocks, &zap));
+        assert_ne!(hash_effects(blocks, &glow), blocks);
+    }
 
     #[test]
     fn identity_tracks_order_and_properties_not_gameplay_data() {
-        let facts = |a: &str, b: &str| format!(r#"{{"states":[["x",0,0,0,{a}],["y",0,0,0,{b}]]}}"#);
+        let facts = |a: &str, b: &str| {
+            format!(r#"{{"states":[["x",false,false,"x",{a}],["y",false,false,"y",{b}]]}}"#)
+        };
         let a = r#"{"id":"demo:a","properties":{"facing":"north"}}"#;
         let b = r#"{"id":"demo:b"}"#;
         let first = hash_facts(facts(a, b).as_bytes()).unwrap();
@@ -62,9 +147,10 @@ mod tests {
         );
         assert_ne!(
             first,
-            hash_facts(format!(r#"{{"states":[["x",0,0,0,{a}]]}}"#).as_bytes()).unwrap()
+            hash_facts(format!(r#"{{"states":[["x",false,false,"x",{a}]]}}"#).as_bytes()).unwrap()
         );
-        assert!(hash_facts(br#"{"states":[[0,0,0,0,"minecraft:stone"]]}"#).is_ok());
+        assert!(hash_facts(br#"{"states":[["x",false,false,"x","minecraft:stone"]]}"#).is_err());
         assert!(hash_facts(br#"{"states":[[]]}"#).is_err());
+        assert!(hash_facts(br#"{"states":[["x",false,false,"x",{"id":"x"},0]]}"#).is_err());
     }
 }

crates/horizon-client/src/crafting.rs

@@ -28,7 +28,7 @@ impl Ingredient {
     pub fn of(items: Vec<String>) -> Self {
         Self(items.iter().cloned().collect(), items)
     }
-    pub(crate) fn parse(v: &Value, items: &Items) -> Option<Self> {
+    pub fn parse(v: &Value, items: &Items) -> Option<Self> {
         let mut list: Vec<String> = Vec::new();
         let mut add = |s: &str| {
             let more: Vec<String> = match s.strip_prefix('#') {
@@ -1099,9 +1099,30 @@ pub struct Cooking {
     pub experience: f32,
     pub time: u32,
 }
+/// A recipe of a type of a mod's own, kept as its file says: the mod reads it.
+#[derive(Clone, Debug, PartialEq)]
+pub struct CustomRecipe {
+    /// `<namespace>:<path>`, its place under `data/<namespace>/recipe/`.
+    pub id: String,
+    pub json: Arc<Value>,
+}
+/// An item stack as a recipe's `result` names it (`ItemStackTemplate`); none
+/// with no `id` or a count outside 1 to 99.
+pub fn recipe_result(v: &Value) -> Option<ItemStack> {
+    let template = Template::parse(v)?;
+    template.item.is_some().then(|| template.create())
+}
+/// The type of a recipe the game doesn't craft itself: one outside `minecraft`.
+fn custom_type(v: &Value) -> Option<&str> {
+    v["type"]
+        .as_str()
+        .filter(|t| t.contains(':') && !t.starts_with("minecraft:"))
+}
 pub struct Recipes {
     pub crafting: Vec<(String, Recipe)>,
     pub cooking: Vec<Cooking>,
+    /// The recipes of types of mods' own, by type, in file order.
+    pub custom: HashMap<String, Vec<CustomRecipe>>,
     /// `category` and `group` of each crafting recipe, by file name.
     pub meta: HashMap<String, (String, String)>,
     facts: HashMap<Arc<str>, Facts>,
@@ -1184,6 +1205,7 @@ impl Recipes {
     pub fn load(root: &Path, items: &Items, overlay: &PackOverlay) -> Result<Self> {
         let mut crafting = Vec::new();
         let mut cooking = Vec::new();
+        let mut custom: HashMap<String, Vec<CustomRecipe>> = HashMap::new();
         let mut meta = HashMap::new();
         let json_files = |dir: &Path| -> Result<Vec<PathBuf>> {
             let mut files: Vec<_> = fs::read_dir(dir)?
@@ -1241,6 +1263,20 @@ impl Recipes {
                     continue;
                 }
             };
+            if let Some(kind) = custom_type(&v) {
+                let id = if name.contains(':') {
+                    name
+                } else {
+                    format!("minecraft:{name}")
+                };
+                let kind = kind.to_owned();
+                let json = Arc::new(v);
+                custom
+                    .entry(kind)
+                    .or_default()
+                    .push(CustomRecipe { id, json });
+                continue;
+            }
             let text = |k: &str| v[k].as_str().unwrap_or("").to_owned();
             meta.insert(name.clone(), (text("category"), text("group")));
             let ing = |k: &str| Ingredient::parse(&v[k], items);
@@ -1447,6 +1483,7 @@ impl Recipes {
         Ok(Self {
             crafting,
             cooking,
+            custom,
             meta,
             facts,
             curses,
@@ -1728,6 +1765,7 @@ mod tests {
         Recipes {
             crafting: Vec::new(),
             cooking,
+            custom: HashMap::new(),
             meta: HashMap::new(),
             facts: HashMap::new(),
             curses: HashSet::new(),
@@ -1735,6 +1773,101 @@ mod tests {
         }
     }
     #[test]
+    fn only_types_outside_minecraft_are_custom() {
+        let kind = |json: &str| {
+            let v: Value = serde_json::from_str(json).unwrap();
+            custom_type(&v).map(str::to_owned)
+        };
+        assert_eq!(
+            kind(r#"{"type":"mymod:crusher"}"#).as_deref(),
+            Some("mymod:crusher")
+        );
+        assert_eq!(kind(r#"{"type":"minecraft:smelting"}"#), None);
+        assert_eq!(kind(r#"{"type":"minecraft:from_a_later_version"}"#), None);
+        assert_eq!(kind(r#"{"type":"no_namespace"}"#), None);
+        assert_eq!(kind(r#"{"type":7}"#), None);
+        assert_eq!(kind("{}"), None);
+    }
+    /// Recipes of a mod's own types land in `custom` by type, in file order,
+    /// with the id the file has; a data pack overrides by id and adds more; a
+    /// `minecraft` type the game doesn't know is dropped.
+    #[test]
+    fn custom_recipes_load_by_type_with_pack_override() {
+        let root =
+            std::env::temp_dir().join(format!("horizon-custom-recipes-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&root);
+        fs::create_dir_all(root.join("data/minecraft/recipe")).unwrap();
+        fs::create_dir_all(root.join("data/mymod/recipe")).unwrap();
+        fs::write(
+            root.join(horizon_items::content_namespaces::MARKER),
+            br#"["mymod"]"#,
+        )
+        .unwrap();
+        let file =
+            |kind: &str, tag: &str| format!(r#"{{"type":"{kind}","tag":"{tag}"}}"#).into_bytes();
+        fs::write(
+            root.join("data/mymod/recipe/a.json"),
+            file("mymod:crusher", "a"),
+        )
+        .unwrap();
+        fs::write(
+            root.join("data/mymod/recipe/b.json"),
+            file("mymod:crusher", "b"),
+        )
+        .unwrap();
+        fs::write(
+            root.join("data/mymod/recipe/c.json"),
+            file("mymod:mixer", "c"),
+        )
+        .unwrap();
+        fs::write(
+            root.join("data/minecraft/recipe/later.json"),
+            file("minecraft:from_a_later_version", "x"),
+        )
+        .unwrap();
+        let items = Items::for_tests(HashMap::new());
+        let recipes = Recipes::load(&root, &items, &PackOverlay::NONE).unwrap();
+        let ids = |kind: &str| -> Vec<String> {
+            recipes.custom[kind].iter().map(|r| r.id.clone()).collect()
+        };
+        assert_eq!(ids("mymod:crusher"), ["mymod:a", "mymod:b"]);
+        assert_eq!(ids("mymod:mixer"), ["mymod:c"]);
+        assert_eq!(recipes.custom.len(), 2);
+        // Not crafted, and no recipe-book meta of their own.
+        assert!(recipes.crafting.is_empty() && recipes.cooking.is_empty());
+        assert!(!recipes.meta.keys().any(|k| k.starts_with("mymod:")));
+        // A pack replaces `mymod:b`, and adds `pack:d` and a `minecraft:p` of its own type.
+        let packs = [
+            (
+                "recipe/mymod:b".to_owned(),
+                vec![file("mymod:crusher", "pack-b")],
+            ),
+            ("recipe/pack:d".to_owned(), vec![file("mymod:crusher", "d")]),
+            (
+                "recipe/minecraft:p".to_owned(),
+                vec![file("pack:press", "p")],
+            ),
+        ];
+        let recipes = Recipes::load(&root, &items, &PackOverlay { files: &packs }).unwrap();
+        let crusher = &recipes.custom["mymod:crusher"];
+        assert_eq!(
+            crusher.iter().map(|r| r.id.as_str()).collect::<Vec<_>>(),
+            ["mymod:a", "mymod:b", "pack:d"]
+        );
+        assert_eq!(crusher[1].json["tag"], "pack-b");
+        assert_eq!(recipes.custom["pack:press"][0].id, "minecraft:p");
+        let _ = fs::remove_dir_all(&root);
+    }
+    #[test]
+    fn a_recipe_result_needs_an_item_and_a_sane_count() {
+        let result = |json: &str| recipe_result(&serde_json::from_str(json).unwrap());
+        let stack = result(r#"{"id":"minecraft:iron_ingot","count":2}"#).unwrap();
+        assert_eq!((&*stack.item, stack.count), ("minecraft:iron_ingot", 2));
+        assert_eq!(result(r#"{"id":"minecraft:iron_ingot"}"#).unwrap().count, 1);
+        assert!(result(r#"{"count":2}"#).is_none());
+        assert!(result(r#"{"id":"minecraft:iron_ingot","count":0}"#).is_none());
+    }
+    #[test]
     fn cook_finds_the_first_recipe_the_scan_finds() {
         let recipes = cooking_book();
         for kind in [
@@ -1780,6 +1913,7 @@ mod tests {
         let recipes = Recipes {
             crafting: Vec::new(),
             cooking: Vec::new(),
+            custom: HashMap::new(),
             meta: HashMap::new(),
             facts: HashMap::new(),
             curses: HashSet::new(),

crates/horizon-client/src/entities.rs

@@ -2,7 +2,8 @@
 //! `ItemEntity.tick`: gravity 0.04, 0.98 drag (block friction on the ground),
 //! a ground bounce of -0.5, slime landing restitution (0.8, including a moving
 //! piston that is carrying slime), water buoyancy, pickup delay, 6000-tick despawn,
-//! and `HoneyBlock.entityInside` when falling against a honey block's side.
+//! `HoneyBlock.entityInside` when falling against a honey block's side, and
+//! `BubbleColumnBlock.entityInside` (lift / drag, including the surface jump).
 use crate::{
     blocks::{BlockFacts, Fluid},
     collisions::SceneCollisions,
@@ -219,6 +220,7 @@ impl ItemEntity {
     pub fn tick(
         &mut self,
         world: &World,
+        registry: &horizon_world::registry::BlockRegistry,
         facts: &BlockFacts,
         collision: &BlockCollisionRegistry<'_>,
         no_physics: bool,
@@ -229,7 +231,6 @@ impl ItemEntity {
         if self.pickup_delay > 0 && self.pickup_delay != u32::MAX {
             self.pickup_delay -= 1;
         }
-        // Entity.baseTick pushes before ItemEntity applies buoyancy and moves.
         let (water_height, lava_height) = self.update_fluids(world, fluids);
         let in_water = water_height > f64::from(0.1f32);
         if in_water {
@@ -249,6 +250,10 @@ impl ItemEntity {
             self.velocity.y -= 0.04;
         }
         let horizontal = self.velocity.x * self.velocity.x + self.velocity.z * self.velocity.z;
+        // ItemEntity.tick: skip move 3 of 4 ticks while grounded with no
+        // horizontal speed. The idle branch still runs bubble-column push
+        // (`applyEffectsFromBlocksForLastMovements`), so lift builds up and
+        // the item moves on the next wake-up (#4558).
         if !self.on_ground || horizontal > 1.0e-5 || (self.age + self.id).is_multiple_of(4) {
             let mut scene = SceneCollisions {
                 world,
@@ -285,8 +290,17 @@ impl ItemEntity {
                 let slime = item_support_is_slime(world, facts, self.position);
                 self.velocity.y = item_vertical_collision_velocity(wanted.y, slime);
             }
-            // Entity.move -> applyEffectsFromBlocks: HoneyBlock.entityInside.
+            // Entity.move -> applyEffectsFromBlocks: honey then bubble columns
+            // (before air drag), matching ItemEntity.tick.
             self.apply_honey_slide(world, facts);
+            crate::motion::bubble_column_push(
+                world,
+                registry,
+                facts,
+                collision,
+                self.bounds(),
+                &mut self.velocity,
+            );
             let mut friction = 0.98;
             if self.on_ground {
                 let below = world.block(
@@ -304,9 +318,19 @@ impl ItemEntity {
             if self.on_ground && self.velocity.y < 0.0 {
                 self.velocity.y *= -0.5;
             }
+        } else {
+            // applyEffectsFromBlocksForLastMovements: still lift/drag while idle.
+            crate::motion::bubble_column_push(
+                world,
+                registry,
+                facts,
+                collision,
+                self.bounds(),
+                &mut self.velocity,
+            );
         }
         self.age += 1;
-        // ItemEntity.tick refreshes immersion and pushes again after moving.
+        // ItemEntity.tick refreshes immersion after moving.
         self.update_fluids(world, fluids);
         self.age < 6000 && self.position.y > -128.0
     }
@@ -882,6 +906,10 @@ pub struct ArmorStand {
     /// `DATA_HEAD_POSE` to `DATA_RIGHT_LEG_POSE`: head, body, left arm, right
     /// arm, left leg, right leg, in degrees (`POSE_KEYS` order).
     pub pose: [[f32; 3]; 6],
+    /// `Entity.vehicle` on a server's client (`SetPassengers`): the mob it
+    /// rides, which seats it every tick (`positionRider`), as NPC plugins hang
+    /// a second name over a player's head.
+    pub vehicle: Option<u32>,
 }
 impl ArmorStand {
     pub const SLOTS: [&'static str; 6] = ["mainhand", "offhand", "feet", "legs", "chest", "head"];
@@ -916,6 +944,7 @@ impl ArmorStand {
             name_visible: false,
             last_hit: i64::MIN / 2,
             pose: Self::DEFAULT_POSE,
+            vehicle: None,
         }
     }
     pub fn environment_tick(
@@ -1380,6 +1409,101 @@ mod merge_tests {
 mod honey_slide_tests {
     use super::*;
 
+    /// Gravity still stacks on idle ticks; waking every 4th tick zeroes Y on
+    /// the ground (`ItemEntity.tick` with `onGround`).
+    #[test]
+    fn a_resting_item_skips_move_three_of_four_ticks() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = crate::assets::Assets::load(&root).unwrap();
+        let render = assets.reload(&root).unwrap();
+        let facts = crate::blocks::BlockFacts::load(&root, assets.registry).unwrap();
+        let fluids = crate::motion::FluidResources::new(&assets, &facts).unwrap();
+        let collision = crate::collisions::load(&root, assets.registry).unwrap();
+        let mut world = World::test_scene(&assets, &render, 3).unwrap();
+        let stone = assets.registry.default_state("minecraft:stone").unwrap();
+        for x in 19..=21 {
+            for z in 19..=21 {
+                world.set(x, 3, z, stone).unwrap();
+            }
+        }
+        let at = Vec3::new(20.5, 4.0, 20.5);
+        let mut item = falling_item(at.x, at.y, at.z, 0.0, 0.0, 0.0);
+        item.on_ground = true;
+        item.age = 0;
+        item.id = 1;
+        let mut ys = Vec::new();
+        for _ in 0..8 {
+            item.tick(&world, assets.registry, &facts, &collision, false, &fluids);
+            ys.push(item.velocity.y);
+        }
+        // Idle ticks keep gravity; the 4th tick's move hits the floor and
+        // clears Y (vanilla's sequence for a resting item).
+        assert_eq!(ys, vec![-0.04, -0.08, -0.12, 0.0, -0.04, -0.08, -0.12, 0.0]);
+        assert_eq!(item.position.y, at.y);
+    }
+
+    /// #4558: idle ticks still run `BubbleColumnBlock.entityInside`, so lift
+    /// builds and the next wake-up rises off the soul sand.
+    #[test]
+    fn a_grounded_item_in_a_soul_sand_column_rises() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("movement-properties.nbt").exists() {
+            return;
+        }
+        let assets = crate::assets::Assets::load(&root).unwrap();
+        let render = assets.reload(&root).unwrap();
+        let facts = crate::blocks::BlockFacts::load(&root, assets.registry).unwrap();
+        let fluids = crate::motion::FluidResources::new(&assets, &facts).unwrap();
+        let collision = crate::collisions::load(&root, assets.registry).unwrap();
+        let mut world = World::test_scene(&assets, &render, 3).unwrap();
+        let soul = assets
+            .registry
+            .default_state("minecraft:soul_sand")
+            .unwrap();
+        let mut column = assets
+            .registry
+            .state(
+                assets
+                    .registry
+                    .default_state("minecraft:bubble_column")
+                    .unwrap(),
+            )
+            .unwrap()
+            .clone();
+        column.properties.insert("drag".into(), "false".into());
+        let column = assets.registry.resolve(&column).unwrap();
+        for x in 19..=21 {
+            for z in 19..=21 {
+                world.set(x, 3, z, soul).unwrap();
+                for y in 4..=8 {
+                    world.set(x, y, z, column).unwrap();
+                }
+            }
+        }
+        let at = Vec3::new(20.5, 4.0, 20.5);
+        let mut item = falling_item(at.x, at.y, at.z, 0.0, 0.0, 0.0);
+        item.on_ground = true;
+        item.age = 0;
+        item.id = 1;
+        let before = item.position.y;
+        for _ in 0..16 {
+            item.tick(&world, assets.registry, &facts, &collision, false, &fluids);
+        }
+        assert!(
+            item.position.y > before + 0.5,
+            "expected rise from soul-sand column, y={} (was {})",
+            item.position.y,
+            before
+        );
+    }
+
     fn falling_item(x: f64, y: f64, z: f64, vx: f64, vy: f64, vz: f64) -> ItemEntity {
         let at = Vec3::new(x, y, z);
         ItemEntity {

crates/horizon-client/src/entities/fluids.rs

@@ -200,17 +200,17 @@ mod tests {
             ticks: 0,
         };
         let mut still = item.clone();
-        assert!(still.tick(&world, &facts, &collision, false, &fluids));
+        assert!(still.tick(&world, assets.registry, &facts, &collision, false, &fluids));
         assert_eq!(still.position.x, at.x);
         assert_eq!(still.velocity.x, 0.0);
         world.set(21, 4, 20, flowing).unwrap();
         let mut carried = item;
-        assert!(carried.tick(&world, &facts, &collision, false, &fluids));
+        assert!(carried.tick(&world, assets.registry, &facts, &collision, false, &fluids));
         // First push is damped by buoyancy before motion, second follows drag.
         assert!((carried.position.x - at.x - 0.014 * 0.99).abs() < 1e-12);
         assert!((carried.velocity.x - (0.014 * 0.99 * 0.98 + 0.014)).abs() < 1e-12);
         for _ in 0..20 {
-            carried.tick(&world, &facts, &collision, false, &fluids);
+            carried.tick(&world, assets.registry, &facts, &collision, false, &fluids);
         }
         assert!(carried.position.x > at.x + 0.5);
     }

crates/horizon-client/src/entity_nbt.rs

@@ -2949,7 +2949,11 @@ pub fn bucket_components(m: &Mob) -> crate::item_data::StackData {
     }
     data
 }
-pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
+/// `Entity.applyComponentsFromItemStack` → the spawned mob's
+/// `applyImplicitComponents`: a bucket's contents (`MobBucketItem.spawn`) and
+/// a spawn egg (`PostSpawnProcessor.apply`) both land here. Vanilla applies
+/// these after `finalizeSpawn`, so a component wins over the biome variant.
+pub fn apply_item_components(m: &mut Mob, stack: &crate::items::ItemStack) {
     let Some(components) = stack.data() else {
         return;
     };
@@ -3030,6 +3034,51 @@ pub fn load_bucket_data(m: &mut Mob, stack: &crate::items::ItemStack) {
             m.extra.variant3 = id as u8;
         }
     }
+    // Chicken, Cow and Pig.applyImplicitComponents: their variant and sound
+    // variant components, both registry names (`minecraft:warm`,
+    // `minecraft:picky`).
+    let species = m.species();
+    let (variant, sound) = match species {
+        crate::mobs::Species::Chicken => (
+            Some("minecraft:chicken/variant"),
+            Some("minecraft:chicken/sound_variant"),
+        ),
+        crate::mobs::Species::Cow => (
+            Some("minecraft:cow/variant"),
+            Some("minecraft:cow/sound_variant"),
+        ),
+        crate::mobs::Species::Pig => (
+            Some("minecraft:pig/variant"),
+            Some("minecraft:pig/sound_variant"),
+        ),
+        _ => (None, None),
+    };
+    if let Some(name) = variant.and_then(|id| text(components.other(id))) {
+        m.extra.variant = crate::mobs::finalize::variant_index(species, &name);
+    }
+    if let Some(name) = sound.and_then(|id| text(components.other(id)))
+        && let Some(i) = crate::mobs::finalize::sound_variants(species)
+            .iter()
+            .position(|v| *v == name.trim_start_matches("minecraft:"))
+    {
+        m.extra.sound_variant = Some(i as u8);
+    }
+    // MushroomCow.applyImplicitComponents: `Variant.DEFAULT` is red, as the
+    // save's `Type` reads it.
+    if species == crate::mobs::Species::Mooshroom
+        && let Some(name) = text(components.other("minecraft:mooshroom/variant"))
+    {
+        m.extra.variant = u8::from(name.trim_start_matches("minecraft:") == "brown");
+    }
+    // Sheep.applyImplicitComponents: the wool colour, a DyeColor id.
+    if species == crate::mobs::Species::Sheep
+        && let Some(name) = text(components.other("minecraft:sheep/color"))
+        && let Some(i) = crate::mobs::render::DYE_NAMES
+            .iter()
+            .position(|c| *c == name.trim_start_matches("minecraft:"))
+    {
+        m.extra.color = i as u8;
+    }
 }
 
 #[cfg(test)]
@@ -3101,7 +3150,7 @@ mod axolotl_nbt_tests {
         assert!(bucket_data(&m).get("Variant").is_none());
         let stack = item_from_nbt(&item_to_nbt(&stack)).unwrap();
         let mut restored = Mob::new(2, kind, Vec3::new(0.0, 4.0, 0.0), 0.0);
-        load_bucket_data(&mut restored, &stack);
+        apply_item_components(&mut restored, &stack);
         assert_eq!(
             crate::mobs::animal_brain::hunting_cooldown(&restored),
             Some(123)
@@ -3140,10 +3189,10 @@ mod axolotl_nbt_tests {
                 .data_mut()
                 .set_other("minecraft:bucket_entity_data", Some(data));
             restored.persistent = false;
-            load_bucket_data(&mut restored, &bucket);
+            apply_item_components(&mut restored, &bucket);
             assert_eq!(restored.persistent, expected);
             restored.persistent = true;
-            load_bucket_data(&mut restored, &bucket);
+            apply_item_components(&mut restored, &bucket);
             assert!(restored.persistent, "bucket data cannot clear persistence");
         }
         restored.ticks_frozen = 140;
@@ -3161,7 +3210,7 @@ mod axolotl_nbt_tests {
                 other: vec![("minecraft:axolotl/variant".into(), string(name))],
                 ..Default::default()
             }));
-            load_bucket_data(&mut restored, &vanilla);
+            apply_item_components(&mut restored, &vanilla);
             assert_eq!(
                 usize::from(restored.extra.variant),
                 id,
@@ -3176,12 +3225,12 @@ mod axolotl_nbt_tests {
             )],
             ..Default::default()
         }));
-        load_bucket_data(&mut restored, &legacy);
+        apply_item_components(&mut restored, &legacy);
         assert_eq!(restored.extra.variant, 3);
         legacy
             .data_mut()
             .set_other("minecraft:axolotl/variant", Some(string("gold")));
-        load_bucket_data(&mut restored, &legacy);
+        apply_item_components(&mut restored, &legacy);
         assert_eq!(
             restored.extra.variant, 2,
             "component wins over old Horizon data"
@@ -3241,6 +3290,37 @@ mod sheep_nbt_tests {
         assert_eq!((back.extra.color, back.extra.sheared), (14, true));
     }
 
+    /// The only lib test that registers mod effects (once per process).
+    #[test]
+    fn a_mob_keeps_a_mod_effect() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("items.json").exists() {
+            return;
+        }
+        let types: HashMap<String, Arc<MobType>> = crate::mobs::MobTypes::load(&root)
+            .unwrap()
+            .types
+            .into_iter()
+            .map(|(k, v)| (k, Arc::new(v)))
+            .collect();
+        crate::brewing::register_mod_effects([(
+            "testfx:glow".to_owned(),
+            1,
+            crate::brewing::Category::Harmful,
+        )]);
+        let mut m = Mob::new(1, types["minecraft:pig"].clone(), Vec3::ZERO, 0.0);
+        m.add_effect(crate::brewing::effect("testfx:glow").unwrap().id, 200, 2);
+        let tag = mob_to_nbt(&m, [1, 2, 3, 4], None);
+        let Some(Tag::List(saved)) = tag.get("active_effects") else {
+            panic!("no active_effects");
+        };
+        assert_eq!(text(saved[0].get("id")).as_deref(), Some("testfx:glow"));
+        let back = mob_from_nbt(&tag, &types, 2).unwrap();
+        assert_eq!(back.extra.effects, [("testfx:glow", 200, 2)]);
+    }
+
     #[test]
     fn farm_animals_keep_their_variant_and_sound_variant() {
         let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
@@ -3397,6 +3477,46 @@ mod sheep_nbt_tests {
     }
 }
 
+#[cfg(test)]
+mod item_component_tests {
+    use super::*;
+    #[test]
+    fn a_spawn_egg_beats_the_biome_variant() {
+        let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../.local/horizon-client")
+            .join(horizon_core::VANILLA_VERSION);
+        if !root.join("items.json").exists() {
+            return;
+        }
+        let data = crate::mobs::MobTypes::load(&root).unwrap();
+        let spawn = |kind: &str, id: u32| {
+            let mut m = Mob::new(
+                id,
+                Arc::new(data.types[kind].clone()),
+                Vec3::new(0.0, 4.0, 0.0),
+                0.0,
+            );
+            // What `finalizeSpawn` leaves in a temperate biome.
+            m.extra.variant = 0;
+            m
+        };
+        let mut egg = crate::items::ItemStack::new("minecraft:chicken_spawn_egg", 1);
+        egg.data_mut()
+            .set_other("minecraft:chicken/variant", Some(string("minecraft:warm")));
+        let mut hen = spawn("minecraft:chicken", 1);
+        assert_eq!(hen.extra.variant, 0);
+        apply_item_components(&mut hen, &egg);
+        assert_eq!(hen.extra.variant, 1, "minecraft:warm, not the biome's");
+        // Sheep.applyImplicitComponents: the egg's colour over the mob's.
+        let mut egg = crate::items::ItemStack::new("minecraft:sheep_spawn_egg", 1);
+        egg.data_mut()
+            .set_other("minecraft:sheep/color", Some(string("lime")));
+        let mut sheep = spawn("minecraft:sheep", 2);
+        apply_item_components(&mut sheep, &egg);
+        assert_eq!(sheep.extra.color, 5, "lime, not the white it started as");
+    }
+}
+
 #[cfg(test)]
 mod fireball_nbt_tests {
     use super::*;

crates/horizon-client/src/game/advancements.rs

@@ -212,8 +212,8 @@ impl adv::World for View<'_, '_> {
     fn in_tag(&self, registry: &str, tag: &str, id: &str) -> bool {
         let items = &self.0.res.items();
         match registry {
-            "item" => items.item_tags.get(tag).is_some_and(|t| t.contains(id)),
-            "block" => items.block_tags.get(tag).is_some_and(|t| t.contains(id)),
+            "item" => items.item_in_tag(tag, id),
+            "block" => items.block_in_tag(tag, id),
             "entity_type" => self.0.res.mob_data().entity_has(tag, id),
             "worldgen/biome" => self.0.res.mob_data().biome_has(tag, id),
             "damage_type" => self
@@ -432,7 +432,10 @@ impl Game<'_> {
                 .effects
                 .list
                 .iter()
-                .map(|e| (format!("minecraft:{}", e.id), e.amplifier, e.duration))
+                .map(|e| {
+                    let id = horizon_client::brewing::namespaced(e.id);
+                    (id.to_owned(), e.amplifier, e.duration)
+                })
                 .collect(),
             gamemode: Some(self.mode.name().to_owned()),
             ..Default::default()
@@ -594,6 +597,39 @@ impl Game<'_> {
             });
         }
     }
+    /// `KnowledgeBookItem.use`: the recipes the book names become known and it
+    /// is used up. A book naming a recipe this server does not have is
+    /// vanilla's `Invalid recipe: {}` and knows nothing. Whether the click
+    /// ends here: `InteractionResult.SUCCESS` does and swings, `FAIL` leaves
+    /// the other hand its turn (`Minecraft.startUseItem`).
+    pub(super) fn use_knowledge_book(&mut self, stack: &ItemStack) -> bool {
+        if &*stack.item != "minecraft:knowledge_book" {
+            return false;
+        }
+        let slot = self.held_slot();
+        let mut hand = self.stack_in(slot).cloned();
+        let infinite = self.creative;
+        let index = &world_stations!(self).recipe_index;
+        let result = self
+            .level
+            .recipe_book
+            .use_knowledge_book(index, &mut hand, infinite);
+        *self.stack_in_mut(slot) = hand;
+        match result {
+            Ok(unlocked) => {
+                self.recipe_unlocked(&unlocked);
+                self.stats.add("used", &stack.item, 1);
+                self.swing_arm();
+                true
+            }
+            Err(invalid) => {
+                if let Some(id) = invalid {
+                    log::error!("Invalid recipe: {id}");
+                }
+                false
+            }
+        }
+    }
     /// `PlayerAdvancements.award` once done: rewards, toast, announcement.
     fn award(&mut self, index: usize) {
         let tree = self.adv.tree.clone();
@@ -1711,19 +1747,43 @@ impl Game<'_> {
         let atlas = &self.gui.atlas;
         batch.sprite(atlas, "gui/sprites/toast/advancement", x, y);
         let (key, color) = match frame {
-            Frame::Task => ("advancements.toast.task", 0xFF00_FFFF),
-            Frame::Goal => ("advancements.toast.goal", 0xFF00_FFFF),
+            Frame::Task => ("advancements.toast.task", 0xFFFF_FF00),
+            Frame::Goal => ("advancements.toast.goal", 0xFFFF_FF00),
             Frame::Challenge => ("advancements.toast.challenge", 0xFFFF_88FF),
         };
-        batch.text_styled(
-            atlas,
-            &Text::translate(key, &[]),
-            x + 30.0,
-            y + 7.0,
-            color,
-            false,
-        );
-        batch.text_styled(atlas, &title, x + 30.0, y + 18.0, u32::MAX, false);
+        // AdvancementToast.extractRenderState: a title of one line sits under
+        // the frame's label; a longer one is wrapped at 125, the label fading
+        // out first (to 1.5 s) and the lines fading in after it over 0.3 s.
+        let lines = atlas.font.split(&title.resolve_legacy(), 125.0);
+        let label = Text::translate(key, &[]);
+        let rgb = color & 0x00FF_FFFF;
+        if let [line] = lines.as_slice() {
+            batch.text_styled(atlas, &label, x + 30.0, y + 7.0, color, false);
+            batch.text_styled(atlas, line, x + 30.0, y + 18.0, u32::MAX, false);
+        } else if fully_for < 1500 {
+            let fade = ((1500 - fully_for) as f32 / 300.0).clamp(0.0, 1.0);
+            let alpha = (fade * 255.0).floor() as u32;
+            if alpha != 0 {
+                batch.text_styled(atlas, &label, x + 30.0, y + 11.0, alpha << 24 | rgb, false);
+            }
+        } else {
+            let fade = ((fully_for - 1500) as f32 / 300.0).clamp(0.0, 1.0);
+            let alpha = (fade * 252.0).floor() as u32;
+            if alpha != 0 {
+                let mut line_y = y + (16 - lines.len() as i32 * 9 / 2) as f32;
+                for line in &lines {
+                    batch.text_styled(
+                        atlas,
+                        line,
+                        x + 30.0,
+                        line_y,
+                        alpha << 24 | 0x00FF_FFFF,
+                        false,
+                    );
+                    line_y += 9.0;
+                }
+            }
+        }
         self.draw_item(batch, &ItemStack::new(&icon, 1), x + 8.0, y + 8.0);
     }
 }

crates/horizon-client/src/game/agent.rs

@@ -638,6 +638,7 @@ impl Game<'_> {
                 json!({ "mode": "multiplayer-warning", "check": check })
             }
             Mode::Onboarding(_) => json!({ "mode": "accessibility-onboarding" }),
+            Mode::BanNotice(_) => json!({ "mode": "ban-notice" }),
         }
     }