fix: datapack into the render crate

crash.rs: main's separator-neutral manifest path, with the render crate's suffix.

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

.githooks/pre-commit

@@ -1,2 +1,11 @@
 #!/bin/sh
-exec python3 tools/check_public_tree.py
+# Git for Windows puts a `python3` on PATH that is only the Microsoft Store
+# stub: it prints "Python" and exits non-zero, so the hook fails with no other
+# output. Use the first name that actually runs Python 3.
+for py in python3 python py; do
+    if "$py" -c "import sys; sys.exit(sys.version_info < (3,))" >/dev/null 2>&1; then
+        exec "$py" tools/check_public_tree.py
+    fi
+done
+echo "check_public_tree: no working Python 3 found" >&2
+exit 1

.githooks/pre-push

@@ -1,2 +1,11 @@
 #!/bin/sh
-exec python3 tools/check_public_tree.py --pre-push
+# Git for Windows puts a `python3` on PATH that is only the Microsoft Store
+# stub: it prints "Python" and exits non-zero, so the hook fails with no other
+# output. Use the first name that actually runs Python 3.
+for py in python3 python py; do
+    if "$py" -c "import sys; sys.exit(sys.version_info < (3,))" >/dev/null 2>&1; then
+        exec "$py" tools/check_public_tree.py --pre-push
+    fi
+done
+echo "check_public_tree: no working Python 3 found" >&2
+exit 1

.github/trusted-reviewers.txt

@@ -6,3 +6,4 @@
 kacpherek    # added by Ludovic, 2026-10-27
 rdbtCVS      # added by Ludovic, 2026-10-27
 Online5277   # added by Ludovic, 2026-10-27 (his top three by merged pull requests)
+levzzz5154   # added by Ludovic, 2026-10-28 (Horizon Team; author of horizon-mixins)

.github/workflows/launcher.yml

@@ -192,9 +192,11 @@ jobs:
           retry "$launcher" install latest
           "$launcher" versions --installed
           "$launcher" links --json
-          clients=("$HORIZON_LAUNCHER_HOME"/versions/v*/horizon-client*)
+          # `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]}"
           echo "installed client: $client"
+          [[ -f "$client" ]] || { echo "::error::no game installed under versions/"; exit 1; }
           # The game's Linux build is the game's to keep portable (release.yml checks it): a
           # release linked to a Nix store is a warning here, not a broken launcher.
           soft() { if [[ "$RUNNER_OS" == "Linux" ]]; then "$@" || echo "::warning::$* failed"; else "$@"; fi; }

.github/workflows/nightly-build.yml

@@ -1,11 +1,12 @@
 name: nightly build
 run-name: nightly build${{ inputs.request && format(' (request {0})', inputs.request) || '' }}
-# The opt-in Nightly channel (docs/release-flow.md "Nightly"; Ludovic, 2026-10-27). Once a night, and when a trusted
+# The Nightly, the only build Horizon ships since 2026-10-28 (docs/release-flow.md "Nightly"; Ludovic). When the batch
+# train decides (release.yml, with the commit as `base`), once a night, and when a trusted
 # reviewer asks (`/nightly 2640 2642`, nightly-command.yml), it builds main plus the pull requests the reviewers
-# picked, merged in order (tools/ci/nightly_set.py). With none picked, it builds the newest union branch on origin
-# (union/<agent>-<name>: main plus pull requests the contribution gate proved together), or main when no union is
-# newer. It publishes the result as the `nightly` pre-release. Launchers install it only for players who turn Nightly
-# on. The previous nightly stays a week as nightly-<date>.
+# picked, merged in order (tools/ci/nightly_set.py), or main alone with none picked. Main is its newest commit where
+# checks and parity-main passed (or the `base` input), as for a release, and no Nightly is published while a
+# release-blocker is open. It publishes the result as the `nightly` pre-release, which every launcher and
+# `horizon-server update` install. The previous nightly stays a week as nightly-<date>.
 #
 # Why the signing key never meets the pull requests' code:
 # - `pick` merges the picked heads onto main with `git merge-tree --write-tree`: git objects only, no working tree,
@@ -13,11 +14,11 @@ run-name: nightly build${{ inputs.request && format(' (request {0})', inputs.req
 #   request that changes a path CODEOWNERS gives to Ludovic (this folder, tools/ci/, the signing and update code),
 #   pushes the merge as nightly/build-<date>-<n> and saves the set on the nightly-state branch.
 # - This file, game-build.yml and every script below run from main's copy: a schedule runs the default branch, and
-#   `uses: ./…` takes the caller's commit. The union's own .github/ is never read.
+#   `uses: ./…` takes the caller's commit. A picked pull request's own .github/ is never read.
 # - `build` (game-build.yml, `trusted: false`) never reaches a release's tools: its macOS jobs run on the runner
 #   that already runs pull requests' parity jobs, never the release runner; its Rust cache has its own key and is
 #   never saved; and releases don't read the machine's shared sccache.
-# - `build` (game-build.yml) checks out and compiles the merge (or the union) with no secrets: its token reads contents only and
+# - `build` (game-build.yml) checks out and compiles the merge with no secrets: its token reads contents only and
 #   isn't kept in the checkout; the macOS programs are signed ad hoc (Developer ID needs the runner's keychain,
 #   which stays locked for nightlies).
 # - `sign` is the only job with RELEASE_SIGNING_KEY. It checks out nothing but main's tools/ci/sign_release.sh, which
@@ -25,6 +26,9 @@ run-name: nightly build${{ inputs.request && format(' (request {0})', inputs.req
 #   names the channel ("horizon release nightly"), so a nightly's signature can't pass for a release's.
 # - `publish` verifies the signature with main's horizon-release-sign, checks the smoke test, and only then moves
 #   the tag. Like sign, it never executes what build produced.
+# - The source ships with the build: `pick` writes horizon-source.tar.gz with `git archive` (git objects again, nothing
+#   run), `sign` signs it with the builds, and `publish` attaches it and tags the commit nightly-source/<date>-<short>
+#   for good (the dated release and the build branch go after 7 days; native mods pin the commit: docs/native-mods.md).
 #   gh workflow run "nightly build"                     # now (skips when the pick is the same commit as last night's)
 #   gh workflow run "nightly build" -f force=true       # build and publish even if unchanged
 #   gh workflow run "nightly build" -f dry_run=true     # build and sign with a throwaway key, publish nothing
@@ -53,6 +57,14 @@ on:
         description: A dry run's own set, `2640@<head> 2642@<head>` (the saved set stays)
         type: string
         default: ''
+      base:
+        description: The commit of main to build on (default main's newest with green checks and parity-main)
+        type: string
+        default: ''
+      urgent:
+        description: Past the day's cap of 12 builds (the train, for a release-now pull request or a forced run)
+        type: boolean
+        default: false
 permissions:
   contents: read
 concurrency:
@@ -68,6 +80,7 @@ jobs:
       contents: write       # nightly/build-<date>-<n> and the nightly-state branch (main is protected)
       issues: write         # says in the thread when the picked pull requests conflict
       pull-requests: write
+      actions: read         # main's newest green checks and parity-main runs (the base)
     outputs:
       build: ${{ steps.pick.outputs.build }}
       sha: ${{ steps.pick.outputs.sha }}
@@ -76,6 +89,7 @@ jobs:
       date: ${{ steps.pick.outputs.date }}
       version: ${{ steps.pick.outputs.version }}
       nightly: ${{ steps.pick.outputs.nightly }}
+      source_tag: ${{ steps.pick.outputs.source_tag }}
       dry_run: ${{ steps.mode.outputs.dry_run }}
     steps:
       - uses: actions/checkout@v4
@@ -92,6 +106,8 @@ jobs:
           DRY_RUN: ${{ steps.mode.outputs.dry_run }}
           NIGHTLY_ISSUE: ${{ inputs.issue }}
           NIGHTLY_PRS: ${{ inputs.prs }}
+          NIGHTLY_BASE: ${{ inputs.base }}
+          NIGHTLY_URGENT: ${{ inputs.urgent }}
         run: |
           python3 tools/ci/nightly.py pick ${FORCE:+--force} | tee -a "$GITHUB_STEP_SUMMARY"
           { echo; cat nightly-notes.md; } >> "$GITHUB_STEP_SUMMARY"
@@ -103,6 +119,18 @@ jobs:
           GH_TOKEN: ${{ github.token }}
         run: |
           { echo "### nightly/build-* branches"; python3 tools/ci/nightly.py prune-builds --days 7; } | tee -a "$GITHUB_STEP_SUMMARY"
+      - name: The source of the build (horizon-source.tar.gz)
+        if: steps.pick.outputs.build == 'true'
+        env:
+          SHA: ${{ steps.pick.outputs.sha }}
+        run: git archive --format=tar.gz --prefix="horizon-${SHA:0:7}/" -o horizon-source.tar.gz "$SHA"
+      - uses: actions/upload-artifact@v4
+        if: steps.pick.outputs.build == 'true'
+        with:
+          name: horizon-source
+          path: horizon-source.tar.gz
+          if-no-files-found: error
+          retention-days: 3
       - uses: actions/upload-artifact@v4
         with:
           name: nightly-notes
@@ -144,7 +172,7 @@ 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-macos-arm64.zip dist/horizon-server-linux-x86_64.tar.gz dist/horizon-source.tar.gz
       - uses: actions/upload-artifact@v4
         with:
           name: signature
@@ -164,6 +192,7 @@ jobs:
     timeout-minutes: 15
     permissions:
       contents: write
+      issues: read          # the open release-blocker issues (gate)
     steps:
       - uses: actions/checkout@v4
         with:
@@ -178,27 +207,39 @@ jobs:
         run: |
           key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)")
           cargo run --locked --quiet -p horizon-release-sign -- verify --tag nightly --publishing "${key[@]}" dist
-      - name: The smoke test drew a world
-        # No release-blocker check: a nightly is how blockers get tested.
-        run: python3 tools/release_train.py gate --kind game --smoke dist/smoke-test.json
+      - name: Ready to publish (the smoke test drew a world, no release-blocker is open)
+        # Right before publishing, as for a release: an issue labelled while the builds ran still holds it. A dry run
+        # only reports what a real run would do (that is how a blocker's fix is tried).
+        env:
+          GH_TOKEN: ${{ github.token }}
+          DRY_RUN: ${{ needs.pick.outputs.dry_run }}
+        run: |
+          if ! python3 tools/release_train.py gate --kind game --smoke dist/smoke-test.json --blockers; then
+            [[ "$DRY_RUN" == true ]] || { echo "::error::Nothing published"; exit 1; }
+            echo "::warning::A real run would publish nothing"
+          fi
       - name: Publish as the `nightly` pre-release
         if: needs.pick.outputs.dry_run != 'true'
         env:
           GH_TOKEN: ${{ github.token }}
           SHA: ${{ needs.pick.outputs.sha }}
           DATE: ${{ needs.pick.outputs.date }}
+          SOURCE_TAG: ${{ needs.pick.outputs.source_tag }}
         run: |
           set -euo pipefail
           python3 tools/ci/nightly.py rotate
           signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig)
-          # A pre-release, never GitHub's latest: launchers on the release channel never see it.
+          # A pre-release, never GitHub's latest: the latest stays the last vX.Y.Z, which launchers and servers from
+          # before the Nightly-only switch keep (they don't read Nightlies).
           gh release create nightly --prerelease --latest=false --target "$SHA" \
             --title "Nightly $DATE · ${SHA:0:7}" --notes-file dist/nightly-notes.md \
             "dist/horizon-linux-x86_64.tar.gz#Nightly game files: Linux (horizon-linux-x86_64.tar.gz)" \
             "dist/horizon-windows-x64.zip#Nightly game files: Windows (horizon-windows-x64.zip)" \
             "dist/horizon-macos-arm64.zip#Nightly game files: macOS (horizon-macos-arm64.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
+          python3 tools/ci/nightly.py keep-source "$SHA" "$DATE"
           python3 tools/ci/nightly.py prune --days 7
       - name: Dry run, the nightly that would be published
         if: needs.pick.outputs.dry_run == 'true'
@@ -230,7 +271,7 @@ jobs:
           elif [[ "$PUBLISHED" == success && "$DRY_RUN" == true ]]; then
             text="the dry run built and signed $NAME; nothing was published. $RUN"
           elif [[ "$PUBLISHED" == success ]]; then
-            text="published $NAME: https://github.com/$GITHUB_REPOSITORY/releases/tag/nightly. Launchers with Nightly on install it at their next start."
+            text="published $NAME: https://github.com/$GITHUB_REPOSITORY/releases/tag/nightly. Launchers install it at their next check."
           else
             text="the build failed, nothing was published: $RUN"
           fi

.github/workflows/release.yml

@@ -1,22 +1,15 @@
 name: release
-# Automatic game releases (docs/release-flow.md). After every green `checks` run on main, every 10 minutes (so a
-# release waiting for merges to settle goes out without another merge) and by hand, tools/release_train.py decides,
-# for a commit whose checks and parity-main (the vanilla harnesses on main) both passed:
-# a release when 5 pull requests merged since the last one changed what players run and the newest merged 5 minutes
-# ago, or when the oldest has waited 6 hours, or at once for a pull request labelled release-now.
-# RELEASES_PAUSED=1 (repository variable) stops them; so does an open issue labelled release-blocker, forced runs too.
-# Builds Linux (an older Ubuntu, so the binary runs on any recent distribution and on NixOS through nix-ld) and
-# Windows on GitHub, macOS on the Mac mini's runner (MAC_RUNNER=macos-latest sends it to GitHub), then
-# publishes vX.Y.Z on the release line in .github/release-line.txt (docs/versioning.md; without it, the dated
-# vYYYY.MM.DD[.N] from before 0.2) with notes from the merged pull requests, as the release and GitHub's latest: one
-# channel, which launchers, `horizon-server update` and install.sh follow at once. So it is published only after the
-# checks that used to gate a promotion pass in this run: the Mac mini's smoke test drew a world, and no release-blocker
-# is open (tools/release_train.py gate); otherwise nothing is published. macOS: with the repository variable
-# MACOS_SIGN_IDENTITY set, the programs are signed with
-# Developer ID and the hardened runtime and the zip is notarized, from the runner's signing keychain
-# (packaging/macos/README.md); unset (forks), ad hoc.
-#   gh workflow run release --ref <branch>                       # dry run: builds and notes, publishes nothing
-#   gh workflow run release -f dry_run=false -f force=true       # on main: release now, whatever the rules say
+# Automatic game releases (docs/release-flow.md). Horizon ships only the Nightly since 2026-10-28 (Ludovic): this
+# workflow is the batch train that decides when a new Nightly goes out, and `nightly build` (nightly-build.yml) builds,
+# signs and publishes it. After every green `checks` run on main, every 10 minutes (so a batch waiting for merges to
+# settle goes out without another merge) and by hand, tools/release_train.py decides, for a commit whose checks and
+# parity-main (the vanilla harnesses on main) both passed: a Nightly when 5 pull requests merged since the published
+# Nightly changed what players run and the newest merged 5 minutes ago, or when the oldest has waited 6 hours, or at
+# once for a pull request labelled release-now. RELEASES_PAUSED=1 (repository variable) stops it; so does an open issue
+# labelled release-blocker, forced runs too (nightly-build.yml checks again before publishing). One Nightly build at a
+# time, at most 12 a day (release-now and force=true pass the cap). No `vX.Y.Z` game release is made any more.
+#   gh workflow run release --ref <branch>                       # dry run: decides, starts nothing
+#   gh workflow run release -f dry_run=false -f force=true       # on main: a Nightly now, whatever the rules say
 on:
   workflow_run:
     # A game release ships a commit both passed on (parity-main runs on batches: the newest commit it passed on).
@@ -28,17 +21,19 @@ on:
   workflow_dispatch:
     inputs:
       dry_run:
-        description: Build everything and write the notes, but publish nothing
+        description: Decide only; start no Nightly build
         type: boolean
         default: true
       force:
-        description: Release even without player-facing changes, before merges settle or while paused
+        description: A Nightly even without player-facing changes, before merges settle, while paused or past the day's cap
         type: boolean
         default: false
 permissions:
   contents: read
   # The open release-blocker issues (decide).
   issues: read
+  # The checks, parity-main and nightly build runs (decide).
+  actions: read
 concurrency:
   # One release at a time. A hand-started dry run publishes nothing, so it can't race a real release: it gets a
   # group of its own. In the shared group, a release queued behind it replaced it as the pending run and GitHub
@@ -54,9 +49,8 @@ jobs:
     timeout-minutes: 10
     outputs:
       release: ${{ steps.decide.outputs.release }}
-      tag: ${{ steps.decide.outputs.tag }}
-      version: ${{ steps.decide.outputs.version }}
       head: ${{ steps.decide.outputs.head }}
+      urgent: ${{ steps.decide.outputs.urgent }}
       dry_run: ${{ steps.mode.outputs.dry_run }}
     steps:
       - uses: actions/checkout@v4
@@ -76,127 +70,21 @@ jobs:
         run: |
           python3 tools/release_train.py decide --kind game ${HEAD_SHA:+--head "$HEAD_SHA"} ${FORCE:+--force} | tee decision.json
           echo "### $(jq -r '.reason' decision.json)" >> "$GITHUB_STEP_SUMMARY"
-          # The version the programs are built with (docs/versioning.md): the tag without its v.
-          tag=$(jq -r '.tag' decision.json)
-          echo "version=${tag#v}" >> "$GITHUB_OUTPUT"
-          # A dry run builds whatever the decision, to test the builds.
-          if [[ "${{ steps.mode.outputs.dry_run }}" == true ]]; then echo "release=true" >> "$GITHUB_OUTPUT"; fi
 
-  build:
+  nightly:
+    # The Nightly is the release: nightly-build.yml builds the decided commit plus the reviewers' picks, signs it for
+    # the Nightly channel and publishes it once its smoke test passed and no release-blocker is open.
     needs: decide
-    if: needs.decide.outputs.release == 'true'
-    # Every platform's archive, and macOS's smoke test (game-build.yml).
-    uses: ./.github/workflows/game-build.yml
-    with:
-      ref: ${{ needs.decide.outputs.head }}
-      version: ${{ needs.decide.outputs.version }}
-      trusted: true  # main: the release runner, the release cache, no shared sccache
-
-  sign:
-    needs: [decide, build]
+    if: needs.decide.outputs.release == 'true' && needs.decide.outputs.dry_run != 'true'
     runs-on: ubuntu-latest
-    timeout-minutes: 10
-    # The only job that holds the release signing key, a secret of the `release` environment, which only main's real
-    # releases enter (dry runs sign with a throwaway key). It runs no code from the repository but
-    # tools/ci/sign_release.sh, which calls only the runner's sha256sum and OpenSSL (docs/release-flow.md).
-    environment: ${{ needs.decide.outputs.dry_run != 'true' && 'release' || '' }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          sparse-checkout: tools/ci/sign_release.sh
-          sparse-checkout-cone-mode: false
-          persist-credentials: false
-      - uses: actions/download-artifact@v4
-        with:
-          path: dist
-          pattern: horizon-*
-          merge-multiple: true
-      - name: Sign the checksums (SHA256SUMS, SHA256SUMS.sig)
-        env:
-          RELEASE_SIGNING_KEY: ${{ secrets.RELEASE_SIGNING_KEY }}
-          RELEASE_SIGNING_KEY_NEXT: ${{ secrets.RELEASE_SIGNING_KEY_NEXT }}
-          EPHEMERAL: ${{ needs.decide.outputs.dry_run == 'true' && 'yes' || '' }}
-          TAG: ${{ needs.decide.outputs.tag }}
-        run: |
-          bash tools/ci/sign_release.sh "$TAG" 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
-      - uses: actions/upload-artifact@v4
-        with:
-          name: signature
-          path: dist/SHA256SUMS*
-          if-no-files-found: error
-          retention-days: 3
-      - uses: actions/upload-artifact@v4
-        if: needs.decide.outputs.dry_run == 'true'
-        with:
-          name: ephemeral.pub
-          path: dist/ephemeral.pub
-          retention-days: 3
-
-  publish:
-    needs: [decide, build, sign]
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
+    timeout-minutes: 5
     permissions:
-      contents: write
-      issues: read
+      actions: write  # starts `nightly build`
     steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Notes
-        env:
+      - env:
           GH_TOKEN: ${{ github.token }}
+          HEAD_SHA: ${{ needs.decide.outputs.head }}
+          URGENT: ${{ needs.decide.outputs.urgent }}
         run: |
-          python3 tools/release_train.py notes --kind game --tag "${{ needs.decide.outputs.tag }}" \
-            --head "${{ needs.decide.outputs.head }}" --out notes > /dev/null
-          { echo "## $(cat notes/title.txt)"; echo; cat notes/body.md; } >> "$GITHUB_STEP_SUMMARY"
-      - uses: actions/download-artifact@v4
-        with:
-          path: dist
-          merge-multiple: true
-      - name: The signature, checked as launchers check it
-        env:
-          TAG: ${{ needs.decide.outputs.tag }}
-          EPHEMERAL: ${{ needs.decide.outputs.dry_run == 'true' && 'yes' || '' }}
-        run: |
-          key=(); [[ -n "$EPHEMERAL" ]] && key=(--key "$(cat dist/ephemeral.pub)")
-          cargo run --locked --quiet -p horizon-release-sign -- verify --tag "$TAG" --publishing "${key[@]}" dist
-      - name: Ready to publish (the smoke test passed, no release-blocker is open)
-        # Right before publishing: an issue labelled while the builds ran still holds this release. A dry run only
-        # reports what a real run would do.
-        env:
-          GH_TOKEN: ${{ github.token }}
-          DRY_RUN: ${{ needs.decide.outputs.dry_run }}
-        run: |
-          if ! python3 tools/release_train.py gate --kind game --smoke dist/smoke-test.json --blockers; then
-            [[ "$DRY_RUN" == true ]] || { echo "::error::Nothing published"; exit 1; }
-            echo "::warning::A real run would publish nothing"
-          fi
-      - name: Publish ${{ needs.decide.outputs.tag }}
-        if: needs.decide.outputs.dry_run != 'true'
-        env:
-          GH_TOKEN: ${{ github.token }}
-          TAG: ${{ needs.decide.outputs.tag }}
-        run: |
-          signature=(); [[ -f dist/SHA256SUMS.sig ]] && signature=(dist/SHA256SUMS.sig)
-          # The release and the latest at once: there is one channel (docs/release-flow.md). Each archive gets a
-          # label (file#label), which GitHub's page shows instead of the file name, so nobody takes the game's
-          # files for the download (#1647). Launchers, servers and install.sh match the name, which stays.
-          gh release create "$TAG" --target "${{ needs.decide.outputs.head }}" --title "$(cat notes/title.txt)" \
-            --notes-file notes/body.md --latest \
-            "dist/horizon-linux-x86_64.tar.gz#Game files the launcher installs: Linux (horizon-linux-x86_64.tar.gz)" \
-            "dist/horizon-windows-x64.zip#Game files the launcher installs: Windows (horizon-windows-x64.zip)" \
-            "dist/horizon-macos-arm64.zip#Game files the launcher installs: macOS (horizon-macos-arm64.zip)" \
-            "dist/horizon-server-linux-x86_64.tar.gz#Dedicated server for Linux (horizon-server-linux-x86_64.tar.gz)" \
-            dist/SHA256SUMS "${signature[@]}" dist/smoke-test.json
-      - name: Dry run, the release that would be published
-        if: needs.decide.outputs.dry_run == 'true'
-        run: |
-          echo "Would publish ${{ needs.decide.outputs.tag }} at ${{ needs.decide.outputs.head }} as the release and latest: $(cat notes/title.txt)"
-          ls -l dist
-      - uses: actions/upload-artifact@v4
-        with:
-          name: release-notes
-          path: notes/
-          retention-days: 3
+          gh workflow run nightly-build.yml --repo "$GITHUB_REPOSITORY" --ref main -f base="$HEAD_SHA" -f urgent="$URGENT"
+          echo "### Started \`nightly build\` on ${HEAD_SHA:0:9}" >> "$GITHUB_STEP_SUMMARY"

AGENTS.md

@@ -35,10 +35,12 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se
 
 | Crate | Owns |
 |---|---|
-| `horizon-client` | The game: a lib (`src/lib.rs`, ~170 flat modules) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
+| `horizon-client` | The game: a lib (`src/lib.rs`, ~100 flat modules: gameplay, networking, title screens) and the bin (`src/main.rs` → `game.rs` + `game/`), plus `horizon-ctl` (`src/bin/horizon-ctl/`). Also the dedicated server (`--dedicated`) |
 | `horizon-items` | Blocks and items below gameplay: `blocks.rs` (block facts), `items.rs`, `item_data.rs` (components), `enchant.rs`, `cooldowns.rs`, `bundle.rs`, `item_nbt.rs`. Re-exported as `horizon_client::items`... |
 | `horizon-command` | Command parsing (Brigadier): the vanilla tree, argument types, selectors, suggestions, the tree's network form. Re-exported as `horizon_client::command` |
 | `horizon-client-core` | The client lib's bottom layer: `text.rs`, `lang.rs`, `snbt.rs`, `nbt_path.rs`, `component.rs`, `scoreboard.rs`, `bossbar.rs`, `gamerules.rs`, `block_entity_nbt.rs`, registry/particle/sound tables. Re-exported under the old paths (`horizon_client::text`...) |
+| `horizon-client-input` | Key bindings and key names, toggle keys, mouse options, controller settings and glyphs, the clipboard, window options (`keybinds.rs`, `gamepad.rs`, `mouse.rs`, `window.rs`...). Re-exported under the old paths |
+| `horizon-client-render` | The client's world data, rendering and screens (chunks, meshing, light, streaming, `gfx`, HUD, menus, settings): ~80 modules that horizon-client re-exports under the same paths. Nothing in it reaches gameplay |
 | `horizon-world` | Vanilla world data with no gameplay loop: NBT, regions, chunks, `datafix/`, `worldgen/`, `level/` (server-side block behaviour, ticks, redstone), entity physics, items, effects, food, damage |
 | `horizon-core` | Simulation primitives: Java `Random`s, `jmath` (HotSpot-exact `Math`), positions, noise, density, paletted storage, `version.rs` (the pinned version) |
 | `horizon-protocol` | Network protocol 777: codecs, framing, encryption, `packets/{handshake,status,login,configuration,play}.rs`, `entity_data.rs` |
@@ -109,12 +111,13 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 
 ## horizon-client: where things live
 
-`L:` = lib (`crates/horizon-client/src/`), `G:` = bin (`crates/horizon-client/src/game/`). The lib can't see
+`L:` = lib (`crates/horizon-client/src/`, or `crates/horizon-client-render/src/` for the modules that crate holds, under
+the same `horizon_client::<module>` paths), `G:` = bin (`crates/horizon-client/src/game/`). The lib can't see
 `Game`; bin code reaches the lib as `horizon_client::<module>`.
 
 | Subsystem | Files |
 |---|---|
-| Game loop, tick, frame | `game.rs`: `fn run`, `impl ApplicationHandler for Game` (`window_event`, `about_to_wait`), `fn tick`, `fn tick_world`, `fn render`; L: `clock.rs`, `window.rs`, `spans.rs` |
+| Game loop, tick, frame | `game.rs`: `fn run`, `impl ApplicationHandler for Game` (`window_event`, `about_to_wait`), `fn tick`, `fn tick_world`, `fn render`; L: `clock.rs`, `spans.rs`; `horizon-client-input/src/window.rs` |
 | Rendering | L: `gfx.rs` (`Renderer::new`, `Renderer::render`), `gfx/` (cull, occlusion, translucency, upload, timing, lod, weather, stars, end_sky), `*.wgsl`, `particles.rs`, `block_entity_render.rs`, `item_render.rs`, `fog.rs`, `clouds.rs`, `camera.rs`, `first_person.rs`; G: `render_tick.rs`, `item_draw.rs` |
 | Chunks, streaming, light | L: `streaming.rs` (worker pool: generate, light, mesh), `world.rs`, `chunk.rs`, `chunk_map.rs`, `light.rs`, `mesher.rs` + `mesher/`, `vanillagen.rs` (binds horizon-world's generator), `lod.rs` + `lod/`, `ticket_levels.rs`; G: `world_loading.rs`, `postprocess.rs`; game.rs `fn update_world` |
 | World generation | `crates/horizon-world/src/worldgen/` (`generator*.rs`, `feature_graph.rs`, `structure/`, `carver/`) |
@@ -130,7 +133,7 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 | Integrated server | G: `integrated.rs` (the server thread), `levels.rs` (one level per dimension, `fn tick_server`), `server_travel.rs` |
 | Dedicated server | G: `dedicated.rs`, `dedicated/status.rs`; crates `horizon-server-files`, `horizon-server` |
 | Save and load | L: `save.rs` (level.dat, regions, playerdata), `entity_nbt.rs`, `options_file.rs`; `horizon-client-core/src/block_entity_nbt.rs`; G: `saving.rs`, `persist.rs` (entities); `crates/horizon-world/src/{region.rs,nbt.rs,datafix/}` |
-| Input | game.rs `fn window_event`, `fn key_pressed`, `fn play_mouse`; L: `keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `osk.rs`, `clipboard.rs`; G: `pad.rs`, `pad_menu.rs` |
+| Input | game.rs `fn window_event`, `fn key_pressed`, `fn play_mouse`; crate `horizon-client-input` (`keybinds.rs`, `keymapping.rs`, `key_names.rs`, `mouse.rs`, `input.rs`, `interaction_input.rs`, `gamepad.rs`, `clipboard.rs`); L: `osk.rs`; G: `pad.rs`, `pad_menu.rs` |
 | Audio | L: `audio.rs` (mixer), `sound_engine.rs`, `sound_events.rs`, `music.rs`, `ambience.rs`; G: `music.rs`, `subtitle_hud.rs` |
 | Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`; `horizon-client-core/src/lang.rs`; crate `horizon-assets`; G: `packs.rs` |
 | Agent control | L: `control.rs` (socket), `bin/horizon-ctl/`; G: `control.rs`, `agent.rs`, `events.rs`, `ui_control.rs` ([docs/agent-control.md](docs/agent-control.md)) |

CONTRIBUTING.md

@@ -86,6 +86,9 @@ configuration and toolchain changes select the whole workspace; CI also keeps it
   release notes), `skip-release` when players see no change (tooling, docs, tests), nothing for a fix.
   `release-now` is for crash fixes that shouldn't wait. pr_ready suggests one.
 
+Who reviews and merges: the Horizon Team, on CI for ordinary pull requests; risky ones (saves, network, world
+generation, the launcher's updates) wait for a local proof first ([merging](docs/release-flow.md#merging)).
+
 Every merge to main is released automatically ([release flow](docs/release-flow.md)), so main always stays playable.
 How agents, checks, releases and signed updates keep this safe: [security](docs/security.md).
 

Cargo.lock

@@ -876,6 +876,12 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"
 
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
 [[package]]
 name = "either"
 version = "1.19.0"
@@ -1370,7 +1376,6 @@ name = "horizon-client"
 version = "0.1.0"
 dependencies = [
  "ab_glyph",
- "arboard",
  "bytemuck",
  "chrono",
  "cpal",
@@ -1380,6 +1385,8 @@ dependencies = [
  "horizon-assets",
  "horizon-bench",
  "horizon-client-core",
+ "horizon-client-input",
+ "horizon-client-render",
  "horizon-command",
  "horizon-core",
  "horizon-dualsense",
@@ -1398,6 +1405,7 @@ dependencies = [
  "log",
  "miniz_oxide 0.8.9",
  "naga",
+ "open",
  "png",
  "pollster",
  "rustix 1.1.5",
@@ -1422,6 +1430,58 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "horizon-client-input"
+version = "0.1.0"
+dependencies = [
+ "arboard",
+ "horizon-client-core",
+ "horizon-dualsense",
+ "horizon-theme",
+ "png",
+ "winit",
+]
+
+[[package]]
+name = "horizon-client-render"
+version = "0.1.0"
+dependencies = [
+ "ab_glyph",
+ "bytemuck",
+ "chrono",
+ "flate2",
+ "glam",
+ "horizon-assets",
+ "horizon-bench",
+ "horizon-client-core",
+ "horizon-client-input",
+ "horizon-command",
+ "horizon-core",
+ "horizon-hdr",
+ "horizon-items",
+ "horizon-protocol",
+ "horizon-shader-api",
+ "horizon-shaders",
+ "horizon-telemetry",
+ "horizon-theme",
+ "horizon-threads",
+ "horizon-world",
+ "log",
+ "miniz_oxide 0.8.9",
+ "naga",
+ "png",
+ "pollster",
+ "rustix 1.1.5",
+ "serde",
+ "serde_json",
+ "sha2",
+ "unicode-bidi",
+ "ureq",
+ "wgpu",
+ "winit",
+ "zip",
+]
+
 [[package]]
 name = "horizon-command"
 version = "0.1.0"
@@ -1865,6 +1925,25 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "is-docker"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "is-wsl"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
+dependencies = [
+ "is-docker",
+ "once_cell",
+]
+
 [[package]]
 name = "itertools"
 version = "0.14.0"
@@ -2679,6 +2758,17 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
+[[package]]
+name = "open"
+version = "5.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d8c8b8e725ad26404d6896eb2f064294a0a7b4f1d9120210d85544684c4ca95"
+dependencies = [
+ "dunce",
+ "is-wsl",
+ "libc",
+]
+
 [[package]]
 name = "orbclient"
 version = "0.3.55"
@@ -3194,9 +3284,9 @@ dependencies = [
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.15"
+version = "0.103.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -4374,14 +4464,14 @@ version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "webpki-roots 1.0.9",
+ "webpki-roots 1.0.10",
 ]
 
 [[package]]
 name = "webpki-roots"
-version = "1.0.9"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
+checksum = "1c1c8e20c8a38fc7d65abfe74eb7280e4aa667e8eec8bc84996d2874810748d9"
 dependencies = [
  "rustls-pki-types",
 ]

Cargo.toml

@@ -8,6 +8,8 @@ members = [
     "crates/horizon-world",
     "crates/horizon-client",
     "crates/horizon-client-core",
+    "crates/horizon-client-input",
+    "crates/horizon-client-render",
     "crates/horizon-command",
     "crates/horizon-items",
     "crates/horizon-server-files",
@@ -60,8 +62,10 @@ large_enum_variant = "allow"
 # wgpu-hal 30.0.1 with gfx-rs/wgpu#10124: wgpu 30 creates a Vulkan descriptor
 # pool with no pool sizes while it creates the device, which Vulkan allows only
 # since 1.3.215, and Intel's Windows driver for 6th-10th gen iGPUs (HD 520/530,
-# UHD 620/630) crashes on it with an access violation (#746). Drop this and the
-# folder once a wgpu release has the fix.
+# 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.
 [patch.crates-io]
 wgpu-hal = { path = "third_party/wgpu-hal" }
 

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Ludovic
+Copyright (c) 2026 Ludovic Marie and the Horizon contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -29,9 +29,9 @@ Horizon is Minecraft: Java Edition 26.3 rewritten in Rust: a native game that re
 
 ## 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 and updates the game, prepares its files from your own copy of Minecraft, and updates itself.
+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 and updates the game, prepares its files from your copy of Minecraft (your own install, or downloaded from Mojang for your account), 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)); Minecraft: Java Edition 26.3, played once (the official launcher, Prism, MultiMC and other launchers all work); a Java 25 runtime, for the one-time preparation; and a GPU with Vulkan on Linux and Windows, or any Apple Silicon Mac. 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 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 on Linux and 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).
 
 <table>
   <tr>
@@ -93,7 +93,7 @@ Commands block until the action is done and reply with what happened; errors are
 
 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.
 
-Horizon contains no game files and never downloads them. It builds its resources from **your own copy** of Minecraft: Java Edition 26.3, verified against the checksums in `research-lock.json`:
+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.

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

@@ -97,6 +97,9 @@ impl Report {
         for r in &f.requires {
             out += &format!("  needs {} {} ({})\n", r.id, r.version, &r.sha256[..12]);
         }
+        if self.kind == Kind::NativeMod {
+            out += "  native source: unsandboxed; not executed by the registry check. Compile and test against the exact pinned Horizon and Mixins revisions before review.\n";
+        }
         if self.kind == Kind::Mod && !self.code {
             out += "  no code: content only, nothing to run\n";
         } else if self.kind == Kind::Mod {
@@ -118,6 +121,7 @@ impl Report {
 pub fn kind_of(path: &Path) -> Option<Kind> {
     match path.extension()?.to_str()? {
         "hmod" => Some(Kind::Mod),
+        "hnmod" => Some(Kind::NativeMod),
         "hpack" => Some(Kind::Modpack),
         "zip" => Some(Kind::ResourcePack),
         "hshader" => Some(Kind::Shader),

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

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

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

@@ -195,6 +195,11 @@ fn object_style(o: &serde_json::Map<String, Value>) -> Style {
             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,
         };
     }

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

@@ -16,3 +16,20 @@ pub fn parse_identifier(raw: &str) -> Option<String> {
     });
     (ns_ok && path_ok).then(|| format!("{ns}:{path}"))
 }
+
+/// `Identifier.CODEC` parsing an entity id: lowercase namespace and path
+/// characters, `minecraft` when the namespace is left out.
+pub fn normalize_id(s: &str) -> Option<String> {
+    let (ns, path) = match s.split_once(':') {
+        Some((ns, path)) => (if ns.is_empty() { "minecraft" } else { ns }, path),
+        None => ("minecraft", s),
+    };
+    let ok = |c: char, slash: bool| {
+        c.is_ascii_lowercase()
+            || c.is_ascii_digit()
+            || matches!(c, '_' | '-' | '.')
+            || slash && c == '/'
+    };
+    (ns.chars().all(|c| ok(c, false)) && path.chars().all(|c| ok(c, true)))
+        .then(|| format!("{ns}:{path}"))
+}

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

@@ -22,3 +22,11 @@ pub fn number(tag: Option<&Tag>) -> Option<i64> {
         _ => return None,
     })
 }
+/// Any numeric tag as f64, keeping a float's or double's fraction.
+pub fn float(tag: Option<&Tag>) -> Option<f64> {
+    Some(match tag? {
+        Tag::Float(b) => f64::from(f32::from_bits(*b)),
+        Tag::Double(b) => f64::from_bits(*b),
+        other => number(Some(other))? as f64,
+    })
+}

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

@@ -50,6 +50,9 @@ pub enum ClickEvent {
     /// `ClickEvent.RunCommand`: the command, with or without its `/`.
     RunCommand(String),
     CopyToClipboard(String),
+    /// `ClickEvent.ShowDialog`: a `minecraft:dialog` registry id, or the
+    /// dialog itself as the component carried it.
+    ShowDialog(horizon_world::nbt::Tag),
     /// A local file to open with the system handler.
     /// Only allow this in locally constructed messages, never server/LAN text.
     OpenFile(String),
@@ -557,6 +560,11 @@ fn style_json(style: &Style) -> Vec<(String, Value)> {
             ClickEvent::RunCommand(command) => {
                 json!({ "action": "run_command", "command": command })
             }
+            // ClickEvent.ShowDialog.CODEC: the dialog the server sent it with.
+            ClickEvent::ShowDialog(dialog) => json!({
+                "action": "show_dialog",
+                "dialog": crate::scoreboard::tag_to_json(dialog),
+            }),
             ClickEvent::OpenFile(path) => json!({ "action": "open_file", "path": path }),
         };
         out.push(("click_event".to_owned(), event));

crates/horizon-client-input/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "horizon-client-input"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version = "1.90"
+description = "The client's input layer: key bindings and their names, mouse, controllers, clipboard and window options"
+
+[dependencies]
+horizon-client-core = { path = "../horizon-client-core" }
+winit = "0.30.13"
+# The window icon.
+horizon-theme = { path = "../horizon-theme" }
+png = "0.18"
+arboard = { version = "3.6.1", default-features = false, features = ["wayland-data-control"] }
+# The DualSense's trigger effects (the `controllers` feature).
+horizon-dualsense = { path = "../horizon-dualsense", optional = true }
+
+[features]
+controllers = ["dep:horizon-dualsense"]
+
+[lints]
+workspace = true

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

@@ -145,6 +145,22 @@ const KEYS: &[(&str, KeyCode)] = &[
     ("key.keyboard.period", KeyCode::Period),
     ("key.keyboard.slash", KeyCode::Slash),
     ("key.keyboard.caps.lock", KeyCode::CapsLock),
+    ("key.keyboard.world.1", KeyCode::IntlBackslash),
+    ("key.keyboard.international1", KeyCode::IntlRo),
+    ("key.keyboard.international3", KeyCode::IntlYen),
+    ("key.keyboard.lang1", KeyCode::Lang1),
+    ("key.keyboard.lang2", KeyCode::Lang2),
+    ("key.keyboard.lang3", KeyCode::Lang3),
+    ("key.keyboard.lang4", KeyCode::Lang4),
+    ("key.keyboard.lang5", KeyCode::Lang5),
+    ("key.keyboard.help", KeyCode::Help),
+    ("key.keyboard.select", KeyCode::Select),
+    ("key.keyboard.again", KeyCode::Again),
+    ("key.keyboard.undo", KeyCode::Undo),
+    ("key.keyboard.cut", KeyCode::Cut),
+    ("key.keyboard.copy", KeyCode::Copy),
+    ("key.keyboard.paste", KeyCode::Paste),
+    ("key.keyboard.find", KeyCode::Find),
     ("key.keyboard.f1", KeyCode::F1),
     ("key.keyboard.f2", KeyCode::F2),
     ("key.keyboard.f3", KeyCode::F3),
@@ -157,6 +173,18 @@ const KEYS: &[(&str, KeyCode)] = &[
     ("key.keyboard.f10", KeyCode::F10),
     ("key.keyboard.f11", KeyCode::F11),
     ("key.keyboard.f12", KeyCode::F12),
+    ("key.keyboard.f13", KeyCode::F13),
+    ("key.keyboard.f14", KeyCode::F14),
+    ("key.keyboard.f15", KeyCode::F15),
+    ("key.keyboard.f16", KeyCode::F16),
+    ("key.keyboard.f17", KeyCode::F17),
+    ("key.keyboard.f18", KeyCode::F18),
+    ("key.keyboard.f19", KeyCode::F19),
+    ("key.keyboard.f20", KeyCode::F20),
+    ("key.keyboard.f21", KeyCode::F21),
+    ("key.keyboard.f22", KeyCode::F22),
+    ("key.keyboard.f23", KeyCode::F23),
+    ("key.keyboard.f24", KeyCode::F24),
     ("key.keyboard.print.screen", KeyCode::PrintScreen),
     ("key.keyboard.scroll.lock", KeyCode::ScrollLock),
     ("key.keyboard.pause", KeyCode::Pause),
@@ -188,6 +216,36 @@ const KEYS: &[(&str, KeyCode)] = &[
     ("key.keyboard.keypad.0", KeyCode::Numpad0),
     ("key.keyboard.keypad.period", KeyCode::NumpadDecimal),
     ("key.keyboard.keypad.equal", KeyCode::NumpadEqual),
+    ("key.keyboard.keypad.comma", KeyCode::NumpadComma),
+    ("key.keyboard.keypad.backspace", KeyCode::NumpadBackspace),
+    (
+        "key.keyboard.keypad.left.parenthesis",
+        KeyCode::NumpadParenLeft,
+    ),
+    (
+        "key.keyboard.keypad.right.parenthesis",
+        KeyCode::NumpadParenRight,
+    ),
+    ("key.keyboard.keypad.hash", KeyCode::NumpadHash),
+    (
+        "key.keyboard.keypad.memory.store",
+        KeyCode::NumpadMemoryStore,
+    ),
+    (
+        "key.keyboard.keypad.memory.recall",
+        KeyCode::NumpadMemoryRecall,
+    ),
+    (
+        "key.keyboard.keypad.memory.clear",
+        KeyCode::NumpadMemoryClear,
+    ),
+    ("key.keyboard.keypad.memory.add", KeyCode::NumpadMemoryAdd),
+    (
+        "key.keyboard.keypad.memory.subtract",
+        KeyCode::NumpadMemorySubtract,
+    ),
+    ("key.keyboard.keypad.clear", KeyCode::NumpadClear),
+    ("key.keyboard.keypad.clear.entry", KeyCode::NumpadClearEntry),
     ("key.keyboard.menu", KeyCode::ContextMenu),
     ("key.keyboard.left.control", KeyCode::ControlLeft),
     ("key.keyboard.left.shift", KeyCode::ShiftLeft),

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

@@ -0,0 +1,14 @@
+//! The client's input layer, below gameplay and screens: key bindings and their
+//! names, toggle keys, mouse settings, controllers, the clipboard and window
+//! options. horizon-client re-exports each module under its old path
+//! (`horizon_client::keybinds`, ...).
+#![forbid(unsafe_code)]
+pub mod clipboard;
+pub mod gamepad;
+pub mod input;
+pub mod interaction_input;
+pub mod key_names;
+pub mod keybinds;
+pub mod keymapping;
+pub mod mouse;
+pub mod window;

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

@@ -324,6 +324,24 @@ pub fn ease_in_out(t: f64) -> f64 {
     0.5 - 0.5 * (std::f64::consts::PI * t).cos()
 }
 
+/// `MouseHandler.grabMouse` / `releaseMouse`: the mouse position is the
+/// window's centre whenever the pointer's grab state changes, so a screen
+/// opened from gameplay starts with the cursor in the middle. A release of
+/// an already free pointer (or a grab of an already grabbed one) leaves the
+/// position where it is, as vanilla does.
+pub fn mouse_position_after_grab_change(
+    grab: bool,
+    was_grabbed: bool,
+    size: [u32; 2],
+    scale: f32,
+) -> Option<(f32, f32)> {
+    if grab == was_grabbed {
+        None
+    } else {
+        Some((size[0] as f32 / 2.0 / scale, size[1] as f32 / 2.0 / scale))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -485,4 +503,27 @@ mod tests {
         assert_eq!(look.on_scroll(0.0, 0.4, false, 1.0), None);
         assert_eq!(look.on_scroll(0.0, 0.7, false, 1.0), Some((1, (0, 1))));
     }
+    #[test]
+    fn the_mouse_position_is_the_centre_when_the_grab_changes() {
+        // A grab of a free pointer and a release of a grabbed one both put
+        // the position at the window's centre (`MouseHandler.grabMouse`,
+        // `MouseHandler.releaseMouse`).
+        assert_eq!(
+            mouse_position_after_grab_change(true, false, [1920, 1080], 1.0),
+            Some((960.0, 540.0))
+        );
+        assert_eq!(
+            mouse_position_after_grab_change(false, true, [1920, 1080], 2.0),
+            Some((480.0, 270.0))
+        );
+        // Without a change of the grab state the position stays where it is.
+        assert_eq!(
+            mouse_position_after_grab_change(false, false, [1920, 1080], 1.0),
+            None
+        );
+        assert_eq!(
+            mouse_position_after_grab_change(true, true, [1920, 1080], 1.0),
+            None
+        );
+    }
 }

crates/horizon-client-render/Cargo.toml

@@ -0,0 +1,62 @@
+[package]
+name = "horizon-client-render"
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version = "1.90"
+description = "The client's world data, rendering and screens: chunks, meshing, light, streaming, the renderer, the HUD, menus and settings; no gameplay"
+
+[dependencies]
+horizon-assets = { path = "../horizon-assets" }
+horizon-bench = { path = "../horizon-bench" }
+horizon-client-core = { path = "../horizon-client-core" }
+horizon-client-input = { path = "../horizon-client-input" }
+horizon-command = { path = "../horizon-command" }
+horizon-core = { path = "../horizon-core" }
+horizon-hdr = { path = "../horizon-hdr" }
+horizon-items = { path = "../horizon-items" }
+horizon-protocol = { path = "../horizon-protocol" }
+horizon-shader-api = { path = "../horizon-shader-api" }
+horizon-shaders = { path = "../horizon-shaders" }
+horizon-telemetry = { path = "../horizon-telemetry", default-features = false, features = ["live"] }
+horizon-theme = { path = "../horizon-theme" }
+horizon-threads = { path = "../horizon-threads" }
+horizon-world = { path = "../horizon-world" }
+ab_glyph = "0.2.32"
+bytemuck = { version = "1.24", features = ["derive"] }
+chrono = { version = "0.4.42", default-features = false, features = ["clock", "std"] }
+flate2 = { version = "1.1.10", default-features = false, features = ["zlib-rs", "runtime_detection"] }
+glam = "0.30"
+log = "0.4"
+miniz_oxide = "0.8"
+naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out"] }
+png = "0.18"
+pollster = "0.4"
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1.0.151", features = ["raw_value"] }
+sha2 = "0.10.9"
+unicode-bidi = "0.3.18"
+ureq = { version = "2", default-features = false, features = ["tls"] }
+wgpu = { version = "30.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "metal", "wgsl", "naga-ir"] }
+winit = "0.30.13"
+zip = { version = "2", default-features = false, features = ["deflate"] }
+
+[target.'cfg(unix)'.dependencies]
+rustix = { version = "1", default-features = false, features = ["std", "time"] }
+
+[target.'cfg(windows)'.dependencies]
+wgpu = { version = "30.0.1", default-features = false, features = ["dx12"] }
+
+[target.'cfg(not(target_os = "macos"))'.dependencies]
+wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }
+
+[features]
+# Helpers horizon-client's tests build their fixtures with.
+test-support = []
+
+[lints]
+workspace = true
+
+[dev-dependencies]
+horizon-items = { path = "../horizon-items", features = ["test-support"] }
+naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out", "msl-out", "spv-out"] }

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

@@ -42,11 +42,11 @@ impl HeightmapState for StateFacts {
 }
 #[derive(Clone)]
 pub struct Properties(Arc<Vec<StateFacts>>);
-#[cfg(test)]
+#[cfg(any(test, feature = "test-support"))]
 impl Properties {
     /// Heightmap facts for tests, per state: (air, has a fluid, blocks
     /// motion, blocks motion but is not leaves). State 0 is minecraft:air.
-    pub(crate) fn for_tests(states: &[(bool, bool, bool, bool)]) -> Self {
+    pub fn for_tests(states: &[(bool, bool, bool, bool)]) -> Self {
         Self(Arc::new(
             states
                 .iter()
@@ -218,6 +218,8 @@ impl RenderAssets {
             sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
         }
         sprites.finish();
+        // `finish` grows the buffer by doubling: keep only the bytes in use.
+        sprites.pixels.shrink_to_fit();
         Ok(Self {
             sprite_size: sprites.size,
             sprite_minimum_size: sprites.minimum_size,

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

@@ -20,12 +20,68 @@ pub struct SpawnEntry {
     /// A `ConstantInt` count (sampling draws nothing).
     pub constant: bool,
 }
+/// A `natural_mob_spawns` / `spawn_overrides` entry list.
+pub fn parse_entries(list: &Value) -> Vec<SpawnEntry> {
+    list.as_array()
+        .into_iter()
+        .flatten()
+        .filter_map(|e| {
+            let count = &e["count"];
+            let (min, max, constant) = match count {
+                Value::Number(n) => {
+                    let n = n.as_u64().unwrap_or(1) as u32;
+                    (n, n, true)
+                }
+                c if c["type"].as_str() == Some("minecraft:constant") => {
+                    let n = c["value"].as_u64().unwrap_or(1) as u32;
+                    (n, n, true)
+                }
+                c => (
+                    c["min_inclusive"].as_u64().unwrap_or(1) as u32,
+                    c["max_inclusive"].as_u64().unwrap_or(1) as u32,
+                    false,
+                ),
+            };
+            Some(SpawnEntry {
+                entity: e["type"].as_str()?.to_owned(),
+                weight: e["weight"].as_u64().unwrap_or(1) as u32,
+                min,
+                max,
+                constant,
+            })
+        })
+        .collect()
+}
+/// `MobSpawnSettings.MobSpawnCost`.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct SpawnCost {
+    pub energy_budget: f64,
+    pub charge: f64,
+}
+/// The `spawn_costs` of a `natural_mob_spawns` value.
+pub fn parse_costs(costs: &Value) -> HashMap<String, SpawnCost> {
+    costs
+        .as_object()
+        .into_iter()
+        .flatten()
+        .map(|(k, c)| {
+            (
+                k.clone(),
+                SpawnCost {
+                    energy_budget: c["energy_budget"].as_f64().unwrap_or(0.0),
+                    charge: c["charge"].as_f64().unwrap_or(0.0),
+                },
+            )
+        })
+        .collect()
+}
+
 #[derive(Clone, Debug)]
 pub struct BiomeInfo {
     /// `natural_mob_spawns` by category (creature, monster, ...).
     pub spawns: HashMap<String, Vec<SpawnEntry>>,
     /// `natural_mob_spawns` spawn costs by entity type.
-    pub spawn_costs: HashMap<String, crate::mobs::spawn_selection::SpawnCost>,
+    pub spawn_costs: HashMap<String, SpawnCost>,
     /// The `gameplay/creature_world_gen_spawn_probability` attribute.
     pub creature_probability: f32,
     /// The `gameplay/increased_fire_burnout` attribute (jungles, swamps, peaks,
@@ -150,12 +206,12 @@ impl Biomes {
             };
             let categories = &natural["spawns_by_category"];
             for (category, entries) in categories.as_object().into_iter().flatten() {
-                let list = crate::mobs::spawn_selection::parse_entries(entries);
+                let list = parse_entries(entries);
                 spawns.insert(category.clone(), list);
             }
             list.push(BiomeInfo {
                 spawns,
-                spawn_costs: crate::mobs::spawn_selection::parse_costs(&natural["spawn_costs"]),
+                spawn_costs: parse_costs(&natural["spawn_costs"]),
                 creature_probability:
                     attributes["minecraft:gameplay/creature_world_gen_spawn_probability"]
                         .as_f64()

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

@@ -26,6 +26,7 @@
 use crate::chunk::block_entity::BlockEntity;
 use crate::fast_hash::{FxHashMap, FxHashSet};
 use std::collections::HashMap;
+use std::sync::Arc;
 
 pub type Pos = (i32, i32, i32);
 
@@ -46,7 +47,7 @@ pub enum Ticking {
 pub struct BlockEntities {
     map: HashMap<Pos, BlockEntity>,
     /// `Level.blockEntityTickers`: positions and the slot each was given.
-    tickers: Vec<(Pos, u32)>,
+    tickers: Arc<Vec<(Pos, u32)>>,
     /// `LevelChunk.tickersInLevel`: the live slot of each ticking position.
     live: FxHashMap<Pos, u32>,
     /// Positions that may need a slot, in the order vanilla would have made
@@ -233,7 +234,7 @@ impl BlockEntities {
     }
     pub fn clear(&mut self) {
         self.map.clear();
-        self.tickers.clear();
+        self.tickers = Arc::default();
         self.live.clear();
         self.added.clear();
         self.pending.clear();
@@ -274,7 +275,7 @@ impl BlockEntities {
     /// and freed ones leave it. `state` reads the block state at a position.
     /// Returns the slots to tick, in order; check each with `is_live` before
     /// ticking it, as the ticks before it can free it.
-    pub fn tickers(&mut self, state: impl Fn(Pos) -> u32) -> Vec<(Pos, u32)> {
+    pub fn tickers(&mut self, state: impl Fn(Pos) -> u32) -> Arc<Vec<(Pos, u32)>> {
         for (pos, token) in std::mem::take(&mut self.added) {
             if self.pending.get(&pos) != Some(&token) {
                 continue;
@@ -288,21 +289,21 @@ impl BlockEntities {
             }
             let slot = self.next();
             self.live.insert(pos, slot);
-            self.tickers.push((pos, slot));
+            Arc::make_mut(&mut self.tickers).push((pos, slot));
         }
         if !std::mem::take(&mut self.freed) && self.out.is_empty() {
-            return self.tickers.clone();
+            return Arc::clone(&self.tickers);
         }
         self.out.clear();
         let (live, map) = (&mut self.live, &self.map);
-        self.tickers.retain(|(p, slot)| {
+        Arc::make_mut(&mut self.tickers).retain(|(p, slot)| {
             let mine = live.get(p) == Some(slot);
             if mine && !map.contains_key(p) {
                 live.remove(p);
             }
             mine && map.contains_key(p)
         });
-        self.tickers.clone()
+        Arc::clone(&self.tickers)
     }
     /// Whether a slot from `tickers` still ticks.
     pub fn is_live(&self, (pos, slot): (Pos, u32)) -> bool {
@@ -329,8 +330,8 @@ mod tests {
     }
     fn order(b: &mut BlockEntities, states: &HashMap<Pos, u32>) -> Vec<Pos> {
         b.tickers(|p| states.get(&p).copied().unwrap_or(0))
-            .into_iter()
-            .map(|(p, _)| p)
+            .iter()
+            .map(|(p, _)| *p)
             .collect()
     }
 

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

@@ -435,7 +435,8 @@ pub struct BellTick {
     pub ended: Option<(Vec<([f64; 3], i32)>, Vec<u64>)>,
 }
 
-fn closer_to_center_than(pos: [i32; 3], p: [f64; 3], distance: f64) -> bool {
+/// `Vec3i.closerToCenterThan`: `p` is within `distance` of the block's centre.
+pub fn closer_to_center_than(pos: [i32; 3], p: [f64; 3], distance: f64) -> bool {
     let dx = f64::from(pos[0]) + 0.5 - p[0];
     let dy = f64::from(pos[1]) + 0.5 - p[1];
     let dz = f64::from(pos[2]) + 0.5 - p[2];

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

@@ -97,6 +97,16 @@ pub fn diffuse(normal: Vec3, lights: (Vec3, Vec3)) -> f32 {
 pub fn vertex_light(packed: u8) -> u32 {
     (u32::from(packed >> 4) * 16) | ((u32::from(packed & 15) * 16) << 8)
 }
+/// `ChestRenderer.xmasTextures`: `SpecialDates.isExtendedChristmas` (24 to 26
+/// December in the local time zone), read once when the renderer is created.
+fn extended_christmas() -> bool {
+    use chrono::Datelike;
+    static XMAS: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
+    *XMAS.get_or_init(|| {
+        let now = chrono::Local::now();
+        now.month() == 12 && (24..=26).contains(&now.day())
+    })
+}
 fn pack_color(rgb: u32, alpha: u32, brightness: f32) -> u32 {
     let c = |shift: u32| (((rgb >> shift) & 255) as f32 * brightness) as u32;
     alpha << 24 | c(0) << 16 | c(8) << 8 | c(16)
@@ -587,6 +597,18 @@ fn first_line(line: &str, max_width: f32, advance: &dyn Fn(char) -> f32) -> Stri
     line.to_owned()
 }
 
+/// `AbstractSignRenderer.isOutlineVisible`: the camera within 16 blocks of
+/// the sign's centre.
+fn sign_text_near(pos: [i32; 3], camera: DVec3) -> bool {
+    DVec3::new(
+        f64::from(pos[0]) + 0.5,
+        f64::from(pos[1]) + 0.5,
+        f64::from(pos[2]) + 0.5,
+    )
+    .distance_squared(camera)
+        < 256.0
+}
+
 /// `AbstractSignRenderer.submitSignText`: four centred lines, glowing text
 /// full-bright with an 8x outline in the dark colour.
 fn sign_text_calls(
@@ -747,6 +769,9 @@ pub struct Scene<'a> {
     pub skull: &'a dyn Fn([i32; 3]) -> Option<String>,
     /// Font glyph cell (none for blank glyphs such as the space) and advance.
     pub glyph: &'a dyn Fn(char) -> (Option<Rect>, f32),
+    /// Changes whenever `glyph` may answer differently (`Font::epoch`): sign
+    /// text laid out under another value is laid out again.
+    pub glyphs: u64,
 }
 
 pub struct BlockEntityRenderer {
@@ -758,7 +783,30 @@ pub struct BlockEntityRenderer {
     pot_patterns: HashMap<String, String>,
     /// `Block.shouldRenderFace` for End gateway faces (its occlusion pair cache needs a lock).
     visibility: Option<Mutex<FaceVisibility>>,
+    sign_texts: Mutex<SignTexts>,
 }
+/// Laid-out sign text by position. `AbstractSignRenderer` lays the text out
+/// again each frame, glyph by glyph; its vertices only change with what is
+/// in the key, so they are kept relative to the block and moved to the camera.
+#[derive(Default)]
+struct SignTexts {
+    signs: crate::fast_hash::FxHashMap<[i32; 3], SignTextEntry>,
+    /// Game time of the last sweep of signs out of view.
+    swept: i64,
+}
+struct SignTextEntry {
+    state: u32,
+    data: crate::signs::SignData,
+    packed: u8,
+    /// Within the glowing text outline's distance (only kept for glowing text).
+    near: bool,
+    glyphs: u64,
+    /// Game time it was last drawn.
+    used: i64,
+    vertices: Vec<Vertex>,
+}
+/// Game ticks a sign's text is kept after it was last drawn.
+const SIGN_TEXT_KEEP: i64 = 100;
 const MODELS: [(&str, &str); 27] = [
     ("chest", "minecraft:chest#main"),
     ("double_chest_left", "minecraft:double_chest_left#main"),
@@ -888,6 +936,7 @@ impl BlockEntityRenderer {
             closed_chests,
             pot_patterns: HashMap::new(),
             visibility: None,
+            sign_texts: Mutex::default(),
         }
     }
     fn kind(&self, state: u32) -> &Kind {
@@ -922,11 +971,81 @@ impl BlockEntityRenderer {
             let origin = (DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]))
                 - scene.camera)
                 .as_vec3();
-            let base = Mat4::from_translation(origin);
             let packed = scene.world.light(pos[0], pos[1], pos[2]);
+            if matches!(kind, Kind::Sign { .. }) && scene.texts.is_none() {
+                self.sign_text(scene, *pos, *state, origin, packed, out);
+                continue;
+            }
+            let base = Mat4::from_translation(origin);
             self.render_one(scene, *pos, kind, base, packed, lights, false, true, out);
         }
     }
+    /// A sign's text from the cache, laid out again when its data, light,
+    /// state, outline or font changed.
+    fn sign_text(
+        &self,
+        scene: &Scene,
+        pos: [i32; 3],
+        state: u32,
+        origin: Vec3,
+        packed: u8,
+        out: &mut Vec<Vertex>,
+    ) {
+        let Some(data) = (scene.sign)(pos) else {
+            return;
+        };
+        let near = (data.front.glowing || data.back.glowing) && sign_text_near(pos, scene.camera);
+        let Ok(mut cache) = self.sign_texts.lock() else {
+            return;
+        };
+        let now = scene.game_time;
+        if (now - cache.swept).abs() >= SIGN_TEXT_KEEP {
+            cache.swept = now;
+            cache
+                .signs
+                .retain(|_, e| (now - SIGN_TEXT_KEEP..=now).contains(&e.used));
+        }
+        let glyphs = scene.glyphs;
+        let signs = &mut cache.signs;
+        if !signs.get(&pos).is_some_and(|e| {
+            (e.state, e.packed, e.near, e.glyphs) == (state, packed, near, glyphs)
+                && e.data == *data
+        }) {
+            let mut vertices = signs.remove(&pos).map_or_else(Vec::new, |e| e.vertices);
+            vertices.clear();
+            self.render_one(
+                scene,
+                pos,
+                self.kind(state),
+                Mat4::IDENTITY,
+                packed,
+                diffuse_lights(scene.nether),
+                false,
+                true,
+                &mut vertices,
+            );
+            signs.insert(
+                pos,
+                SignTextEntry {
+                    state,
+                    data: data.clone(),
+                    packed,
+                    near,
+                    glyphs,
+                    used: now,
+                    vertices,
+                },
+            );
+        }
+        let Some(entry) = signs.get_mut(&pos) else {
+            return;
+        };
+        entry.used = now;
+        out.extend(entry.vertices.iter().map(|v| Vertex {
+            pos: (Vec3::from_array(v.pos) + origin).to_array(),
+            ..*v
+        }));
+    }
     /// One block entity at `pos` drawn under `base` with the given packed light
     /// (the parity fixture's entry point).
     pub fn render_block(
@@ -1158,13 +1277,7 @@ impl BlockEntityRenderer {
                         m *= Mat4::from_translation(Vec3::new(0.0, 1.0 / 3.0, 0.046_666_667))
                             * Mat4::from_scale(s * 0.010_416_667);
                     }
-                    let near = DVec3::new(
-                        f64::from(pos[0]) + 0.5,
-                        f64::from(pos[1]) + 0.5,
-                        f64::from(pos[2]) + 0.5,
-                    )
-                    .distance_squared(scene.camera)
-                        < 256.0;
+                    let near = sign_text_near(pos, scene.camera);
                     let calls = sign_text_calls(scene, data, text, m, packed, near);
                     match scene.texts {
                         Some(sink) => sink.borrow_mut().extend(calls),
@@ -1173,11 +1286,25 @@ impl BlockEntityRenderer {
                 }
             }
             Kind::Chest {
+                block,
                 texture,
                 part,
                 y_rot,
                 ..
             } => {
+                // ChestRenderer.getChestMaterial: normal and trapped chests use the christmas
+                // sprites on 24-26 December. Copper and ender chests keep theirs.
+                let texture = if matches!(block.as_str(), "chest" | "trapped_chest")
+                    && extended_christmas()
+                {
+                    match part {
+                        ChestPart::Single => "entity/chest/christmas",
+                        ChestPart::Left => "entity/chest/christmas_left",
+                        ChestPart::Right => "entity/chest/christmas_right",
+                    }
+                } else {
+                    *texture
+                };
                 let model = match part {
                     ChestPart::Single => "chest",
                     ChestPart::Left => "double_chest_left",
@@ -1930,6 +2057,7 @@ mod tests {
             banner: &|_| Vec::new(),
             skull: &|_| None,
             glyph: &|_| (None, 0.0),
+            glyphs: 0,
         };
         // Compare the cached world path with the original model renderer,
         // including atlas replacement, current light and animated fallback.
@@ -2130,6 +2258,128 @@ mod tests {
         assert_eq!(out[2].uv, [0.5, 0.5]);
     }
 
+    #[test]
+    fn cached_sign_text_matches_and_follows_changes() {
+        let renderer = BlockEntityRenderer {
+            models: HashMap::new(),
+            kinds: vec![
+                Kind::Sign {
+                    hanging: false,
+                    wall: false,
+                    angle: 180.0,
+                },
+                Kind::Sign {
+                    hanging: true,
+                    wall: true,
+                    angle: 90.0,
+                },
+            ],
+            closed_chests: Default::default(),
+            pot_patterns: HashMap::new(),
+            visibility: None,
+            sign_texts: Mutex::default(),
+        };
+        let world = World::new(BlockStateId(0), 1);
+        let sprites = HashMap::new();
+        let text = |line: &str, glowing| crate::signs::SignText {
+            lines: [line.into(), "two".into(), String::new(), "four".into()],
+            color: 3,
+            glowing,
+        };
+        let first_text = crate::signs::SignData {
+            front: text("one", false),
+            ..Default::default()
+        };
+        let changed = crate::signs::SignData {
+            front: text("changed", false),
+            ..Default::default()
+        };
+        let glowing = crate::signs::SignData {
+            back: text("glow", true),
+            ..changed.clone()
+        };
+        let wide = std::cell::Cell::new(6.0);
+        let glyph = |c: char| {
+            let u = f32::from(c as u8 % 16) / 16.0;
+            let rect = Rect {
+                u0: u,
+                v0: 0.0,
+                u1: u + 0.0625,
+                v1: 0.0625,
+                w: 8,
+                h: 8,
+            };
+            ((c != ' ').then_some(rect), wide.get())
+        };
+        let (first_sign, changed_sign, glowing_sign) = (
+            |_| Some(&first_text),
+            |_| Some(&changed),
+            |_| Some(&glowing),
+        );
+        let mut scene = Scene {
+            camera: DVec3::new(3.25, 70.5, -4.75),
+            orientation: Quat::IDENTITY,
+            anim: &|_| BlockAnim::default(),
+            texts: None,
+            partial: 0.0,
+            game_time: 0,
+            max_y: 320,
+            world: &world,
+            sprites: &sprites,
+            nether: false,
+            lid: &|_| 0.0,
+            sign: &first_sign,
+            banner: &|_| Vec::new(),
+            skull: &|_| None,
+            glyph: &glyph,
+            glyphs: 0,
+        };
+        let check = |scene: &Scene, pos: [i32; 3], state: u32| {
+            let mut cached = Vec::new();
+            renderer.render(scene, [(pos, state)].iter(), &mut cached);
+            let corner = DVec3::new(f64::from(pos[0]), f64::from(pos[1]), f64::from(pos[2]));
+            let mut original = Vec::new();
+            renderer.render_one(
+                scene,
+                pos,
+                renderer.kind(state),
+                Mat4::from_translation((corner - scene.camera).as_vec3()),
+                world.light(pos[0], pos[1], pos[2]),
+                diffuse_lights(false),
+                false,
+                true,
+                &mut original,
+            );
+            assert!(!cached.is_empty());
+            assert_eq!(cached.len(), original.len());
+            for (a, b) in cached.iter().zip(&original) {
+                assert!((Vec3::from_array(a.pos) - Vec3::from_array(b.pos)).length() < 1e-5);
+                assert_eq!((a.uv, a.color, a.light), (b.uv, b.color, b.light));
+            }
+            cached.len()
+        };
+        let (pos, other) = ([1, 70, 2], [-3, 64, 9]);
+        let first = check(&scene, pos, 0);
+        // The camera moves: the same text, moved.
+        scene.camera.x += 0.5;
+        check(&scene, pos, 0);
+        // New text, glowing text near and far, another state, other glyphs.
+        scene.sign = &changed_sign;
+        assert_ne!(check(&scene, pos, 0), first);
+        scene.sign = &glowing_sign;
+        check(&scene, pos, 0);
+        scene.camera.z -= 20.0;
+        check(&scene, pos, 0);
+        check(&scene, pos, 1);
+        check(&scene, other, 1);
+        wide.set(5.0);
+        scene.glyphs = 1;
+        check(&scene, pos, 1);
+        // Signs out of view for a while are dropped.
+        scene.game_time = 2 * SIGN_TEXT_KEEP;
+        check(&scene, pos, 0);
+        assert_eq!(renderer.sign_texts.lock().unwrap().signs.len(), 1);
+    }
     #[test]
     fn first_line_wraps_on_bytes_without_splitting_a_char() {
         let advance = |c: char| if c == ' ' { 4.0 } else { 6.0 };
@@ -2190,6 +2440,7 @@ mod tests {
             banner: &|_| Vec::new(),
             skull: &|_| None,
             glyph: &|_| (None, 0.0),
+            glyphs: 0,
         };
         let mut verts = Vec::new();
         renderer.render_block(&scene, [0; 3], state.0, Mat4::IDENTITY, 0xff, &mut verts);

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

@@ -4,8 +4,8 @@
 //! `BrewingStandBlockEntity.serverTick`.
 pub use crate::chunk::block_entity::BrewingStand;
 use crate::{
-    containers::Providers,
     items::{ItemStack, Items},
+    providers::Providers,
 };
 use serde_json::Value;
 use std::{collections::HashSet, fs, path::Path};
@@ -45,20 +45,30 @@ pub fn tooltip(
             Category::Neutral,
         )];
     }
-    def.effects
-        .iter()
+    effect_lines(def.effects.iter().copied(), scale, translate)
+}
+/// `PotionContents.addPotionTooltip`'s line per effect: its name, potency and
+/// scaled duration, for (effect id, duration, amplifier) entries.
+pub fn effect_lines<'a>(
+    effects: impl IntoIterator<Item = (&'a str, i32, i32)>,
+    scale: f32,
+    translate: &dyn Fn(&str) -> Option<String>,
+) -> Vec<(String, Category)> {
+    effects
+        .into_iter()
         .map(|(e, duration, amp)| {
+            let e = e.trim_start_matches("minecraft:");
             let mut line =
-                translate(&format!("effect.minecraft.{e}")).unwrap_or_else(|| (*e).to_owned());
-            if *amp > 0 {
+                translate(&format!("effect.minecraft.{e}")).unwrap_or_else(|| e.to_owned());
+            if amp > 0 {
                 line.push(' ');
                 line.push_str(
                     &translate(&format!("potion.potency.{amp}"))
-                        .unwrap_or_else(|| crate::enchant::level_name(*amp as u32 + 1)),
+                        .unwrap_or_else(|| crate::enchant::level_name(amp as u32 + 1)),
                 );
             }
             let instant = effect(e).is_some_and(|d| d.instant);
-            let scaled = (*duration as f32 * scale) as i32;
+            let scaled = (duration as f32 * scale) as i32;
             if !instant && scaled > 20 {
                 line = format!("{line} ({})", format_duration(scaled));
             }

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

@@ -772,6 +772,27 @@ pub fn bob_matrix(state: &BobState, damage_tilt_strength: f64, bob_view_option:
     pose
 }
 
+/// The spinning effect `GameRenderer.renderLevel` multiplies into the level's
+/// projection after the bob: a skew about a tilted axis, from a portal's or
+/// Nausea's intensity (already scaled by Distortion Effects) and the angle in
+/// degrees. The first-person hand keeps its own projection without it.
+pub fn spinning_effect_matrix(intensity: f32, angle_degrees: f32) -> glam::Mat4 {
+    if intensity <= 0.0 {
+        return glam::Mat4::IDENTITY;
+    }
+    let mut skew = 5.0 / (intensity * intensity + 5.0) - intensity * 0.04;
+    skew *= skew;
+    let axis = glam::Vec3::new(
+        0.0,
+        std::f32::consts::SQRT_2 / 2.0,
+        std::f32::consts::SQRT_2 / 2.0,
+    );
+    let angle = angle_degrees * DEG_TO_RAD;
+    glam::Mat4::from_axis_angle(axis, angle)
+        * glam::Mat4::from_scale(glam::Vec3::new(1.0 / skew, 1.0, 1.0))
+        * glam::Mat4::from_axis_angle(axis, -angle)
+}
+
 #[cfg(test)]
 mod tests {
     #[test]

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

@@ -74,9 +74,28 @@ pub enum BlockEntity {
     /// `DaylightDetectorBlockEntity`: no data, only the ticker
     /// (`DaylightDetectorBlock.tickEntity`).
     DaylightDetector,
+    /// Suspicious sand and gravel: saved loot and the transient brushed face.
+    Brushable(Box<Brushable>),
+    /// A shelf holds three displayed item stacks.
+    Shelf(Box<Shelf>),
     /// `ChiseledBookShelfBlockEntity`: a `Container` of six one-book slots.
     ChiseledBookshelf(Box<ChiseledBookshelf>),
 }
+/// `BrushableBlockEntity`: the loot table is resolved on the first brush.
+#[derive(Clone, Debug, Default)]
+pub struct Brushable {
+    pub loot_table: Option<horizon_world::nbt::Tag>,
+    pub loot_seed: Option<horizon_world::nbt::Tag>,
+    pub item: Option<ItemStack>,
+    /// Direction's legacy network id; not saved to disk by vanilla.
+    pub hit_direction: Option<i32>,
+}
+/// `ShelfBlockEntity`'s displayed slots and alignment flag.
+#[derive(Clone, Debug, Default)]
+pub struct Shelf {
+    pub items: [Option<ItemStack>; 3],
+    pub align_to_bottom: bool,
+}
 /// `ChiseledBookShelfBlockEntity`: six slots and `lastInteractedSlot`.
 #[derive(Clone, Debug, PartialEq)]
 pub struct ChiseledBookshelf {
@@ -230,7 +249,7 @@ pub struct Info {
 /// `VibrationSelector`: the closest, then highest-frequency candidate of a tick.
 #[derive(Clone, Debug, Default, PartialEq)]
 pub struct Selector {
-    pub(crate) current: Option<(Info, i64)>,
+    pub current: Option<(Info, i64)>,
 }
 /// `VibrationSystem.Data`.
 #[derive(Clone, Debug, Default, PartialEq)]
@@ -278,7 +297,7 @@ pub struct SpawnData {
 /// Which `SpawnData` is next: one of the potentials (the same object in
 /// vanilla, so changing it changes the potential) or its own.
 #[derive(Clone, Debug, PartialEq)]
-pub(crate) enum Next {
+pub enum Next {
     Potential(usize),
     Own(SpawnData),
 }
@@ -288,7 +307,7 @@ pub struct Spawner {
     pub spawn_delay: i32,
     /// `SpawnPotentials`: data and weight.
     pub potentials: Vec<(SpawnData, i32)>,
-    pub(crate) next: Option<Next>,
+    pub next: Option<Next>,
     pub min_spawn_delay: i32,
     pub max_spawn_delay: i32,
     pub spawn_count: i32,
@@ -301,6 +320,24 @@ pub struct Spawner {
     pub spin: f64,
     pub o_spin: f64,
 }
+impl Default for Spawner {
+    fn default() -> Self {
+        Self {
+            spawn_delay: 20,
+            potentials: Vec::new(),
+            next: None,
+            min_spawn_delay: 200,
+            max_spawn_delay: 800,
+            spawn_count: 4,
+            max_nearby_entities: 6,
+            required_player_range: 16,
+            spawn_range: 4,
+            client_delay: 20,
+            spin: 0.0,
+            o_spin: 0.0,
+        }
+    }
+}
 /// `TrialSpawnerConfig`.
 #[derive(Clone, Debug, PartialEq)]
 pub struct TrialConfig {
@@ -314,6 +351,26 @@ pub struct TrialConfig {
     pub loot_tables_to_eject: Vec<(String, i32)>,
     pub items_to_drop_when_ominous: String,
 }
+impl Default for TrialConfig {
+    /// `TrialSpawnerConfig.Builder`'s defaults.
+    fn default() -> Self {
+        Self {
+            spawn_range: 4,
+            total_mobs: 6.0,
+            simultaneous_mobs: 2.0,
+            total_mobs_added_per_player: 2.0,
+            simultaneous_mobs_added_per_player: 1.0,
+            ticks_between_spawn: 40,
+            spawn_potentials: Vec::new(),
+            loot_tables_to_eject: vec![
+                ("minecraft:spawners/trial_chamber/consumables".into(), 1),
+                ("minecraft:spawners/trial_chamber/key".into(), 1),
+            ],
+            items_to_drop_when_ominous:
+                "minecraft:spawners/trial_chamber/items_to_drop_when_ominous".into(),
+        }
+    }
+}
 /// A `Holder<TrialSpawnerConfig>` as saved: a registry id
 /// (`minecraft:trial_chamber/breeze/normal`) or an inline config.
 #[derive(Clone, Debug, Default, PartialEq)]
@@ -347,6 +404,28 @@ pub struct TrialSpawner {
     /// and their weights (the rolled counts).
     pub dispensing: Option<Vec<ItemStack>>,
 }
+impl Default for TrialSpawner {
+    fn default() -> Self {
+        Self {
+            normal: ConfigSlot::default(),
+            ominous: ConfigSlot::default(),
+            target_cooldown_length: 36000,
+            required_player_range: 14,
+            detected_players: Vec::new(),
+            current_mobs: Vec::new(),
+            cooldown_ends_at: 0,
+            next_mob_spawns_at: 0,
+            total_mobs_spawned: 0,
+            next_spawn_data: None,
+            ejecting_loot_table: None,
+            is_ominous: false,
+            has_display: false,
+            spin: 0.0,
+            o_spin: 0.0,
+            dispensing: None,
+        }
+    }
+}
 /// `VaultConfig`.
 #[derive(Clone, Debug, PartialEq)]
 pub struct VaultConfig {

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

@@ -2,8 +2,9 @@
 //! count comparators read, the output it keeps, and the powered, automatic
 //! and condition flags `CommandBlock.tick` runs on.
 pub use crate::chunk::block_entity::CommandBlock;
-use crate::{
-    save::{number, text},
+use horizon_client_core::{
+    nbt_value::{number, text},
+    scoreboard,
     text::Text,
 };
 use horizon_world::nbt::Tag;
@@ -108,7 +109,7 @@ impl CommandBlock {
             last_output: track_output
                 .then(|| tag.get("LastOutput"))
                 .flatten()
-                .map(|t| crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(t))),
+                .map(|t| scoreboard::comp_text(&scoreboard::tag_to_json(t))),
             update_last_execution,
             last_execution: if update_last_execution {
                 number(tag.get("LastExecution")).unwrap_or(-1)
@@ -164,7 +165,7 @@ impl CommandBlock {
     pub fn name(&self) -> Text {
         self.custom_name.as_ref().map_or_else(
             || Text::literal("@"),
-            |t| crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(t)),
+            |t| scoreboard::comp_text(&scoreboard::tag_to_json(t)),
         )
     }
 }

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

@@ -2,15 +2,11 @@
 //! kinds, ticking as `AbstractFurnaceBlockEntity.serverTick` with fuel times
 //! from the data-driven `context_int_provider`/`context_float_provider` files.
 pub use crate::chunk::block_entity::{
-    Banner, Beacon, BlockEntity, Campfire, ChiseledBookshelf, Crafter, CreakingHeart, EndGateway,
-    Furnace, FurnaceKind, Jukebox, Lectern, Skull, SkullSkin,
+    Banner, Beacon, BlockEntity, Brushable, Campfire, ChiseledBookshelf, Crafter, CreakingHeart,
+    EndGateway, Furnace, FurnaceKind, Jukebox, Lectern, Shelf, Skull, SkullSkin,
 };
-use crate::{
-    crafting::Recipes,
-    items::{ItemStack, Items},
-};
-use serde_json::Value;
-use std::{collections::HashMap, fs, path::Path, sync::Arc};
+use crate::items::ItemStack;
+use std::collections::HashMap;
 
 impl FurnaceKind {
     pub fn recipe_type(self) -> &'static str {
@@ -46,6 +42,45 @@ pub fn recipe_used_key(id: &str) -> String {
 /// A hopper's slots: the only plain container with five.
 pub const HOPPER_SLOTS: usize = 5;
 
+/// `getDefaultName` of the `BaseContainerBlockEntity` that `block` holds: the
+/// translation key of its menu's title when it has no custom name. Copper
+/// chests hold a `ChestBlockEntity`, shulker boxes of every colour a
+/// `ShulkerBoxBlockEntity`.
+pub fn default_name_key(block: &str) -> Option<&'static str> {
+    Some(match block {
+        "minecraft:chest" | "minecraft:trapped_chest" => "container.chest",
+        n if n.ends_with("copper_chest") => "container.chest",
+        "minecraft:barrel" => "container.barrel",
+        n if n.ends_with("shulker_box") => "container.shulkerBox",
+        "minecraft:dispenser" => "container.dispenser",
+        "minecraft:dropper" => "container.dropper",
+        "minecraft:hopper" => "container.hopper",
+        "minecraft:furnace" => "container.furnace",
+        "minecraft:smoker" => "container.smoker",
+        "minecraft:blast_furnace" => "container.blast_furnace",
+        "minecraft:brewing_stand" => "container.brewing",
+        "minecraft:crafter" => "container.crafter",
+        _ => return None,
+    })
+}
+
+/// `BaseContainerBlockEntity.getDisplayName` (`getName`), the title of the
+/// `ClientboundOpenScreenPacket` that opens it: the block entity's custom
+/// name (`CustomName`, a literal), else its default name.
+pub fn display_name(custom: Option<&str>, default_key: &str) -> horizon_world::nbt::Tag {
+    match custom {
+        Some(name) => horizon_protocol::text::literal(name),
+        None => horizon_protocol::text::translatable(default_key, &[]),
+    }
+}
+
+/// `ChestBlock.MENU_PROVIDER_COMBINER`'s `getDisplayName` for a double chest:
+/// the first half's custom name (the right half, `DoubleBlockCombiner`'s
+/// `FIRST`), else the second's, else `container.chestDouble`.
+pub fn double_chest_name(first: Option<&str>, second: Option<&str>) -> horizon_world::nbt::Tag {
+    display_name(first.or(second), "container.chestDouble")
+}
+
 impl Campfire {
     /// `placeFood`'s slot: the first empty one, given the item's
     /// `campfire_cooking` time; it takes one item of `held`.
@@ -195,6 +230,14 @@ impl BlockEntity {
                 recipes_used: HashMap::new(),
             }));
         }
+        if matches!(
+            name,
+            "minecraft:suspicious_sand"
+                | "minecraft:suspicious_gravel"
+                | "minecraft:brushable_block"
+        ) {
+            return Some(Self::Brushable(Box::default()));
+        }
         if name == "minecraft:creaking_heart" {
             return Some(Self::CreakingHeart(Box::default()));
         }
@@ -257,6 +300,9 @@ impl BlockEntity {
         if name == "minecraft:campfire" || name == "minecraft:soul_campfire" {
             return Some(Self::Campfire(Box::default()));
         }
+        if name == "minecraft:shelf" || name.ends_with("_shelf") {
+            return Some(Self::Shelf(Box::default()));
+        }
         if name == "minecraft:chiseled_bookshelf" {
             return Some(Self::ChiseledBookshelf(Box::default()));
         }
@@ -299,8 +345,10 @@ impl BlockEntity {
             Self::Skull(_) => "minecraft:skull",
             Self::EndGateway(_) => "minecraft:end_gateway",
             Self::DaylightDetector => "minecraft:daylight_detector",
+            Self::Brushable(_) => "minecraft:brushable_block",
             Self::Campfire(_) => "minecraft:campfire",
             Self::ChiseledBookshelf(_) => "minecraft:chiseled_bookshelf",
+            Self::Shelf(_) => "minecraft:shelf",
         }
     }
     pub fn contents(&self) -> Vec<ItemStack> {
@@ -319,13 +367,15 @@ impl BlockEntity {
             | Self::CommandBlock(_)
             | Self::EndGateway(_)
             | Self::Skull(_)
-            | Self::DaylightDetector => Vec::new(),
+            | Self::DaylightDetector
+            | Self::Brushable(_) => Vec::new(),
             Self::Lectern(l) => l.book.iter().cloned().collect(),
             Self::Sculk(_) => Vec::new(),
             Self::Banner(_) => Vec::new(),
             Self::Crafter(c) => c.items.iter().flatten().cloned().collect(),
             Self::Campfire(c) => c.items.iter().flatten().cloned().collect(),
             Self::ChiseledBookshelf(b) => b.items.iter().flatten().cloned().collect(),
+            Self::Shelf(b) => b.items.iter().flatten().cloned().collect(),
         }
     }
     pub fn slots(&self) -> &[Option<ItemStack>] {
@@ -341,9 +391,11 @@ impl BlockEntity {
             | Self::Banner(_)
             | Self::EndGateway(_)
             | Self::Skull(_)
-            | Self::DaylightDetector => &[],
+            | Self::DaylightDetector
+            | Self::Brushable(_) => &[],
             Self::Crafter(c) => &c.items,
             Self::ChiseledBookshelf(b) => &b.items,
+            Self::Shelf(b) => &b.items,
             Self::CreakingHeart(_)
             | Self::Spawner(_)
             | Self::TrialSpawner(_)
@@ -367,9 +419,11 @@ impl BlockEntity {
             | Self::Banner(_)
             | Self::EndGateway(_)
             | Self::Skull(_)
-            | Self::DaylightDetector => &mut [],
+            | Self::DaylightDetector
+            | Self::Brushable(_) => &mut [],
             Self::Crafter(c) => &mut c.items,
             Self::ChiseledBookshelf(b) => &mut b.items,
+            Self::Shelf(b) => &mut b.items,
             Self::CreakingHeart(_)
             | Self::Spawner(_)
             | Self::TrialSpawner(_)
@@ -380,283 +434,7 @@ impl BlockEntity {
         }
     }
 }
-/// Evaluator for `context_int_provider` / `context_float_provider` values.
-pub struct Providers {
-    ints: HashMap<String, Value>,
-    floats: HashMap<String, Value>,
-}
-fn load_dir(dir: &Path, prefix: &str, out: &mut HashMap<String, Value>) {
-    let Ok(entries) = fs::read_dir(dir) else {
-        return;
-    };
-    for e in entries.flatten() {
-        let p = e.path();
-        let name = p
-            .file_stem()
-            .and_then(|s| s.to_str())
-            .unwrap_or("")
-            .to_owned();
-        if p.is_dir() {
-            load_dir(&p, &format!("{prefix}{name}/"), out);
-        } else if let Ok(bytes) = fs::read(&p)
-            && let Ok(v) = serde_json::from_slice(&bytes)
-        {
-            out.insert(format!("minecraft:{prefix}{name}"), v);
-        }
-    }
-}
-impl Providers {
-    pub fn load(root: &Path) -> Self {
-        let mut ints = HashMap::new();
-        let mut floats = HashMap::new();
-        load_dir(
-            &root.join("data/minecraft/context_int_provider"),
-            "",
-            &mut ints,
-        );
-        load_dir(
-            &root.join("data/minecraft/context_float_provider"),
-            "",
-            &mut floats,
-        );
-        Self { ints, floats }
-    }
-    fn eval(v: &Value, fast: bool, table: &HashMap<String, Value>, depth: u32) -> f64 {
-        if depth > 16 {
-            return 0.0;
-        }
-        match v {
-            Value::Number(n) => n.as_f64().unwrap_or(0.0),
-            Value::String(name) => table
-                .get(name)
-                .map_or(0.0, |v| Self::eval(v, fast, table, depth + 1)),
-            Value::Object(o) => {
-                let f =
-                    |k: &str| Self::eval(o.get(k).unwrap_or(&Value::Null), fast, table, depth + 1);
-                match o.get("type").and_then(Value::as_str).unwrap_or("") {
-                    "minecraft:div" => {
-                        let r = f("right");
-                        if r == 0.0 {
-                            0.0
-                        } else {
-                            (f("left") / r).trunc()
-                        }
-                    }
-                    "minecraft:mul" => f("left") * f("right"),
-                    "minecraft:add" | "minecraft:sum" => f("left") + f("right"),
-                    "minecraft:sub" => f("left") - f("right"),
-                    "minecraft:constant" => f("value"),
-                    "minecraft:conditional" => {
-                        // The only condition in the pinned data: block/fast_cooking.
-                        let condition = o.get("condition").and_then(Value::as_str)
-                            == Some("minecraft:block/fast_cooking");
-                        if condition && fast {
-                            f("on_true")
-                        } else {
-                            f("on_false")
-                        }
-                    }
-                    _ => 0.0,
-                }
-            }
-            _ => 0.0,
-        }
-    }
-    /// A plain `context_int_provider` value or reference (no context conditions).
-    pub fn int_value(&self, v: &Value) -> i32 {
-        Self::eval(v, false, &self.ints, 0) as i32
-    }
-    /// A plain `context_float_provider` value or reference; `default` when absent.
-    pub fn float_value(&self, v: &Value, default: f32) -> f32 {
-        if v.is_null() {
-            default
-        } else {
-            Self::eval(v, false, &self.floats, 0) as f32
-        }
-    }
-    #[cfg(test)]
-    pub fn empty() -> Self {
-        Self {
-            ints: HashMap::new(),
-            floats: HashMap::new(),
-        }
-    }
-    pub fn burn_time(&self, items: &Items, stack: &ItemStack, fast: bool) -> i32 {
-        items
-            .get(&stack.item)
-            .and_then(|i| i.fuel.as_ref())
-            .map_or(0, |(time, _)| Self::eval(time, fast, &self.ints, 0) as i32)
-    }
-    pub fn speed(&self, items: &Items, stack: &ItemStack, fast: bool) -> f32 {
-        items
-            .get(&stack.item)
-            .and_then(|i| i.fuel.as_ref())
-            .map_or(1.0, |(_, speed)| {
-                Self::eval(speed, fast, &self.floats, 0) as f32
-            })
-    }
-}
-fn remainder(item: &str) -> Option<&'static str> {
-    match item {
-        "minecraft:lava_bucket" | "minecraft:water_bucket" | "minecraft:milk_bucket" => {
-            Some("minecraft:bucket")
-        }
-        _ => None,
-    }
-}
-impl Furnace {
-    /// `AbstractFurnaceBlockEntity.setItem` on the input slot: anything but
-    /// the same item with the same components restarts cooking, with the
-    /// total time of the new input's recipe (200 ticks without one).
-    pub fn set_input(&mut self, recipes: &Recipes, stack: Option<ItemStack>) {
-        let same = match (&self.items[0], &stack) {
-            (Some(old), Some(new)) => old.same_item_same_components(new),
-            _ => false,
-        };
-        self.items[0] = stack;
-        if !same {
-            self.cooking_total = self.items[0]
-                .as_ref()
-                .and_then(|input| recipes.cook(self.kind.recipe_type(), input))
-                .map_or(200, |recipe| total_time(recipe.time, self.speed));
-            self.cooking_timer = 0;
-        }
-    }
-    /// `recipesUsed`, each recipe with its `experience` (0 for one this data pack does
-    /// not have), in the order `getRecipesToAwardAndPopExperience` pays them.
-    pub fn recipe_experience(&self, recipes: &Recipes) -> Vec<(u32, f32)> {
-        self.recipes_used
-            .iter()
-            .map(|(id, count)| (*count, recipes.cooking_experience(id)))
-            .collect()
-    }
-    /// A menu click wrote its slots into `items`, and `before` was the input
-    /// slot until then: the menu called `setItem` on it only if it changed
-    /// (`Slot.setByPlayer`; partial takes and merges keep the stack).
-    pub fn input_clicked(&mut self, recipes: &Recipes, before: Option<ItemStack>) {
-        if self.items[0] != before {
-            let after = std::mem::replace(&mut self.items[0], before);
-            self.set_input(recipes, after);
-        }
-    }
-    /// One server tick. Returns `Some(lit)` when the LIT block state must change.
-    pub fn tick(
-        &mut self,
-        recipes: &Recipes,
-        items: &Items,
-        providers: &Providers,
-    ) -> Option<bool> {
-        let was_lit = self.lit_remaining > 0;
-        let mut lit = false;
-        if self.lit_remaining > 0 {
-            self.lit_remaining -= 1;
-            lit = self.lit_remaining > 0;
-        }
-        let fast = self.kind.fast();
-        let has_ingredient = self.items[0].is_some();
-        let has_fuel = self.items[1].is_some();
-        if lit || has_fuel && has_ingredient {
-            if let Some(ingredient) = self.items[0].clone() {
-                if let Some(recipe) = recipes.cook(self.kind.recipe_type(), &ingredient) {
-                    if self.cooking_timer == 0 {
-                        self.cooking_total = total_time(recipe.time, self.speed);
-                    }
-                    let max = items.get(&recipe.result.item).map_or(64, |i| i.max_stack);
-                    let can_burn = match &self.items[2] {
-                        None => true,
-                        Some(out) => {
-                            out.item == recipe.result.item && out.count + recipe.result.count <= max
-                        }
-                    };
-                    if can_burn {
-                        if !lit {
-                            let fuel = self.items[1].clone();
-                            let time = fuel
-                                .as_ref()
-                                .map_or(0, |f| providers.burn_time(items, f, fast));
-                            let speed = fuel
-                                .as_ref()
-                                .map_or(1.0, |f| providers.speed(items, f, fast));
-                            self.lit_remaining = time;
-                            self.lit_total = time;
-                            self.speed = speed;
-                            if self.cooking_total > 0 && self.cooking_timer < self.cooking_total {
-                                let ratio = self.cooking_timer as f32 / self.cooking_total as f32;
-                                self.cooking_total = total_time(recipe.time, self.speed);
-                                self.cooking_timer =
-                                    (ratio * self.cooking_total as f32).ceil() as i32;
-                            }
-                            if time > 0 {
-                                if let Some(f) = self.items[1].as_mut() {
-                                    let item = f.item.clone();
-                                    f.count -= 1;
-                                    if f.count == 0 {
-                                        self.items[1] = remainder(&item).map(|r| ItemStack {
-                                            item: Arc::from(r),
-                                            count: 1,
-                                            damage: 0,
-                                            extra: None,
-                                        });
-                                    }
-                                }
-                                lit = true;
-                            }
-                        }
-                        if lit {
-                            self.cooking_timer += 1;
-                            if self.cooking_timer >= self.cooking_total {
-                                self.cooking_timer = 0;
-                                self.cooking_total = total_time(recipe.time, self.speed);
-                                match &mut self.items[2] {
-                                    Some(out) => out.count += recipe.result.count,
-                                    None => self.items[2] = Some(recipe.result.clone()),
-                                }
-                                *self
-                                    .recipes_used
-                                    .entry(recipe_used_key(&recipe.id))
-                                    .or_insert(0) += 1;
-                                // AbstractFurnaceBlockEntity.burn: drying a wet sponge fills
-                                // the bucket in the fuel slot.
-                                if self.items[0]
-                                    .as_ref()
-                                    .is_some_and(|i| &*i.item == "minecraft:wet_sponge")
-                                    && self.items[1]
-                                        .as_ref()
-                                        .is_some_and(|f| &*f.item == "minecraft:bucket")
-                                {
-                                    self.items[1] =
-                                        Some(ItemStack::new("minecraft:water_bucket", 1));
-                                }
-                                if let Some(i) = self.items[0].as_mut() {
-                                    i.count -= 1;
-                                    if i.count == 0 {
-                                        self.items[0] = None;
-                                    }
-                                }
-                            }
-                        } else {
-                            self.cooking_timer = 0;
-                        }
-                    } else {
-                        self.cooking_timer = 0;
-                    }
-                }
-            } else {
-                self.cooking_timer = 0;
-            }
-        } else if self.cooking_timer > 0 {
-            self.cooking_timer = (self.cooking_timer - 2).clamp(0, self.cooking_total);
-        }
-        (was_lit != lit).then_some(lit)
-    }
-}
-fn total_time(time: u32, speed: f32) -> i32 {
-    if speed > 0.0 {
-        (time as f32 / speed).ceil() as i32
-    } else {
-        time as i32
-    }
-}
+pub use crate::providers::Providers;
 
 /// `AbstractFurnaceBlockEntity.createExperience`: `count * experience`, floored, and one
 /// more with the chance of what is left over (a level random draw only when there is some).

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

@@ -308,6 +308,25 @@ fn deliver(home: &Path, report: Report) -> Option<PathBuf> {
     }
 }
 
+/// The report for a hung server tick, written by the watchdog thread
+/// (`ServerWatchdog`): the stuck thread's stack is not available to Rust, so
+/// the report carries none.
+pub fn report_watchdog(home: &Path, side: &'static str, message: String) -> Option<PathBuf> {
+    deliver(
+        home,
+        Report {
+            time: Local::now(),
+            description: "Watching Server".into(),
+            error: format!("{message} (Watching Server)"),
+            stack: String::new(),
+            thread: thread_name(),
+            side,
+            details: system_details(),
+            log: crate::logging::recent_lines(),
+        },
+    )
+}
+
 fn panic_message(info: &std::panic::PanicHookInfo) -> String {
     let payload = info.payload();
     let text = payload
@@ -326,16 +345,18 @@ fn panic_message(info: &std::panic::PanicHookInfo) -> String {
 /// frames go. Paths inside the workspace lose the build machine's prefix.
 pub fn stack_lines(backtrace: &str, from_panic: bool) -> String {
     // The workspace as it was on the machine that built this binary (it need not exist here).
-    let manifest = env!("CARGO_MANIFEST_DIR");
+    // A report names workspace files the same way on every host, whatever
+    // separator the build machine used.
+    let manifest = env!("CARGO_MANIFEST_DIR").replace('\\', "/");
     let root = manifest
-        .strip_suffix("crates/horizon-client")
-        .unwrap_or(manifest);
+        .strip_suffix("crates/horizon-client-render")
+        .unwrap_or(&manifest);
     let mut frames: Vec<(String, Option<String>)> = Vec::new();
     for line in backtrace.lines() {
         let line = line.trim();
         if let Some(at) = line.strip_prefix("at ") {
             if let Some(frame) = frames.last_mut() {
-                frame.1 = Some(short_path(at, root).to_owned());
+                frame.1 = Some(short_path(&at.replace('\\', "/"), root).to_owned());
             }
         } else if let Some((n, name)) = line.split_once(": ")
             && n.chars().all(|c| c.is_ascii_digit())
@@ -603,7 +624,7 @@ mod tests {
         );
         assert_eq!(
             stack_lines(&bt, true),
-            "horizon_client::crash::debug_crash_tick (crates/horizon-client/src/crash.rs:359:9)\nwinit::dispatch (winit-0.30.13/src/event_loop.rs:642:56)\nmain\n"
+            "horizon_client::crash::debug_crash_tick (crates/horizon-client-render/src/crash.rs:359:9)\nwinit::dispatch (winit-0.30.13/src/event_loop.rs:642:56)\nmain\n"
         );
     }
 

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

@@ -125,6 +125,114 @@ pub fn discover(world: &Path) -> Vec<DataPack> {
     packs
 }
 
+// ---- Create World ------------------------------------------------------------
+
+/// Create World's Data Packs screen (`PackSelectionScreen` on vanilla's
+/// `mcworld-` folder): the folder's packs (`PackSource.WORLD`) and the
+/// built-in one (`resources` holds its `pack.png`), which can be unselected
+/// and stays at the bottom. Horizon has no experiments, so their feature
+/// packs are not offered.
+pub fn screen_packs(dir: &Path, resources: &Path) -> Vec<crate::pack_screen::PackInfo> {
+    use crate::{
+        pack_screen::{Compat, PackInfo, Source, load_icon},
+        packs::Position,
+        text::{Style, Text},
+    };
+    let format = horizon_core::version::DATA_PACK_FORMAT;
+    let mut infos: Vec<PackInfo> = crate::packs::folder(dir, format)
+        .into_iter()
+        .map(|p| PackInfo {
+            icon: p.icon_png().as_deref().and_then(load_icon),
+            id: p.id,
+            title: p.title,
+            description: p.raw_description,
+            description_style: p.description_style,
+            source: Source::World,
+            compat: p.compatibility,
+            required: false,
+            position: Position::Top,
+            fixed: false,
+        })
+        .collect();
+    infos.push(PackInfo {
+        id: "vanilla".into(),
+        title: Text::translate("dataPack.vanilla.name", &[]),
+        description: Text::translate("dataPack.vanilla.description", &[]),
+        description_style: Style::default(),
+        source: Source::BuiltIn,
+        compat: Compat::Compatible,
+        icon: std::fs::read(resources.join("pack.png"))
+            .ok()
+            .as_deref()
+            .and_then(load_icon),
+        required: false,
+        position: Position::Bottom,
+        fixed: false,
+    });
+    infos
+}
+/// A new empty folder for Create World's packs
+/// (`Files.createTempDirectory("mcworld-")`).
+pub fn temp_folder() -> std::io::Result<PathBuf> {
+    let nanos = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+    let dir = std::env::temp_dir().join(format!("mcworld-{}-{nanos}", std::process::id()));
+    std::fs::create_dir_all(&dir)?;
+    Ok(dir)
+}
+/// What's in a folder of packs, to notice packs added or removed while the
+/// screen shows it (`PackSelectionScreen.Watcher`).
+pub fn folder_stamp(dir: &Path) -> Vec<(String, Option<std::time::SystemTime>)> {
+    let mut stamp: Vec<_> = std::fs::read_dir(dir)
+        .into_iter()
+        .flatten()
+        .flatten()
+        .map(|e| {
+            let modified = e.metadata().and_then(|m| m.modified()).ok();
+            (e.file_name().to_string_lossy().into_owned(), modified)
+        })
+        .collect();
+    stamp.sort();
+    stamp
+}
+/// Create World's packs into the new world before it opens
+/// (`copyTempDataPackDirToNewWorld`): every pack of `dir` goes to
+/// `<world>/datapacks`, and `datapacks.json` enables those `selected`
+/// (lowest priority first) and disables the rest.
+pub fn install(dir: &Path, world: &Path, selected: &[String]) -> Result<(), String> {
+    let err = |p: &Path, e: std::io::Error| format!("{}: {e}", p.display());
+    let target = world.join("datapacks");
+    std::fs::create_dir_all(&target).map_err(|e| err(&target, e))?;
+    let mut disabled = Vec::new();
+    for pack in crate::packs::folder(dir, horizon_core::version::DATA_PACK_FORMAT) {
+        let (crate::packs::Source::Dir(from) | crate::packs::Source::Zip(from)) = &pack.source;
+        copy(from, &target.join(pack.id.trim_start_matches("file/")))?;
+        if !selected.contains(&pack.id) {
+            disabled.push(pack.id);
+        }
+    }
+    if !selected.iter().any(|id| id == "vanilla") {
+        disabled.push("vanilla".into());
+    }
+    let json = serde_json::json!({ "enabled": selected, "disabled": disabled });
+    let file = world.join("datapacks.json");
+    std::fs::write(&file, json.to_string()).map_err(|e| err(&file, e))
+}
+/// 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());
+    if !from.is_dir() {
+        return std::fs::copy(from, to).map(drop).map_err(err);
+    }
+    std::fs::create_dir_all(to).map_err(err)?;
+    for e in std::fs::read_dir(from).map_err(err)?.flatten() {
+        copy(&e.path(), &to.join(e.file_name()))?;
+    }
+    Ok(())
+}
+
 // ---- functions ---------------------------------------------------------------
 
 /// A `.mcfunction`: plain command lines and macro lines.
@@ -566,4 +674,51 @@ mod tests {
         assert_eq!(p.list_kinds(&kinds), wanted);
         let _ = std::fs::remove_dir_all(&dir);
     }
+
+    #[test]
+    fn create_world_installs_its_packs() {
+        let root = std::env::temp_dir().join(format!("hz-datapack-install-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&root);
+        let (dir, world) = (root.join("mcworld"), root.join("world"));
+        let write = |pack: &str, p: &str, t: &str| {
+            let path = dir.join(pack).join(p);
+            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+            std::fs::write(path, t).unwrap();
+        };
+        write("fns", "pack.mcmeta", r#"{"pack":{"pack_format":121}}"#);
+        write("fns", "data/x/function/f.mcfunction", "say hi");
+        write("off", "pack.mcmeta", r#"{"pack":{"pack_format":121}}"#);
+        std::fs::create_dir_all(&dir).unwrap();
+        let mut zip = zip::ZipWriter::new(std::fs::File::create(dir.join("old.zip")).unwrap());
+        zip.start_file("pack.mcmeta", zip::write::SimpleFileOptions::default())
+            .unwrap();
+        std::io::Write::write_all(&mut zip, br#"{"pack":{"pack_format":48}}"#).unwrap();
+        zip.finish().unwrap();
+        let infos = screen_packs(&dir, &root);
+        let ids: Vec<&str> = infos.iter().map(|p| p.id.as_str()).collect();
+        assert_eq!(ids, ["file/fns", "file/off", "file/old.zip", "vanilla"]);
+        let compat: Vec<_> = infos.iter().map(|p| p.compat).collect();
+        use crate::pack_screen::Compat;
+        assert_eq!(
+            compat,
+            [
+                Compat::Compatible,
+                Compat::Compatible,
+                Compat::TooOld,
+                Compat::Compatible
+            ]
+        );
+        let selected = ["vanilla", "file/old.zip", "file/fns"].map(String::from);
+        install(&dir, &world, &selected).unwrap();
+        let packs = discover(&world);
+        let ids: Vec<&str> = packs.iter().map(|p| p.id.as_str()).collect();
+        assert_eq!(ids, ["file/fns", "file/off", "file/old.zip"]);
+        let saved: serde_json::Value =
+            serde_json::from_slice(&std::fs::read(world.join("datapacks.json")).unwrap()).unwrap();
+        assert_eq!(
+            saved,
+            serde_json::json!({"enabled": selected, "disabled": ["file/off"]})
+        );
+        let _ = std::fs::remove_dir_all(&root);
+    }
 }

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

@@ -29,6 +29,10 @@ impl EffectInstance {
     fn infinite(&self) -> bool {
         self.duration == -1
     }
+    /// `MobEffectInstance.endsWithin`.
+    pub fn ends_within(&self, ticks: i32) -> bool {
+        !self.infinite() && self.duration <= ticks
+    }
     fn shorter_than(&self, other: &Self) -> bool {
         !self.infinite() && (self.duration < other.duration || other.infinite())
     }

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

@@ -56,6 +56,9 @@ struct Out {
     @location(11) glint_uv: vec2<f32>,
     // 1 drops the quad's back-facing pixels (Vertex::normal w = 1), like a culling render type.
     @location(12) @interpolate(flat) cull: u32,
+    // HDR tier of a light-giving particle (mesher::hdr_tier), from the overlay's
+    // high bits (particles.rs): fs_hdr_mark marks the frame with it.
+    @location(13) @interpolate(flat) tier: u32,
 }
 // Shipped light.glsl; normals are already transformed and RGBA8_SNORM packed.
 fn entity_light(normal: vec3<f32>, nether: bool) -> f32 {
@@ -125,8 +128,9 @@ fn entity_vertex(position: vec3<f32>, uv: vec2<f32>,
 @vertex fn vs_entity(@location(0) position: vec3<f32>, @location(1) uv: vec2<f32>,
     @location(2) overlay: u32, @location(3) color: vec4<f32>, @location(4) light: vec4<u32>,
     @location(5) normal: vec4<f32>, @location(6) glint_uv: vec2<f32>) -> Out {
-    var out = entity_vertex(position, uv, overlay, color, light, normal);
+    var out = entity_vertex(position, uv, overlay & 0xffffu, color, light, normal);
     out.glint_uv = glint_uv;
+    out.tier = overlay >> 16u;
     return out;
 }
 // Retained bolt-local geometry, translated using the same f64 camera
@@ -263,11 +267,29 @@ fn crumbling_uv(uv: vec2<f32>, packed_origin: vec2<f32>, sprite_size: vec2<f32>,
 
 // rendertype_outline.fsh: the vertex colour (the team colour; outline vertices carry no
 // normal, so no cardinal light) wherever the texture is not fully clear.
+// 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> {
+    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),
+                linear_fog(in.cylindrical, globals.fog.z, globals.fog.w));
+    return vec4(mix(color.rgb, globals.fog_color.rgb, f * globals.fog_color.a), color.a);
+}
+
 @fragment fn fs_outline(in: Out) -> @location(0) vec4<f32> {
     if textureSample(atlas, atlas_sampler, in.uv).a == 0.0 { discard; }
     return vec4(in.color.rgb, 1.0);
 }
 
+// HDR output: a light-giving particle's pixels marked in the frame's alpha the
+// way terrain.wgsl marks a light source's, drawn again after the entities with
+// only alpha written, so its colour stays as blended.
+@fragment fn fs_hdr_mark(in: Out) -> @location(0) vec4<f32> {
+    if in.tier == 0u || textureSample(atlas, atlas_sampler, in.uv).a < 0.1 { discard; }
+    return vec4(0.0, 0.0, 0.0, 0.7 * f32(4u - min(in.tier, 4u)) / 4.0);
+}
+
 fn celestial_color(in: Out) -> vec4<f32> {
     return textureSample(atlas, atlas_sampler, in.uv) * in.color * in.light_color;
 }

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

@@ -203,6 +203,13 @@ pub struct FogInputs<'a> {
     /// `BossHealthOverlay.shouldCreateWorldFog`: a boss bar with
     /// `createWorldFog` is shown (the Ender Dragon's).
     pub boss_world_fog: bool,
+    /// The camera entity is a spectator (`LavaFogEnvironment`).
+    pub spectator: bool,
+    /// The camera entity has Fire Resistance (`LavaFogEnvironment`).
+    pub fire_resistance: bool,
+    /// `GameRenderer.nightVisionScale` while Night Vision is on without
+    /// Darkness, else 0 (`FogRenderer.computeFogColor`'s brightenFactor).
+    pub night_vision: f32,
 }
 
 /// `FogRenderer.setupFog` + `computeFogColor`.
@@ -272,7 +279,11 @@ pub fn setup_fog(tables: &FogTables, state: &FogState, input: &FogInputs) -> Fog
         color[1] += (color[1] * 0.6 - color[1]) * t;
         color[2] += (color[2] * 0.6 - color[2]) * t;
     }
-    let brighten = if eye_in_water { water_vision } else { 0.0 };
+    let brighten = if eye_in_water {
+        water_vision
+    } else {
+        input.night_vision
+    };
     if color.iter().all(|&c| c != 0.0) {
         let scale = 1.0 / color[0].max(color[1]).max(color[2]);
         color = color.map(|c| c + (c * scale - c) * brighten);
@@ -288,10 +299,16 @@ pub fn setup_fog(tables: &FogTables, state: &FogState, input: &FogInputs) -> Fog
     };
     match input.fog_type {
         FogType::Lava => {
-            fog.environmental_start = 0.25;
-            fog.environmental_end = 1.0;
-            fog.sky_end = 1.0;
-            fog.cloud_end = 1.0;
+            // LavaFogEnvironment.setupFog.
+            (fog.environmental_start, fog.environmental_end) = if input.spectator {
+                (-8.0, rd * 0.5)
+            } else if input.fire_resistance {
+                (0.0, 5.0)
+            } else {
+                (0.25, 1.0)
+            };
+            fog.sky_end = fog.environmental_end;
+            fog.cloud_end = fog.environmental_end;
         }
         FogType::PowderSnow => {
             fog.environmental_start = 0.0;
@@ -405,6 +422,9 @@ mod tests {
             darkness: None,
             darken_world: 0.0,
             boss_world_fog: false,
+            spectator: false,
+            fire_resistance: false,
+            night_vision: 0.0,
         }
     }
     #[test]

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

@@ -130,6 +130,8 @@ pub struct Font {
     atlas: (u32, u32),
     region: (u32, u32),
     cache: RefCell<Cache>,
+    /// Set anew for each font and each `reset_cache` (see `epoch`).
+    generation: std::cell::Cell<u64>,
     /// "Force Unicode Font": the `uniform` filter option.
     pub uniform: bool,
     /// "Japanese Glyph Variants": the `jp` filter option.
@@ -559,6 +561,11 @@ impl Region {
         Some((ax, ay))
     }
 }
+/// A value no font has had yet (`Font::epoch`).
+fn next_generation() -> u64 {
+    static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+    NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+}
 impl Font {
     /// Build from the atlas holding the bitmap font sheets (`sprites`, of
     /// `atlas` size) with `region` the reserved rows.
@@ -603,6 +610,7 @@ impl Font {
                         .map_or(0, |d| d.as_nanos() as i64),
                 ),
             }),
+            generation: std::cell::Cell::new(next_generation()),
             uniform: false,
             japanese: false,
         };
@@ -661,6 +669,13 @@ impl Font {
         }
         cache.region.cursor = (0, 0);
         cache.region.row = 0;
+        self.generation.set(next_generation());
+    }
+    /// Changes whenever a glyph may come out different: another font, a
+    /// cache reset (glyphs move in the atlas) or other font options. Text laid
+    /// out under one epoch can be kept until it changes.
+    pub fn epoch(&self) -> u64 {
+        self.generation.get() << 2 | u64::from(self.uniform) << 1 | u64::from(self.japanese)
     }
     /// The glyph for a character in the default font (FontSet.getGlyph).
     pub fn glyph(&self, c: char) -> Glyph {

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

@@ -105,12 +105,9 @@ const COMPLETE_COLUMN: u32 = (1 << (crate::chunk::HEIGHT / 16)) - 1;
 /// its fixed-point UVs (`terrain.wgsl`'s `terrain_uv`).
 /// The world pass again after occlusion culling's test: it loads both
 /// targets (phase 2 draws over phase 1, reading the test's results).
-/// LevelRenderer: no sky inside lava or powder snow (sky fog ends within 2 blocks).
+/// `LevelRenderer.addSkyPass`: fluids and camera effects block the sky pass.
 fn sky_open(frame: &Frame) -> bool {
-    match frame.fog {
-        Some(f) => f.sky_end > 2.0,
-        None => !frame.underwater,
-    }
+    !frame.sky_blocked
 }
 
 /// The Overworld-style sky (disc, sunset, stars, void) draws this frame.
@@ -222,6 +219,9 @@ pub struct Frame<'a> {
     /// The `GameRenderer.bobHurt`/`bobView` pose multiplied into the
     /// projection (`crate::camera::bob_matrix`).
     pub bob: Mat4,
+    /// The spinning effect multiplied into the level's projection only
+    /// (`crate::camera::spinning_effect_matrix`), not the hand's.
+    pub spin: Mat4,
     pub sky: Sky,
     /// Render distance in blocks (fog end).
     pub distance: f32,
@@ -235,6 +235,8 @@ pub struct Frame<'a> {
     pub cave_culling: bool,
     /// Title screen: only the dedicated panorama cube map and the HUD.
     pub title: bool,
+    /// Lava, powder snow, blindness or darkness blocks the sky pass.
+    pub sky_blocked: bool,
     /// Dimensions without a skybox (the Nether) clear to the fog colour.
     pub skybox: bool,
     /// The End: clear to black and draw the resident sky box behind the world.
@@ -347,6 +349,14 @@ struct BorderUniform {
     color: [f32; 4],
     offset: [f32; 4],
 }
+/// A frame to save as a PNG: F2's screenshot, an agent's `game_screenshot`,
+/// or the icon the Select World list shows.
+pub struct ScreenshotRequest {
+    pub path: PathBuf,
+    /// `GameRenderer.takeAutoScreenshot`: centre-crop the frame to a square
+    /// and average it down to this size. `None` saves the frame as drawn.
+    pub size: Option<[u32; 2]>,
+}
 pub struct Renderer {
     instance: wgpu::Instance,
     adapter: wgpu::Adapter,
@@ -405,6 +415,7 @@ pub struct Renderer {
     crosshair_group: wgpu::BindGroup,
     crosshair_globals: wgpu::Buffer,
     entity_pipeline: wgpu::RenderPipeline,
+    hdr_mark_pipeline: wgpu::RenderPipeline,
     weather: weather::Weather,
     crumbling_pipeline: wgpu::RenderPipeline,
     shadow_blob_pipeline: wgpu::RenderPipeline,
@@ -537,6 +548,9 @@ pub struct Renderer {
     hdr: Option<hdr::Hdr>,
     /// The HDR output the window's surface can present.
     hdr_output: Option<hdr::Output>,
+    /// The marker file of an HDR output that has not presented a frame yet
+    /// (`graphics::HDR_MARKER`).
+    hdr_marker: Option<std::path::PathBuf>,
     /// The shader pack's post-processing, and the dimension (legacy id) it was loaded for.
     pack_post: Option<(i32, Option<pack_post::PackPost>)>,
     /// The post passes of one of Horizon's own shader packs; never beside `pack_post`'s.
@@ -565,8 +579,8 @@ pub struct Renderer {
     pub section_draw_calls: usize,
     pub uploaded_bytes: u64,
     started: Instant,
-    /// Write the next presented frame to this PNG path (control socket).
-    pub screenshot: Option<PathBuf>,
+    /// The next frame to write to a PNG path (control socket, F2, world icon).
+    pub screenshot: Option<ScreenshotRequest>,
     /// Outcome of the last screenshot: frame size, or the error.
     pub screenshot_result: Option<std::result::Result<[u32; 2], String>>,
     /// Brightness option (lightmap gamma), 0..1.
@@ -1123,7 +1137,14 @@ impl Renderer {
                 ));
             }
             surface.configure(&device, &config);
-            (config, caps.present_modes.clone(), hdr::output(&caps))
+            let hdr_output = hdr::output(&caps);
+            if previous.is_none() {
+                log::info!(
+                    "Horizon renderer: HDR output {}",
+                    hdr_output.map_or("not offered by this display", hdr::Output::name)
+                );
+            }
+            (config, caps.present_modes.clone(), hdr_output)
         } else {
             let format = wgpu::TextureFormat::Bgra8Unorm;
             let config = wgpu::SurfaceConfiguration {
@@ -1964,7 +1985,7 @@ impl Renderer {
         // ulps covers that spread at any resolution while staying far below
         // the 0.001 a model's feet sit higher, so shadows never bleed onto
         // the feet.
-        let shadow_blob_pipeline = entity_pipeline(
+        let shadow_blob_pipeline = entity_pipeline_with(
             "Entity shadows",
             None,
             false,
@@ -1976,6 +1997,8 @@ impl Renderer {
             },
             alpha_blend,
             false,
+            "fs_entity_shadow",
+            wgpu::ColorWrites::ALL,
         );
         // RenderPipelines.ITEM_TRANSLUCENT: blended, depth tested. Drawn before
         // translucent terrain, it cannot write depth: the water behind a
@@ -2039,6 +2062,18 @@ impl Renderer {
             "fs_energy_swirl",
             wgpu::ColorWrites::ALL,
         );
+        // HDR output's mark on light-giving particles (entity.wgsl fs_hdr_mark).
+        let hdr_mark_pipeline = entity_pipeline_with(
+            "HDR particle mark",
+            None,
+            false,
+            wgpu::CompareFunction::GreaterEqual,
+            Default::default(),
+            wgpu::BlendState::REPLACE,
+            false,
+            "fs_hdr_mark",
+            wgpu::ColorWrites::ALPHA,
+        );
         // Attribute 7: 6 is the entity vertex buffer's glint UV.
         let lightning_attributes = wgpu::vertex_attr_array![7=>Float32x3];
         let lightning_vertex = [
@@ -2550,6 +2585,7 @@ impl Renderer {
             crosshair_group,
             crosshair_globals,
             entity_pipeline,
+            hdr_mark_pipeline,
             weather,
             crumbling_pipeline,
             shadow_blob_pipeline,
@@ -2642,6 +2678,7 @@ impl Renderer {
             world_post,
             hdr: None,
             hdr_output,
+            hdr_marker: None,
             pack_post: None,
             native: None,
             pass_timing: pack_timing::PassTiming::logging(),
@@ -3198,14 +3235,43 @@ impl Renderer {
         }
         config
     }
+    /// The F3 screen's HDR line while the setting is on: the swapchain HDR presents to with
+    /// its paper white and peak, or that the surface offers none.
+    pub fn hdr_line(&self) -> String {
+        match &self.hdr {
+            Some(hdr) => format!(
+                "HDR: {}, {}/{} nits",
+                hdr.output.name(),
+                hdr.paper_white.round(),
+                hdr.peak.round()
+            ),
+            None => "HDR: not offered by this display".into(),
+        }
+    }
     /// HDR output (Horizon setting): HDR10 or scRGB at `paper_white` nits, the world's
     /// highlights expanded up to `peak` nits. Off where the surface can't present it.
-    pub fn set_hdr(&mut self, on: bool, paper_white: f32, peak: f32) {
+    pub fn set_hdr(&mut self, on: bool, paper_white: f32, peak: f32, marker: &std::path::Path) {
         let output = self.hdr_output.filter(|_| on && self.surface.is_some());
         if output.is_some() != self.hdr.is_some() {
+            // If the game dies before HDR output shows a frame, the marker is still there at
+            // the next start, which then comes up with HDR off.
+            if output.is_some() {
+                let _ = std::fs::write(marker, "HDR output was being switched on\n");
+                self.hdr_marker = Some(marker.to_owned());
+            } else if let Some(marker) = self.hdr_marker.take() {
+                let _ = std::fs::remove_file(marker);
+            }
             let format = self.config.format.remove_srgb_suffix();
             self.hdr = output.map(|output| hdr::Hdr::new(&self.device, format, output));
             self.configure_surface();
+            match output {
+                Some(output) => log::info!(
+                    "Horizon renderer: HDR on: {} ({:?}), {paper_white}/{peak} nits",
+                    output.name(),
+                    output.format()
+                ),
+                None => log::info!("Horizon renderer: HDR off"),
+            }
         }
         if let Some(hdr) = &mut self.hdr
             && (hdr.paper_white, hdr.peak) != (paper_white, peak)
@@ -3418,7 +3484,7 @@ impl Renderer {
             frame.fov_degrees,
             frame.yaw,
             frame.pitch,
-            frame.bob,
+            frame.bob * frame.spin,
             frame.depth_far,
         )
     }
@@ -4508,7 +4574,7 @@ impl Renderer {
             cull.bind_depth(&self.device, world_depth);
         }
         let cull = self.cull.as_ref().filter(|_| culling && solid_draws > 0);
-        let clear = if frame.title || (frame.end_sky && !frame.underwater) {
+        let clear = if frame.title || (frame.end_sky && !frame.underwater && sky_open(frame)) {
             wgpu::Color::BLACK
         } else {
             wgpu::Color {
@@ -4739,6 +4805,10 @@ impl Renderer {
                 pass.set_bind_group(0, &self.entity_group, &[]);
                 pass.set_vertex_buffer(0, self.entity_buffer.slice(..));
                 pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
+                if self.hdr.is_some() {
+                    pass.set_pipeline(&self.hdr_mark_pipeline);
+                    pass.draw_indexed(0..entity_quads * 6, 0, 0..1);
+                }
                 pass.set_bind_group(0, &self.group, &[]);
             }
             if translucent_item_quads > 0 {
@@ -5070,6 +5140,13 @@ impl Renderer {
             &self.entity_group,
             &self.indices,
         );
+        // The world icon grabs here: after the level and the hand, before
+        // the effects and the HUD draw over them (`tryTakeScreenshotIfNeeded`
+        // runs right after `renderLevel`).
+        let readback = self
+            .screenshot
+            .take_if(|request| request.size.is_some())
+            .and_then(|request| self.take_readback(request, &mut encoder, &target_texture));
         if !frame.screen.is_empty() {
             let attachments = [Some(wgpu::RenderPassColorAttachment {
                 view: &view_target,
@@ -5173,18 +5250,10 @@ impl Renderer {
                 (&view_target, self.config.format.remove_srgb_suffix()),
             );
         }
-        let readback = self.screenshot.take().and_then(|path| {
-            // The copy and PNG writer both assume 8-bit pixels; a float surface would make
-            // the row stride too small for the copy and abort in validation.
-            if self.config.format.block_copy_size(None) == Some(4) {
-                Some((path, self.copy_frame(&mut encoder, &target_texture)))
-            } else {
-                self.screenshot_result = Some(Err(format!(
-                    "screenshots need a 32-bit surface format, not {:?}",
-                    self.config.format
-                )));
-                None
-            }
+        let readback = readback.or_else(|| {
+            self.screenshot
+                .take()
+                .and_then(|request| self.take_readback(request, &mut encoder, &target_texture))
         });
         self.uploads.finish(&encoder);
         if has_section_copies {
@@ -5211,9 +5280,9 @@ impl Renderer {
         if let Some(Some(timer)) = Self::pass_timer(&mut self.pack_post, &mut self.native) {
             timer.submitted(&self.queue);
         }
-        if let Some((path, buffer)) = readback {
+        if let Some((request, buffer)) = readback {
             self.screenshot_result = Some(
-                self.write_screenshot(&path, &buffer)
+                self.write_screenshot(&request, &buffer)
                     .map_err(|e| e.to_string()),
             );
         }
@@ -5229,6 +5298,12 @@ impl Renderer {
                 startup_step(format_args!("presenting the first frame"));
             }
             self.queue.present(surface_frame);
+            if self.hdr.is_some()
+                && let Some(marker) = self.hdr_marker.take()
+            {
+                let _ = std::fs::remove_file(marker);
+                log::info!("Horizon renderer: HDR output presented its first frame");
+            }
             if reconfigure && let Some(surface) = &self.surface {
                 Self::configure(
                     &self.device,
@@ -5261,6 +5336,26 @@ impl Renderer {
     fn padded_row(&self) -> u32 {
         (self.config.width * 4).next_multiple_of(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT)
     }
+    /// Take a screenshot request: queue the frame's copy, or report why the
+    /// frame cannot be read back.
+    fn take_readback(
+        &mut self,
+        request: ScreenshotRequest,
+        encoder: &mut wgpu::CommandEncoder,
+        texture: &wgpu::Texture,
+    ) -> Option<(ScreenshotRequest, wgpu::Buffer)> {
+        // The copy and PNG writer both assume 8-bit pixels; a float surface would make
+        // the row stride too small for the copy and abort in validation.
+        if self.config.format.block_copy_size(None) == Some(4) {
+            Some((request, self.copy_frame(encoder, texture)))
+        } else {
+            self.screenshot_result = Some(Err(format!(
+                "screenshots need a 32-bit surface format, not {:?}",
+                self.config.format
+            )));
+            None
+        }
+    }
     fn copy_frame(
         &self,
         encoder: &mut wgpu::CommandEncoder,
@@ -5290,7 +5385,11 @@ impl Renderer {
         );
         buffer
     }
-    fn write_screenshot(&self, path: &std::path::Path, buffer: &wgpu::Buffer) -> Result<[u32; 2]> {
+    fn write_screenshot(
+        &self,
+        request: &ScreenshotRequest,
+        buffer: &wgpu::Buffer,
+    ) -> Result<[u32; 2]> {
         if !self.config.usage.contains(wgpu::TextureUsages::COPY_SRC) {
             return Err("this surface does not support frame readback".into());
         }
@@ -5328,8 +5427,18 @@ impl Renderer {
             }
         }
         buffer.unmap();
+        // NativeImage.resizeSubRectTo on takeAutoScreenshot's grab: the icon
+        // is the frame's centre square averaged down to its size.
+        let (width, height, pixels) = match request.size {
+            Some(size) => (
+                size[0],
+                size[1],
+                square_downscale(&pixels, self.config.width, self.config.height, size),
+            ),
+            None => (self.config.width, self.config.height, pixels),
+        };
         let mut encoder = png::Encoder::new(
-            std::io::BufWriter::new(std::fs::File::create(path)?),
+            std::io::BufWriter::new(std::fs::File::create(&request.path)?),
             width,
             height,
         );
@@ -5339,6 +5448,42 @@ impl Renderer {
         Ok([width, height])
     }
 }
+/// Centre-crop the frame to a square and average it down to `size`.
+pub(crate) fn square_downscale(pixels: &[u8], width: u32, height: u32, size: [u32; 2]) -> Vec<u8> {
+    let (side, cx, cy) = if width > height {
+        (height, (width - height) / 2, 0)
+    } else {
+        (width, 0, (height - width) / 2)
+    };
+    let [tw, th] = size;
+    let mut out = vec![0u8; (tw * th * 4) as usize];
+    for ty in 0..th {
+        let y0 = cy + ty * side / th;
+        let y1 = cy + (ty + 1) * side / th;
+        for tx in 0..tw {
+            let x0 = cx + tx * side / tw;
+            let x1 = cx + (tx + 1) * side / tw;
+            let (mut r, mut g, mut b) = (0u32, 0u32, 0u32);
+            for y in y0..y1 {
+                for x in x0..x1 {
+                    let p = ((y * width + x) * 4) as usize;
+                    r += u32::from(pixels[p]);
+                    g += u32::from(pixels[p + 1]);
+                    b += u32::from(pixels[p + 2]);
+                }
+            }
+            let count = (x1 - x0) * (y1 - y0);
+            let o = ((ty * tw + tx) * 4) as usize;
+            out[o..o + 4].copy_from_slice(&[
+                (r / count) as u8,
+                (g / count) as u8,
+                (b / count) as u8,
+                255,
+            ]);
+        }
+    }
+    out
+}
 /// Camera-relative clip planes (`Frustum`).
 #[derive(Clone, Copy, Debug)]
 pub struct Frustum {

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

@@ -25,12 +25,26 @@ pub const TRANSLUCENT_ITEM_OVERLAY: u32 = 32;
 /// A translucent item with an enchantment glint.
 pub const TRANSLUCENT_GLINT_ITEM_OVERLAY: u32 = 33;
 
+/// The material of a quad by its overlay (`MATERIALS` order).
+fn material(layer: u32) -> usize {
+    match layer {
+        11 => 1,
+        12 => 2,
+        WATER_MASK_OVERLAY => 3,
+        ENERGY_SWIRL_OVERLAY => 4,
+        SHADOW_OVERLAY => 5,
+        TRANSLUCENT_PARTICLE_OVERLAY => 6,
+        TRANSLUCENT_ITEM_OVERLAY | TRANSLUCENT_GLINT_ITEM_OVERLAY => 7,
+        _ => 0,
+    }
+}
+
 #[derive(Default)]
 pub(super) struct EntityBatch {
-    // Quad indices avoid copying vertices twice while grouping materials.
-    // Keep initialized high-water storage; local counts delimit active entries.
-    // Each bucket can hold all quads, removing per-quad Vec growth checks.
-    buckets: [Vec<usize>; MATERIALS],
+    // Runs of consecutive quads of one material (first quad, quad count): a
+    // model's quads share one, so whole runs are copied at once. Cleared each
+    // frame, keeping their storage.
+    runs: [Vec<(usize, usize)>; MATERIALS],
     pub(super) combined: Vec<Vertex>,
 }
 
@@ -43,50 +57,29 @@ impl EntityBatch {
         see_through: &[Vertex],
     ) -> [u32; MATERIALS] {
         let quads = entities.as_chunks::<4>().0;
-        for bucket in &mut self.buckets {
-            if bucket.len() < quads.len() {
-                bucket.resize(quads.len(), 0);
-            }
+        for runs in &mut self.runs {
+            runs.clear();
         }
         let mut counts = [0usize; MATERIALS];
-        for (index, quad) in quads.iter().enumerate() {
-            let material = match quad[0].layer {
-                11 => 1,
-                12 => 2,
-                WATER_MASK_OVERLAY => 3,
-                ENERGY_SWIRL_OVERLAY => 4,
-                SHADOW_OVERLAY => 5,
-                TRANSLUCENT_PARTICLE_OVERLAY => 6,
-                TRANSLUCENT_ITEM_OVERLAY | TRANSLUCENT_GLINT_ITEM_OVERLAY => 7,
-                _ => 0,
-            };
-            self.buckets[material][counts[material]] = index;
-            counts[material] += 1;
+        let mut start = 0;
+        while start < quads.len() {
+            let kind = material(quads[start][0].layer);
+            let end = quads[start + 1..]
+                .iter()
+                .position(|quad| material(quad[0].layer) != kind)
+                .map_or(quads.len(), |n| start + 1 + n);
+            self.runs[kind].push((start, end - start));
+            counts[kind] += end - start;
+            start = end;
         }
         let entity_vertices = quads.len() * 4;
-        self.combined.reserve(
-            (entity_vertices + additive.len() + hand.len() + see_through.len())
-                .saturating_sub(self.combined.len()),
-        );
+        self.combined.clear();
         self.combined
-            .resize(entity_vertices, bytemuck::Zeroable::zeroed());
-        if counts.contains(&quads.len()) {
-            // Uniform materials are already ordered; copy the whole batch.
-            self.combined.copy_from_slice(&entities[..entity_vertices]);
-        } else {
-            let mut offset = 0;
-            for (bucket, &count) in self.buckets.iter().zip(&counts) {
-                let bucket = &bucket[..count];
-                let end = offset + count * 4;
-                for (output, &index) in self.combined[offset..end]
-                    .as_chunks_mut::<4>()
-                    .0
-                    .iter_mut()
-                    .zip(bucket)
-                {
-                    *output = quads[index];
-                }
-                offset = end;
+            .reserve(entity_vertices + additive.len() + hand.len() + see_through.len());
+        for runs in &self.runs {
+            for &(first, count) in runs {
+                self.combined
+                    .extend_from_slice(&entities[first * 4..(first + count) * 4]);
             }
         }
         self.combined.extend_from_slice(additive);
@@ -174,12 +167,12 @@ mod tests {
         let hand = geometry(2, false);
         // Warm every bucket and the combined buffer to their maximum sizes.
         equivalent(&mut batch, &entities, &additive, &hand);
-        let capacities = batch.buckets.each_ref().map(|b| b.capacity());
+        let capacities = batch.runs.each_ref().map(|b| b.capacity());
         let capacity = batch.combined.capacity();
         let pointer = batch.combined.as_ptr();
         for length in [0, 1, 3, 4, 511, entities.len(), 17, 0, entities.len()] {
             equivalent(&mut batch, &entities[..length], &additive[..5], &hand[..3]);
-            assert_eq!(batch.buckets.each_ref().map(|b| b.capacity()), capacities);
+            assert_eq!(batch.runs.each_ref().map(|b| b.capacity()), capacities);
             assert_eq!(batch.combined.capacity(), capacity);
             assert_eq!(batch.combined.as_ptr(), pointer);
         }
@@ -188,11 +181,11 @@ mod tests {
         // Grow again, then confirm empty/small frames retain the new storage.
         let larger = geometry(8192, true);
         equivalent(&mut batch, &larger, &additive, &hand);
-        let capacities = batch.buckets.each_ref().map(|b| b.capacity());
+        let capacities = batch.runs.each_ref().map(|b| b.capacity());
         let capacity = batch.combined.capacity();
         for entities in [&larger[..7], &larger[..], &[]] {
             equivalent(&mut batch, entities, &[], &[]);
-            assert_eq!(batch.buckets.each_ref().map(|b| b.capacity()), capacities);
+            assert_eq!(batch.runs.each_ref().map(|b| b.capacity()), capacities);
             assert_eq!(batch.combined.capacity(), capacity);
         }
     }
@@ -255,9 +248,9 @@ mod tests {
                 before[7] as f64 / after[7] as f64,
                 batch.combined.capacity() * std::mem::size_of::<Vertex>()
                     + batch
-                        .buckets
+                        .runs
                         .iter()
-                        .map(|b| b.capacity() * std::mem::size_of::<usize>())
+                        .map(|b| b.capacity() * std::mem::size_of::<(usize, usize)>())
                         .sum::<usize>()
             );
         }

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

@@ -14,6 +14,12 @@ pub enum Output {
 }
 
 impl Output {
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Pq => "HDR10 (PQ)",
+            Self::ScRgb => "scRGB",
+        }
+    }
     pub fn format(self) -> wgpu::TextureFormat {
         match self {
             Self::Pq => wgpu::TextureFormat::Rgb10a2Unorm,
@@ -54,6 +60,38 @@ struct Targets {
     group: wgpu::BindGroup,
 }
 
+/// How one tier of light sources (`mesher::hdr_tier`) shines: `share` of the headroom for
+/// its brightest pixels, lifted from brightness `start` (none) to `full` (all of it).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Tier {
+    pub share: f32,
+    pub start: f32,
+    pub full: f32,
+}
+/// Low, incandescent, bright and very bright.
+pub const TIERS: [Tier; 4] = [
+    Tier {
+        share: 0.2,
+        start: 0.08,
+        full: 0.09,
+    },
+    Tier {
+        share: 0.5,
+        start: 0.14,
+        full: 0.38,
+    },
+    Tier {
+        share: 0.6,
+        start: 0.14,
+        full: 0.38,
+    },
+    Tier {
+        share: 1.0,
+        start: 0.14,
+        full: 0.38,
+    },
+];
+
 pub struct Hdr {
     layout: wgpu::BindGroupLayout,
     pipeline: wgpu::RenderPipeline,
@@ -62,11 +100,12 @@ pub struct Hdr {
     /// The frame's format: what every other pipeline draws in.
     format: wgpu::TextureFormat,
     targets: Option<Targets>,
-    /// `HORIZON_HDR_DEBUG=1`: paint expanded pixels magenta.
+    /// `HORIZON_HDR_DEBUG=1`: grey what isn't expanded, tint what is magenta.
     debug: bool,
     /// Paper white and peak brightness, in nits.
     pub paper_white: f32,
     pub peak: f32,
+    pub tiers: [Tier; 4],
 }
 
 impl Hdr {
@@ -134,7 +173,7 @@ impl Hdr {
         });
         let params = device.create_buffer(&wgpu::BufferDescriptor {
             label: Some("Horizon HDR parameters"),
-            size: 32,
+            size: 80,
             usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
             mapped_at_creation: false,
         });
@@ -148,6 +187,7 @@ impl Hdr {
             debug: std::env::var_os("HORIZON_HDR_DEBUG").is_some_and(|v| v == "1"),
             paper_white: 200.0,
             peak: 1000.0,
+            tiers: TIERS,
         }
     }
 
@@ -228,16 +268,19 @@ impl Hdr {
             return;
         };
         let paper = self.paper_white.max(1.0);
-        let params = [
+        let mut params = [0.0; 20];
+        params[..5].copy_from_slice(&[
             paper / 80.0,
             (self.peak / paper).max(1.0),
             f32::from(u8::from(world)),
             f32::from(u8::from(self.debug)),
             f32::from(u8::from(self.output == Output::Pq)),
-            0.0,
-            0.0,
-            0.0,
-        ];
+        ]);
+        for (i, t) in self.tiers.iter().enumerate() {
+            params[8 + i] = t.share;
+            params[12 + i] = t.start;
+            params[16 + i] = t.full;
+        }
         queue.write_buffer(&self.params, 0, bytemuck::cast_slice(&params));
         let view = target.create_view(&Default::default());
         let attachments = [Some(wgpu::RenderPassColorAttachment {
@@ -265,6 +308,24 @@ mod tests {
     use super::{Output, pick};
     use wgpu::{SurfaceColorSpaces as S, TextureFormat as F};
 
+    #[test]
+    fn hdr_shaders_validate() {
+        let entity = crate::overlay::wgsl_constants() + include_str!("../entity.wgsl");
+        for source in [
+            include_str!("../hdr.wgsl"),
+            include_str!("../terrain.wgsl"),
+            &entity,
+        ] {
+            let module = naga::front::wgsl::parse_str(source).unwrap();
+            naga::valid::Validator::new(
+                naga::valid::ValidationFlags::all(),
+                naga::valid::Capabilities::all(),
+            )
+            .validate(&module)
+            .unwrap();
+        }
+    }
+
     fn caps(offered: &[(F, S)]) -> wgpu::SurfaceCapabilities {
         wgpu::SurfaceCapabilities {
             format_capabilities: offered

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

@@ -361,8 +361,9 @@ impl NativePost {
 pub fn frame_inputs(frame: &Frame, size: [u32; 2], seconds: f32, index: u32) -> FrameInputs {
     let aspect = size[0] as f32 / size[1].max(1) as f32;
     let view = crate::camera::view_matrix(frame.yaw, frame.pitch);
-    let projection =
-        super::world_projection(frame.fov_degrees, aspect, frame.depth_far) * frame.bob;
+    let projection = super::world_projection(frame.fov_degrees, aspect, frame.depth_far)
+        * frame.bob
+        * frame.spin;
     // A celestial body's direction at `angle` degrees (SkyRenderer: Y -90°, then X by the
     // angle, of straight up): overhead at 0, rising in the east (+x).
     let body = |angle: f32| {

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

@@ -287,7 +287,8 @@ impl FrameUniforms {
             aspect,
             0.05,
             frame.depth_far,
-        ) * frame.bob;
+        ) * frame.bob
+            * frame.spin;
         let camera = frame.camera.as_vec3();
         let (previous_camera, previous_view, previous_projection) =
             self.previous