Merge pull request #6280 from levzzz5154/mods/entity-tick

Native mods: an entity's tick, EntityTickEvent.Pre / Post
Merge pull request #6359 from levzzz5154/mods/native-blocks-items
2026-11-08 17:19:10 -10:00 · 2026-11-02 01:05:36 +05:00 · 2026-11-02 01:02:01 +05:00 · 2026-11-02 01:01:50 +05:00 · 2026-11-01 20:57:44 +01:00 · 2026-11-01 20:57:39 +01:00
552 changed files with 42183 additions and 2742 deletions
@@ -150,7 +150,7 @@ jobs:
        if: runner.os == 'Linux'
        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
      - name: Build the client, horizon-ctl, horizon-prepare and horizon-server
-        run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} -p horizon-client --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
+        run: cargo build --release --locked ${{ matrix.target && format('--target {0}', matrix.target) || '' }} -p horizon-client -p horizon-client-lib --bin horizon-client --bin horizon-ctl -p horizon-prepare --bin horizon-prepare -p horizon-server --bin horizon-server
      - name: Every program the release folder takes was built
        run: |
          for binary in horizon-client horizon-ctl horizon-prepare horizon-server; do
@@ -0,0 +1,61 @@
+name: pack load bench
+# How long resource packs take to load: crates/horizon-client-render/examples/pack_load_bench.rs on generated packs
+# (no game files), on the branch and then on `base` with the branch's copy of the bench, on the same runner, so a pull
+# request can show its numbers next to main's. Started by hand, or by a push to a `pack-bench/*` branch (a fork can't
+# start a workflow its main lacks), against horizon-rust/horizon's main.
+on:
+  push:
+    branches: ['pack-bench/**']
+  workflow_dispatch:
+    inputs:
+      base:
+        description: Ref to compare against
+        default: main
+      scale:
+        description: How many times the default pack sizes
+        default: '1'
+permissions:
+  contents: read
+env:
+  HORIZON_TELEMETRY_URL: "off"
+  CARGO_TERM_COLOR: never
+
+jobs:
+  bench:
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust and the ALSA and udev headers
+        run: |
+          sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev
+          rustup toolchain install stable --profile minimal
+      - uses: Swatinem/rust-cache@v2
+        with:
+          shared-key: pack-bench
+      - name: Bench the branch
+        env:
+          SCALE: ${{ inputs.scale || '1' }}
+        run: |
+          cargo run --profile fast -p horizon-client-render --example pack_load_bench -- --scale "$SCALE" > head.md
+      - name: Bench the base, with the branch's bench
+        env:
+          BASE: ${{ inputs.base || 'main' }}
+          SCALE: ${{ inputs.scale || '1' }}
+        run: |
+          git fetch https://github.com/horizon-rust/horizon.git "$BASE"
+          git worktree add ../base FETCH_HEAD
+          cp crates/horizon-client-render/examples/pack_load_bench.rs ../base/crates/horizon-client-render/examples/
+          # A bench row that times a function the base lacks keeps it from building there: then
+          # the branch's own rows compare the two ways.
+          (cd ../base && CARGO_TARGET_DIR="$GITHUB_WORKSPACE/target" cargo run --profile fast -p horizon-client-render \
+            --example pack_load_bench -- --scale "$SCALE") > base.md \
+            || echo "The bench does not build on the base." > base.md
+      - name: Summary
+        run: |
+          {
+            echo "### Branch ($(git rev-parse --short HEAD))"; cat head.md
+            echo; echo "### Base (${{ inputs.base || 'main' }})"; cat base.md
+          } | tee -a "$GITHUB_STEP_SUMMARY"
@@ -30,6 +30,7 @@ Feature → files → harness for the most-changed areas: [docs/architecture.md]
  change), none for a fix. Agents never add `release-now`: the maintainer decides it. Merges ship in batches of 5, or after
  6 hours ([docs/release-flow.md](docs/release-flow.md)).
 - Contributors first: `gh pr list --state open --search <area>` before you start; never duplicate theirs.
+- **No hardcoded user-facing strings.** Keep UI translation-ready from the start. In the launcher (`launcher/`), wrap visible text with `tr("...")` or `trf("... {arg} ...", &[("arg", &val)])` from `crate::i18n` instead of raw string literals or `format!`. In the game, use translation keys (`Text::tr`, `lang::get`), never hardcoded English strings.
 - **Claim before you start**: comment `/claim` on the issue (no issue yet: open one, then claim it). An assigned
  issue is taken: pick another. `/unclaim` when you stop; a claim with no open PR linking it is released after 5 days.

@@ -39,7 +40,8 @@ Game workspace (root `Cargo.toml`); `launcher/` and `crates/horizon-telemetry-se

 | Crate | Owns |
 |---|---|
-| `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-client` | Gameplay library (`src/lib.rs`: `game.rs` + `game/`, `entry.rs`) and thin executable (`src/main.rs`). Also the dedicated server (`--dedicated`). Re-exports `horizon-client-lib` for existing mod paths. |
+| `horizon-client-lib` | Reusable client systems, `horizon-ctl`, probes and their tests. Its manifest points to the existing sources under `crates/horizon-client/`; the library root is `src/client_lib.rs`. It never depends on gameplay. |
 | `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`...) |
@@ -84,8 +86,8 @@ reads `README.md`, `launcher/links.json`, `docs/api/`, `roadmap/roadmap.json` an
 ```sh
 python3 tools/pr_ready.py                  # the self-check: fmt, clippy -D warnings, touched crates' tests, harnesses; paste its block in the PR
 python3 tools/pr_ready.py --quick          # same without harnesses
-cargo test -p horizon-client --lib --bins --tests   # skips the 104 examples (pr_ready does this); `--doc` separately
-cargo test -p horizon-client --lib mod_content::tests:: -- --ignored   # the 5 slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
+cargo test -p horizon-client -p horizon-client-lib --lib --bins --tests   # skips the 104 examples (pr_ready does this); `--doc` separately
+cargo test -p horizon-client-lib --lib mod_content::tests:: -- --ignored   # the 5 slow content-root tests, #[ignore]d; pr_ready runs them when mod content, assets, blocks or items change
 cargo build --profile fast -p horizon-client        # optimized, quick to link: use it to play or run lan_e2e
 python3 tools/parity.py --changed origin/main       # the harnesses your branch can affect (CI's parity job)
 python3 tools/parity.py --changed-files paths.txt --list   # which harnesses cover these files, without running them
@@ -102,8 +104,11 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
  or the game binary with a fixture env var (`game/dispense_fixture.rs`, `game/sculk_fixture.rs`,
  `game/command_harness.rs`, `game/net_harness.rs`). Copy a nearby harness for a new one.
 - Probes build into `.local/parity-target/`; harnesses find binaries via `lab.cargo_target()`, never `target/`.
- What a change reruns (of 329 harnesses, measured 2026-10-23): a file of the game binary (`game.rs`, `game/`)
-  ~25, a file of the client lib ~103, of `horizon-world` ~103–109, of `horizon-core` ~119. Plan for it.
+- Harness selection uses Cargo dep-info and reachable-code narrowing (`tools/parity_reach.py`).
+  `horizon-client-lib` builds the control tool and client probes without gameplay; their dep-info
+  excludes `game.rs` and `game/`, so gameplay edits do not rebuild or select those probes.
+  Source paths remain in `crates/horizon-client/`. Measure actual harness selection on refreshed
+  records with `tools/parity.py --changed-files paths.txt --list`; historical counts are not a guarantee.
 - Rust integration tests: `crates/horizon-client/tests/` (`lan_bot.rs`, `generation_saves.rs`, `streaming_meshes.rs`).
 - Linux needs `libasound2-dev libudev-dev`; `--no-default-features` drops audio and controllers (the server build).
 - Run and drive the game (starts the `horizon-client` beside `horizon-ctl`; other arguments go to the game):
@@ -128,8 +133,11 @@ python3 tools/agent_control_e2e.py         # horizon-ctl / MCP end to end
 ## horizon-client: where things live

 `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>`.
+the same `horizon_client::<module>` paths), `G:` = gameplay (`crates/horizon-client/src/game/`), also in the lib in normal builds.
+Gameplay keeps its `horizon_client::<module>` imports through a self-crate alias. The executable
+contains only the allocator, mod API marker and a call to `entry::main`. For unit tests, the lib
+excludes `entry` and `game`, and the executable test target owns `game` so its process-wide test
+state stays separate from the library tests. This compiles gameplay twice for executable tests.

 | Subsystem | Files |
 |---|---|
@@ -151,7 +159,7 @@ the same `horizon_client::<module>` paths), `G:` = bin (`crates/horizon-client/s
 | 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`; 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` |
+| Resource packs | L: `packs.rs` + `packs/`, `pack_screen.rs`, `atlas_sources.rs`, `sprites.rs`, `mipmap.rs`, `model_library.rs`, `font.rs`, `mobs/cem.rs` + `mobs/cem_anim.rs` (OptiFine/EMF entity models and their animations); `horizon-client-core/src/lang.rs`; crates `horizon-assets`, `horizon-optifine`; 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)) |
 | Mods | crate `horizon-mods`; G: `mods.rs`; L: `mod_content.rs`, `mod_list.rs` |
 | Horizon extras, settings | L: `extras.rs`, `graphics.rs`, `settings.rs`, `minimap.rs`; G: `extras.rs`, `tweaks.rs`, `options.rs` |
@@ -160,7 +168,7 @@ the same `horizon_client::<module>` paths), `G:` = bin (`crates/horizon-client/s

 - `struct Game` (game.rs, ~290 fields) holds everything. Its methods are spread over ~180 files: game.rs keeps
  the core (tick, render, input, inventory, world open/close) and each `game/<feature>.rs` adds an
-  `impl Game<'_>` block for one feature, with its own state types. Fields are private to the bin.
+  `impl Game<'_>` block for one feature, with its own state types. Fields stay private to the gameplay module and its descendants. Gameplay tests run in the gameplay library, separate from reusable-library tests.
 - Find a feature's code: `grep -rn "fn tick_<thing>\|fn <verb>_<thing>" crates/horizon-client/src/game*`;
  the file is usually `game/<thing>s.rs`. Who calls it: grep the name in game.rs's `fn tick` / `fn tick_world`.
 - Fields that say which mode runs: `remote` (this window is a client of a server: multiplayer, LAN guest, or
@@ -1314,6 +1314,7 @@ dependencies = [
 "horizon-chat-filter",
 "horizon-client-core",
 "horizon-client-input",
+ "horizon-client-lib",
 "horizon-client-render",
 "horizon-command",
 "horizon-core",
@@ -1374,6 +1375,62 @@ dependencies = [
 "winit",
 ]

+[[package]]
+name = "horizon-client-lib"
+version = "0.1.0"
+dependencies = [
+ "ab_glyph",
+ "bytemuck",
+ "chrono",
+ "flate2",
+ "fs4",
+ "gilrs",
+ "glam",
+ "horizon-anticheat",
+ "horizon-assets",
+ "horizon-bench",
+ "horizon-chat-filter",
+ "horizon-client-core",
+ "horizon-client-input",
+ "horizon-client-render",
+ "horizon-command",
+ "horizon-core",
+ "horizon-dualsense",
+ "horizon-friends",
+ "horizon-hdr",
+ "horizon-items",
+ "horizon-mods",
+ "horizon-narrator",
+ "horizon-optifine",
+ "horizon-protocol",
+ "horizon-server-files",
+ "horizon-shader-api",
+ "horizon-shaders",
+ "horizon-telemetry",
+ "horizon-theme",
+ "horizon-threads",
+ "horizon-world",
+ "log",
+ "miniz_oxide 0.8.9",
+ "naga",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
+ "objc2-foundation 0.3.2",
+ "open",
+ "png",
+ "pollster",
+ "rustix 1.1.5",
+ "serde",
+ "serde_json",
+ "sha1",
+ "sha2",
+ "unicode-bidi",
+ "ureq",
+ "wgpu",
+ "winit",
+ "zip",
+]
+
 [[package]]
 name = "horizon-client-render"
 version = "0.1.0"
@@ -1395,6 +1452,7 @@ dependencies = [
 "horizon-hdr",
 "horizon-items",
 "horizon-narrator",
+ "horizon-optifine",
 "horizon-protocol",
 "horizon-shader-api",
 "horizon-shaders",
@@ -1516,6 +1574,7 @@ name = "horizon-optifine"
 version = "0.1.0"
 dependencies = [
 "horizon-bench",
+ "log",
 "regex",
 ]

@@ -8,6 +8,7 @@ members = [
    "crates/horizon-hdr",
    "crates/horizon-world",
    "crates/horizon-client",
+    "crates/horizon-client-lib",
    "crates/horizon-client-core",
    "crates/horizon-client-input",
    "crates/horizon-client-render",
@@ -66,3 +66,28 @@ with Microsoft accounts
 The four-square Microsoft symbol in `launcher/src/microsoft.rs` reproduces the squares, positions and
 colours of Microsoft's official `ms-symbollockup_mssymbol_19.svg` from that page, unmodified. Microsoft
 and its logo are trademarks of the Microsoft group of companies; Horizon is not endorsed by Microsoft.
+
+## CIT Resewn
+
+`crates/horizon-optifine/src/cit.rs` and `crates/horizon-client-render/src/cit.rs` follow the
+condition semantics of [CIT Resewn Continuation](https://github.com/EthanVisagie/CIT-Resewn-Continuation-1.21.11)
+(at `b792f9a`), a continuation of [CIT Resewn](https://github.com/SHsuperCM/CITResewn) by SHsuperCM: the
+1.21 component paths, enchantment levels, percent damage, text matching and rule ordering. It is
+licensed under the MIT license:
+
+> Copyright (c) 2021 SHsuperCM
+>
+> Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+> and associated documentation files (the "Software"), to deal in the Software without
+> restriction, including without limitation the rights to use, copy, modify, merge, publish,
+> distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+> Software is furnished to do so, subject to the following conditions:
+>
+> The above copyright notice and this permission notice shall be included in all copies or
+> substantial portions of the Software.
+>
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+> BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+> DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
@@ -281,6 +281,13 @@ pub struct Player {
    pub ground: Option<(u64, f64)>,
    /// The client ticks the prediction plays again (only while it runs).
    pub record: Option<Box<prediction::Record>>,
+    /// Sprinting as the client's own commands left it (ServerboundPlayerCommandPacket's
+    /// START_SPRINTING and STOP_SPRINTING: LocalPlayer.wasSprinting), which the record's ticks take.
+    /// Not the server's player: a hit with extra knockback stops its sprint
+    /// (Player.causeExtraKnockback), the client's own `Player.attack` doesn't (a mob's `hurtClient`
+    /// is false), and once the server's flag reaches it LocalPlayer.aiStep starts the sprint again
+    /// while the sprint key is held, with nothing to say: wasSprinting never changed.
+    pub sprinting: bool,
    /// The attacks of the client tick being heard.
    pub attacks: combat::Attacks,
 }
@@ -202,10 +202,8 @@ fn os_version() -> Option<String> {
 #[cfg(target_os = "linux")]
 fn cpu() -> Option<String> {
    let info = std::fs::read_to_string("/proc/cpuinfo").ok()?;
-    // x86 names the CPU per core; ARM boards name the machine once.
-    key_value(&info, "model name", ':')
-        .or_else(|| key_value(&info, "Model", ':'))
-        .map(str::to_owned)
+    // x86 names the CPU per core; arm64 only gives the core's implementer and part.
+    horizon_telemetry::system::linux_cpu_name(&info)
 }

 #[cfg(target_os = "linux")]
@@ -227,12 +225,12 @@ fn key_value<'a>(text: &'a str, key: &str, sep: char) -> Option<&'a str> {

 #[cfg(target_os = "windows")]
 fn os_version() -> Option<String> {
-    output("cmd", &["/C", "ver"])
+    horizon_telemetry::system::windows_version()
 }

 #[cfg(target_os = "windows")]
 fn cpu() -> Option<String> {
-    std::env::var("PROCESSOR_IDENTIFIER").ok()
+    horizon_telemetry::system::windows_cpu()
 }

 #[cfg(target_os = "windows")]
@@ -281,4 +279,16 @@ mod tests {
            assert!(cpu_seconds(std::process::id()).unwrap() >= 0.0);
        }
    }
+
+    /// `hardware.cpu` is the brand name, not the family and model `PROCESSOR_IDENTIFIER` holds.
+    #[cfg(windows)]
+    #[test]
+    fn windows_reports_the_cpu_brand() {
+        let cpu = Hardware::detect().cpu.expect("a CPU name");
+        assert!(
+            !cpu.is_empty() && !cpu.contains(" Family ") && !cpu.contains("Stepping"),
+            "family and model, not a name: {cpu:?}"
+        );
+        assert_eq!(cpu, cpu.trim());
+    }
 }
@@ -73,8 +73,11 @@ horizon-bots: load-test bots for a Minecraft Java Edition 26.3 server (offline m
  --attack NAME          attack the player NAME twice a second, from wherever the bot is (a reach test),
                         swinging after each attack as vanilla's client does. NAME,NAME...: each of them
                         in the same tick (a multi-target kill aura, for the anticheat's tests);
-                         the report gives each bot's last health
+                         the report gives each bot's last health. A UUID instead of a NAME: the
+                         entity with that UUID (a boat summoned with it, say)
  --attack-after S       start attacking S seconds after joining; default 5
+  --attack-rounds N      stop after N rounds of attacks (each hits every target seen so far once);
+                         default no limit
  --no-swing             attack without swinging (a kill aura hiding its swing, for the anticheat's tests)
  --no-loaded            never say the level is loaded (ServerboundPlayerLoadedPacket): a vanilla server
                         ignores the player's moves and actions for its first 3 seconds
@@ -153,9 +156,11 @@ struct Options {
    seed: u64,
    explore_speed: f64,
    pvp: bool,
-    /// The player to attack, and how long after joining to start.
+    /// The players or entity UUIDs to attack, how long after joining to start,
+    /// and how many rounds.
    attack: Option<String>,
    attack_after: f64,
+    attack_rounds: u32,
    no_swing: bool,
    flood: usize,
    no_read: bool,
@@ -190,6 +195,7 @@ fn options() -> Result<Options, String> {
        pvp: true,
        attack: None,
        attack_after: 5.0,
+        attack_rounds: u32::MAX,
        no_swing: false,
        flood: 100,
        no_read: false,
@@ -247,6 +253,7 @@ fn options() -> Result<Options, String> {
            "--flood" => o.flood = value.parse().map_err(|_| number("packets a tick"))?,
            "--attack" => o.attack = Some(value),
            "--attack-after" => o.attack_after = value.parse().map_err(|_| number("seconds"))?,
+            "--attack-rounds" => o.attack_rounds = value.parse().map_err(|_| number("a number"))?,
            "--name" => o.name = value,
            "--report" => o.report = Some(value),
            "--brand" => o.brand = Some(value),
@@ -401,6 +408,16 @@ fn join_summary(mut times: Vec<u64>) -> serde_json::Value {
    })
 }

+/// An `--attack` target's UUID: a UUID as written (`8-4-4-4-12` hex), else
+/// the offline UUID of the player with that name (a name has no `-`).
+fn target_uuid(name: &str) -> u128 {
+    let hex: String = name.chars().filter(|&c| c != '-').collect();
+    match u128::from_str_radix(&hex, 16) {
+        Ok(uuid) if name.contains('-') && hex.len() == 32 => uuid,
+        _ => offline_uuid(name),
+    }
+}
+
 /// A small deterministic generator (SplitMix64), so every run moves the bots the same way.
 struct Random(u64);
 impl Random {
@@ -984,7 +1001,7 @@ fn run_bot(
        .attack
        .iter()
        .flat_map(|names| names.split(','))
-        .map(|name| (offline_uuid(name), None))
+        .map(|name| (target_uuid(name), None))
        .collect();
    bot.online.store(true, Ordering::SeqCst);
    {
@@ -1039,6 +1056,7 @@ fn run_bot(
        send(play::Serverbound::SetCarriedItem(play::SetCarriedItem { slot: 0 }).encode());
    }
    let mut sequence = 0;
+    let mut rounds = 0;
    let mut random = Random(o.seed ^ (index as u64).wrapping_mul(0x2545_F491_4F6C_DD1D));
    let mut pos = spawn;
    // Fight bots stay at their spawn height; the others climb to fly above the terrain.
@@ -1202,8 +1220,13 @@ fn run_bot(
                send(body);
            }
        }
-        if joined.elapsed().as_secs_f64() >= o.attack_after && tick % 10 == 0 {
+        if joined.elapsed().as_secs_f64() >= o.attack_after
+            && tick % 10 == 0
+            && rounds < o.attack_rounds
+        {
            let targets: Vec<i32> = lock(&bot.target).iter().filter_map(|t| t.1).collect();
+            // A round counts once a target is known.
+            rounds += u32::from(!targets.is_empty());
            for id in targets {
                send(play::Serverbound::Attack(play::Attack { id }).encode());
                // Minecraft.startAttack swings right after the attack.
@@ -1446,6 +1469,20 @@ mod tests {
        })
    }

+    /// `--attack`: a UUID names that entity, anything else a player.
+    #[test]
+    fn attack_targets_a_uuid_or_a_player() {
+        assert_eq!(target_uuid("00000000-0000-0000-0000-00000000000a"), 10);
+        assert_eq!(
+            target_uuid("0000000a-0000-0001-0000-000000000002"),
+            0x0000000a_0000_0001_0000_000000000002
+        );
+        assert_eq!(target_uuid("V0"), offline_uuid("V0"));
+        // A name of 32 hex digits is a name: a UUID is written with dashes.
+        let name = "0123456789abcdef0123456789abcdef";
+        assert_eq!(target_uuid(name), offline_uuid(name));
+    }
+
    #[test]
    fn tracks_living_entities_only() {
        let mut e = Entities::default();
@@ -72,6 +72,19 @@ impl ResourceSource for Bundled {
            "assets/horizon/lang/tr_tr.json" => {
                include_str!("../../horizon-client/assets/horizon/lang/tr_tr.json")
            }
+            "assets/horizon/lang/de_de.json" | "assets/horizon/lang/de_at.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/de_de.json")
+            }
+            // Swiss German writes "ss" for "ß", as vanilla's de_ch does.
+            "assets/horizon/lang/de_ch.json" => {
+                let de = include_str!("../../horizon-client/assets/horizon/lang/de_de.json");
+                return Some(de.replace('ß', "ss").into_bytes());
+            }
+            "assets/horizon/lang/fr_fr.json"
+            | "assets/horizon/lang/fr_ca.json"
+            | "assets/horizon/lang/fr_ch.json" => {
+                include_str!("../../horizon-client/assets/horizon/lang/fr_fr.json")
+            }
            "assets/horizon/lang/es_es.json"
            | "assets/horizon/lang/es_ar.json"
            | "assets/horizon/lang/es_cl.json"
@@ -316,6 +329,20 @@ mod tests {
        assert_eq!(tr.get("horizon.options.controller"), Some("Kontrolcü"));
        let es = Language::load(&[&empty], "es_es");
        assert_eq!(es.get("horizon.options.controller"), Some("Mando"));
+        // German and French, and their regional variants on the same file
+        // (Swiss German without "ß").
+        let de = Language::load(&[&empty], "de_de");
+        assert_eq!(de.get("horizon.osk.close"), Some("Schließen"));
+        let fr = Language::load(&[&empty], "fr_fr");
+        assert_eq!(fr.get("horizon.osk.close"), Some("Fermer"));
+        for (code, base) in [("de_at", &de), ("fr_ca", &fr), ("fr_ch", &fr)] {
+            let variant = Language::load(&[&empty], code);
+            assert_eq!(variant.map(), base.map(), "{code}");
+        }
+        let de_ch = Language::load(&[&empty], "de_ch");
+        assert_eq!(de_ch.get("horizon.osk.close"), Some("Schliessen"));
+        assert!(de_ch.map().values().all(|v| !v.contains('ß')));
+        assert_eq!(de_ch.len(), de.len());
        let es_ve = Language::load(&[&empty], "es_ve");
        assert_eq!(
            es_ve.get("horizon.options.on_screen_keyboard"),
@@ -323,6 +350,148 @@ mod tests {
        );
    }

+    /// `crates/horizon-client/assets/horizon/lang`, where Horizon's own strings live.
+    fn bundled_dir() -> std::path::PathBuf {
+        std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../horizon-client/assets/horizon/lang")
+    }
+    /// The keys of a flat bundled file in file order, duplicates included (a map
+    /// would keep only the last of two equal keys). One `"key": "value"` per line.
+    fn file_keys(body: &str) -> Vec<String> {
+        body.lines()
+            .filter(|line| line.starts_with("  \""))
+            .map(|line| {
+                serde_json::Deserializer::from_str(line.trim_start())
+                    .into_iter::<String>()
+                    .next()
+                    .and_then(Result::ok)
+                    .unwrap_or_else(|| panic!("no key on line {line}"))
+            })
+            .collect()
+    }
+    /// The fields the code fills in (`%s`, `%d`, `%1$s`, `%.2f`, `%%`), sorted. A
+    /// percent sign that starts none of them ("100% is") is plain text.
+    fn placeholders(text: &str) -> Vec<String> {
+        let mut found = Vec::new();
+        let mut rest = text;
+        while let Some(at) = rest.find('%') {
+            rest = &rest[at + 1..];
+            let spec = rest
+                .find(|c: char| !(c.is_ascii_digit() || c == '$' || c == '.'))
+                .unwrap_or(rest.len());
+            let after = rest[spec..].chars().next();
+            if after.is_some_and(|c| matches!(c, 's' | 'd' | 'f' | '%')) {
+                let end = spec + 1;
+                found.push(format!("%{}", &rest[..end]));
+                rest = &rest[end..];
+            }
+        }
+        found.sort();
+        found
+    }
+
+    #[test]
+    fn bundled_files_are_served_and_have_no_stale_or_repeated_keys() {
+        let dir = bundled_dir();
+        let en_body = std::fs::read_to_string(dir.join("en_us.json")).unwrap();
+        let en: HashMap<String, String> = serde_json::from_str(&en_body).unwrap();
+        let mut seen = 0;
+        for entry in std::fs::read_dir(&dir).unwrap().flatten() {
+            let name = entry.file_name().into_string().unwrap();
+            let Some(code) = name.strip_suffix(".json") else {
+                continue;
+            };
+            seen += 1;
+            // A file that Bundled::read does not name is never loaded.
+            let path = format!("assets/horizon/lang/{name}");
+            assert!(
+                Bundled.read(&path).is_some(),
+                "{name} is not served by Bundled"
+            );
+            let body = std::fs::read_to_string(entry.path()).unwrap();
+            let map: HashMap<String, String> = serde_json::from_str(&body)
+                .unwrap_or_else(|e| panic!("{name} is not a flat string map: {e}"));
+            let keys = file_keys(&body);
+            assert_eq!(
+                keys.len(),
+                map.len(),
+                "{name} repeats a key or has a multi-line entry"
+            );
+            for (key, value) in &map {
+                // Stale: the code no longer asks for it, or it was renamed in en_us only.
+                let english = en
+                    .get(key)
+                    .unwrap_or_else(|| panic!("{code}: {key} is not in en_us.json"));
+                // A translation keeps the fields the code fills in.
+                assert_eq!(
+                    placeholders(value),
+                    placeholders(english),
+                    "{code}: {key} changes the placeholders of the English text"
+                );
+                assert!(!value.trim().is_empty(), "{code}: {key} is empty");
+            }
+        }
+        assert!(
+            seen >= 7,
+            "found {seen} bundled lang files in {}",
+            dir.display()
+        );
+    }
+
+    #[test]
+    fn every_horizon_key_the_code_names_is_in_en_us() {
+        fn rust_files(dir: &std::path::Path, out: &mut Vec<std::path::PathBuf>) {
+            for entry in std::fs::read_dir(dir).into_iter().flatten().flatten() {
+                let path = entry.path();
+                if path.is_dir() {
+                    rust_files(&path, out);
+                } else if path.extension().is_some_and(|e| e == "rs") {
+                    out.push(path);
+                }
+            }
+        }
+        let en: HashMap<String, String> = serde_json::from_str(
+            &std::fs::read_to_string(bundled_dir().join("en_us.json")).unwrap(),
+        )
+        .unwrap();
+        let crates = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
+        let mut files = Vec::new();
+        for krate in [
+            "horizon-client",
+            "horizon-client-render",
+            "horizon-client-core",
+        ] {
+            rust_files(&crates.join(krate).join("src"), &mut files);
+        }
+        assert!(files.len() > 100, "found only {} sources", files.len());
+        let mut found = 0;
+        for file in files {
+            let text = std::fs::read_to_string(&file).unwrap();
+            for (at, _) in text.match_indices("\"horizon.") {
+                let rest = &text[at + 1..];
+                let Some(end) = rest.find('"') else { continue };
+                let key = &rest[..end];
+                // A key is `horizon.<group>.<name>`: lower-case letters, digits and `_`
+                // between the dots. A key built at run time has a brace; a file name
+                // has one dot; the server addresses that look like keys are listed.
+                const NOT_KEYS: &[&str] = &["horizon.bunchy7s.dev"];
+                let key_like = key
+                    .bytes()
+                    .all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || b"_.".contains(&b));
+                if key.matches('.').count() < 2 || !key_like || NOT_KEYS.contains(&key) {
+                    continue;
+                }
+                found += 1;
+                assert!(
+                    en.contains_key(key),
+                    "{} names {key}, which is not in en_us.json",
+                    file.display()
+                );
+            }
+        }
+        assert!(found > 50, "found only {found} key names");
+    }
+
    #[test]
    fn layers_selected_language_over_english() {
        let base = Mem(HashMap::from([
@@ -483,6 +483,21 @@ impl KeyBinds {
            .find(|mapping| self.get(mapping) == name)
            .and_then(|mapping| key_code(Self::default_of(mapping)))
    }
+    /// `AbstractContainerScreen.checkHotbarKeyPressed`: the off hand and the
+    /// hotbar slots, as the controls bind them now. Answers the key the menu
+    /// acts on (`KeyF` for the off hand, `DigitN` for a slot), so a rebound key
+    /// swaps instead of reaching the screen.
+    pub fn container_hotbar_key(&self, key: KeyCode) -> Option<KeyCode> {
+        let name = key_name(key)?;
+        if self.get("key.swapOffhand") == name {
+            return Some(KeyCode::KeyF);
+        }
+        MAPPINGS
+            .iter()
+            .filter(|m| m.0.starts_with("key.hotbar."))
+            .find(|m| self.get(m.0) == name)
+            .and_then(|m| key_code(Self::default_of(m.0)))
+    }
 }

 #[cfg(test)]
@@ -519,6 +534,29 @@ mod tests {
        assert_eq!(keys.container_mouse_key(MouseButton::Forward, false), None);
    }

+    #[test]
+    fn container_hotkeys_follow_the_bound_keys() {
+        let mut keys = KeyBinds::default();
+        assert_eq!(
+            keys.container_hotbar_key(KeyCode::KeyF),
+            Some(KeyCode::KeyF)
+        );
+        assert_eq!(
+            keys.container_hotbar_key(KeyCode::Digit3),
+            Some(KeyCode::Digit3)
+        );
+        assert_eq!(keys.container_hotbar_key(KeyCode::Tab), None);
+        // The report's key: bound to the off hand, the menu takes it first.
+        keys.set("key.swapOffhand", "key.keyboard.tab");
+        assert_eq!(keys.container_hotbar_key(KeyCode::Tab), Some(KeyCode::KeyF));
+        assert_eq!(keys.container_hotbar_key(KeyCode::KeyF), None);
+        keys.set("key.hotbar.3", "key.keyboard.t");
+        assert_eq!(
+            keys.container_hotbar_key(KeyCode::KeyT),
+            Some(KeyCode::Digit3)
+        );
+    }
+
    #[test]
    fn rebinding_translates_to_defaults() {
        let mut k = KeyBinds::default();
@@ -549,6 +549,7 @@ pub fn fullscreen_request(
 /// it from the `horizon.desktop` entry, macOS from the app bundle). `None` if it can't be read.
 pub fn icon() -> Option<winit::window::Icon> {
    let mut decoder = png::Decoder::new(std::io::Cursor::new(horizon_theme::ICON_PNG));
+    decoder.ignore_checksums(true);
    decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
    let mut reader = decoder.read_info().ok()?;
    let mut bytes = vec![0; reader.output_buffer_size()?];
@@ -0,0 +1,221 @@
+[package]
+name = "horizon-client-lib"
+autobins = false
+autoexamples = false
+autotests = false
+version = "0.1.0"
+edition.workspace = true
+license.workspace = true
+rust-version = "1.90"
+description = "Reusable client systems, control tool and parity probes"
+
+[lib]
+path = "../horizon-client/src/client_lib.rs"
+
+[dependencies]
+horizon-assets = { path = "../horizon-assets" }
+horizon-client-core = { path = "../horizon-client-core" }
+horizon-client-input = { path = "../horizon-client-input" }
+horizon-client-render = { path = "../horizon-client-render" }
+horizon-command = { path = "../horizon-command" }
+horizon-items = { path = "../horizon-items" }
+horizon-core = { path = "../horizon-core" }
+# The server thread ahead of the workers (MinecraftServer.spin's Thread.setPriority).
+horizon-optifine = { path = "../horizon-optifine" }
+horizon-threads = { path = "../horizon-threads" }
+horizon-hdr = { path = "../horizon-hdr" }
+horizon-world = { path = "../horizon-world" }
+horizon-protocol = { path = "../horizon-protocol" }
+# server.properties, eula.txt and the user lists, shared with horizon-server.
+horizon-server-files = { path = "../horizon-server-files" }
+# The dedicated server's anticheat, off unless server.toml's [anticheat] turns it on (docs/anticheat.md).
+horizon-anticheat = { path = "../horizon-anticheat" }
+# The dedicated server's chat filter: [chat_filter], the slur list, mutes (docs/chat-filter.md).
+horizon-chat-filter = { path = "../horizon-chat-filter" }
+# Shader packs: reading them and turning their GLSL into naga modules.
+horizon-shaders = { path = "../horizon-shaders" }
+# Horizon's own shader packs: the format, the stages and the check (docs/shaders.md).
+horizon-shader-api = { path = "../horizon-shader-api" }
+horizon-friends = { path = "../horizon-friends" }
+# The narrator (GameNarrator): text-to-speech of chat, system messages and screens.
+horizon-narrator = { path = "../horizon-narrator" }
+# Horizon mods: sandboxed WebAssembly components, off unless installed and turned on (docs/mods.md).
+# Their runtime is the `mods` feature.
+horizon-mods = { path = "../horizon-mods", default-features = false, features = ["index"] }
+wgpu = { version = "30.0.1", default-features = false, features = ["std", "parking_lot", "vulkan", "metal", "wgsl", "naga-ir"] }
+winit = "0.30.13"
+pollster = "0.4"
+bytemuck = { version = "1.24", features = ["derive"] }
+glam = "0.30"
+png = "0.18"
+sha2 = "0.10.9"
+# Server resource packs are checked and cached by their SHA-1, as vanilla does.
+sha1 = "0.10"
+serde = { version = "1", features = ["derive"] }
+serde_json = { version = "1.0.151", features = ["raw_value"] }
+# hlsl-out: the gfx.rs tests translate every shader as wgpu's DirectX 12 backend does. A normal feature,
+# not a dev-dependency's, so builds, tests and examples share one build of naga, wgpu and this crate.
+naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out"] }
+miniz_oxide = "0.8"
+ab_glyph = "0.2.32"
+log = "0.4"
+chrono = { version = "0.4.42", default-features = false, features = ["clock", "std"] }
+flate2 = { version = "1.1.10", default-features = false, features = ["zlib-rs", "runtime_detection"] }
+horizon-theme = { path = "../horizon-theme" }
+# Opt-in data collection: the game keeps, the launcher sends (docs/telemetry.md); `live` is
+# the anonymous "I'm playing" ping the game sends itself (`heartbeat.rs`).
+horizon-telemetry = { path = "../horizon-telemetry", default-features = false, features = ["live"] }
+horizon-bench = { path = "../horizon-bench" }
+zip = { version = "9.1.3", default-features = false, features = ["deflate"] }
+# Controllers (evdev + libudev on Linux, IOKit on macOS, Windows.Gaming.Input); the `controllers` feature.
+gilrs = { version = "0.11", optional = true }
+# The DualSense's rumble, adaptive triggers and lights over HID (gilrs only reads it).
+horizon-dualsense = { path = "../horizon-dualsense", optional = true }
+# HTTPS to the Minecraft services (online-mode session join).
+ureq = { version = "2", default-features = false, features = ["tls"] }
+unicode-bidi = "0.3.18"
+# `LevelStorageAccess.estimateDiskSpace`: usable disk space, without unsafe code on Windows.
+fs4 = { version = "1.1.0", default-features = false, features = ["sync"] }
+
+[target.'cfg(unix)'.dependencies]
+# The server thread's CPU time per tick (`HORIZON_SPIKES`, spans.rs).
+rustix = { version = "1", default-features = false, features = ["std", "time", "process", "fs"] }
+
+[target.'cfg(windows)'.dependencies]
+# Use the registered URI handler without routing links through Explorer/cmd.
+open = { version = "5.4.5", features = ["shellexecute-on-windows"] }
+# DirectX 12, where Vulkan has no adapter or device, or by choice (`graphicsApi`, graphics.rs).
+# Shaders compile with FXC (d3dcompiler_47.dll, part of Windows), or DXC when dxcompiler.dll is
+# on the PATH.
+wgpu = { version = "30.0.1", default-features = false, features = ["dx12"] }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+# Splitscreen: a window filling a monitor goes over its menu bar (game/split/windows.rs
+# `above_menu_bar`); all already in the tree through winit and wgpu.
+objc2 = "0.6"
+objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSApplication", "NSResponder", "NSWindow", "NSScreen"] }
+objc2-foundation = { version = "0.3", default-features = false, features = ["std", "NSArray", "NSString"] }
+
+[target.'cfg(not(target_os = "macos"))'.dependencies]
+# OpenGL (WGL on Windows, EGL on Linux), the last fallback, for GPUs with no Vulkan or
+# DirectX 12 driver (`graphicsApi`, graphics.rs).
+wgpu = { version = "30.0.1", default-features = false, features = ["gles"] }
+
+[features]
+default = ["audio", "controllers"]
+# Sound output. Without it (and `controllers`) the program links neither libasound nor libudev on
+# Linux: the server build (`--no-default-features`, released as horizon-engine; docs/server.md).
+audio = ["horizon-client-render/audio"]
+# Controllers: gilrs, and the DualSense's own output. Without it only `horizon-ctl pad`'s virtual pad.
+controllers = ["dep:gilrs", "dep:horizon-dualsense", "horizon-client-input/controllers"]
+# Records the call sites of mob random draws (`mob_ai_probe` traces).
+rng-trace = ["horizon-core/rng-trace"]
+# Compatibility with earlier experiment commands: main already uses mimalloc.
+windows-mimalloc = []
+# Opt-in Windows heap experiment; see docs/windows-allocators.md.
+windows-segment-heap = []
+
+[lints]
+workspace = true
+
+[dev-dependencies]
+horizon-client-render = { path = "../horizon-client-render", features = ["test-support"] }
+horizon-items = { path = "../horizon-items", features = ["test-support"] }
+# Every WGSL shader translated as wgpu's DirectX 12 backend does (gfx.rs tests).
+naga = { version = "30.0.1", features = ["wgsl-in", "hlsl-out", "msl-out", "spv-out"] }
+
+[[bin]]
+name = "horizon-ctl"
+path = "../horizon-client/src/bin/horizon-ctl/main.rs"
+
+[[example]]
+name = "chunk_load_bench"
+path = "../horizon-client/examples/chunk_load_bench.rs"
+
+[[example]]
+name = "gameplay_decode_profile"
+path = "../horizon-client/examples/gameplay_decode_profile.rs"
+
+[[example]]
+name = "json_load_bench"
+path = "../horizon-client/examples/json_load_bench.rs"
+
+[[example]]
+name = "mod_port_probe"
+path = "../horizon-client/examples/mod_port_probe.rs"
+
+[[example]]
+name = "model_library_bench"
+path = "../horizon-client/examples/model_library_bench.rs"
+
+[[example]]
+name = "model_states_bench"
+path = "../horizon-client/examples/model_states_bench.rs"
+
+[[example]]
+name = "old_world_fixture"
+path = "../horizon-client/examples/old_world_fixture.rs"
+
+[[example]]
+name = "portal_scan_bench"
+path = "../horizon-client/examples/portal_scan_bench.rs"
+
+[[example]]
+name = "random_tick_eligibility_bench"
+path = "../horizon-client/examples/random_tick_eligibility_bench.rs"
+
+[[example]]
+name = "resource_memory"
+path = "../horizon-client/examples/resource_memory.rs"
+
+[[example]]
+name = "save_batch_bench"
+path = "../horizon-client/examples/save_batch_bench.rs"
+
+[[example]]
+name = "shared_json_startup_profile"
+path = "../horizon-client/examples/shared_json_startup_profile.rs"
+
+[[example]]
+name = "sprite_cache_parity"
+path = "../horizon-client/examples/sprite_cache_parity.rs"
+
+[[example]]
+name = "client_probe"
+path = "../horizon-client/examples/probe/main.rs"
+
+[[test]]
+name = "custom_component_api"
+path = "../horizon-client/tests/custom_component_api.rs"
+
+[[test]]
+name = "custom_component_unregistered"
+path = "../horizon-client/tests/custom_component_unregistered.rs"
+
+[[test]]
+name = "custom_component_wire"
+path = "../horizon-client/tests/custom_component_wire.rs"
+
+[[test]]
+name = "forced_chunks"
+path = "../horizon-client/tests/forced_chunks.rs"
+
+[[test]]
+name = "generation_saves"
+path = "../horizon-client/tests/generation_saves.rs"
+
+[[test]]
+name = "lan_bot"
+path = "../horizon-client/tests/lan_bot.rs"
+
+[[test]]
+name = "streaming_meshes"
+path = "../horizon-client/tests/streaming_meshes.rs"
+
+[[test]]
+name = "tall_column"
+path = "../horizon-client/tests/tall_column.rs"
+
+[[test]]
+name = "wide_states"
+path = "../horizon-client/tests/wide_states.rs"
@@ -17,6 +17,9 @@ horizon-hdr = { path = "../horizon-hdr" }
 horizon-items = { path = "../horizon-items" }
 # The narrator option's status and whether the narrator is there (Options.narrator).
 horizon-narrator = { path = "../horizon-narrator" }
+# OptiFine-format pack files: random entity textures (hud.rs), connected textures
+# (connected.rs) and custom item texture rules (cit.rs).
+horizon-optifine = { path = "../horizon-optifine" }
 horizon-protocol = { path = "../horizon-protocol" }
 horizon-shader-api = { path = "../horizon-shader-api" }
 horizon-shaders = { path = "../horizon-shaders" }
@@ -0,0 +1,436 @@
+//! How long a big resource pack takes to load and reload, on generated files only (no game
+//! resources): a stand-in vanilla root, a server-style zip pack of many namespaces, and a
+//! high-resolution pack over vanilla's own textures. Each stage runs a few times; the median
+//! is printed as a Markdown table.
+//! `cargo run --profile fast -p horizon-client-render --example pack_load_bench [-- --scale 1]`
+//! (`.github/workflows/pack-bench.yml` runs it on a branch and on its base, side by side).
+use horizon_client_render::{
+    hud::HudAtlas,
+    model_library::ParsedModels,
+    packs::{self, Pack},
+    sprites::Sprites,
+};
+use std::{
+    fs,
+    path::{Path, PathBuf},
+    time::Instant,
+};
+
+/// A small deterministic generator: the same files on every run and every branch.
+struct Noise(u64);
+impl Noise {
+    fn next(&mut self) -> u64 {
+        self.0 ^= self.0 << 13;
+        self.0 ^= self.0 >> 7;
+        self.0 ^= self.0 << 17;
+        self.0
+    }
+}
+
+/// A `side`x`side` RGBA PNG (`frames` tall when animated) of blotchy pixels, which compress
+/// about as well as real textures do.
+fn png(noise: &mut Noise, side: u32, frames: u32, alpha: bool) -> Vec<u8> {
+    let mut out = Vec::new();
+    {
+        let mut encoder = png::Encoder::new(&mut out, side, side * frames);
+        encoder.set_color(png::ColorType::Rgba);
+        encoder.set_depth(png::BitDepth::Eight);
+        let mut writer = encoder.write_header().unwrap();
+        let mut pixels = Vec::with_capacity((side * side * frames * 4) as usize);
+        let mut colour = [0u8; 4];
+        for i in 0..side * side * frames {
+            if i % 3 == 0 {
+                let n = noise.next();
+                colour = [n as u8, (n >> 8) as u8, (n >> 16) as u8, 255];
+                if alpha && n >> 40 & 3 == 0 {
+                    colour[3] = 0;
+                }
+            }
+            pixels.extend_from_slice(&colour);
+        }
+        writer.write_image_data(&pixels).unwrap();
+    }
+    out
+}
+
+fn model(noise: &mut Noise, namespace: &str, texture: &str) -> Vec<u8> {
+    let n = noise.next() % 4;
+    format!(
+        r##"{{"parent":"minecraft:block/cube_all","textures":{{"all":"{namespace}:{texture}"}},"elements":[{{"from":[0,0,0],"to":[16,{h},16],"faces":{{"north":{{"texture":"#all","uv":[0,0,16,16]}},"up":{{"texture":"#all"}}}}}}]}}"##,
+        h = 4 + n * 4
+    )
+    .into_bytes()
+}
+
+fn write(root: &Path, name: &str, bytes: &[u8]) {
+    let path = root.join(name);
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    fs::write(path, bytes).unwrap();
+}
+
+/// A deflated zip written by hand (the reader skips CRCs, so they stay zero), at most 65535
+/// entries.
+#[derive(Default)]
+struct ZipOut {
+    out: Vec<u8>,
+    central: Vec<u8>,
+    count: u16,
+}
+impl ZipOut {
+    fn put(&mut self, name: &str, body: &[u8]) {
+        let data = miniz_oxide::deflate::compress_to_vec(body, 6);
+        let offset = u32::try_from(self.out.len()).unwrap();
+        let sizes = [data.len() as u32, body.len() as u32];
+        self.out.extend(0x0403_4b50u32.to_le_bytes());
+        self.out.extend([20, 0, 0, 0, 8, 0]);
+        self.out.extend([0; 8]);
+        sizes.iter().for_each(|s| self.out.extend(s.to_le_bytes()));
+        self.out.extend((name.len() as u16).to_le_bytes());
+        self.out.extend([0; 2]);
+        self.out.extend(name.as_bytes());
+        self.out.extend(&data);
+        self.central.extend(0x0201_4b50u32.to_le_bytes());
+        self.central.extend([20, 0, 20, 0, 0, 0, 8, 0]);
+        self.central.extend([0; 8]);
+        sizes
+            .iter()
+            .for_each(|s| self.central.extend(s.to_le_bytes()));
+        self.central.extend((name.len() as u16).to_le_bytes());
+        self.central.extend([0; 12]);
+        self.central.extend(offset.to_le_bytes());
+        self.central.extend(name.as_bytes());
+        self.count = self.count.checked_add(1).expect("too many zip entries");
+    }
+    fn finish(mut self, path: &Path) {
+        let start = self.out.len() as u32;
+        self.out.extend(&self.central);
+        self.out.extend(0x0605_4b50u32.to_le_bytes());
+        self.out.extend([0; 4]);
+        self.out.extend(self.count.to_le_bytes());
+        self.out.extend(self.count.to_le_bytes());
+        self.out.extend((self.central.len() as u32).to_le_bytes());
+        self.out.extend(start.to_le_bytes());
+        self.out.extend([0; 2]);
+        fs::write(path, self.out).unwrap();
+    }
+}
+
+const META: &[u8] = br#"{"pack":{"description":"bench","min_format":[69,0],"max_format":[999,0]}}"#;
+
+/// The stand-in game resources: vanilla-sized texture folders, models and the stacked JSON
+/// files (lang, sounds, fonts, atlases) every reload merges.
+fn vanilla(root: &Path, scale: usize, noise: &mut Noise) -> Vec<String> {
+    let mut blocks = Vec::new();
+    for i in 0..1100 * scale {
+        let name = format!("block/b{i}");
+        let frames = if i % 50 == 0 { 8 } else { 1 };
+        write(
+            root,
+            &format!("assets/minecraft/textures/{name}.png"),
+            &png(noise, 16, frames, i % 7 == 0),
+        );
+        if frames > 1 {
+            write(
+                root,
+                &format!("assets/minecraft/textures/{name}.png.mcmeta"),
+                br#"{"animation":{"frametime":2}}"#,
+            );
+        }
+        write(
+            root,
+            &format!("assets/minecraft/models/block/b{i}.json"),
+            &model(noise, "minecraft", &name),
+        );
+        blocks.push(format!("minecraft:{name}"));
+    }
+    for (folder, count, side) in [("item", 1500, 16), ("entity", 900, 64), ("gui", 800, 16)] {
+        for i in 0..count * scale {
+            let sub = if folder == "gui" { "sprites/" } else { "" };
+            write(
+                root,
+                &format!(
+                    "assets/minecraft/textures/{folder}/{sub}{}/t{i}.png",
+                    i % 20
+                ),
+                &png(noise, side, 1, true),
+            );
+        }
+    }
+    for i in 0..1500 * scale {
+        write(
+            root,
+            &format!("assets/minecraft/models/item/i{i}.json"),
+            &model(noise, "minecraft", &format!("item/{}/t{i}", i % 20)),
+        );
+    }
+    let lang: String = (0..4000)
+        .map(|i| format!("\"key.{i}\":\"Value {i}\""))
+        .collect::<Vec<_>>()
+        .join(",");
+    write(
+        root,
+        "assets/minecraft/lang/en_us.json",
+        format!("{{{lang}}}").as_bytes(),
+    );
+    write(
+        root,
+        "assets/minecraft/sounds.json",
+        br#"{"a":{"sounds":["a"]}}"#,
+    );
+    write(
+        root,
+        "assets/minecraft/atlases/blocks.json",
+        br#"{"sources":[{"type":"directory","source":"block","prefix":"block/"}]}"#,
+    );
+    write(root, "pack.mcmeta", META);
+    blocks
+}
+
+/// A server pack the way ItemsAdder-style plugins make them: one zip of many namespaces, each
+/// with its own items' textures and models, its sounds and its lang files.
+fn server_zip(path: &Path, scale: usize, noise: &mut Noise) {
+    let mut zip = ZipOut::default();
+    zip.put("pack.mcmeta", META);
+    for n in 0..190 {
+        let ns = format!("plugin{n}");
+        for i in 0..50 * scale {
+            let texture = format!("item/{}/t{i}", i % 5);
+            zip.put(
+                &format!("assets/{ns}/textures/{texture}.png"),
+                &png(noise, 32, 1, true),
+            );
+            zip.put(
+                &format!("assets/{ns}/models/item/{}/m{i}.json", i % 5),
+                &model(noise, &ns, &texture),
+            );
+            if i % 10 == 0 {
+                zip.put(&format!("assets/{ns}/sounds/s{i}.ogg"), &[0; 2048]);
+            }
+        }
+        zip.put(
+            &format!("assets/{ns}/lang/en_us.json"),
+            br#"{"item.custom":"Custom"}"#,
+        );
+    }
+    let lang: String = (0..2000)
+        .map(|i| format!("\"server.{i}\":\"Server {i}\""))
+        .collect::<Vec<_>>()
+        .join(",");
+    zip.put(
+        "assets/minecraft/lang/en_us.json",
+        format!("{{{lang}}}").as_bytes(),
+    );
+    zip.finish(path);
+}
+
+/// A 64x pack over vanilla's own block, item and entity textures, with OptiFine CTM-style
+/// tiles beside them: what the big OptiFine packs look like on disk.
+fn hd_zip(path: &Path, scale: usize, noise: &mut Noise) {
+    let mut zip = ZipOut::default();
+    zip.put("pack.mcmeta", META);
+    for i in 0..1100 * scale {
+        zip.put(
+            &format!("assets/minecraft/textures/block/b{i}.png"),
+            &png(noise, 64, 1, i % 7 == 0),
+        );
+        if i % 4 == 0 {
+            for tile in 0..12 {
+                zip.put(
+                    &format!("assets/minecraft/optifine/ctm/b{i}/{tile}.png"),
+                    &png(noise, 64, 1, false),
+                );
+            }
+            zip.put(
+                &format!("assets/minecraft/optifine/ctm/b{i}/b{i}.properties"),
+                format!("matchTiles=b{i}\nmethod=ctm\ntiles=0-11\n").as_bytes(),
+            );
+        }
+    }
+    for i in 0..750 * scale {
+        zip.put(
+            &format!("assets/minecraft/textures/item/{}/t{i}.png", i % 20),
+            &png(noise, 64, 1, true),
+        );
+    }
+    zip.finish(path);
+}
+
+fn median(mut ms: Vec<f64>) -> f64 {
+    ms.sort_by(f64::total_cmp);
+    ms[ms.len() / 2]
+}
+
+/// `f`'s median time over `runs`, with `before` (not timed) ahead of each run.
+fn time(runs: usize, mut before: impl FnMut(), mut f: impl FnMut()) -> f64 {
+    median(
+        (0..runs)
+            .map(|_| {
+                before();
+                let started = Instant::now();
+                f();
+                started.elapsed().as_secs_f64() * 1000.0
+            })
+            .collect(),
+    )
+}
+
+fn zip_pack(id: &str, path: PathBuf) -> Pack {
+    // Read the way `packs::folder` reads a `resourcepacks/` zip.
+    let dir = path.parent().unwrap().join(format!("{id}-dir"));
+    fs::create_dir_all(&dir).unwrap();
+    let at = dir.join(path.file_name().unwrap());
+    fs::rename(&path, &at).unwrap();
+    packs::folder(&dir, packs::RESOURCE_FORMAT)
+        .into_iter()
+        .next()
+        .unwrap_or_else(|| panic!("{id} is not a pack"))
+}
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    let scale = args
+        .iter()
+        .position(|a| a == "--scale")
+        .and_then(|i| args.get(i + 1))
+        .map_or(1, |s| s.parse().unwrap());
+    let runs = 3;
+    let scratch = std::env::temp_dir().join(format!("horizon-pack-bench-{}", std::process::id()));
+    let _ = fs::remove_dir_all(&scratch);
+    fs::create_dir_all(&scratch).unwrap();
+    let mut noise = Noise(0x9e37_79b9_7f4a_7c15);
+    let vanilla_root = scratch.join("vanilla");
+    let blocks = vanilla(&vanilla_root, scale, &mut noise);
+    server_zip(&scratch.join("server.zip"), scale, &mut noise);
+    hd_zip(&scratch.join("hd.zip"), scale, &mut noise);
+    let server = zip_pack("server", scratch.join("server.zip"));
+    let hd = zip_pack("hd", scratch.join("hd.zip"));
+    let cache = scratch.join("cache");
+    let both = [hd.clone(), server.clone()];
+
+    let mut rows: Vec<(String, f64)> = Vec::new();
+    let mut row = |name: &str, ms: f64| {
+        eprintln!("{name}: {ms:.1} ms");
+        rows.push((name.to_owned(), ms));
+    };
+    let fresh = || {
+        let _ = fs::remove_dir_all(&cache);
+    };
+    row(
+        "overlay: build, both packs (cold)",
+        time(runs, fresh, || {
+            packs::resource_root(&vanilla_root, &both, &cache).unwrap();
+        }),
+    );
+    let root = packs::resource_root(&vanilla_root, &both, &cache).unwrap();
+    row(
+        "overlay: reuse, both packs (cache hit)",
+        time(
+            runs,
+            || {},
+            || {
+                packs::resource_root(&vanilla_root, &both, &cache).unwrap();
+            },
+        ),
+    );
+    // The pack screen: one pack turned off, then on again.
+    row(
+        "overlay: toggle the server pack off (new selection)",
+        time(
+            runs,
+            || {
+                let only =
+                    packs::resource_root(&vanilla_root, std::slice::from_ref(&hd), &cache).unwrap();
+                fs::remove_dir_all(&only).unwrap();
+            },
+            || {
+                packs::resource_root(&vanilla_root, std::slice::from_ref(&hd), &cache).unwrap();
+            },
+        ),
+    );
+    row(
+        "models: parse every model",
+        time(
+            runs,
+            || {},
+            || {
+                std::hint::black_box(ParsedModels::load(&root));
+            },
+        ),
+    );
+    let sprite_cache = root.join("horizon-sprites.cache");
+    // OptiFine connected-texture tiles, inserted by their path as `ConnectedTextures` does.
+    let tiles: Vec<String> = (0..1100 * scale)
+        .step_by(4)
+        .flat_map(|i| (0..12).map(move |t| format!("assets/minecraft/optifine/ctm/b{i}/{t}.png")))
+        .collect();
+    let sprites = |cold: bool, prefetch: bool, names: &[String], files: bool| {
+        time(
+            runs,
+            || {
+                if cold {
+                    let _ = fs::remove_file(&sprite_cache);
+                }
+            },
+            || {
+                let mut sprites = Sprites::with_disk_cache(&root);
+                if prefetch {
+                    sprites.prefetch(&root, names.iter().map(String::as_str));
+                }
+                for name in names {
+                    if files {
+                        sprites.insert_file(&root, name).unwrap();
+                    } else {
+                        sprites.insert(&root, name).unwrap();
+                    }
+                }
+                sprites.save_disk_cache();
+                sprites.finish();
+                std::hint::black_box(&sprites.pixels);
+            },
+        )
+    };
+    row(
+        "block sprites: one by one (no cache)",
+        sprites(true, false, &blocks, false),
+    );
+    row(
+        "block sprites: prefetched (no cache)",
+        sprites(true, true, &blocks, false),
+    );
+    row(
+        "block sprites: from the disk cache",
+        sprites(false, false, &blocks, false),
+    );
+    row("CTM tiles: one by one", sprites(false, false, &tiles, true));
+    row("CTM tiles: prefetched", sprites(false, true, &tiles, true));
+    row(
+        "GUI atlas: decode and stitch, both packs",
+        time(
+            runs,
+            || {},
+            || {
+                if let Err(e) = HudAtlas::build_over(&root, &vanilla_root) {
+                    eprintln!("GUI atlas failed: {e}");
+                }
+            },
+        ),
+    );
+    row(
+        "GUI atlas: vanilla alone",
+        time(
+            runs,
+            || {},
+            || {
+                let _ = HudAtlas::build(&vanilla_root);
+            },
+        ),
+    );
+
+    let cores = std::thread::available_parallelism().map_or(1, |n| n.get());
+    println!("| Stage (scale {scale}, {cores} threads, median of {runs}) | ms |");
+    println!("|---|---:|");
+    for (name, ms) in &rows {
+        println!("| {name} | {ms:.0} |");
+    }
+    let _ = fs::remove_dir_all(&scratch);
+}
@@ -101,6 +101,8 @@ pub struct RenderAssets {
    pub pbr_normals: Vec<u8>,
    pub pbr_specular: Vec<u8>,
    pub pbr_size: u32,
+    /// OptiFine connected textures (empty without `optifine/ctm` files).
+    pub connected: crate::connected::ConnectedTextures,
 }
 fn invalid(message: &str) -> io::Error {
    io::Error::new(io::ErrorKind::InvalidData, message)
@@ -240,9 +242,34 @@ impl RenderAssets {
        for stage in 0..10 {
            sprites.insert(root, &format!("minecraft:block/destroy_stage_{stage}"))?;
        }
-        if draws {
+        let connected = if draws {
            crate::native_emissive::load(root, &mut sprites);
-        }
+            // A side's sprite, for rules that connect by tile: the first quad facing it.
+            let catalog = &models.catalog;
+            let mut found = Vec::new();
+            crate::connected::ConnectedTextures::load(
+                root,
+                registry,
+                &mut sprites,
+                |state, face| {
+                    let side = horizon_assets::model::Direction::ALL[face as usize];
+                    catalog
+                        .models_at(
+                            state,
+                            horizon_core::position::BlockPos::new(0, 0, 0),
+                            &mut found,
+                        )
+                        .ok()?;
+                    found
+                        .iter()
+                        .flat_map(|m| &m.faces)
+                        .find(|f| f.quad.facing == side)
+                        .map(|f| f.layer)
+                },
+            )
+        } else {
+            Default::default()
+        };
        sprites.save_disk_cache();
        if draws {
            sprites.finish();
@@ -267,6 +294,7 @@ impl RenderAssets {
            pbr_normals: sprites.normals,
            pbr_specular: sprites.specular,
            pbr_size: sprites.pbr_size,
+            connected,
        })
    }
 }
@@ -172,6 +172,7 @@ fn color(v: &Value) -> Option<u32> {
 fn colormap(root: &Path, name: &str) -> Result<Vec<u32>> {
    let path = root.join(format!("assets/minecraft/textures/colormap/{name}.png"));
    let mut decoder = png::Decoder::new(std::io::BufReader::new(fs::File::open(path)?));
+    decoder.ignore_checksums(true);
    decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
    let mut reader = decoder.read_info()?;
    let mut bytes = vec![0; reader.output_buffer_size().ok_or("colormap too large")?];
@@ -0,0 +1,306 @@
+//! Bulk block edits: runs of blocks up columns written straight into the
+//! resident sections, a section unpacked and packed once however many of its
+//! blocks change, instead of a `World::set` per block. Nothing round them is
+//! told (as `fill ... strict`); the light of each chunk changed is worked out
+//! again whole, off the game thread, rather than block by block, and each
+//! section changed is remeshed once.
+use crate::chunk::index;
+use crate::fast_hash::FxHashMap;
+use crate::world::World;
+
+/// A run of one column, resolved: blocks `y0..=y1` of column (x, z) set to
+/// `state` where filter `only` (if any) passes the block there.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Run {
+    pub x: i32,
+    pub z: i32,
+    pub y0: i32,
+    pub y1: i32,
+    pub state: u32,
+    pub only: Option<u16>,
+}
+
+/// What an edit changed.
+#[derive(Debug, Default)]
+pub struct Outcome {
+    /// Blocks changed.
+    pub changed: u64,
+    /// Chunks with a change.
+    pub chunks: usize,
+    /// Changes of the states `tracked` asked for (block entities, watched
+    /// blocks): position, previous and new state.
+    pub tracked: Vec<((i32, i32, i32), u32, u32)>,
+}
+
+/// Per state answers, worked out once each.
+struct Memo(Vec<u8>);
+impl Memo {
+    #[inline]
+    fn get(&mut self, state: u32, ask: impl FnOnce(u32) -> bool) -> bool {
+        let i = state as usize;
+        if i >= self.0.len() {
+            self.0.resize(i + 1, 0);
+        }
+        if self.0[i] == 0 {
+            self.0[i] = 1 + u8::from(ask(state));
+        }
+        self.0[i] == 2
+    }
+}
+
+impl World {
+    /// Make `runs` in order, each seeing the changes of those before it.
+    /// `matches(filter, state)` says whether a filter passes a state, and
+    /// `tracked(state)` whether its changes are reported; each is asked once
+    /// per state. Runs in unloaded chunks and the parts of runs outside each
+    /// chunk's own column (`Chunk::layout`) are left out.
+    ///
+    /// Unlike `World::set`, this records nothing per block: no
+    /// `block_entities.state_changed` (a caller adds or removes block
+    /// entities itself, from `Outcome::tracked`), no `watched_writes` (ask
+    /// for those states through `tracked`), no `block_log` entry (the chunk
+    /// goes in `bulk_log` instead, sent whole), no `path_writes` (mobs'
+    /// paths are not recomputed for these blocks) and no `light_edits` (the
+    /// chunk and its neighbours are lit again whole, through `dirty_light`).
+    pub fn edit_runs(
+        &mut self,
+        runs: &[Run],
+        mut matches: impl FnMut(u16, u32) -> bool,
+        mut tracked: impl FnMut(u32) -> bool,
+    ) -> Outcome {
+        let mut out = Outcome::default();
+        // the runs of each chunk, in order, and the chunks in the order they were first named
+        let mut by_chunk: FxHashMap<(i32, i32), Vec<u32>> = FxHashMap::default();
+        let mut order = Vec::new();
+        for (i, r) in runs.iter().enumerate() {
+            if r.y1 < r.y0 {
+                continue;
+            }
+            let key = (r.x >> 4, r.z >> 4);
+            by_chunk
+                .entry(key)
+                .or_insert_with(|| {
+                    order.push(key);
+                    Vec::new()
+                })
+                .push(i as u32);
+        }
+        let mut filter_memo: Vec<Memo> = Vec::new();
+        let mut tracked_memo = Memo(Vec::new());
+        let mut values: Vec<Option<Box<[u32; 4096]>>> = Vec::new();
+        let mut changed: Vec<bool> = Vec::new();
+        for key in order {
+            let Some(chunk) = self.chunks.get(&key) else {
+                continue;
+            };
+            let (min_y, sections) = (chunk.min_y(), chunk.sections.len());
+            let max_y = chunk.max_y();
+            let list = &by_chunk[&key];
+            changed.clear();
+            changed.resize(sections, false);
+            values.clear();
+            values.resize_with(sections, || None);
+            let mut any = 0u64;
+            for &i in list {
+                let r = runs[i as usize];
+                let (lx, lz) = (r.x & 15, r.z & 15);
+                let (y0, y1) = (r.y0.max(min_y), r.y1.min(max_y - 1));
+                let mut y = y0;
+                while y <= y1 {
+                    let s = ((y - min_y) >> 4) as usize;
+                    let top = (min_y + (s as i32 + 1) * 16 - 1).min(y1);
+                    let vals = values[s].get_or_insert_with(|| {
+                        let mut v = Box::new([0u32; 4096]);
+                        chunk.sections[s].unpack(&mut v);
+                        v
+                    });
+                    for yy in y..=top {
+                        let at = index(lx, yy, lz);
+                        let old = vals[at];
+                        if old == r.state {
+                            continue;
+                        }
+                        if let Some(f) = r.only {
+                            let f = f as usize;
+                            if filter_memo.len() <= f {
+                                filter_memo.resize_with(f + 1, || Memo(Vec::new()));
+                            }
+                            if !filter_memo[f].get(old, |s| matches(f as u16, s)) {
+                                continue;
+                            }
+                        }
+                        vals[at] = r.state;
+                        changed[s] = true;
+                        any += 1;
+                        if tracked_memo.get(old, &mut tracked)
+                            || tracked_memo.get(r.state, &mut tracked)
+                        {
+                            out.tracked.push(((r.x, yy, r.z), old, r.state));
+                        }
+                    }
+                    y = top + 1;
+                }
+            }
+            if any == 0 {
+                continue;
+            }
+            out.changed += any;
+            out.chunks += 1;
+            let chunk =
+                std::sync::Arc::make_mut(self.chunks.get_mut(&key).expect("looked up above"));
+            for s in 0..sections {
+                if changed[s]
+                    && let Some(v) = &values[s]
+                {
+                    chunk.replace_blocks(s, v);
+                }
+            }
+            self.revision = self.revision.wrapping_add(1);
+            self.modified.insert(key);
+            if self.block_log.is_some() {
+                self.bulk_log.insert(key);
+            }
+            // remeshed once (with the neighbours whose faces and light it touches), lit again whole
+            for (s, _) in changed.iter().enumerate().filter(|c| *c.1) {
+                for ds in -1..=1 {
+                    let sy = s as i32 + ds;
+                    if !(0..sections as i32).contains(&sy) {
+                        continue;
+                    }
+                    for dz in -1..=1 {
+                        for dx in -1..=1 {
+                            self.dirty_sections.insert((key.0 + dx, sy, key.1 + dz));
+                        }
+                    }
+                }
+            }
+            for dz in -1..=1 {
+                for dx in -1..=1 {
+                    self.dirty_light.insert((key.0 + dx, key.1 + dz));
+                }
+            }
+        }
+        out
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::chunk::Chunk;
+    use horizon_world::registry::BlockStateId;
+    use std::sync::Arc;
+
+    fn world() -> World {
+        let mut w = World::new(BlockStateId(0), 0);
+        for cz in -1..=1 {
+            for cx in -1..=1 {
+                w.chunks.insert((cx, cz), Arc::new(Chunk::empty(cx, cz)));
+            }
+        }
+        // stone up to y 63
+        for z in -16..32 {
+            for x in -16..32 {
+                for y in -64..64 {
+                    w.set(x, y, z, BlockStateId(1)).unwrap();
+                }
+            }
+        }
+        w.dirty_light.clear();
+        w.dirty_sections.clear();
+        w.block_log = Some(Vec::new());
+        w
+    }
+    fn run(x: i32, z: i32, y0: i32, y1: i32, state: u32, only: Option<u16>) -> Run {
+        Run {
+            x,
+            z,
+            y0,
+            y1,
+            state,
+            only,
+        }
+    }
+
+    #[test]
+    fn runs_change_their_blocks_in_order() {
+        let mut w = world();
+        let runs = [
+            run(3, 4, 10, 40, 0, None),
+            run(3, 4, 10, 12, 5, None),
+            // only where it is air: over the stone, and the three blocks of 5 stay
+            run(3, 4, 0, 80, 7, Some(0)),
+            run(-1, 20, -70, 400, 9, None),
+        ];
+        let out = w.edit_runs(&runs, |_, s| s == 0, |_| false);
+        assert_eq!(w.block(3, 9, 4).0, 1);
+        assert_eq!(w.block(3, 11, 4).0, 5);
+        assert_eq!(w.block(3, 13, 4).0, 7);
+        assert_eq!(w.block(3, 70, 4).0, 7);
+        assert_eq!(w.block(3, 81, 4).0, 0);
+        assert_eq!(w.block(3, 0, 4).0, 1);
+        assert_eq!(w.block(-1, -64, 20).0, 9);
+        assert_eq!(w.block(-1, 319, 20).0, 9);
+        assert_eq!(w.block(0, 30, 20).0, 1);
+        // 31 dug, 3 set again, the air over them filled (28, and 17 over the stone), the whole of the other column
+        assert_eq!(out.changed, 31 + 3 + 45 + 384);
+        assert_eq!(out.chunks, 2);
+        assert!(w.bulk_log.contains(&(0, 0)) && w.bulk_log.contains(&(-1, 1)));
+        assert!(w.dirty_light.contains(&(1, 1)) && w.dirty_light.contains(&(-2, 2)));
+        assert!(w.dirty_sections.contains(&(1, 4, 1)));
+        // the per-block log is left to the blocks set one at a time
+        assert!(w.block_log.as_ref().unwrap().is_empty());
+    }
+
+    #[test]
+    fn unloaded_chunks_and_unchanged_blocks_are_left_out() {
+        let mut w = world();
+        let out = w.edit_runs(
+            &[run(100, 100, 0, 10, 0, None), run(0, 0, 0, 10, 1, None)],
+            |_, _| true,
+            |_| false,
+        );
+        assert_eq!(out.changed, 0);
+        assert_eq!(out.chunks, 0);
+        assert!(w.bulk_log.is_empty() && w.dirty_light.is_empty());
+    }
+
+    #[test]
+    fn tracked_states_are_reported() {
+        let mut w = world();
+        let out = w.edit_runs(&[run(1, 1, 60, 65, 3, None)], |_, _| true, |s| s == 3);
+        assert_eq!(out.tracked.len(), 6);
+        assert_eq!(out.tracked[0], ((1, 60, 1), 1, 3));
+        assert_eq!(out.tracked[5], ((1, 65, 1), 0, 3));
+    }
+
+    #[test]
+    fn heightmaps_follow_the_edit() {
+        let mut w = world();
+        let air = |s: u32| s == 0;
+        assert_eq!(w.world_surface(5, 5, |s| air(s.0)), 64);
+        w.edit_runs(&[run(5, 5, 20, 63, 0, None)], |_, _| true, |_| false);
+        assert_eq!(w.world_surface(5, 5, |s| air(s.0)), 20);
+        w.edit_runs(&[run(5, 5, 90, 90, 2, None)], |_, _| true, |_| false);
+        assert_eq!(w.world_surface(5, 5, |s| air(s.0)), 91);
+    }
+
+    #[test]
+    fn runs_follow_each_chunks_own_layout() {
+        use crate::chunk::ColumnLayout;
+        // a data pack's taller dimension: -128..=511
+        let tall = ColumnLayout::new(-128, 640).unwrap();
+        let mut w = World::new(BlockStateId(0), 0);
+        w.chunks
+            .insert((0, 0), Arc::new(Chunk::with_layout(0, 0, tall)));
+        let out = w.edit_runs(&[run(2, 3, -500, 900, 4, None)], |_, _| true, |_| false);
+        assert_eq!(out.changed, 640);
+        let chunk = &w.chunks[&(0, 0)];
+        assert_eq!(chunk.block(2, -128, 3).0, 4);
+        assert_eq!(chunk.block(2, -65, 3).0, 4);
+        assert_eq!(chunk.block(2, 320, 3).0, 4);
+        assert_eq!(chunk.block(2, 511, 3).0, 4);
+        assert!(w.dirty_sections.contains(&(0, 39, 0)));
+        assert!(!w.dirty_sections.contains(&(0, 40, 0)));
+    }
+}
@@ -23,7 +23,7 @@
 //! Which states tick is a table by state id, built by the game from the block
 //! registry; whether a slot is made is decided when the slot is promoted at
 //! the start of the next tick, from the block state then.
-use crate::chunk::block_entity::{BlockEntity, ModContainer, ModFluidTanks};
+use crate::chunk::block_entity::{BlockEntity, ModContainer, ModEnergyBuffer, ModFluidTanks};
 use crate::fast_hash::{FxHashMap, FxHashSet};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -76,6 +76,29 @@ pub struct BlockEntities {
    /// The fluid tanks of mod blocks' block entities, by block state id;
    /// built with `states`, like the containers.
    mod_fluids: FxHashMap<u32, Arc<ModFluidTanks>>,
+    /// The energy buffers of mod blocks' block entities, by block state id;
+    /// built with `states`, like the containers.
+    mod_energy: FxHashMap<u32, Arc<ModEnergyBuffer>>,
+    /// The positions of the mod block entities (`BlockEntity::Mod`) by chunk,
+    /// for the renderer: the mesher lists block entities by their template,
+    /// which leaves out a mod block whose template has none. One taken out
+    /// (`take`) stays listed until `put` or `remove`.
+    mods: FxHashMap<(i32, i32), FxHashSet<Pos>>,
+}
+
+fn chunk_of((x, _, z): Pos) -> (i32, i32) {
+    (x >> 4, z >> 4)
+}
+
+/// Takes `pos` out of its chunk's mod block entity set.
+fn forget_mod(mods: &mut FxHashMap<(i32, i32), FxHashSet<Pos>>, pos: Pos) {
+    let chunk = chunk_of(pos);
+    if let Some(set) = mods.get_mut(&chunk) {
+        set.remove(&pos);
+        if set.is_empty() {
+            mods.remove(&chunk);
+        }
+    }
 }

 impl std::ops::Deref for BlockEntities {
@@ -172,6 +195,13 @@ impl BlockEntities {
    pub fn mod_fluids(&self, state: u32) -> Option<&Arc<ModFluidTanks>> {
        self.mod_fluids.get(&state)
    }
+    pub fn set_mod_energy(&mut self, energy: FxHashMap<u32, Arc<ModEnergyBuffer>>) {
+        self.mod_energy = energy;
+    }
+    /// The energy buffer of a mod block's block entity in block state `state`.
+    pub fn mod_energy(&self, state: u32) -> Option<&Arc<ModEnergyBuffer>> {
+        self.mod_energy.get(&state)
+    }

    fn next(&mut self) -> u32 {
        let n = self.next_slot;
@@ -190,6 +220,23 @@ impl BlockEntities {
        self.pending.remove(pos);
    }

+    /// Whether any mod block entity is in the map: until one is, a block change
+    /// never looks one up (`LevelAccess::has_mod_block_entity`).
+    pub fn has_mods(&self) -> bool {
+        !self.mods.is_empty()
+    }
+    /// The mod block entities within `radius` blocks of `x`, `z` (by chunk, so
+    /// far ones are skipped whole; the caller checks each distance).
+    pub fn mods_near(&self, x: f64, z: f64, radius: f64) -> impl Iterator<Item = &Pos> {
+        let far = move |c: i32, at: f64| {
+            let (lo, hi) = (f64::from(c * 16), f64::from(c * 16 + 16));
+            at < lo - radius || at > hi + radius
+        };
+        self.mods
+            .iter()
+            .filter(move |((cx, cz), _)| !far(*cx, x) && !far(*cz, z))
+            .flat_map(|(_, set)| set)
+    }
    pub fn get_mut(&mut self, pos: &Pos) -> Option<&mut BlockEntity> {
        self.map.get_mut(pos)
    }
@@ -202,10 +249,16 @@ impl BlockEntities {
    /// `LevelChunk.setBlockEntity` (+ `addAndRegisterBlockEntity`): a new
    /// block entity may get a slot; one replacing another keeps its slot.
    pub fn insert(&mut self, pos: Pos, entity: BlockEntity) -> Option<BlockEntity> {
+        let new_is_mod = matches!(entity, BlockEntity::Mod(_));
        let old = self.map.insert(pos, entity);
        if old.is_none() {
            self.add(pos);
        }
+        if new_is_mod {
+            self.mods.entry(chunk_of(pos)).or_default().insert(pos);
+        } else if matches!(old, Some(BlockEntity::Mod(_))) {
+            forget_mod(&mut self.mods, pos);
+        }
        old
    }
    /// The block entity at `pos`, made by `make` when there is none.
@@ -214,15 +267,24 @@ impl BlockEntities {
        pos: Pos,
        make: impl FnOnce() -> BlockEntity,
    ) -> &mut BlockEntity {
-        if !self.map.contains_key(&pos) {
+        let absent = !self.map.contains_key(&pos);
+        if absent {
            self.add(pos);
        }
-        self.map.entry(pos).or_insert_with(make)
+        let entity = self.map.entry(pos).or_insert_with(make);
+        if absent && matches!(entity, BlockEntity::Mod(_)) {
+            self.mods.entry(chunk_of(pos)).or_default().insert(pos);
+        }
+        entity
    }
    /// `LevelChunk.removeBlockEntity`: the block entity and its slot.
    pub fn remove(&mut self, pos: &Pos) -> Option<BlockEntity> {
        self.cancel(pos);
-        self.map.remove(pos)
+        let removed = self.map.remove(pos);
+        if matches!(removed, Some(BlockEntity::Mod(_))) {
+            forget_mod(&mut self.mods, *pos);
+        }
+        removed
    }
    /// The block entity at `pos`, out of the map for a while: its slot stays
    /// for `put` to bring it back (a tick working on it).
@@ -236,6 +298,9 @@ impl BlockEntities {
    /// Brings back what `take` took, in its slot.
    pub fn put(&mut self, pos: Pos, entity: BlockEntity) {
        self.out.remove(&pos);
+        if matches!(entity, BlockEntity::Mod(_)) {
+            self.mods.entry(chunk_of(pos)).or_default().insert(pos);
+        }
        if self.map.insert(pos, entity).is_none()
            && !self.live.contains_key(&pos)
            && !self.pending.contains_key(&pos)
@@ -247,17 +312,20 @@ impl BlockEntities {
    /// (`clearAllBlockEntities` of unloaded chunks).
    pub fn retain(&mut self, mut keep: impl FnMut(&Pos, &mut BlockEntity) -> bool) {
        let (live, pending, freed) = (&mut self.live, &mut self.pending, &mut self.freed);
+        let mods = &mut self.mods;
        self.map.retain(|p, e| {
            let kept = keep(p, e);
            if !kept {
                *freed |= live.remove(p).is_some();
                pending.remove(p);
+                forget_mod(mods, *p);
            }
            kept
        });
    }
    pub fn clear(&mut self) {
        self.map.clear();
+        self.mods.clear();
        self.tickers = Arc::default();
        self.live.clear();
        self.added.clear();
@@ -274,9 +342,16 @@ impl BlockEntities {
    pub fn load_chunk(&mut self, entities: Vec<(Pos, BlockEntity)>) {
        let order = chunk_map_order(entities.iter().map(|(p, _)| *p));
        for (p, e) in entities {
-            if self.map.insert(p, e).is_some() {
+            let new_is_mod = matches!(e, BlockEntity::Mod(_));
+            let old = self.map.insert(p, e);
+            if old.is_some() {
                self.replaced.insert(p);
            }
+            if new_is_mod {
+                self.mods.entry(chunk_of(p)).or_default().insert(p);
+            } else if matches!(old, Some(BlockEntity::Mod(_))) {
+                forget_mod(&mut self.mods, p);
+            }
        }
        for p in order {
            self.add(p);
@@ -369,6 +444,38 @@ mod tests {
            .collect()
    }

+    fn near(b: &BlockEntities, x: f64, z: f64, radius: f64) -> Vec<Pos> {
+        let mut found: Vec<Pos> = b.mods_near(x, z, radius).copied().collect();
+        found.sort();
+        found
+    }
+    #[test]
+    fn mod_block_entities_are_listed_by_chunk_until_they_go() {
+        let mut b = level();
+        let modded = || BlockEntity::Mod(Box::default());
+        b.insert((1, 64, 1), modded());
+        b.insert((200, 64, 1), modded());
+        b.insert((2, 64, 2), hopper());
+        b.get_or_insert_with((3, 64, 3), modded);
+        b.load_chunk(vec![((4, 64, 4), modded()), ((5, 64, 5), hopper())]);
+        // Only mods, and only chunks within reach.
+        assert_eq!(
+            near(&b, 0.0, 0.0, 64.0),
+            [(1, 64, 1), (3, 64, 3), (4, 64, 4)]
+        );
+        assert_eq!(near(&b, 200.0, 0.0, 8.0), [(200, 64, 1)]);
+        // Taken out for a tick, still listed; removed or replaced, gone.
+        let taken = b.take(&(1, 64, 1)).unwrap();
+        assert_eq!(near(&b, 0.0, 0.0, 64.0).len(), 3);
+        b.put((1, 64, 1), taken);
+        b.remove(&(3, 64, 3));
+        b.insert((4, 64, 4), hopper());
+        assert_eq!(near(&b, 0.0, 0.0, 64.0), [(1, 64, 1)]);
+        b.retain(|p, _| p.0 != 1);
+        assert!(near(&b, 0.0, 0.0, 64.0).is_empty());
+        b.clear();
+        assert!(near(&b, 200.0, 0.0, 8.0).is_empty());
+    }
    #[test]
    fn slots_follow_vanilla_lifecycle() {
        let mut b = level();
@@ -29,6 +29,10 @@ pub type Signature = horizon_protocol::secure_chat::Signature;
 /// How long a message shows before a deletion replaces it
 /// (`ChatComponent.deleteMessageOrDelay`: `addedTime + 60`).
 const DELETION_DELAY: u64 = 60;
+/// The smooth chat extra: the ticks a new line takes to slide in and fade in,
+/// and how far left of its place it starts (GUI pixels).
+const INTRO_TICKS: f32 = 5.0;
+const INTRO_WIDTH: f32 = 12.0;

 /// `ChatVisiblity`: the Chat option's three values.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -233,14 +237,10 @@ impl Tag {

 /// `ChatComponent.AlphaCalculator.timeBased`: opaque for 180 ticks, then
 /// fading out quadratically over 20.
-fn time_alpha(ticks: u64, added: u64) -> f32 {
-    let delta = ticks as i64 - added as i64;
-    let mut t = delta as f64 / 200.0;
-    t = 1.0 - t;
-    t *= 10.0;
-    t = t.clamp(0.0, 1.0);
-    t *= t;
-    t as f32
+fn time_alpha(ticks: f32, added: u64) -> f32 {
+    let mut t = 1.0 - (ticks - added as f32) / 200.0;
+    t = (t * 10.0).clamp(0.0, 1.0);
+    t * t
 }
 #[derive(Default)]
 pub struct Chat {
@@ -256,6 +256,11 @@ pub struct Chat {
    scroll: usize,
    new_since_scroll: bool,
    pub options: ChatOptions,
+    /// The smooth chat extra: a new line slides in from the left while it
+    /// fades in, instead of appearing whole.
+    pub smooth: bool,
+    /// The smooth chat extra: no indicator bar at the left of a line.
+    pub hide_indicator: bool,
    /// Messages printed to stdout as `[CHAT]` (vanilla logs them).
    pub log: bool,
    /// Messages added since the start, for the control socket's events.
@@ -555,7 +560,7 @@ impl Chat {
    }
    /// `ChatComponent.extractRenderState` (background mode unless `focused`)
    /// on a screen `height` GUI pixels tall at `Hud.tickCount` `ticks`.
-    pub fn layout(&self, height: i32, ticks: u64, focused: bool) -> Vec<GuiDraw> {
+    pub fn layout(&self, height: i32, ticks: f32, focused: bool) -> Vec<GuiDraw> {
        let total = self.lines.len();
        if total == 0 {
            return Vec::new();
@@ -569,28 +574,47 @@ impl Chat {
        let entry_height = o.line_height();
        let bottom_to_text =
            (8.0 * (o.line_spacing + 1.0) - 4.0 * o.line_spacing + 0.5).floor() as i32;
+        // Vanilla's 200-tick fade reads the whole GUI ticks
+        // (`Gui.getGuiTicks`); only the smooth chat extra eases it per frame.
+        let fade_ticks = if self.smooth { ticks } else { ticks.floor() };
        let alpha_of = |line: &Line| {
            if focused {
                1.0
            } else {
-                time_alpha(ticks, line.added)
+                time_alpha(fade_ticks, line.added)
            }
        };
+        // The smooth chat extra: how far into its intro a line is, 0 at the
+        // tick it was added and 1 once it has arrived, as (alpha, offset x).
+        let intro_of = |line: &Line| {
+            if focused || !self.smooth {
+                return (1.0, 0.0);
+            }
+            let t = ((ticks - line.added as f32) / INTRO_TICKS).clamp(0.0, 1.0);
+            let eased = 1.0 - (1.0 - t) * (1.0 - t);
+            (eased, (eased - 1.0) * INTRO_WIDTH)
+        };
        let visible = total
            .saturating_sub(self.scroll)
            .min(self.lines_per_page(focused));
-        let lines: Vec<(usize, &Line, f32)> = (0..visible)
+        let lines: Vec<(usize, &Line, f32, f32)> = (0..visible)
            .rev()
            .map(|i| (i, &self.lines[i + self.scroll]))
-            .map(|(i, line)| (i, line, alpha_of(line)))
-            .filter(|(_, _, alpha)| *alpha > 1.0e-5)
+            .map(|(i, line)| {
+                let (eased, slide) = intro_of(line);
+                (i, line, alpha_of(line) * eased, slide)
+            })
+            .filter(|(_, _, alpha, _)| *alpha > 1.0e-5)
            .collect();
        let mut out = vec![GuiDraw::Push(vec![
            PoseOp::Scale(scale, scale),
            PoseOp::Translate(4.0, 0.0),
        ])];
-        for &(i, _, alpha) in &lines {
+        for &(i, _, alpha, slide) in &lines {
            let bottom = chat_bottom - i as i32 * entry_height;
+            if slide != 0.0 {
+                out.push(GuiDraw::Push(vec![PoseOp::Translate(slide, 0.0)]));
+            }
            out.push(hud_layout::fill(
                -4,
                bottom - entry_height,
@@ -598,9 +622,15 @@ impl Chat {
                bottom,
                hud_layout::as8(alpha * background_opacity) << 24,
            ));
+            if slide != 0.0 {
+                out.push(GuiDraw::Pop);
+            }
        }
-        for &(i, line, alpha) in &lines {
+        for &(i, line, alpha, slide) in &lines {
            let bottom = chat_bottom - i as i32 * entry_height;
+            if slide != 0.0 {
+                out.push(GuiDraw::Push(vec![PoseOp::Translate(slide, 0.0)]));
+            }
            let opacity = alpha * text_opacity;
            let color = hud_layout::white(opacity);
            if color >> 24 != 0 {
@@ -612,7 +642,7 @@ impl Chat {
                    shadow: true,
                });
            }
-            if let Some(tag) = &line.tag {
+            if let Some(tag) = line.tag.as_ref().filter(|_| !self.hide_indicator) {
                let color = hud_layout::as8(opacity) << 24 | tag.color & 0xFF_FFFF;
                out.push(hud_layout::fill(
                    -4,
@@ -622,6 +652,9 @@ impl Chat {
                    color,
                ));
            }
+            if slide != 0.0 {
+                out.push(GuiDraw::Pop);
+            }
        }
        if focused {
            let count = lines.len() as i32;
@@ -658,7 +691,7 @@ impl Chat {
    }
    /// Draws [`Chat::layout`] into the HUD batch, and with the chat screen
    /// open the restricted prompt above the lines.
-    pub fn draw(&self, batch: &mut HudBatch, atlas: &HudAtlas, ticks: u64, focused: bool) {
+    pub fn draw(&self, batch: &mut HudBatch, atlas: &HudAtlas, ticks: f32, focused: bool) {
        let draws = self.layout(batch.height as i32, ticks, focused);
        hud_layout::paint(batch, atlas, &draws);
        if focused && self.abilities.any_restriction() {
@@ -39,6 +39,61 @@ fn add(chat: &mut Chat, font: &Font, content: Text) {
    }
 }

+#[test]
+fn smooth_chat_slides_a_line_in_and_can_hide_the_indicator() {
+    let mut chat = Chat {
+        smooth: true,
+        ..Chat::default()
+    };
+    chat.lines.push(Line {
+        added: 0,
+        content: Text::literal("hi"),
+        tag: Some(std::sync::Arc::new(Tag::system_single_player(
+            SYSTEM_INDICATOR,
+        ))),
+    });
+    let text_alpha = |draws: &[GuiDraw]| {
+        draws.iter().find_map(|d| match d {
+            GuiDraw::Text { color, .. } => Some(color >> 24),
+            _ => None,
+        })
+    };
+    // The slide is the negative translate the line carries while it moves.
+    let slide = |draws: &[GuiDraw]| {
+        draws.iter().find_map(|d| match d {
+            GuiDraw::Push(ops) => ops.iter().find_map(|op| match op {
+                PoseOp::Translate(x, _) if *x < 0.0 => Some(*x),
+                _ => None,
+            }),
+            _ => None,
+        })
+    };
+    // The tick it arrives: fully faded out, so nothing is drawn.
+    assert_eq!(text_alpha(&chat.layout(361, 0.0, false)), None);
+    // Halfway through the intro: left of its place and still faint.
+    let halfway = chat.layout(361, INTRO_TICKS / 2.0, false);
+    assert!(slide(&halfway).is_some_and(|x| (-INTRO_WIDTH..0.0).contains(&x)));
+    let faded = text_alpha(&halfway).expect("the line shows halfway through");
+    // Settled: in place and as opaque as vanilla's line.
+    let settled = chat.layout(361, INTRO_TICKS, false);
+    assert_eq!(slide(&settled), None);
+    assert!(text_alpha(&settled).expect("settled") > faded);
+    // The extra off draws the line whole on the tick it arrives, as vanilla.
+    chat.smooth = false;
+    let plain = chat.layout(361, 0.0, false);
+    assert_eq!(slide(&plain), None);
+    assert_eq!(text_alpha(&plain), text_alpha(&settled));
+    // The indicator bar is the -4 to -2 fill at the left of the line.
+    let bar = |draws: &[GuiDraw]| {
+        draws
+            .iter()
+            .any(|d| matches!(d, GuiDraw::Fill { x0: -4, x1: -2, .. }))
+    };
+    assert!(bar(&plain));
+    chat.hide_indicator = true;
+    assert!(!bar(&chat.layout(361, 0.0, false)));
+}
+
 #[test]
 fn clicking_seed_copies_the_raw_value_only_inside_the_link() {
    let font = font();
@@ -95,7 +150,7 @@ fn click_targets_match_rendered_spans_when_scaled_wrapped_and_scrolled() {
            for scroll in [0, 3, 12] {
                chat.scroll = scroll;
                let mut links = 0;
-                for draw in chat.layout(361, 0, true) {
+                for draw in chat.layout(361, 0.0, true) {
                    if let GuiDraw::Text { text, x, y, .. } = draw {
                        let mut at = x as f64;
                        for (c, style) in text.chars() {
@@ -508,6 +508,15 @@ impl Chunk {
        }
        previous
    }
+    /// Section `s`'s block states replaced whole (a bulk edit): its storage
+    /// compacted, and the heightmaps built again on their next read.
+    pub fn replace_blocks(&mut self, s: usize, values: &[u32; 4096]) {
+        let section = Arc::make_mut(&mut self.sections[s]);
+        section.blocks = Section::from_blocks(values);
+        section.compact();
+        self.surface = OnceLock::new();
+        self.motion_blocking = OnceLock::new();
+    }
    /// `getHeight(Heightmap.Types.WORLD_SURFACE, x, z)` (`x`, `z` within the
    /// chunk): one above the highest block that isn't `air`, or the column's
    /// minimum Y.
@@ -135,6 +135,23 @@ pub struct ModFluidTanks {
    /// The tanks a drain may take from (`canTakeItemThroughFace`).
    pub outputs: Vec<usize>,
 }
+/// The energy buffer of a mod block's block entity (NeoForge's
+/// `SimpleEnergyHandler`): its capacity, the most one insert and one extract
+/// moves, and the faces a fill may come through and a drain may leave by.
+/// The amount is not here: it lives in the entity's saved compound, under
+/// `energy`, so it survives restarts and the block's own tick reads it.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ModEnergyBuffer {
+    pub capacity: i32,
+    /// The most one insert moves; 0 takes none.
+    pub max_insert: i32,
+    /// The most one extract moves; 0 gives none.
+    pub max_extract: i32,
+    /// The faces, by `Direction` number, a fill may come through.
+    pub insert_faces: [bool; 6],
+    /// The faces a drain may leave by.
+    pub extract_faces: [bool; 6],
+}
 /// The vanilla menus a mod container can open, with the slot count each
 /// shows: slot grids, and the furnaces' (input, fuel, result), whose four
 /// data slots draw the flame (`data[0]` of `data[1]`) and the arrow
@@ -0,0 +1,662 @@
+//! OptiFine's Custom Item Textures (and CIT Resewn's): the rules of the enabled packs'
+//! `optifine/cit/**/*.properties`, read from the overlay resource root. The rules themselves are
+//! `horizon_optifine::cit`'s.
+
+pub use horizon_optifine::cit::{Hand, Kind, Rule};
+
+use horizon_client_core::component::name_text;
+use horizon_client_core::scoreboard::comp_text;
+use horizon_items::item_data::{canon_tag, encode_components};
+use horizon_items::items::ItemStack;
+use horizon_optifine::cit::{ComponentTest, Source, ValueTest};
+use horizon_optifine::{Properties, properties_files_in};
+use horizon_world::nbt::{JavaString, Tag, parse_snbt};
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::fs;
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::path::Path;
+use std::sync::Mutex;
+
+/// Every rule under the root's `optifine/cit/`, `mcpatcher/cit/` and CIT Resewn's
+/// `citresewn/cit/` folders, the one chosen first when several match first (`Rule::priority`).
+/// The pack's global `cit.properties` is not a rule.
+pub fn load_rules(root: &Path) -> Vec<Rule> {
+    let tops = ["optifine", "mcpatcher", "citresewn"];
+    let mut rules: Vec<Rule> = properties_files_in(root, &tops, "cit")
+        .into_iter()
+        .filter(|path| !path.ends_with("/cit.properties"))
+        .filter_map(|path| {
+            // Java reads `.properties` as Latin-1: a pack saved that way still loads.
+            let bytes = fs::read(root.join(&path)).ok()?;
+            let text = String::from_utf8(bytes)
+                .unwrap_or_else(|e| e.into_bytes().iter().map(|&b| char::from(b)).collect());
+            let rule = Rule::parse(&path, &Properties::parse_equals_first(&text), |p| {
+                root.join(p).is_file()
+            });
+            if rule.is_none() {
+                log::warn!("custom item textures: {path} is not a rule Horizon can read");
+            }
+            rule
+        })
+        .collect();
+    rules.sort_by(Rule::priority);
+    rules
+}
+
+/// The rules with an index by item and a cache of what each stack matched.
+#[derive(Debug, Default)]
+pub struct CitRules {
+    pub rules: Vec<Rule>,
+    /// Per kind (`Kind as usize`), the rules naming each item, in priority order.
+    by_item: [HashMap<String, Vec<u32>>; 4],
+    /// Enchantment rules without `items`, in priority order.
+    any_item: Vec<u32>,
+    /// Per rule, per component test: its literal read as SNBT and as a JSON text component.
+    literals: Vec<Vec<Prepared>>,
+    selected: Mutex<HashMap<u64, Option<u32>>>,
+    enchanted: Mutex<HashMap<u64, Vec<u32>>>,
+}
+
+#[derive(Debug, Default)]
+struct Prepared {
+    snbt: Option<Tag>,
+    json: Option<String>,
+}
+
+/// Cache entries kept before the cache starts over.
+const CACHE_LIMIT: usize = 4096;
+
+impl CitRules {
+    /// The enabled packs' rules under the overlay resource root.
+    pub fn load(root: &Path) -> Self {
+        Self::new(load_rules(root))
+    }
+
+    /// `rules` in priority order, the winner first.
+    pub fn new(rules: Vec<Rule>) -> Self {
+        let mut by_item: [HashMap<String, Vec<u32>>; 4] = Default::default();
+        let mut any_item = Vec::new();
+        for (i, rule) in rules.iter().enumerate() {
+            let i = i as u32;
+            if rule.kind == Kind::Enchantment && rule.items.is_empty() {
+                any_item.push(i);
+            }
+            for item in &rule.items {
+                let list = by_item[rule.kind as usize].entry(item.clone()).or_default();
+                if list.last() != Some(&i) {
+                    list.push(i);
+                }
+            }
+        }
+        let literals = rules
+            .iter()
+            .map(|r| r.components.iter().map(prepare).collect())
+            .collect();
+        Self {
+            rules,
+            by_item,
+            any_item,
+            literals,
+            ..Default::default()
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.rules.is_empty()
+    }
+
+    /// The winning rule of `kind` (Item, Armor or Elytra) for this stack, as an index into `rules`.
+    pub fn select(
+        &self,
+        kind: Kind,
+        stack: &ItemStack,
+        hand: Hand,
+        max_damage: u32,
+    ) -> Option<usize> {
+        let candidates = self.by_item[kind as usize].get(&*stack.item)?;
+        let comps = encode_components(stack);
+        let key = cache_key((0, kind, hand), stack, max_damage, comps.as_ref());
+        if let Some(hit) = lock(&self.selected).get(&key) {
+            return hit.map(|i| i as usize);
+        }
+        let found = candidates
+            .iter()
+            .copied()
+            .find(|&i| self.matches(i, stack, Some(hand), max_damage, comps.as_ref()));
+        remember(&self.selected, key, found);
+        found.map(|i| i as usize)
+    }
+
+    /// Every matching Enchantment rule, in priority order (layers are the glint PR's business).
+    pub fn enchantments(&self, stack: &ItemStack, max_damage: u32) -> Vec<usize> {
+        let named = self.by_item[Kind::Enchantment as usize]
+            .get(&*stack.item)
+            .map_or(&[][..], Vec::as_slice);
+        if named.is_empty() && self.any_item.is_empty() {
+            return Vec::new();
+        }
+        let comps = encode_components(stack);
+        let key = cache_key(
+            (1, Kind::Enchantment, Hand::Any),
+            stack,
+            max_damage,
+            comps.as_ref(),
+        );
+        let hit = lock(&self.enchanted).get(&key).cloned();
+        let found = hit.unwrap_or_else(|| {
+            let mut all: Vec<u32> = named.iter().chain(&self.any_item).copied().collect();
+            all.sort_unstable();
+            all.retain(|&i| self.matches(i, stack, None, max_damage, comps.as_ref()));
+            remember(&self.enchanted, key, all.clone());
+            all
+        });
+        found.into_iter().map(|i| i as usize).collect()
+    }
+
+    /// Whether rule `i` matches; `hand` None skips the hand test (enchantment glints).
+    fn matches(
+        &self,
+        i: u32,
+        stack: &ItemStack,
+        hand: Option<Hand>,
+        max_damage: u32,
+        comps: Option<&Tag>,
+    ) -> bool {
+        let rule = &self.rules[i as usize];
+        if hand.is_some_and(|h| rule.hand != Hand::Any && rule.hand != h) {
+            return false;
+        }
+        let count = i32::try_from(stack.count).unwrap_or(i32::MAX);
+        if rule.stack_size.as_ref().is_some_and(|r| !r.contains(count)) {
+            return false;
+        }
+        // CIT Resewn: only damageable items have damage.
+        let damage = if max_damage > 0 { stack.damage } else { 0 };
+        if rule
+            .damage
+            .as_ref()
+            .is_some_and(|d| !d.matches(damage, max_damage))
+        {
+            return false;
+        }
+        let enchantments = stack.crafting_enchantments();
+        let listed = |id: &str| rule.enchantments.iter().any(|e| e == id);
+        if !rule.enchantments.is_empty() && !enchantments.iter().any(|(id, _)| listed(id)) {
+            return false;
+        }
+        if let Some(levels) = &rule.enchantment_levels {
+            let level_in_range = enchantments.iter().any(|(id, level)| {
+                (rule.enchantments.is_empty() || listed(id))
+                    && levels.contains(i32::try_from(*level).unwrap_or(i32::MAX))
+            });
+            if !level_in_range {
+                return false;
+            }
+        }
+        let literals = &self.literals[i as usize];
+        rule.components
+            .iter()
+            .zip(literals)
+            .all(|(test, lit)| component_test(test, lit, stack, comps) != test.negate)
+    }
+}
+
+fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
+    m.lock().unwrap_or_else(|e| e.into_inner())
+}
+
+fn remember<V>(cache: &Mutex<HashMap<u64, V>>, key: u64, value: V) {
+    let mut cache = lock(cache);
+    if cache.len() >= CACHE_LIMIT {
+        cache.clear();
+    }
+    cache.insert(key, value);
+}
+
+/// What a cached answer depends on; `query` tells `select` from `enchantments`.
+fn cache_key(query: (u8, Kind, Hand), stack: &ItemStack, max: u32, comps: Option<&Tag>) -> u64 {
+    let mut h = DefaultHasher::new();
+    (query.0, query.1 as u8, query.2 as u8, &*stack.item).hash(&mut h);
+    (stack.count, stack.damage, max, comps).hash(&mut h);
+    h.finish()
+}
+
+fn prepare(test: &ComponentTest) -> Prepared {
+    let ValueTest::Literal(lit) = &test.value else {
+        return Prepared::default();
+    };
+    let text = lit.text.trim();
+    let snbt = match parse_snbt(text) {
+        Ok((tag, read)) if read == text.len() && text.starts_with(['{', '[']) => Some(tag),
+        _ => None,
+    };
+    let json = json_plain(text);
+    Prepared { snbt, json }
+}
+
+/// The plain text of `s` read as a JSON text component.
+fn json_plain(s: &str) -> Option<String> {
+    if !s.starts_with(['{', '[', '"']) {
+        return None;
+    }
+    let value: serde_json::Value = serde_json::from_str(s).ok()?;
+    Some(comp_text(&value).plain())
+}
+
+/// Whether one test passes, before its `negate`.
+fn component_test(
+    test: &ComponentTest,
+    lit: &Prepared,
+    stack: &ItemStack,
+    comps: Option<&Tag>,
+) -> bool {
+    let legacy;
+    let (root, text_depth) = match &test.source {
+        Source::Component(id) => {
+            let depth = match id.as_str() {
+                "minecraft:custom_name" | "minecraft:item_name" => Some(0),
+                "minecraft:lore" => Some(1),
+                _ => None,
+            };
+            (comps.and_then(|c| c.get(id)), depth)
+        }
+        Source::LegacyEnchantments { stored } => {
+            let levels = if *stored {
+                stack.stored_enchantments()
+            } else {
+                stack.enchantments()
+            };
+            legacy = Tag::List(
+                levels
+                    .iter()
+                    .map(|(id, lvl)| {
+                        let lvl = i16::try_from(*lvl).unwrap_or(i16::MAX);
+                        Tag::compound([
+                            ("id", Tag::String((&**id).into())),
+                            ("lvl", Tag::Short(lvl)),
+                        ])
+                    })
+                    .collect(),
+            );
+            (Some(&legacy), None)
+        }
+    };
+    // Fields the component leaves out when 0, which pre-1.20.5 items always wrote.
+    let defaulted;
+    let root = match (&test.source, root, test.path.first()) {
+        (Source::Component(id), Some(Tag::Compound(map)), Some(field))
+            if matches!(
+                (id.as_str(), field.as_str()),
+                ("minecraft:written_book_content", "generation")
+                    | ("minecraft:fireworks", "flight_duration")
+            ) && !map.contains_key(&JavaString::from(field.as_str())) =>
+        {
+            let mut map = map.clone();
+            map.insert(JavaString::from(field.as_str()), Tag::Int(0));
+            defaulted = Tag::Compound(map);
+            Some(&defaulted)
+        }
+        (_, root, _) => root,
+    };
+    let Some(root) = root else {
+        return matches!(test.value, ValueTest::Exists(false));
+    };
+    if let ValueTest::Exists(want) = test.value {
+        return walk(root, &test.path, 0, &mut |_, _| true) == want;
+    }
+    walk(root, &test.path, 0, &mut |tag, depth| {
+        value_test(&test.value, lit, tag, text_depth == Some(depth))
+    })
+}
+
+/// Visits what `path` reaches from `tag`, true once `visit` is.
+fn walk(
+    tag: &Tag,
+    path: &[String],
+    depth: usize,
+    visit: &mut dyn FnMut(&Tag, usize) -> bool,
+) -> bool {
+    let Some((seg, rest)) = path.split_first() else {
+        return visit(tag, depth);
+    };
+    let mut next = |t: &Tag| walk(t, rest, depth + 1, visit);
+    let len = match tag {
+        Tag::Compound(map) if seg == "*" => return map.values().any(&mut next),
+        Tag::Compound(map) => return map.get(&JavaString::from(seg.as_str())).is_some_and(next),
+        Tag::List(v) => v.len(),
+        Tag::ByteArray(v) => v.len(),
+        Tag::IntArray(v) => v.len(),
+        Tag::LongArray(v) => v.len(),
+        _ => return false,
+    };
+    let element = |i: usize| match tag {
+        Tag::List(v) => Cow::Borrowed(&v[i]),
+        Tag::ByteArray(v) => Cow::Owned(Tag::Byte(v[i] as i8)),
+        Tag::IntArray(v) => Cow::Owned(Tag::Int(v[i])),
+        Tag::LongArray(v) => Cow::Owned(Tag::Long(v[i])),
+        _ => Cow::Owned(Tag::End),
+    };
+    if seg == "count" {
+        return next(&Tag::Int(i32::try_from(len).unwrap_or(i32::MAX)));
+    }
+    if seg == "*" {
+        return (0..len).any(|i| next(&element(i)));
+    }
+    seg.parse::<usize>()
+        .ok()
+        .filter(|&i| i < len)
+        .is_some_and(|i| next(&element(i)))
+}
+
+fn int_value(tag: &Tag) -> Option<i64> {
+    match *tag {
+        Tag::Byte(v) => Some(v.into()),
+        Tag::Short(v) => Some(v.into()),
+        Tag::Int(v) => Some(v.into()),
+        Tag::Long(v) => Some(v),
+        _ => None,
+    }
+}
+
+/// A number as Java's `String.valueOf` writes it (`3`, `3.0`).
+fn decimal(tag: &Tag) -> Option<String> {
+    let s = match *tag {
+        Tag::Float(b) => f32::from_bits(b).to_string(),
+        Tag::Double(b) => f64::from_bits(b).to_string(),
+        _ => return int_value(tag).map(|v| v.to_string()),
+    };
+    Some(if s.contains(['.', 'e', 'N', 'i']) {
+        s
+    } else {
+        s + ".0"
+    })
+}
+
+/// `text` against a string, its JSON text, or the plain text of a text component.
+fn text_matches(tag: &Tag, is_text: bool, text: impl Fn(&str) -> bool) -> bool {
+    match tag {
+        Tag::String(s) => {
+            let s = s.to_string_lossy();
+            text(&s)
+                || (is_text && text(&name_text(tag).plain()))
+                || json_plain(&s).is_some_and(|p| text(&p))
+        }
+        Tag::Compound(_) | Tag::List(_) => is_text && text(&name_text(tag).plain()),
+        _ => false,
+    }
+}
+
+fn value_test(test: &ValueTest, lit: &Prepared, tag: &Tag, is_text: bool) -> bool {
+    match test {
+        ValueTest::Exists(_) => true,
+        ValueTest::Range(r) => {
+            int_value(tag).is_some_and(|v| i32::try_from(v).is_ok_and(|v| r.contains(v)))
+        }
+        ValueTest::Raw(name) => name.matches(&canon_tag(tag)),
+        ValueTest::Text(name) => match decimal(tag) {
+            Some(n) => name.matches(&n),
+            None => text_matches(tag, is_text, |s| name.matches(s)),
+        },
+        ValueTest::Literal(l) => match tag {
+            Tag::Float(b) => l.text.trim().parse::<f32>().ok() == Some(f32::from_bits(*b)),
+            Tag::Double(b) => l.float == Some(f64::from_bits(*b)),
+            Tag::Compound(_) | Tag::List(_)
+                if lit.snbt.as_ref().is_some_and(|e| contains(e, tag)) =>
+            {
+                true
+            }
+            _ => match int_value(tag) {
+                Some(v) => l.int == Some(v),
+                None => text_matches(tag, is_text, |s| {
+                    s == l.text || lit.json.as_deref() == Some(s)
+                }),
+            },
+        },
+    }
+}
+
+/// `NbtUtils.compareNbt(expected, actual, true)`: every key and element of `expected` found in
+/// `actual`.
+fn contains(expected: &Tag, actual: &Tag) -> bool {
+    match (expected, actual) {
+        (Tag::Compound(e), Tag::Compound(a)) => e
+            .iter()
+            .all(|(k, v)| a.get(k).is_some_and(|a| contains(v, a))),
+        (Tag::List(e), Tag::List(a)) if e.is_empty() => a.is_empty(),
+        (Tag::List(e), Tag::List(a)) => e.iter().all(|e| a.iter().any(|a| contains(e, a))),
+        _ => expected == actual,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Arc;
+
+    /// Rules from (file stem, properties), sorted as `load_rules` sorts them.
+    fn rules(files: &[(&str, &str)]) -> CitRules {
+        let mut rules: Vec<Rule> = files
+            .iter()
+            .map(|(stem, text)| {
+                let path = format!("assets/minecraft/optifine/cit/{stem}.properties");
+                let text = format!("texture=x\n{text}");
+                Rule::parse(&path, &Properties::parse_equals_first(&text), |_| true).unwrap()
+            })
+            .collect();
+        rules.sort_by(Rule::priority);
+        CitRules::new(rules)
+    }
+
+    fn stem(cit: &CitRules, i: Option<usize>) -> Option<&str> {
+        let path = &cit.rules[i?].path;
+        path.rsplit('/').next()?.strip_suffix(".properties")
+    }
+
+    fn item(cit: &CitRules, stack: ItemStack) -> Option<&str> {
+        stem(cit, cit.select(Kind::Item, &stack, Hand::Main, 0))
+    }
+
+    fn new(id: &str) -> ItemStack {
+        ItemStack::new(&format!("minecraft:{id}"), 1)
+    }
+
+    fn string(s: &str) -> Tag {
+        Tag::String(s.into())
+    }
+
+    fn with(id: &str, component: &str, tag: Tag) -> ItemStack {
+        let mut stack = new(id);
+        let component = format!("minecraft:{component}");
+        stack.data_mut().other.push((component, tag));
+        stack
+    }
+
+    fn enchanted(id: &str, levels: &[(&str, u32)]) -> ItemStack {
+        let mut stack = new(id);
+        let levels = levels
+            .iter()
+            .map(|(e, l)| (Arc::from(format!("minecraft:{e}")), *l));
+        stack.data_mut().enchantments = levels.collect();
+        stack
+    }
+
+    #[test]
+    fn heavier_rules_win_and_kinds_stay_apart() {
+        let cit = rules(&[
+            ("plain", "items=stick"),
+            ("heavy", "items=stick\nweight=2\nstackSize=2-"),
+            ("offhand", "items=stick\nweight=5\nhand=off"),
+            ("armor", "type=armor\nitems=stick"),
+            ("wings", "type=elytra"),
+        ]);
+        assert_eq!(item(&cit, new("stick")), Some("plain"));
+        assert_eq!(
+            item(&cit, ItemStack::new("minecraft:stick", 3)),
+            Some("heavy")
+        );
+        let pick = |kind, id, hand, max| stem(&cit, cit.select(kind, &new(id), hand, max));
+        assert_eq!(pick(Kind::Item, "stick", Hand::Off, 0), Some("offhand"));
+        assert_eq!(item(&cit, new("stone")), None);
+        assert_eq!(item(&cit, new("elytra")), None);
+        assert_eq!(pick(Kind::Elytra, "elytra", Hand::Main, 432), Some("wings"));
+        assert_eq!(pick(Kind::Armor, "stick", Hand::Main, 0), Some("armor"));
+    }
+
+    #[test]
+    fn names_match_by_their_plain_text() {
+        let cit = rules(&[
+            ("glob", "items=stick\nnbt.display.Name=ipattern:*sword"),
+            ("exact", "items=stone\ncomponents.custom_name=My Sword"),
+            ("json", "items=dirt\nnbt.display.Name=[\"My \",\"Sword\"]"),
+        ]);
+        let named = |id: &str, name: Tag| {
+            let mut stack = new(id);
+            stack.data_mut().custom_name = Some(name);
+            stack
+        };
+        let styled = Tag::compound([("text", string("My Sword")), ("color", string("red"))]);
+        assert_eq!(item(&cit, named("stick", styled.clone())), Some("glob"));
+        assert_eq!(item(&cit, named("stick", string("Blade"))), None);
+        assert_eq!(item(&cit, new("stick")), None);
+        assert_eq!(item(&cit, named("stone", styled.clone())), Some("exact"));
+        assert_eq!(item(&cit, named("dirt", styled)), Some("json"));
+    }
+
+    #[test]
+    fn lore_lines_and_list_counts() {
+        let cit = rules(&[
+            (
+                "any_line",
+                "items=stick\nnbt.display.Lore.*=ipattern:*legendary*",
+            ),
+            ("two_lines", "items=stone\ncomponents.lore.count=2"),
+        ]);
+        let bold = Tag::compound([("text", string("A LEGENDARY item")), ("bold", Tag::Byte(1))]);
+        let lore = Tag::List(vec![string("Common"), bold]);
+        assert_eq!(
+            item(&cit, with("stick", "lore", lore.clone())),
+            Some("any_line")
+        );
+        assert_eq!(item(&cit, with("stone", "lore", lore)), Some("two_lines"));
+        let one = Tag::List(vec![string("A legendary item")]);
+        assert_eq!(item(&cit, with("stone", "lore", one)), None);
+    }
+
+    #[test]
+    fn custom_data_existence_and_negation() {
+        let cit = rules(&[
+            (
+                "aote",
+                "items=stick\nweight=2\nnbt.ExtraAttributes.id=ASPECT_OF_THE_END",
+            ),
+            (
+                "not_hyp",
+                "items=stick\nweight=1\ncomponent.custom_data.ExtraAttributes.id=!HYP",
+            ),
+            ("unnamed", "items=stick\nnbt.display.Name=exists:false"),
+        ]);
+        let data = |id: &str| {
+            let attributes =
+                Tag::compound([("ExtraAttributes", Tag::compound([("id", string(id))]))]);
+            with("stick", "custom_data", attributes)
+        };
+        assert_eq!(item(&cit, data("ASPECT_OF_THE_END")), Some("aote"));
+        assert_eq!(item(&cit, data("MIDAS")), Some("not_hyp"));
+        assert_eq!(item(&cit, data("HYP")), Some("unnamed"));
+        let mut named = data("HYP");
+        named.data_mut().custom_name = Some(string("Hyperion"));
+        assert_eq!(item(&cit, named), None);
+    }
+
+    #[test]
+    fn legacy_enchantment_lists_and_model_data() {
+        let cit = rules(&[
+            (
+                "sharp",
+                "items=stick\nnbt.Enchantments.*.id=minecraft:sharpness\nnbt.Enchantments.0.lvl=5",
+            ),
+            ("cmd", "items=stone\nnbt.CustomModelData=3"),
+            (
+                "cmd_snbt",
+                "items=dirt\ncomponents.custom_model_data={floats:[3.0f]}",
+            ),
+        ]);
+        assert_eq!(
+            item(&cit, enchanted("stick", &[("sharpness", 5)])),
+            Some("sharp")
+        );
+        assert_eq!(item(&cit, enchanted("stick", &[("sharpness", 4)])), None);
+        let model = |id: &str, f: f32| {
+            let floats = Tag::List(vec![Tag::Float(f.to_bits()), Tag::Float(7f32.to_bits())]);
+            with(id, "custom_model_data", Tag::compound([("floats", floats)]))
+        };
+        assert_eq!(item(&cit, model("stone", 3.0)), Some("cmd"));
+        assert_eq!(item(&cit, model("stone", 3.5)), None);
+        assert_eq!(item(&cit, model("dirt", 3.0)), Some("cmd_snbt"));
+        assert_eq!(item(&cit, model("dirt", 2.0)), None);
+    }
+
+    #[test]
+    fn fields_left_out_at_zero_read_as_zero() {
+        let cit = rules(&[("zero", "items=firework_rocket\nnbt.Fireworks.Flight=0")]);
+        let mut rocket = new("firework_rocket");
+        rocket.data_mut().fireworks = Some((0, Vec::new()));
+        assert_eq!(item(&cit, rocket.clone()), Some("zero"));
+        rocket.data_mut().fireworks = Some((2, Vec::new()));
+        assert_eq!(item(&cit, rocket), None);
+    }
+
+    #[test]
+    fn damage_counts_only_for_damageable_items() {
+        let cit = rules(&[
+            ("worn", "items=diamond_sword\ndamage=50-100%"),
+            ("new", "items=stick\ndamage=0"),
+        ]);
+        let damaged = |id: &str, damage: u32, max: u32| {
+            let mut stack = new(id);
+            stack.damage = damage;
+            stem(&cit, cit.select(Kind::Item, &stack, Hand::Main, max))
+        };
+        // Half of 1561 is 780.5.
+        assert_eq!(damaged("diamond_sword", 780, 1561), None);
+        assert_eq!(damaged("diamond_sword", 781, 1561), Some("worn"));
+        assert_eq!(damaged("stick", 5, 0), Some("new"));
+    }
+
+    #[test]
+    fn enchantment_levels_and_rules_for_any_item() {
+        let cit = rules(&[
+            (
+                "sharp3",
+                "items=stick\nenchantments=sharpness\nenchantmentLevels=3-",
+            ),
+            ("any3", "items=stone\nenchantmentLevels=3-"),
+            ("glint", "type=enchantment\nenchantments=sharpness"),
+            (
+                "sword_glint",
+                "type=enchantment\nitems=diamond_sword\nweight=2",
+            ),
+        ]);
+        let mixed = [("sharpness", 2), ("unbreaking", 3)];
+        assert_eq!(item(&cit, enchanted("stick", &mixed)), None);
+        assert_eq!(
+            item(&cit, enchanted("stick", &[("sharpness", 4)])),
+            Some("sharp3")
+        );
+        assert_eq!(item(&cit, enchanted("stone", &mixed)), Some("any3"));
+        let glints = |stack: ItemStack| -> Vec<&str> {
+            let found = cit.enchantments(&stack, 0).into_iter();
+            found.map(|i| stem(&cit, Some(i)).unwrap()).collect()
+        };
+        let sharp = [("sharpness", 1)];
+        assert_eq!(
+            glints(enchanted("diamond_sword", &sharp)),
+            ["sword_glint", "glint"]
+        );
+        assert_eq!(glints(enchanted("stick", &sharp)), ["glint"]);
+        assert!(glints(new("stick")).is_empty());
+        // Glints are never an item's texture.
+        assert_eq!(item(&cit, enchanted("diamond_sword", &sharp)), None);
+    }
+}
@@ -199,8 +199,9 @@ where
 }
 impl SceneCollisions<'_, '_> {
    /// Position contexts permit geometric movement probes without inventing a
-    /// player, inventory, effects or fluid-standing behavior; a lava walker
-    /// collides as the living entity it is, empty-handed.
+    /// player, inventory, effects or fluid-standing behavior; a lava walker or
+    /// a living entity in leather boots collides as the living entity it is,
+    /// empty-handed.
    pub fn resolve(
        &mut self,
        bounds: Aabb,
@@ -236,7 +237,10 @@ impl SceneCollisions<'_, '_> {
    }
    fn context(&self, bounds: Aabb) -> CollisionContext<'static> {
        let y = bounds.min_position().y;
-        if !self.subject.is_some_and(|s| s.lava_walker) {
+        if !self
+            .subject
+            .is_some_and(|s| s.lava_walker || s.leather_boots)
+        {
            return CollisionContext::position(y);
        }
        CollisionContext::for_entity(
@@ -0,0 +1,735 @@
+//! OptiFine connected textures (`optifine/ctm`) at mesh time. The active packs' rules are read
+//! once at load, their tiles become sprite layers, and each block state and sprite layer gets
+//! the short list of rules that can touch it; meshing a face then walks only those lists
+//! ([`ConnectedTextures::pick`]). Without CTM files there are no rules and nothing changes.
+//!
+//! The rules and the tile geometry are `horizon_optifine::ctm`'s.
+
+use crate::sprites::Sprites;
+use horizon_optifine::ctm::{
+    self, Connect, Method, Orient, Rule, Tile,
+    connect::{self as geometry, Axes, Axis, Face},
+};
+use horizon_world::block_state_properties::BlockProperties;
+use horizon_world::registry::{BlockRegistry, BlockStateId};
+use std::{collections::HashMap, path::Path};
+
+/// A tile as the mesher draws it.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TileLayer {
+    Layer {
+        layer: u16,
+        /// The sprite has fractional alpha (drawn in the translucent pass).
+        translucent: bool,
+        /// Every texel is opaque (drawn without an alpha test).
+        opaque: bool,
+    },
+    /// Try the next rule.
+    Skip,
+    /// The face's own sprite.
+    Default,
+}
+
+/// What a face draws.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Pick {
+    /// Its own sprite.
+    Keep,
+    Tile(TileLayer),
+    /// `ctm_compact`: a tile per quarter of the sprite (top-left, top-right, bottom-left,
+    /// bottom-right).
+    Quarters([TileLayer; 4]),
+}
+
+struct LoadedRule {
+    rule: Rule,
+    tiles: Vec<TileLayer>,
+}
+
+#[derive(Clone, Copy, Default)]
+struct StateInfo {
+    /// Index of the state's block (`connect=block`).
+    block: u32,
+    axis: Option<Axis>,
+    /// `half=upper`: `linked` random tiles follow the lower half.
+    upper: bool,
+}
+
+#[derive(Default)]
+pub struct ConnectedTextures {
+    rules: Vec<LoadedRule>,
+    /// By block state, then by sprite layer: ranges of `lists` (rule indices, in rule order).
+    by_state: Vec<(u32, u32)>,
+    by_layer: Vec<(u32, u32)>,
+    lists: Vec<u16>,
+    states: Vec<StateInfo>,
+    /// By block state: the sprite of its model's face on each side (`connect=tile`); empty
+    /// when no rule connects by tile.
+    face_layers: Vec<[u16; 6]>,
+}
+
+/// `list` appended to `lists`, as its range there.
+fn push_list(lists: &mut Vec<u16>, list: &[u16]) -> (u32, u32) {
+    let start = lists.len() as u32;
+    lists.extend_from_slice(list);
+    (start, list.len() as u32)
+}
+
+/// The sprite name of a texture resource path: `ns:path` under `textures/`, else the path
+/// itself (as [`Sprites::insert_file`] names a tile).
+fn sprite_name(resource: &str) -> String {
+    let parts = resource
+        .strip_prefix("assets/")
+        .and_then(|p| p.split_once('/'))
+        .and_then(|(ns, p)| Some((ns, p.strip_prefix("textures/")?.strip_suffix(".png")?)));
+    match parts {
+        Some((ns, path)) => format!("{ns}:{path}"),
+        None => resource.to_owned(),
+    }
+}
+
+impl ConnectedTextures {
+    /// The rules under `root`, with their tiles inserted into `sprites` (before it finishes).
+    /// `face_layer` answers a block state's sprite on a side, for rules that connect by tile.
+    pub fn load(
+        root: &Path,
+        registry: &BlockRegistry,
+        sprites: &mut Sprites,
+        mut face_layer: impl FnMut(BlockStateId, Face) -> Option<u32>,
+    ) -> Self {
+        let mut rules = ctm::load(root);
+        // Rules no face can use load no tiles: overlays (not drawn yet), and custom names (section
+        // meshes see no block entity).
+        rules.retain(|r| !r.method.is_overlay() && r.name.is_none());
+        // Rule indices are `u16`.
+        rules.truncate(usize::from(u16::MAX));
+        if rules.is_empty() {
+            return Self::default();
+        }
+        // The tiles decode side by side; the loop below inserts them in rule order, under the
+        // same names.
+        let tiles: Vec<String> = rules
+            .iter()
+            .flat_map(|rule| &rule.tiles)
+            .filter_map(|tile| match tile {
+                Tile::Texture(path) => Some(sprite_name(path)),
+                _ => None,
+            })
+            .collect();
+        sprites.prefetch(root, tiles.iter().map(String::as_str));
+        let loaded = rules
+            .into_iter()
+            .filter_map(|rule| {
+                let tiles = rule
+                    .tiles
+                    .iter()
+                    .map(|tile| match tile {
+                        Tile::Skip => Ok(TileLayer::Skip),
+                        Tile::Default => Ok(TileLayer::Default),
+                        Tile::Texture(path) => {
+                            // A tile among the textures is that sprite, under its own name.
+                            let layer = match sprite_name(path) {
+                                name if name != *path => sprites.insert(root, &name)?,
+                                _ => sprites.insert_file(root, path)?,
+                            };
+                            Ok(TileLayer::Layer {
+                                layer: u16::try_from(layer)?,
+                                translucent: sprites.translucent[layer as usize],
+                                opaque: sprites.opaque[layer as usize],
+                            })
+                        }
+                    })
+                    .collect::<crate::Result<Vec<_>>>();
+                match tiles {
+                    Ok(tiles) => Some(LoadedRule { rule, tiles }),
+                    Err(e) => {
+                        log::warn!("Horizon: connected textures {}: a tile: {e}", rule.path);
+                        None
+                    }
+                }
+            })
+            .collect();
+        let states = (0..registry.len() as u32).map(|id| {
+            registry
+                .state(BlockStateId(id))
+                .map(|s| (s.name.as_str(), &s.properties))
+        });
+        let mut out = Self::build(loaded, states, |name| sprites.layers.get(name).copied());
+        if out.rules.iter().any(|r| r.rule.connect == Connect::Tile) {
+            out.face_layers = (0..registry.len() as u32)
+                .map(|id| {
+                    Face::ALL
+                        .map(|f| face_layer(BlockStateId(id), f).map_or(u16::MAX, |l| l as u16))
+                })
+                .collect();
+        }
+        out
+    }
+
+    /// The lookups for `rules` (already ordered) over every block state (`None` for an id the
+    /// registry skips), `layer` answering a sprite name's layer.
+    fn build<'a>(
+        rules: Vec<LoadedRule>,
+        states: impl Iterator<Item = Option<(&'a str, &'a BlockProperties)>>,
+        layer: impl Fn(&str) -> Option<u32>,
+    ) -> Self {
+        let mut out = Self {
+            rules,
+            ..Self::default()
+        };
+        let mut blocks = HashMap::new();
+        let mut by_layer: Vec<Vec<u16>> = Vec::new();
+        // Block rules by the block each entry names, so a state tests only its own.
+        let mut by_block: HashMap<&str, Vec<u16>> = HashMap::new();
+        for (i, r) in out.rules.iter().enumerate() {
+            let i = i as u16;
+            for tile in &r.rule.match_tiles {
+                if let Some(l) = layer(&sprite_name(tile)) {
+                    let l = l as usize;
+                    if by_layer.len() <= l {
+                        by_layer.resize(l + 1, Vec::new());
+                    }
+                    if by_layer[l].last() != Some(&i) {
+                        by_layer[l].push(i);
+                    }
+                }
+            }
+            for m in &r.rule.match_blocks {
+                let list = by_block.entry(m.id.as_str()).or_default();
+                if list.last() != Some(&i) {
+                    list.push(i);
+                }
+            }
+        }
+        for list in by_layer {
+            let range = push_list(&mut out.lists, &list);
+            out.by_layer.push(range);
+        }
+        let mut list = Vec::new();
+        for state in states {
+            let Some((name, props)) = state else {
+                out.by_state.push((0, 0));
+                out.states.push(StateInfo::default());
+                continue;
+            };
+            let next = blocks.len() as u32;
+            let block = *blocks.entry(name).or_insert(next);
+            let prop = |k: &str| props.get(k).map(String::as_str);
+            out.states.push(StateInfo {
+                block,
+                axis: match prop("axis") {
+                    Some("x") => Some(Axis::X),
+                    Some("y") => Some(Axis::Y),
+                    Some("z") => Some(Axis::Z),
+                    _ => None,
+                },
+                upper: prop("half") == Some("upper"),
+            });
+            list.clear();
+            if let Some(candidates) = by_block.get(name) {
+                list.extend(
+                    candidates
+                        .iter()
+                        .filter(|&&i| out.rules[usize::from(i)].rule.matches_block(name, prop)),
+                );
+            }
+            let range = push_list(&mut out.lists, &list);
+            out.by_state.push(range);
+        }
+        out
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.rules.is_empty()
+    }
+
+    fn list(&self, ranges: &[(u32, u32)], i: usize) -> &[u16] {
+        ranges.get(i).map_or(&[], |&(start, len)| {
+            &self.lists[start as usize..(start + len) as usize]
+        })
+    }
+
+    /// What the `face` of the block `state` at `pos` draws, for a quad with sprite `layer`.
+    /// `neighbour` answers the state at an offset from the block; `biome` its biome, asked only
+    /// by rules that test one.
+    pub fn pick<'b>(
+        &self,
+        state: u32,
+        layer: u16,
+        face: Face,
+        pos: [i32; 3],
+        neighbour: impl Fn([i32; 3]) -> u32,
+        biome: impl Fn() -> Option<&'b str>,
+    ) -> Pick {
+        let (mut by_state, mut by_layer) = (
+            self.list(&self.by_state, state as usize),
+            self.list(&self.by_layer, layer as usize),
+        );
+        // Both lists are in rule order: walk them as one. A rule naming blocks and tiles needs
+        // both (it is in both lists); one naming either needs that one.
+        loop {
+            let (i, block, tile) = match (by_state.split_first(), by_layer.split_first()) {
+                (None, None) => return Pick::Keep,
+                (Some((&x, rest)), Some((&y, other))) if x == y => {
+                    (by_state, by_layer) = (rest, other);
+                    (x, true, true)
+                }
+                (Some((&x, rest)), Some((&y, _))) if x < y => {
+                    by_state = rest;
+                    (x, true, false)
+                }
+                (Some((&x, rest)), None) => {
+                    by_state = rest;
+                    (x, true, false)
+                }
+                (_, Some((&y, rest))) => {
+                    by_layer = rest;
+                    (y, false, true)
+                }
+            };
+            let r = &self.rules[usize::from(i)];
+            if (block || r.rule.match_blocks.is_empty())
+                && (tile || r.rule.match_tiles.is_empty())
+                && let Some(pick) = self.apply(r, state, layer, face, pos, &neighbour, &biome)
+            {
+                return pick;
+            }
+        }
+    }
+
+    /// One rule on a face: `None` when it doesn't apply or picks `<skip>`.
+    #[allow(clippy::too_many_arguments)]
+    fn apply<'b>(
+        &self,
+        r: &LoadedRule,
+        state: u32,
+        layer: u16,
+        face: Face,
+        pos: [i32; 3],
+        neighbour: &impl Fn([i32; 3]) -> u32,
+        biome: &impl Fn() -> Option<&'b str>,
+    ) -> Option<Pick> {
+        let rule = &r.rule;
+        // `Rule::applies_at`, with the biome looked up only for rules that test one. Rules with
+        // a custom name are not loaded.
+        if rule.faces & face.bit() == 0
+            || rule.heights.as_ref().is_some_and(|h| !h.contains(pos[1]))
+        {
+            return None;
+        }
+        if let Some(biomes) = &rule.biomes
+            && !biome().is_some_and(|b| biomes.matches(b))
+        {
+            return None;
+        }
+        let info = self.states.get(state as usize).copied().unwrap_or_default();
+        let joins = |offset: [i32; 3]| {
+            let other = neighbour(offset);
+            match rule.connect {
+                Connect::Block => {
+                    self.states.get(other as usize).map(|s| s.block) == Some(info.block)
+                }
+                Connect::State => other == state,
+                Connect::Tile => self
+                    .face_layers
+                    .get(other as usize)
+                    .is_some_and(|f| f[face as usize] == layer),
+            }
+        };
+        let axes = |face| match (rule.orient, info.axis) {
+            (Orient::StateAxis, Some(axis)) => Axes::column(face, axis),
+            // `orient=texture` follows the quad's own UVs; vanilla cubes are what it is used on.
+            _ => Axes::cube(face),
+        };
+        let mask = || geometry::neighbours(axes(face), face.normal(), rule.inner_seams, joins);
+        let tile = |i: usize| r.tiles.get(i).copied().unwrap_or(TileLayer::Default);
+        let index = match rule.method {
+            Method::Ctm => geometry::ctm_index(mask()),
+            Method::CtmCompact => {
+                let mask = mask();
+                let case = geometry::ctm_index(mask) as u8;
+                match rule.compact_overrides.iter().find(|&&(c, _)| c == case) {
+                    Some(&(_, t)) => t,
+                    None => {
+                        let quarters = geometry::compact_quarters(mask).map(|q| tile(q.into()));
+                        return if quarters.contains(&TileLayer::Skip) {
+                            None
+                        } else {
+                            Some(Pick::Quarters(quarters))
+                        };
+                    }
+                }
+            }
+            Method::Horizontal => geometry::horizontal(mask()),
+            Method::Vertical => geometry::vertical(mask()),
+            Method::HorizontalVertical => geometry::horizontal_vertical(mask()),
+            Method::VerticalHorizontal => geometry::vertical_horizontal(mask()),
+            Method::Top => {
+                // Only sides join the block above: the top and bottom go on to the next rule.
+                if matches!(face, Face::Up | Face::Down) {
+                    return None;
+                }
+                if !joins([0, 1, 0]) {
+                    return Some(Pick::Keep);
+                }
+                0
+            }
+            Method::Fixed => 0,
+            Method::Random => {
+                let face = geometry::symmetric_face(face, rule.symmetry);
+                let pos = if rule.linked && info.upper {
+                    [pos[0], pos[1] - 1, pos[2]]
+                } else {
+                    pos
+                };
+                geometry::random_index(pos, face, rule.random_loops, &rule.weights, r.tiles.len())
+            }
+            Method::Repeat => {
+                let face = geometry::symmetric_face(face, rule.symmetry);
+                geometry::repeat_index(pos, axes(face), rule.width, rule.height)
+            }
+            // Overlays are not loaded yet.
+            _ => return None,
+        };
+        match tile(index) {
+            TileLayer::Skip => None,
+            TileLayer::Default => Some(Pick::Keep),
+            t => Some(Pick::Tile(t)),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use horizon_optifine::Properties;
+
+    /// A tile whose layer says which tile of its rule it is: rule `r`'s tile `i` is layer
+    /// `1000 * (r + 1) + i`.
+    fn rules(files: &[(&str, &str)]) -> Vec<LoadedRule> {
+        let mut rules: Vec<Rule> = files
+            .iter()
+            .map(|(path, text)| {
+                Rule::parse(
+                    &format!("assets/minecraft/optifine/ctm/{path}"),
+                    &Properties::parse(text),
+                )
+                .unwrap()
+                .unwrap()
+            })
+            .collect();
+        ctm::sort(&mut rules);
+        rules
+            .into_iter()
+            .enumerate()
+            .map(|(n, rule)| LoadedRule {
+                tiles: rule
+                    .tiles
+                    .iter()
+                    .enumerate()
+                    .map(|(i, t)| match t {
+                        Tile::Skip => TileLayer::Skip,
+                        Tile::Default => TileLayer::Default,
+                        Tile::Texture(_) => TileLayer::Layer {
+                            layer: (1000 * (n + 1) + i) as u16,
+                            translucent: false,
+                            opaque: false,
+                        },
+                    })
+                    .collect(),
+                rule,
+            })
+            .collect()
+    }
+
+    /// State 0 air, 1 glass, 2 stone, 3 and 4 oak logs (axis y, x), 5 and 6 a door (lower,
+    /// upper); the stone sprite is layer 7.
+    fn world(files: &[(&str, &str)]) -> ConnectedTextures {
+        let props = |pairs: &[(&str, &str)]| -> BlockProperties {
+            pairs
+                .iter()
+                .map(|(k, v)| (k.to_string(), v.to_string()))
+                .collect()
+        };
+        let states = [
+            ("minecraft:air", props(&[])),
+            ("minecraft:glass", props(&[])),
+            ("minecraft:stone", props(&[])),
+            ("minecraft:oak_log", props(&[("axis", "y")])),
+            ("minecraft:oak_log", props(&[("axis", "x")])),
+            ("minecraft:oak_door", props(&[("half", "lower")])),
+            ("minecraft:oak_door", props(&[("half", "upper")])),
+        ];
+        ConnectedTextures::build(
+            rules(files),
+            states.iter().map(|(n, p)| Some((*n, p))),
+            |name| (name == "minecraft:block/stone").then_some(7),
+        )
+    }
+
+    fn tile(layer: u16) -> Pick {
+        Pick::Tile(TileLayer::Layer {
+            layer,
+            translucent: false,
+            opaque: false,
+        })
+    }
+
+    /// `pick` on `face` of the block at the origin among `blocks` (offset, state).
+    fn pick_in(
+        ctm: &ConnectedTextures,
+        state: u32,
+        layer: u16,
+        face: Face,
+        blocks: &[([i32; 3], u32)],
+    ) -> Pick {
+        let at = |o: [i32; 3]| blocks.iter().find(|(p, _)| *p == o).map_or(0, |b| b.1);
+        ctm.pick(state, layer, face, [0, 64, 0], at, || None)
+    }
+
+    const GLASS: &str = "matchBlocks=glass\nmethod=ctm\ntiles=0-46";
+
+    #[test]
+    fn glass_joins_its_neighbours() {
+        let ctm = world(&[("glass.properties", GLASS)]);
+        // Alone: tile 0. A north face's right is west: glass there is the left end of a row.
+        assert_eq!(pick_in(&ctm, 1, 3, Face::North, &[]), tile(1000));
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([-1, 0, 0], 1)]),
+            tile(1001)
+        );
+        // Glass all around in the face's plane: the middle tile, 26.
+        let ring: Vec<_> = [-1, 0, 1]
+            .into_iter()
+            .flat_map(|x| [-1, 0, 1].map(|y| ([x, y, 0], 1)))
+            .collect();
+        assert_eq!(pick_in(&ctm, 1, 3, Face::North, &ring), tile(1026));
+        // Stone beside it doesn't join; stone has no rule.
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([-1, 0, 0], 2)]),
+            tile(1000)
+        );
+        assert_eq!(pick_in(&ctm, 2, 7, Face::North, &[]), Pick::Keep);
+    }
+
+    #[test]
+    fn rule_order_faces_and_skips() {
+        let ctm = world(&[
+            (
+                "a_sides.properties",
+                "matchBlocks=stone\nmethod=fixed\ntiles=<skip>\nfaces=sides",
+            ),
+            ("b_glass.properties", GLASS),
+            ("stone.properties", "method=fixed\ntiles=x\nfaces=top"),
+            ("z.properties", "matchBlocks=stone\nmethod=fixed\ntiles=y"),
+        ]);
+        // The tile rule (stone.properties, by its file name) comes first, on the top face only.
+        assert_eq!(pick_in(&ctm, 2, 7, Face::Up, &[]), tile(1000));
+        // Sides: a_sides skips, so z draws.
+        assert_eq!(pick_in(&ctm, 2, 7, Face::North, &[]), tile(4000));
+        // The tile rule follows the sprite, whatever the block: glass with the stone sprite.
+        assert_eq!(pick_in(&ctm, 1, 7, Face::Up, &[]), tile(1000));
+    }
+
+    #[test]
+    fn compact_quarters_and_overrides() {
+        let ctm = world(&[(
+            "glass.properties",
+            "matchBlocks=glass\nmethod=ctm_compact\ntiles=0-5\nctm.1=5",
+        )]);
+        let layer = |i: u16| TileLayer::Layer {
+            layer: 1000 + i,
+            translucent: false,
+            opaque: false,
+        };
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[]),
+            Pick::Quarters([layer(0); 4])
+        );
+        // Joined right only is case 1, replaced whole by tile 5.
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([-1, 0, 0], 1)]),
+            tile(1005)
+        );
+        // Joined left only (east of a north face): quarters [3, 0, 3, 0].
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([1, 0, 0], 1)]),
+            Pick::Quarters([layer(3), layer(0), layer(3), layer(0)])
+        );
+    }
+
+    #[test]
+    fn logs_turn_with_their_axis() {
+        let ctm = world(&[(
+            "log.properties",
+            "matchBlocks=oak_log\nmethod=vertical\ntiles=0-3",
+        )]);
+        // An upright log with a log above: the bottom of a column.
+        assert_eq!(
+            pick_in(&ctm, 3, 3, Face::North, &[([0, 1, 0], 3)]),
+            tile(1000)
+        );
+        // A log lying along x: on its north face the texture's up points east, so a log to the
+        // east (same block, other axis state) is above it.
+        assert_eq!(
+            pick_in(&ctm, 4, 3, Face::North, &[([1, 0, 0], 4)]),
+            tile(1000)
+        );
+        assert_eq!(
+            pick_in(&ctm, 4, 3, Face::North, &[([0, 1, 0], 4)]),
+            tile(1003)
+        );
+    }
+
+    #[test]
+    fn top_and_connect_state() {
+        let ctm = world(&[(
+            "block_oak_log.properties",
+            "method=top\ntiles=0\nconnect=state",
+        )]);
+        assert_eq!(
+            pick_in(&ctm, 3, 3, Face::North, &[([0, 1, 0], 3)]),
+            tile(1000)
+        );
+        // The other axis is another state.
+        assert_eq!(
+            pick_in(&ctm, 3, 3, Face::North, &[([0, 1, 0], 4)]),
+            Pick::Keep
+        );
+        assert_eq!(pick_in(&ctm, 3, 3, Face::Up, &[([0, 1, 0], 3)]), Pick::Keep);
+    }
+
+    #[test]
+    fn linked_random_follows_the_lower_half() {
+        let ctm = world(&[(
+            "door.properties",
+            "matchBlocks=oak_door\nmethod=random\ntiles=0-7\nlinked=true",
+        )]);
+        let mut tiles = std::collections::HashSet::new();
+        for x in 0..20 {
+            let lower = ctm.pick(5, 3, Face::North, [x, 64, 0], |_| 0, || None);
+            let upper = ctm.pick(6, 3, Face::North, [x, 65, 0], |_| 0, || None);
+            assert_eq!(lower, upper, "{x}");
+            tiles.insert(format!("{lower:?}"));
+        }
+        assert!(tiles.len() > 3, "the doors are not all alike");
+    }
+
+    #[test]
+    fn heights_and_biomes() {
+        let ctm = world(&[(
+            "glass.properties",
+            "matchBlocks=glass\nmethod=fixed\ntiles=0\nheights=0-63\nbiomes=desert",
+        )]);
+        let at =
+            |y, biome: &'static str| ctm.pick(1, 3, Face::Up, [0, y, 0], |_| 0, || Some(biome));
+        assert_eq!(at(10, "minecraft:desert"), tile(1000));
+        assert_eq!(at(64, "minecraft:desert"), Pick::Keep);
+        assert_eq!(at(10, "minecraft:plains"), Pick::Keep);
+    }
+
+    #[test]
+    fn connect_by_tile_reads_the_neighbours_same_side() {
+        let mut ctm = world(&[(
+            "glass.properties",
+            "matchBlocks=glass\nmethod=horizontal\nconnect=tile\ntiles=0-3",
+        )]);
+        // Stone shows the glass sprite (3) on its north side; the door only on its south.
+        let mut faces = vec![[9u16; 6]; 7];
+        faces[1][Face::North as usize] = 3;
+        faces[2][Face::North as usize] = 3;
+        faces[5][Face::South as usize] = 3;
+        ctm.face_layers = faces;
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([-1, 0, 0], 2)]),
+            tile(1000)
+        );
+        assert_eq!(
+            pick_in(&ctm, 1, 3, Face::North, &[([-1, 0, 0], 5)]),
+            tile(1003)
+        );
+    }
+
+    #[test]
+    fn repeat_and_rows_then_columns() {
+        let ctm = world(&[(
+            "glass.properties",
+            "matchBlocks=glass\nmethod=repeat\nwidth=2\nheight=2\ntiles=0-3",
+        )]);
+        let at = |pos| ctm.pick(1, 3, Face::North, pos, |_| 0, || None);
+        assert_eq!(at([0, 64, 0]), tile(1000));
+        // The north face's right is west; rows run down.
+        assert_eq!(at([-1, 64, 0]), tile(1001));
+        assert_eq!(at([0, 63, 0]), tile(1002));
+        let hv = world(&[(
+            "glass.properties",
+            "matchBlocks=glass\nmethod=horizontal+vertical\ntiles=0-6",
+        )]);
+        // Alone in its row, glass above: the column's bottom, tile 4.
+        assert_eq!(
+            pick_in(&hv, 1, 3, Face::North, &[([0, 1, 0], 1)]),
+            tile(1004)
+        );
+        assert_eq!(
+            pick_in(&hv, 1, 3, Face::North, &[([-1, 0, 0], 1)]),
+            tile(1000)
+        );
+    }
+
+    #[test]
+    fn skips_defaults_and_narrowed_rules() {
+        let ctm = world(&[
+            (
+                "a.properties",
+                "matchBlocks=glass\nmethod=ctm_compact\ntiles=<skip> 1-4",
+            ),
+            (
+                "b.properties",
+                "matchBlocks=glass\nmethod=fixed\ntiles=0\nfaces=sides",
+            ),
+            (
+                "c.properties",
+                "matchBlocks=glass\nmethod=fixed\ntiles=<default>",
+            ),
+            ("d.properties", "matchBlocks=glass\nmethod=fixed\ntiles=0"),
+            (
+                "e.properties",
+                "matchBlocks=stone\nmatchTiles=glass_pane_top\nmethod=fixed\ntiles=0",
+            ),
+        ]);
+        // e names a tile, so it is tried first (tile 1000s), but needs a stone with the pane
+        // sprite. a's skipped quarter drops it; b (3000s) draws the sides; on top c draws the
+        // glass itself, which stops d.
+        assert_eq!(pick_in(&ctm, 1, 3, Face::North, &[]), tile(3000));
+        assert_eq!(pick_in(&ctm, 1, 3, Face::Up, &[]), Pick::Keep);
+        assert_eq!(pick_in(&ctm, 2, 7, Face::Up, &[]), Pick::Keep);
+        let both = world(&[(
+            "e.properties",
+            "matchBlocks=glass\nmatchTiles=stone\nmethod=fixed\ntiles=0",
+        )]);
+        assert_eq!(pick_in(&both, 1, 7, Face::Up, &[]), tile(1000));
+        assert_eq!(pick_in(&both, 1, 3, Face::Up, &[]), Pick::Keep);
+        assert_eq!(pick_in(&both, 2, 7, Face::Up, &[]), Pick::Keep);
+        // `top` passes the top face on.
+        let top = world(&[
+            ("block_glass.properties", "method=top\ntiles=0"),
+            (
+                "z.properties",
+                "matchBlocks=glass\nmethod=fixed\ntiles=0\nfaces=top",
+            ),
+        ]);
+        assert_eq!(pick_in(&top, 1, 3, Face::Up, &[]), tile(2000));
+    }
+
+    #[test]
+    fn sprite_names() {
+        assert_eq!(
+            sprite_name("assets/minecraft/textures/block/dirt.png"),
+            "minecraft:block/dirt"
+        );
+        assert_eq!(
+            sprite_name("assets/minecraft/optifine/ctm/glass/0.png"),
+            "assets/minecraft/optifine/ctm/glass/0.png"
+        );
+    }
+}
@@ -4,7 +4,7 @@
 pub use crate::chunk::block_entity::{
    Banner, Beacon, BlockEntity, Brushable, Campfire, ChiseledBookshelf, Crafter, CreakingHeart,
    EndGateway, Furnace, FurnaceKind, Jukebox, Lectern, MOD_MENUS, ModBlockEntity, ModContainer,
-    ModFluidTanks, PotentSulfur, Shelf, Skull, SkullSkin,
+    ModEnergyBuffer, ModFluidTanks, PotentSulfur, Shelf, Skull, SkullSkin,
 };
 use crate::items::ItemStack;
 use std::collections::HashMap;
@@ -195,14 +195,6 @@ fn read(path: &str) -> Option<String> {
    std::fs::read_to_string(path).ok()
 }

-fn windows_processor_name(query: &str) -> Option<String> {
-    query.lines().find_map(|line| {
-        let (_, value) = line.split_once("REG_SZ")?;
-        let value = value.trim();
-        (!value.is_empty()).then(|| value.to_owned())
-    })
-}
-
 /// `PRETTY_NAME` of /etc/os-release and the kernel, or the system's own version string.
 fn operating_system() -> String {
    let arch = std::env::consts::ARCH;
@@ -220,7 +212,7 @@ fn operating_system() -> String {
    } else if cfg!(target_os = "macos") {
        command_output("sw_vers", &["-productVersion"]).map(|v| format!("macOS {v}"))
    } else if cfg!(windows) {
-        command_output("cmd", &["/C", "ver"])
+        horizon_telemetry::system::windows_version()
    } else {
        None
    };
@@ -235,26 +227,11 @@ fn operating_system() -> String {
 pub fn cpu() -> String {
    let threads = std::thread::available_parallelism().map_or(0, |n| n.get());
    let name = if cfg!(target_os = "linux") {
-        read("/proc/cpuinfo").and_then(|t| {
-            t.lines()
-                .find(|l| l.starts_with("model name"))
-                .and_then(|l| l.split_once(':'))
-                .map(|(_, v)| v.trim().to_owned())
-        })
+        read("/proc/cpuinfo").and_then(|t| horizon_telemetry::system::linux_cpu_name(&t))
    } else if cfg!(target_os = "macos") {
        command_output("sysctl", &["-n", "machdep.cpu.brand_string"])
    } else if cfg!(windows) {
-        command_output(
-            "reg",
-            &[
-                "query",
-                r"HKLM\HARDWARE\DESCRIPTION\System\CentralProcessor\0",
-                "/v",
-                "ProcessorNameString",
-            ],
-        )
-        .and_then(|query| windows_processor_name(&query))
-        .or_else(|| std::env::var("PROCESSOR_IDENTIFIER").ok())
+        horizon_telemetry::system::windows_cpu()
    } else {
        std::env::var("PROCESSOR_IDENTIFIER").ok()
    };
@@ -407,6 +384,30 @@ pub fn report_watchdog(home: &Path, side: &'static str, message: String) -> Opti
    )
 }

+/// The report for a game that went over the player's RAM limit (`ram_limit`), written by the
+/// watcher thread: it says nothing about where the memory went, so it carries no stack. The player
+/// chose this limit, so it is no bug to send (`telemetry::keep_crash`), and leaving that out ends
+/// the game seconds sooner: it keeps running, over its limit, until the report is written.
+pub fn report_memory_limit(home: &Path, side: &'static str, message: String) {
+    if REPORTED.swap(true, Ordering::SeqCst) {
+        return;
+    }
+    let report = Report {
+        time: Local::now(),
+        description: "RAM limit reached".into(),
+        error: message,
+        stack: String::new(),
+        thread: thread_name(side),
+        side,
+        details: system_details(side),
+        log: crate::logging::recent_lines(),
+    };
+    match report.save(home) {
+        Ok(path) => eprintln!("{SAVED_LINE}{}", path.display()),
+        Err(e) => eprintln!("Horizon: could not save a crash report: {e}"),
+    }
+}
+
 fn payload_text(payload: &(dyn std::any::Any + Send)) -> String {
    payload
        .downcast_ref::<&str>()
@@ -657,22 +658,6 @@ pub fn debug_crash_after() -> Option<std::time::Duration> {
 mod tests {
    use super::*;

-    #[test]
-    fn windows_registry_cpu_name_is_read_without_the_registry_columns() {
-        let query = r#"
-HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System\CentralProcessor\0
-    ProcessorNameString    REG_SZ    13th Gen Intel(R) Core(TM) i7-13700F
-"#;
-        assert_eq!(
-            windows_processor_name(query).as_deref(),
-            Some("13th Gen Intel(R) Core(TM) i7-13700F")
-        );
-        assert_eq!(
-            windows_processor_name("ProcessorNameString REG_SZ   "),
-            None
-        );
-    }
-
    #[test]
    fn a_release_reports_its_built_in_version() {
        // release.yml builds with HORIZON_VERSION (docs/versioning.md): `v0.2.3`, wherever it is installed.
@@ -575,7 +575,7 @@ pub struct DataStore {
    /// `item_modifier` files, for `/item modify`.
    pub item_modifiers: BTreeMap<String, serde_json::Value>,
    /// The content tables' raw files from the packs after the built-in one:
-    /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `dialog/` and `tags/…/` files, by
+    /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `dialog/`, `data_maps/` and `tags/…/` files, by
    /// `<kind-dir>/<ns>:<path>`, each id's files in pack order. The tables
    /// merge them over what they read from the resource root.
    pub files: BTreeMap<String, Vec<Vec<u8>>>,
@@ -584,7 +584,7 @@ pub struct DataStore {
 }
 /// `<kind-dir>/<ns>:<path>` for a pack file the content tables read:
 /// `recipe/`, `recipe_filter/`, `loot_table/`, `advancement/`, `trade_set/`,
-/// `villager_trade/`, `dialog/` or `tags/<sub>/`, where the id keeps the sub
+/// `villager_trade/`, `dialog/`, `data_maps/` or `tags/<sub>/`, where the id keeps the sub
 /// path so a nested tag kind stays addressable.
 fn content_id(file: &str) -> Option<String> {
    let rest = file.strip_prefix("data/")?;
@@ -592,7 +592,7 @@ fn content_id(file: &str) -> Option<String> {
    let (kind, rest) = rest.split_once('/')?;
    let kind = match kind {
        "recipe" | "recipe_filter" | "loot_table" | "advancement" | "trade_set"
-        | "villager_trade" | "dialog" => kind,
+        | "villager_trade" | "dialog" | "data_maps" => kind,
        // A tag id is `{ns}:{path-under-tags}` (`tags/worldgen/biome/
        // test:sub/mytag`), the whole path after the namespace, so nested
        // registries keep their directory (`TagLoader`'s id shape).
@@ -623,6 +623,7 @@ impl DataStore {
            let builtin = pack.id == "vanilla";
            for f in pack.list_kinds(&[
                "advancement",
+                "data_maps",
                "dialog",
                "function",
                "item_modifier",
@@ -882,6 +883,15 @@ pub fn worldgen_overrides(
 mod tests {
    use super::*;

+    #[test]
+    fn data_map_files_are_content_files_keyed_by_map_namespace_and_registry() {
+        assert_eq!(
+            content_id("data/mymod/data_maps/item/fuel.json").as_deref(),
+            Some("data_maps/mymod:item/fuel")
+        );
+        assert_eq!(content_id("data/mymod/data_maps/item/fuel.txt"), None);
+    }
+
    #[test]
    fn enabled_packs_override_worldgen_in_order() {
        let dir = std::env::temp_dir().join(format!("hz-datapack-worldgen-{}", std::process::id()));
@@ -111,6 +111,10 @@ pub struct Extras {
    pub sort: bool,
    /// A vanilla key name: sorts the part under the cursor.
    pub sort_key: String,
+    /// A new chat line slides in from the left while it fades in (`Chat::layout`).
+    pub chat_animation: bool,
+    /// The indicator bar at the left of a chat line (on by default, as vanilla).
+    pub chat_indicator: bool,
    /// No AI: every AI feature hidden and off (`horizon_core::no_ai`; the launcher writes it too).
    pub no_ai: bool,
    /// Agents may control the game the player starts: it opens its control socket for
@@ -152,6 +156,8 @@ impl Default for Extras {
            mouse_tweaks_wheel: true,
            sort: false,
            sort_key: "key.keyboard.unknown".into(),
+            chat_animation: false,
+            chat_indicator: true,
            no_ai: false,
            agent_control: false,
            discord_presence: true,
@@ -230,6 +236,8 @@ impl Extras {
                "mouseTweaksWheel" => e.mouse_tweaks_wheel = flag(e.mouse_tweaks_wheel),
                "sort" => e.sort = flag(e.sort),
                "sortKey" if value.starts_with("key.") => e.sort_key = value.to_owned(),
+                "chatAnimation" => e.chat_animation = flag(e.chat_animation),
+                "chatIndicator" => e.chat_indicator = flag(e.chat_indicator),
                horizon_core::no_ai::KEY => e.no_ai = flag(e.no_ai),
                "agentControl" => e.agent_control = flag(e.agent_control),
                "discordPresence" => e.discord_presence = flag(e.discord_presence),
@@ -241,7 +249,7 @@ impl Extras {
    }
    pub fn serialize(&self) -> String {
        format!(
-            "fullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nuiSoundReserve:{}\nownNameTag:{}\nhideBlockParticles:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\n{}:{}\nagentControl:{}\ndiscordPresence:{}\nsplitscreen:{}\n",
+            "fullbright:{}\ndynamicLights:{}\nzoom:{}\nzoomKey:{}\nzoomLevel:{}\nzoomSmooth:{}\nzoomSensitivity:{}\nfps:{}\nfpsCorner:{}\nfpsLows:{}\nkeystrokes:{}\nkeystrokesCorner:{}\nkeystrokesCps:{}\nmovedToMods:{}\nminimap:{}\nminimapCorner:{}\nminimapSize:{}\nminimapShape:{}\nminimapZoom:{}\nminimapRotate:{}\nautoReconnect:{}\nuiSoundReserve:{}\nownNameTag:{}\nhideBlockParticles:{}\nmouseTweaks:{}\nmouseTweaksWheel:{}\nsort:{}\nsortKey:{}\nchatAnimation:{}\nchatIndicator:{}\n{}:{}\nagentControl:{}\ndiscordPresence:{}\nsplitscreen:{}\n",
            bool_text(self.fullbright),
            bool_text(self.dynamic_lights),
            bool_text(self.zoom),
@@ -274,6 +282,8 @@ impl Extras {
            bool_text(self.mouse_tweaks_wheel),
            bool_text(self.sort),
            self.sort_key,
+            bool_text(self.chat_animation),
+            bool_text(self.chat_indicator),
            horizon_core::no_ai::KEY,
            bool_text(self.no_ai),
            bool_text(self.agent_control),
@@ -406,6 +416,10 @@ pub enum Item {
    MouseTweaksWheel,
    Sort,
    SortKey,
+    /// A new chat line slides in and fades in (`Chat::layout`).
+    ChatAnimation,
+    /// The coloured bar at the left of a chat line.
+    ChatIndicator,
    /// Not on the Extras page: Horizon Settings shows No AI, its AI Agent page Agent Control.
    NoAi,
    AgentControl,
@@ -414,29 +428,84 @@ pub enum Item {
    /// On the Splitscreen settings page.
    Splitscreen,
 }
-/// The Extras page: headers and items.
+/// The Extras page: headers (language keys) and items.
 pub fn rows() -> Vec<Result<Item, &'static str>> {
    use Item::*;
    vec![
-        Err("Lighting"),
+        Err("horizon.extras.header.lighting"),
        Ok(Fullbright),
        Ok(DynamicLights),
-        Err("Third person"),
+        Err("horizon.extras.header.third_person"),
        Ok(OwnNameTag),
-        Err("Particles"),
+        Err("horizon.extras.header.particles"),
        Ok(HideBlockParticles),
-        Err("Inventory"),
+        Err("horizon.extras.header.inventory"),
        Ok(MouseTweaks),
        Ok(MouseTweaksWheel),
        Ok(Sort),
        Ok(SortKey),
-        Err("Multiplayer"),
+        Err("horizon.extras.header.chat"),
+        Ok(ChatAnimation),
+        Ok(ChatIndicator),
+        Err("horizon.extras.header.multiplayer"),
        Ok(AutoReconnect),
-        Err("Sound"),
+        Err("horizon.extras.header.sound"),
        Ok(UiSoundReserve),
    ]
 }
 impl Item {
+    /// The language key of the caption (`horizon.*`, assets/horizon/lang).
+    pub fn caption_key(self) -> &'static str {
+        match self {
+            Item::Fullbright => "horizon.extras.fullbright",
+            Item::DynamicLights => "horizon.extras.dynamic_lights",
+            Item::OwnNameTag => "horizon.extras.own_name_tag",
+            Item::HideBlockParticles => "horizon.extras.hide_block_particles",
+            Item::AutoReconnect => "horizon.extras.auto_reconnect",
+            Item::UiSoundReserve => "horizon.extras.ui_sound_reserve",
+            Item::MouseTweaks => "horizon.extras.mouse_tweaks",
+            Item::MouseTweaksWheel => "horizon.extras.mouse_tweaks_wheel",
+            Item::Sort => "horizon.extras.sort",
+            Item::SortKey => "horizon.extras.sort_key",
+            Item::NoAi => "horizon.extras.no_ai",
+            Item::AgentControl => "horizon.extras.agent_control",
+            Item::DiscordPresence => "horizon.extras.discord_presence",
+            Item::Splitscreen => "horizon.extras.splitscreen",
+            Item::ChatAnimation => "horizon.extras.chat_animation",
+            Item::ChatIndicator => "horizon.extras.chat_indicator",
+        }
+    }
+    /// The language key of the description shown as the row's tooltip.
+    pub fn description_key(self) -> &'static str {
+        match self {
+            Item::Fullbright => "horizon.extras.fullbright.tooltip",
+            Item::DynamicLights => "horizon.extras.dynamic_lights.tooltip",
+            Item::OwnNameTag => "horizon.extras.own_name_tag.tooltip",
+            Item::HideBlockParticles => "horizon.extras.hide_block_particles.tooltip",
+            Item::AutoReconnect => "horizon.extras.auto_reconnect.tooltip",
+            Item::UiSoundReserve => "horizon.extras.ui_sound_reserve.tooltip",
+            Item::MouseTweaks => "horizon.extras.mouse_tweaks.tooltip",
+            Item::MouseTweaksWheel => "horizon.extras.mouse_tweaks_wheel.tooltip",
+            Item::Sort => "horizon.extras.sort.tooltip",
+            Item::SortKey => "horizon.extras.sort_key.tooltip",
+            Item::NoAi => "horizon.extras.no_ai.tooltip",
+            Item::AgentControl => "horizon.extras.agent_control.tooltip",
+            Item::DiscordPresence => "horizon.extras.discord_presence.tooltip",
+            Item::Splitscreen => "horizon.extras.splitscreen.tooltip",
+            Item::ChatAnimation => "horizon.extras.chat_animation.tooltip",
+            Item::ChatIndicator => "horizon.extras.chat_indicator.tooltip",
+        }
+    }
+    /// The caption in the current language (English when the key is missing).
+    pub fn caption_text(self) -> String {
+        crate::lang::get_or(self.caption_key(), self.caption())
+    }
+    /// The description in the current language (English when the key is missing).
+    pub fn description_text(self) -> String {
+        crate::lang::get_or(self.description_key(), self.description())
+    }
+    /// The English caption: the fallback of [`Item::caption_text`], and the text of
+    /// `horizon.extras.*` in en_us.json.
    pub fn caption(self) -> &'static str {
        match self {
            Item::Fullbright => "Fullbright",
@@ -449,6 +518,8 @@ impl Item {
            Item::MouseTweaksWheel => "Scroll wheel moves items",
            Item::Sort => "Sort buttons",
            Item::SortKey => "Sort key",
+            Item::ChatAnimation => "Smooth chat",
+            Item::ChatIndicator => "Message indicator",
            Item::NoAi => "No AI",
            Item::AgentControl => "Agent Control",
            Item::DiscordPresence => "Discord Rich Presence",
@@ -462,13 +533,15 @@ impl Item {
            UiSoundReserve => return None,
            MouseTweaksWheel => MouseTweaks,
            SortKey => Sort,
+            ChatIndicator => ChatAnimation,
            Fullbright | DynamicLights | OwnNameTag | HideBlockParticles | MouseTweaks | Sort
-            | AutoReconnect | NoAi | AgentControl | DiscordPresence | Splitscreen => {
+            | AutoReconnect | NoAi | AgentControl | DiscordPresence | Splitscreen
+            | ChatAnimation => {
                return None;
            }
        })
    }
-    /// What the row says under its caption.
+    /// The English description: the fallback of [`Item::description_text`].
    pub fn description(self) -> &'static str {
        match self {
            Item::Fullbright => "Show blocks and entities at full light, even in dark areas.",
@@ -499,6 +572,10 @@ impl Item {
            Item::SortKey => {
                "Sorts the part under the cursor. Click, then press a key; Escape unbinds it."
            }
+            Item::ChatAnimation => {
+                "A new chat line slides in from the left while it fades in, instead of appearing whole."
+            }
+            Item::ChatIndicator => "The coloured bar at the left of a chat line.",
            Item::NoAi => {
                "Hides and turns off every AI feature: agent control, horizon-ctl and the MCP servers. The launcher's switch too."
            }
@@ -520,6 +597,7 @@ impl Item {
            Item::Fullbright => Some(Cost::None),
            Item::UiSoundReserve => Some(Cost::None),
            Item::DynamicLights => Some(Cost::Low),
+            Item::ChatAnimation => Some(Cost::None),
            Item::OwnNameTag
            | Item::HideBlockParticles
            | Item::AutoReconnect
@@ -541,6 +619,8 @@ impl Item {
            Item::MouseTweaks => e.mouse_tweaks,
            Item::MouseTweaksWheel => e.mouse_tweaks_wheel,
            Item::Sort => e.sort,
+            Item::ChatAnimation => e.chat_animation,
+            Item::ChatIndicator => e.chat_indicator,
            Item::NoAi => e.no_ai,
            Item::AgentControl => e.agent_control,
            Item::DiscordPresence => e.discord_presence,
@@ -553,8 +633,8 @@ impl Item {
        match self {
            Item::SortKey => crate::keybinds::display_name(&e.sort_key).plain(),
            other => match other.switch(e) {
-                Some(true) => "On".into(),
-                _ => "Off".into(),
+                Some(true) => crate::lang::get_or("On", "On"),
+                _ => crate::lang::get_or("Off", "Off"),
            },
        }
    }
@@ -571,6 +651,8 @@ impl Item {
            Item::MouseTweaks => e.mouse_tweaks = !e.mouse_tweaks,
            Item::MouseTweaksWheel => e.mouse_tweaks_wheel = !e.mouse_tweaks_wheel,
            Item::Sort => e.sort = !e.sort,
+            Item::ChatAnimation => e.chat_animation = !e.chat_animation,
+            Item::ChatIndicator => e.chat_indicator = !e.chat_indicator,
            Item::NoAi => e.no_ai = !e.no_ai,
            Item::AgentControl => e.agent_control = !e.agent_control,
            Item::DiscordPresence => e.discord_presence = !e.discord_presence,
@@ -633,6 +715,8 @@ mod tests {
        e.mouse_tweaks_wheel = false;
        e.sort = true;
        e.sort_key = "key.keyboard.r".into();
+        e.chat_animation = true;
+        e.chat_indicator = false;
        e.discord_presence = false;
        assert!(!e.splitscreen);
        Item::Splitscreen.cycle(&mut e, false);
@@ -252,6 +252,18 @@ impl Arena {
    pub fn page_vertices(&self) -> u64 {
        self.page_limit
    }
+    /// `page`'s buffer up to the end of its last range in use, as draws bind it:
+    /// wgpu clears what a binding covers and nothing wrote yet when the frame is
+    /// submitted, most of a page just made or grown.
+    pub fn binding(&self, page: u32) -> wgpu::BufferSlice<'_> {
+        let p = self.pages[page as usize].as_ref().expect("live arena page");
+        let end = match p.free.0.last_key_value() {
+            Some((&start, &len)) if start + len == p.capacity => start,
+            _ => p.capacity,
+        };
+        // A page a draw names holds a range; wgpu refuses an empty slice.
+        p.buffer.slice(..end.max(GRAIN) * self.stride)
+    }
    pub fn has_page(&self, page: u32) -> bool {
        self.pages.get(page as usize).is_some_and(Option::is_some)
    }
@@ -784,6 +796,32 @@ mod tests {
        }
    }

+    /// Draws bind a large page up to the end of its last range in use, a grain at
+    /// least: wgpu clears what a binding covers and nothing wrote when the frame is
+    /// submitted, so a grown page bound whole had its new tail cleared on the GPU.
+    #[test]
+    fn large_pages_are_bound_up_to_their_last_range_in_use() {
+        let Some((device, queue)) = device() else {
+            eprintln!("no GPU adapter: skipped");
+            return;
+        };
+        let mut arena = Arena::translucent(&device, 24, GRAIN);
+        let ranges: Vec<_> = (0..3)
+            .map(|_| alloc(&mut arena, &device, &queue, GRAIN).unwrap())
+            .collect();
+        // The third grain grew the page to four.
+        assert_eq!(arena.buffer(0).size(), 4 * GRAIN * 24);
+        assert_eq!(arena.binding(0).size(), 3 * GRAIN * 24);
+        // A free range before the last in use stays bound, none after it; an empty
+        // page binds a grain (wgpu refuses an empty slice).
+        arena.release(0, ranges[1].1, GRAIN);
+        assert_eq!(arena.binding(0).size(), 3 * GRAIN * 24);
+        arena.release(0, ranges[2].1, GRAIN);
+        assert_eq!(arena.binding(0).size(), GRAIN * 24);
+        arena.release(0, ranges[0].1, GRAIN);
+        assert_eq!(arena.binding(0).size(), GRAIN * 24);
+    }
+
    #[test]
    fn empty_pages_are_reclaimed_without_moving_live_ranges() {
        let Some((device, queue)) = device() else {
@@ -585,23 +585,25 @@ impl Cull {
        self.current = Some(self.next);
    }

-    /// After the frame's submission: start reading its results back.
-    pub fn submitted(&mut self) {
-        let Some(i) = self.current.take() else {
-            return;
-        };
+    /// The frame's results to read back, started by calling it right after the frame's
+    /// submission (on the submit thread, when the frame goes there).
+    pub fn submitted(&mut self) -> Option<impl FnOnce() + Send + 'static> {
+        let i = self.current.take()?;
        let r = &self.readbacks[i];
        let state = r.state.clone();
        state.store(PENDING, Ordering::Release);
-        r.buffer
-            .slice(..r.slots.len() as u64 * 4)
-            .map_async(wgpu::MapMode::Read, move |result| {
-                state.store(
-                    if result.is_ok() { MAPPED } else { FREE },
-                    Ordering::Release,
-                );
-            });
+        let (buffer, bytes) = (r.buffer.clone(), r.slots.len() as u64 * 4);
        self.next = (i + 1) % READBACKS;
+        Some(move || {
+            buffer
+                .slice(..bytes)
+                .map_async(wgpu::MapMode::Read, move |result| {
+                    state.store(
+                        if result.is_ok() { MAPPED } else { FREE },
+                        Ordering::Release,
+                    );
+                });
+        })
    }

    fn make_group(
@@ -1,11 +1,572 @@
-//! Frame generation: FSR 3.1's frame interpolation will show a frame halfway between each
-//! two real ones. So far this holds its optical flow, its interpolation and the motion
-//! vectors of what moves on its own; the setting that runs them comes next.
+//! Frame generation (a Horizon setting, off by default): FSR 3.1's frame interpolation
+//! makes a frame halfway between each two real ones. The world, without the hand and
+//! HUD, is kept at the screen's size each frame; optical flow and the interpolation run
+//! on it, the hand and HUD are drawn over the made frame as over the real one, and a
+//! present thread shows the made frame, then the real one half a real frame later.
+//!
+//! The renderer draws into frames of its own while this is on; the present thread
+//! copies each to the swapchain, which it alone acquires and presents.

-// Unused until the renderer runs them.
-#[allow(dead_code)]
 mod interpolation;
-#[allow(dead_code)]
 mod motion;
-#[allow(dead_code)]
 mod optical_flow;
+
+use glam::{DMat4, DVec3, Mat4};
+use std::{
+    sync::{
+        Arc,
+        atomic::{AtomicBool, Ordering},
+        mpsc,
+    },
+    thread,
+    time::{Duration, Instant},
+};
+
+/// Frames to draw into: a pair being drawn, a pair waiting and a pair being shown.
+const FRAMES: usize = 6;
+
+/// `HORIZON_FRAMEGEN_DEBUG=generated`: show only made frames (AMD's debug view), so a
+/// screenshot or an offscreen frame is the made one; `motion`: the same, each made frame
+/// showing what moved on its own in blue (its motion vectors in red and green).
+pub(super) fn generated_only() -> bool {
+    debug().is_some()
+}
+
+fn debug() -> Option<&'static str> {
+    static DEBUG: std::sync::OnceLock<Option<String>> = std::sync::OnceLock::new();
+    DEBUG
+        .get_or_init(|| {
+            std::env::var("HORIZON_FRAMEGEN_DEBUG")
+                .ok()
+                .filter(|v| v == "generated" || v == "motion")
+        })
+        .as_deref()
+}
+
+pub struct FrameGen {
+    pub on: bool,
+    /// The present thread failed to show a frame (or died): until the renderer has
+    /// acquired a frame itself, the normal path runs and handles the surface.
+    pub paused: bool,
+    gpu: Option<Gpu>,
+    presenter: Option<Presenter>,
+    /// When the last real frame was handed over, and the time between real frames.
+    last: Option<Instant>,
+    interval: Duration,
+    /// The last frame's unjittered `view_proj` and camera.
+    previous: Option<(DMat4, DVec3)>,
+    /// The last frame's hand vertices and the bob and view they were drawn with.
+    hand: Vec<crate::mesher::Vertex>,
+    hand_view: Mat4,
+    /// Offscreen, the frame the made frame is drawn into.
+    offscreen_generated: Option<wgpu::Texture>,
+    /// Motion vectors for what moves on its own, made on the first frame.
+    motion: Option<motion::ObjectMotion>,
+    /// Real frames and made ones handed to the screen since `shown_since`, and the share
+    /// of real frames that had a made frame over the last half second (the F3 screen's),
+    /// `None` while off.
+    real: u32,
+    made: u32,
+    shown_since: Instant,
+    pub made_share: Option<f32>,
+}
+
+/// What runs on the GPU for one screen size.
+struct Gpu {
+    size: [u32; 2],
+    flow: optical_flow::OpticalFlow,
+    interpolation: interpolation::Interpolation,
+    /// This frame's world at the screen's size, and bindings that copy it or the
+    /// interpolation's output (`Post::finish_with`).
+    world: wgpu::TextureView,
+    world_group: wgpu::BindGroup,
+    output_group: wgpu::BindGroup,
+    /// The next interpolation has no previous frame.
+    reset: bool,
+}
+
+/// This frame's camera, for the interpolation.
+pub struct Camera {
+    /// The world's projection this frame (with TAA's jitter) and without the jitter.
+    pub jittered: Mat4,
+    pub view_proj: Mat4,
+    pub depth: wgpu::TextureView,
+    pub render_size: [u32; 2],
+    pub jitter: [f32; 2],
+    /// This frame's unjittered clip space to the previous frame's, `None` without one.
+    pub reproject: Option<Mat4>,
+    pub near: f32,
+    pub far: f32,
+    pub fov_y: f32,
+}
+
+impl FrameGen {
+    pub fn new() -> Self {
+        Self {
+            on: false,
+            paused: false,
+            gpu: None,
+            presenter: None,
+            last: None,
+            interval: Duration::from_millis(16),
+            previous: None,
+            hand: Vec::new(),
+            hand_view: Mat4::IDENTITY,
+            offscreen_generated: None,
+            motion: None,
+            real: 0,
+            made: 0,
+            shown_since: Instant::now(),
+            made_share: None,
+        }
+    }
+
+    /// Ends frame generation's frames and present thread: before the surface is
+    /// reconfigured or the renderer acquires from it itself.
+    pub fn stop(&mut self) {
+        self.presenter = None;
+        self.made_share = None;
+        (self.real, self.made) = (0, 0);
+        self.last = None;
+        self.previous = None;
+        self.hand.clear();
+        if let Some(motion) = &mut self.motion {
+            motion.reset();
+        }
+        if let Some(gpu) = &mut self.gpu {
+            gpu.reset = true;
+        }
+    }
+
+    /// The hand for the made frame, appended to `out`: each vertex halfway between where
+    /// it was on screen last frame and where it is now (the hand swings and bobs on its
+    /// own, so the world's interpolation can't move it), in this frame's space
+    /// (`view`: this frame's bob and view). This frame's hand where the two differ in
+    /// shape (another item, the first frame).
+    pub fn halfway_hand(
+        &mut self,
+        hand: &[crate::mesher::Vertex],
+        view: Mat4,
+        out: &mut Vec<crate::mesher::Vertex>,
+    ) {
+        let same = self.hand.len() == hand.len()
+            && self
+                .hand
+                .iter()
+                .zip(hand)
+                .all(|(a, b)| a.layer == b.layer && a.uv == b.uv);
+        if same {
+            let back = view.inverse();
+            out.extend(self.hand.iter().zip(hand).map(|(before, now)| {
+                let then = self.hand_view.transform_point3(before.pos.into());
+                let mid = (then + view.transform_point3(now.pos.into())) * 0.5;
+                crate::mesher::Vertex {
+                    pos: back.transform_point3(mid).into(),
+                    ..*now
+                }
+            }));
+        } else {
+            out.extend_from_slice(hand);
+        }
+        self.hand.clear();
+        self.hand.extend_from_slice(hand);
+        self.hand_view = view;
+    }
+
+    /// This frame's entity vertices (relative to `camera`) and the entity ids of their
+    /// spans (`Frame::entity_motion`), for their own motion vectors; `atlas`: the
+    /// entities' textures. Before `generate`, every frame.
+    pub fn track_entities(
+        &mut self,
+        device: &wgpu::Device,
+        atlas: &wgpu::TextureView,
+        entities: &[crate::mesher::Vertex],
+        spans: &[(u32, u64)],
+        camera: DVec3,
+    ) {
+        self.motion
+            .get_or_insert_with(|| motion::ObjectMotion::new(device, atlas.clone()))
+            .track(entities, spans, camera);
+    }
+
+    /// This frame's unjittered clip space to the last frame's, from their `view_proj`s
+    /// (relative to `camera`); `None` on the first frame.
+    pub fn camera_motion(&mut self, view_proj: Mat4, camera: DVec3) -> Option<Mat4> {
+        let current = view_proj.as_dmat4();
+        let previous = self.previous.replace((current, camera));
+        previous.map(|(p, pc)| super::world_post::reprojection(p, pc, current, camera).as_mat4())
+    }
+
+    /// Frames to draw the real and the made frame into, from the present thread's
+    /// (started for this `config`'s surface) or, offscreen, the offscreen target and
+    /// one of its own. `None` once the present thread failed or died: it is stopped and
+    /// frame generation `paused`.
+    pub fn frames(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        surface: Option<&Arc<wgpu::Surface<'static>>>,
+        offscreen: Option<&wgpu::Texture>,
+        window: &Arc<winit::window::Window>,
+        config: &wgpu::SurfaceConfiguration,
+    ) -> Option<(wgpu::Texture, wgpu::Texture)> {
+        let Some(surface) = surface else {
+            let real = offscreen.cloned().unwrap_or_else(|| frame(device, config));
+            if self
+                .offscreen_generated
+                .as_ref()
+                .is_none_or(|t| t.size() != real.size())
+            {
+                self.offscreen_generated = Some(frame(device, config));
+            }
+            let generated = self.offscreen_generated.clone().expect("made above");
+            return Some((real, generated));
+        };
+        if self.presenter.as_ref().is_some_and(|p| p.config != *config) {
+            self.presenter = None;
+        }
+        let presenter = self.presenter.get_or_insert_with(|| {
+            Presenter::start(device, queue, surface.clone(), window.clone(), config)
+        });
+        // A closed channel: the thread died.
+        let pair = if presenter.failed() {
+            None
+        } else {
+            presenter.free.recv().ok().zip(presenter.free.recv().ok())
+        };
+        if pair.is_none() {
+            self.stop();
+            self.paused = true;
+        }
+        pair
+    }
+
+    /// The world's target at the screen's size this frame, where `Post::finish` draws.
+    pub fn world(
+        &mut self,
+        device: &wgpu::Device,
+        post: &super::world_post::Post,
+        config: &wgpu::SurfaceConfiguration,
+    ) -> wgpu::TextureView {
+        let size = [config.width, config.height];
+        if self.gpu.as_ref().is_none_or(|g| g.size != size) {
+            let world = device
+                .create_texture(&wgpu::TextureDescriptor {
+                    label: Some("Frame generation world"),
+                    size: wgpu::Extent3d {
+                        width: size[0],
+                        height: size[1],
+                        depth_or_array_layers: 1,
+                    },
+                    mip_level_count: 1,
+                    sample_count: 1,
+                    dimension: wgpu::TextureDimension::D2,
+                    format: config.format.remove_srgb_suffix(),
+                    // COPY_SRC: the interpolation keeps it as the previous frame.
+                    usage: wgpu::TextureUsages::RENDER_ATTACHMENT
+                        | wgpu::TextureUsages::TEXTURE_BINDING
+                        | wgpu::TextureUsages::COPY_SRC,
+                    view_formats: &[],
+                })
+                .create_view(&Default::default());
+            let interpolation = interpolation::Interpolation::new(device, size);
+            self.gpu = Some(Gpu {
+                size,
+                flow: optical_flow::OpticalFlow::new(device, size),
+                world_group: post.bind(device, &world),
+                output_group: post.bind(device, interpolation.output()),
+                interpolation,
+                world,
+                reset: true,
+            });
+        }
+        self.gpu.as_ref().expect("made above").world.clone()
+    }
+
+    /// Copy the world (`world`) onto `screen` for the real frame, and draw the made
+    /// frame's world onto `generated`. Returns false when there is no made frame (the
+    /// first after a reset): `generated` then holds this frame's world too.
+    #[allow(clippy::too_many_arguments)]
+    pub fn generate(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        encoder: &mut wgpu::CommandEncoder,
+        post: &super::world_post::Post,
+        screen: &wgpu::TextureView,
+        generated: &wgpu::TextureView,
+        camera: &Camera,
+    ) -> bool {
+        let gpu = self.gpu.as_mut().expect("world() ran this frame");
+        post.finish_with(encoder, screen, &gpu.world_group, None);
+        let reset = gpu.reset || camera.reproject.is_none();
+        let reproject = camera.reproject.unwrap_or(Mat4::IDENTITY);
+        let object_motion = self
+            .motion
+            .as_mut()
+            .expect("track_entities() ran this frame")
+            .draw(
+                device,
+                queue,
+                encoder,
+                &camera.depth,
+                camera.render_size,
+                camera.jittered,
+                camera.view_proj,
+                reproject * camera.view_proj,
+            );
+        gpu.flow.dispatch(device, queue, encoder, &gpu.world, reset);
+        gpu.interpolation.dispatch(
+            device,
+            queue,
+            encoder,
+            &interpolation::Inputs {
+                color: &gpu.world,
+                depth: &camera.depth,
+                render_size: camera.render_size,
+                jitter: camera.jitter,
+                reproject,
+                object_motion: &object_motion,
+                near: camera.near,
+                far: camera.far,
+                fov_y: camera.fov_y,
+                reset,
+                flow_vectors: gpu.flow.vectors(),
+                scene_change: gpu.flow.scene_change(),
+            },
+        );
+        gpu.reset = false;
+        if debug() == Some("motion") {
+            post.finish_with(encoder, generated, &post.bind(device, &object_motion), None);
+            return true;
+        }
+        if reset {
+            post.finish_with(encoder, generated, &gpu.world_group, None);
+        } else {
+            post.finish_with(encoder, generated, &gpu.output_group, None);
+        }
+        !reset
+    }
+
+    /// Hand this frame's pair to the present thread, after the frame's submission: the
+    /// made frame (when `made`) goes first.
+    pub fn present(&mut self, real: wgpu::Texture, generated: wgpu::Texture, made: bool) {
+        let now = Instant::now();
+        if let Some(last) = self.last {
+            // A real frame's time, smoothed: the made frame shows for half of it.
+            let dt = (now - last).min(Duration::from_millis(250));
+            self.interval = self.interval.mul_f32(0.9) + dt.mul_f32(0.1);
+        }
+        self.last = Some(now);
+        self.real += 1;
+        self.made += u32::from(made && !generated_only());
+        if now - self.shown_since >= Duration::from_millis(500) {
+            self.made_share = Some(self.made as f32 / self.real as f32);
+            (self.real, self.made, self.shown_since) = (0, 0, now);
+        }
+        let Some(send) = self.presenter.as_ref().and_then(|p| p.send.as_ref()) else {
+            return;
+        };
+        let pair = if generated_only() {
+            Pair {
+                first: None,
+                second: generated,
+                spare: Some(real),
+                interval: self.interval,
+            }
+        } else if made {
+            Pair {
+                first: Some(generated),
+                second: real,
+                spare: None,
+                interval: self.interval,
+            }
+        } else {
+            Pair {
+                first: None,
+                second: real,
+                spare: Some(generated),
+                interval: self.interval,
+            }
+        };
+        let _ = send.send(pair);
+    }
+}
+
+/// A frame to draw into, like the swapchain's.
+fn frame(device: &wgpu::Device, config: &wgpu::SurfaceConfiguration) -> wgpu::Texture {
+    device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("Frame generation frame"),
+        size: wgpu::Extent3d {
+            width: config.width,
+            height: config.height,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: config.format,
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT
+            | wgpu::TextureUsages::TEXTURE_BINDING
+            | wgpu::TextureUsages::COPY_SRC
+            | wgpu::TextureUsages::COPY_DST,
+        view_formats: &config.view_formats,
+    })
+}
+
+/// One real frame's frames for the present thread: `first` (the made frame) now,
+/// `second` (the real one) half an `interval` later; `spare` goes straight back.
+struct Pair {
+    first: Option<wgpu::Texture>,
+    second: wgpu::Texture,
+    spare: Option<wgpu::Texture>,
+    interval: Duration,
+}
+
+/// The thread that copies frames to the swapchain and presents them on time.
+struct Presenter {
+    config: wgpu::SurfaceConfiguration,
+    send: Option<mpsc::SyncSender<Pair>>,
+    free: mpsc::Receiver<wgpu::Texture>,
+    /// The surface gave something other than a frame: the renderer takes it back.
+    failed: Arc<AtomicBool>,
+    thread: Option<thread::JoinHandle<()>>,
+}
+
+impl Presenter {
+    fn start(
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        surface: Arc<wgpu::Surface<'static>>,
+        window: Arc<winit::window::Window>,
+        config: &wgpu::SurfaceConfiguration,
+    ) -> Self {
+        // One pair waiting at most: the renderer then waits as for a swapchain image.
+        let (send, receive) = mpsc::sync_channel::<Pair>(1);
+        let (give, free) = mpsc::channel();
+        for _ in 0..FRAMES {
+            let _ = give.send(frame(device, config));
+        }
+        let (device, queue) = (device.clone(), queue.clone());
+        let vsync = config.present_mode == wgpu::PresentMode::Fifo;
+        let failed = Arc::new(AtomicBool::new(false));
+        let failed_here = failed.clone();
+        let thread = thread::Builder::new()
+            .name("Frame generation present".into())
+            .spawn(move || {
+                let show = |texture: &wgpu::Texture| {
+                    if failed_here.load(Ordering::Relaxed) {
+                        return;
+                    }
+                    // Anything but a frame (outdated, lost, occluded...): the renderer
+                    // stops this thread and acquires itself, handling it as it does
+                    // without frame generation. A suboptimal frame still shows.
+                    let target = match surface.get_current_texture() {
+                        wgpu::CurrentSurfaceTexture::Success(t) => t,
+                        wgpu::CurrentSurfaceTexture::Suboptimal(t) => {
+                            failed_here.store(true, Ordering::Relaxed);
+                            t
+                        }
+                        _ => {
+                            failed_here.store(true, Ordering::Relaxed);
+                            return;
+                        }
+                    };
+                    let mut encoder = device.create_command_encoder(&Default::default());
+                    encoder.copy_texture_to_texture(
+                        texture.as_image_copy(),
+                        target.texture.as_image_copy(),
+                        target.texture.size(),
+                    );
+                    queue.submit([encoder.finish()]);
+                    if vsync {
+                        window.pre_present_notify();
+                    }
+                    queue.present(target);
+                };
+                while let Ok(pair) = receive.recv() {
+                    if let Some(first) = pair.first {
+                        let shown = Instant::now();
+                        show(&first);
+                        let _ = give.send(first);
+                        // ponytail: sleep pacing; a spin for the last half millisecond
+                        // if it shows uneven on some systems.
+                        let due = shown + pair.interval / 2;
+                        if let Some(wait) = due.checked_duration_since(Instant::now()) {
+                            thread::sleep(wait);
+                        }
+                    }
+                    show(&pair.second);
+                    let _ = give.send(pair.second);
+                    if let Some(spare) = pair.spare {
+                        let _ = give.send(spare);
+                    }
+                }
+            })
+            .expect("spawn the frame generation present thread");
+        Self {
+            config: config.clone(),
+            send: Some(send),
+            free,
+            failed,
+            thread: Some(thread),
+        }
+    }
+
+    /// The surface failed it or the thread died (a panic).
+    fn failed(&self) -> bool {
+        self.failed.load(Ordering::Relaxed) || self.thread.as_ref().is_none_or(|t| t.is_finished())
+    }
+}
+
+impl Drop for Presenter {
+    fn drop(&mut self) {
+        self.send = None;
+        if let Some(thread) = self.thread.take() {
+            let _ = thread.join();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::mesher::Vertex;
+    use glam::Vec3;
+
+    fn vertex(pos: Vec3) -> Vertex {
+        Vertex {
+            pos: pos.into(),
+            ..bytemuck::Zeroable::zeroed()
+        }
+    }
+
+    /// A swing lands halfway; a hand still on screen while the camera turns stays still;
+    /// another item shows as it is.
+    #[test]
+    fn the_made_frame_s_hand_is_halfway_on_screen() {
+        let mut fg = FrameGen::new();
+        let mut out = Vec::new();
+        fg.halfway_hand(
+            &[vertex(Vec3::new(0.0, 0.0, -1.0))],
+            Mat4::IDENTITY,
+            &mut out,
+        );
+        fg.halfway_hand(
+            &[vertex(Vec3::new(0.4, 0.0, -1.0))],
+            Mat4::IDENTITY,
+            &mut out,
+        );
+        assert!((Vec3::from(out[1].pos) - Vec3::new(0.2, 0.0, -1.0)).length() < 1e-6);
+        // The camera turned: the vertex turned with it, the same on screen.
+        let turned = Mat4::from_rotation_y(0.3);
+        let on_screen = Vec3::new(0.4, 0.0, -1.0);
+        let pos = turned.inverse().transform_point3(on_screen);
+        fg.halfway_hand(&[vertex(pos)], turned, &mut out);
+        assert!((Vec3::from(out[2].pos) - pos).length() < 1e-6);
+        let mut other = vertex(Vec3::ZERO);
+        other.uv = [0.5, 0.5];
+        fg.halfway_hand(&[other], turned, &mut out);
+        assert_eq!(out[3].pos, [0.0; 3]);
+    }
+}
@@ -0,0 +1,159 @@
+//! The ICC profile of HDR screenshots, for programs that don't read PNG's `cICP`: BT.2020
+//! primaries and the PQ curve, with HDR reference white (203 nits) as the profile's white.
+//! An ICC profile has no values above white, so those programs show a correct SDR picture
+//! with its highlights clipped, where without it they took PQ's values for sRGB's and showed
+//! them washed out. Programs that read `cICP` ignore this (PNG's third edition).
+
+/// HDR reference white in nits (ITU-R BT.2408): where the curve reaches the profile's white.
+const WHITE: f64 = 203.0;
+/// PQ's values from 0 to 1, in the curve's steps.
+const STEPS: usize = 4096;
+/// BT.2020's primaries, adapted to the profile connection space's D50 (Bradford).
+const RED: [f64; 3] = [0.67348, 0.27904, -0.00193];
+const GREEN: [f64; 3] = [0.16567, 0.67534, 0.02998];
+const BLUE: [f64; 3] = [0.12505, 0.04561, 0.79685];
+const D50: [f64; 3] = [0.9642, 1.0, 0.8249];
+
+/// PQ's EOTF (SMPTE ST 2084): a signal from 0 to 1 in nits.
+fn pq_nits(signal: f64) -> f64 {
+    let (m1, m2) = (2610.0 / 16384.0, 2523.0 / 32.0);
+    let (c1, c2, c3) = (3424.0 / 4096.0, 2413.0 / 128.0, 2392.0 / 128.0);
+    let p = signal.powf(1.0 / m2);
+    10_000.0 * ((p - c1).max(0.0) / (c2 - c3 * p)).powf(1.0 / m1)
+}
+
+fn s15_fixed16(v: f64) -> [u8; 4] {
+    ((v * 65536.0).round() as i32).to_be_bytes()
+}
+
+fn xyz(v: [f64; 3]) -> Vec<u8> {
+    let mut tag = b"XYZ \0\0\0\0".to_vec();
+    tag.extend(v.iter().flat_map(|&c| s15_fixed16(c)));
+    tag
+}
+
+fn curve() -> Vec<u8> {
+    let mut tag = b"curv\0\0\0\0".to_vec();
+    tag.extend((STEPS as u32).to_be_bytes());
+    for i in 0..STEPS {
+        let y = (pq_nits(i as f64 / (STEPS - 1) as f64) / WHITE).min(1.0);
+        tag.extend(((y * 65535.0).round() as u16).to_be_bytes());
+    }
+    tag
+}
+
+/// `textDescriptionType` (ICC v2), with its empty Unicode and ScriptCode parts.
+fn description(text: &str) -> Vec<u8> {
+    let mut tag = b"desc\0\0\0\0".to_vec();
+    tag.extend((text.len() as u32 + 1).to_be_bytes());
+    tag.extend(text.as_bytes());
+    tag.extend([0; 1 + 4 + 4 + 2 + 1 + 67]);
+    tag
+}
+
+/// An ICC v2 matrix-shaper display profile.
+pub(super) fn profile() -> Vec<u8> {
+    let trc = curve();
+    let copyright = b"text\0\0\0\0Public domain\0".to_vec();
+    let tags: [(&[u8; 4], &[u8]); 9] = [
+        (b"desc", &description("BT.2020 PQ, 203 nits = white")),
+        (b"cprt", &copyright),
+        (b"wtpt", &xyz(D50)),
+        (b"rXYZ", &xyz(RED)),
+        (b"gXYZ", &xyz(GREEN)),
+        (b"bXYZ", &xyz(BLUE)),
+        (b"rTRC", &trc),
+        (b"gTRC", &trc),
+        (b"bTRC", &trc),
+    ];
+    let data_start = 128 + 4 + 12 * tags.len();
+    let mut table = (tags.len() as u32).to_be_bytes().to_vec();
+    let mut data = Vec::new();
+    let mut trc_at = None;
+    for (name, tag) in tags {
+        // The three channels share one curve.
+        let is_trc = tag == &trc[..];
+        let at = match trc_at.filter(|_| is_trc) {
+            Some(at) => at,
+            None => {
+                let at = data_start + data.len();
+                data.extend(tag);
+                data.resize(data.len().next_multiple_of(4), 0);
+                at
+            }
+        };
+        if is_trc {
+            trc_at = Some(at);
+        }
+        table.extend(name);
+        table.extend((at as u32).to_be_bytes());
+        table.extend((tag.len() as u32).to_be_bytes());
+    }
+    let mut out = vec![0; 128];
+    let size = data_start + data.len();
+    out[0..4].copy_from_slice(&(size as u32).to_be_bytes());
+    out[8..12].copy_from_slice(&[2, 0x40, 0, 0]);
+    out[12..16].copy_from_slice(b"mntr");
+    out[16..20].copy_from_slice(b"RGB ");
+    out[20..24].copy_from_slice(b"XYZ ");
+    out[36..40].copy_from_slice(b"acsp");
+    // Relative colorimetric, and the connection space's illuminant.
+    out[64..68].copy_from_slice(&1u32.to_be_bytes());
+    for (i, &c) in D50.iter().enumerate() {
+        out[68 + 4 * i..72 + 4 * i].copy_from_slice(&s15_fixed16(c));
+    }
+    out.extend(table);
+    out.extend(data);
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tag<'a>(profile: &'a [u8], name: &[u8; 4]) -> &'a [u8] {
+        let u32_at = |i: usize| u32::from_be_bytes(profile[i..i + 4].try_into().unwrap()) as usize;
+        let at = (0..u32_at(128))
+            .map(|i| 132 + 12 * i)
+            .find(|&e| &profile[e..e + 4] == name)
+            .unwrap();
+        &profile[u32_at(at + 4)..u32_at(at + 4) + u32_at(at + 8)]
+    }
+
+    #[test]
+    fn the_profile_is_whole() {
+        let p = profile();
+        assert_eq!(
+            u32::from_be_bytes(p[0..4].try_into().unwrap()) as usize,
+            p.len()
+        );
+        assert_eq!(&p[36..40], b"acsp");
+        assert_eq!(p.len() % 4, 0);
+        assert_eq!(&tag(&p, b"desc")[0..4], b"desc");
+        // One curve, shared: the profile stays small.
+        assert_eq!(tag(&p, b"rTRC").as_ptr(), tag(&p, b"bTRC").as_ptr());
+        assert!(p.len() < 10_000, "{}", p.len());
+    }
+
+    #[test]
+    fn the_primaries_add_up_to_white() {
+        for i in 0..3 {
+            assert!((RED[i] + GREEN[i] + BLUE[i] - D50[i]).abs() < 0.0001);
+        }
+    }
+
+    #[test]
+    fn the_curve_reaches_white_at_reference_white_and_stays() {
+        let p = profile();
+        let trc = tag(&p, b"rTRC");
+        let value = |signal: f64| {
+            let i = 12 + 2 * (signal * (STEPS - 1) as f64).round() as usize;
+            u16::from_be_bytes([trc[i], trc[i + 1]])
+        };
+        assert_eq!(value(0.0), 0);
+        // 203 nits in PQ is a signal of 0.5807.
+        assert!(value(0.57) < 65535);
+        assert_eq!(value(0.59), 65535);
+        assert_eq!(value(1.0), 65535);
+    }
+}
@@ -42,7 +42,7 @@ struct HorizonMaterialOut {
 }
 fn horizon_material_vertex(position: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>,
    light: vec2<u32>, origin: vec3<f32>) -> HorizonMaterialOut {
-    let pos = position + origin;
+    let pos = horizon_material_displace(position + origin, uv, layer, color, light);
    var out: HorizonMaterialOut;
    out.clip = horizon_terrain_globals.view_proj * vec4(pos, 1.0);
    out.uv = uv;
@@ -139,17 +139,32 @@ fn horizon_material_color(in: HorizonMaterialOut, translucent: bool) -> vec4<f32
    // Water draws translucent and lava solid, so the pass resolves the fluid kind.
    let fluid = select(0u, select(2u, 1u, translucent), in.fluid_quad != 0u);
    let normal = horizon_material_normal(in.position);
+    horizon_material_face_normal = normal;
+    horizon_surface = vec4<f32>(0.0);
    let tangent = horizon_material_tangent(in.position, in.uv, normal);
    return material(MaterialInput(albedo, in.tint, in.light, in.lightmap, in.position, in.uv,
        translucent, horizon_sprite_tags(in.layer & 0x7fffu),
        horizon_sprite_material(in.layer & 0x7fffu), in.clip.xy / frame.resolution,
        in.face, fluid, in.emission, normal, tangent)).color;
 }
-@fragment fn horizon_material_fs_solid(in: HorizonMaterialOut) -> @location(0) vec4<f32> {
+var<private> horizon_material_face_normal: vec3<f32>;
+struct HorizonMaterialSolid {
+    @location(0) color: vec4<f32>,
+    // The surface target's data: `set_surface`'s, then the fragment's depth, which the post
+    // stage's `surface_at` compares with the final depth.
+    @location(1) surface: vec4<f32>,
+}
+@fragment fn horizon_material_fs_solid(in: HorizonMaterialOut) -> HorizonMaterialSolid {
    let color = horizon_material_color(in, false);
    // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
    if color.a < 0.5 && (in.layer & 0x8000u) == 0u { discard; }
-    return horizon_material_fogged(vec4(color.rgb, 1.0), in.spherical, in.cylindrical);
+    if horizon_surface.w == 0.0 {
+        set_surface(horizon_material_face_normal, 0.0, 0.0);
+    }
+    var out: HorizonMaterialSolid;
+    out.color = horizon_material_fogged(vec4(color.rgb, 1.0), in.spherical, in.cylindrical);
+    out.surface = vec4(horizon_surface.xyz, in.clip.z);
+    return out;
 }
@fragment fn horizon_material_fs_translucent(in: HorizonMaterialOut) -> @location(0) vec4<f32> {
    let color = horizon_material_color(in, true);
@@ -189,6 +204,8 @@ pub struct NativeMaterial {
    pub solid: wgpu::RenderPipeline,
    pub translucent: wgpu::RenderPipeline,
    pub flat: Option<(wgpu::RenderPipeline, wgpu::RenderPipeline)>,
+    /// The stage calls `set_surface`: its solid pipelines also write the surface target.
+    pub writes_surface: bool,
 }

 /// terrain.wgsl's terrain section (its globals, bindings, sampling, lighting and fog), with
@@ -203,7 +220,7 @@ fn vanilla_terrain() -> String {
 /// The function `name(layer)`, the value of each sprite layer in `table` and 0 for the rest:
 /// `horizon_sprite_tags` (`MaterialInput.tags`) and `horizon_sprite_material`
 /// (`MaterialInput.material`).
-fn layer_table(name: &str, table: &[(u32, u32)]) -> String {
+pub(super) fn layer_table(name: &str, table: &[(u32, u32)]) -> String {
    let mut out = format!("fn {name}(layer: u32) -> u32 {{\n    switch layer {{\n");
    let mut table = table.to_vec();
    table.sort_unstable_by_key(|&(layer, value)| (value, layer));
@@ -218,12 +235,47 @@ fn layer_table(name: &str, table: &[(u32, u32)]) -> String {
    out + "        default: { return 0u; }\n    }\n}\n"
 }

+/// Where a corner of terrain is drawn without a vertex stage.
+pub(super) const DISPLACE_VANILLA: &str = "
+fn horizon_material_displace(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>,
+    light: vec2<u32>) -> vec3<f32> {
+    return pos;
+}
+";
+
+/// The vertex stage's call, with its inputs from terrain's vertex.
+pub(super) const DISPLACE_PACK: &str = "
+fn horizon_material_displace(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<f32>,
+    light: vec2<u32>) -> vec3<f32> {
+    let flags = u32(round(color.a * 255.0));
+    let high = flags >> 4u;
+    let fluid = high >= 8u && (high & 7u) < 6u;
+    let lit = min(vec2(f32(light.y), f32(light.x)) / 240.0, vec2(1.0));
+    return vertex(VertexInput(pos, uv, horizon_sprite_material(layer & 0x7fffu), lit,
+        vec4(color.rgb, 1.0), select(0u, high & 7u, fluid), u32(fluid)));
+}
+";
+
+/// The surface target (the post stage's `scene_surface`): x the normal (two snorm16 in its
+/// bits), y smoothness, z the pack's data, w the fragment's depth.
+pub const SURFACE_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba32Float;
+
 /// The terrain shader for the pack's material stage `source`, with its sprite `tags` and
-/// `materials`.
-fn shader_source(source: &str, tags: &[(u32, u32)], materials: &[(u32, u32)]) -> String {
+/// `materials`, and the vertex stage in its module when `vertex`.
+fn shader_source(
+    source: &str,
+    tags: &[(u32, u32)],
+    materials: &[(u32, u32)],
+    vertex: bool,
+) -> String {
    format!(
-        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{}{ENTRIES}",
+        "{source}\n// Horizon's terrain (terrain.wgsl)\n{}{}{}{}{ENTRIES}",
        vanilla_terrain(),
+        if vertex {
+            DISPLACE_PACK
+        } else {
+            DISPLACE_VANILLA
+        },
        layer_table("horizon_sprite_tags", tags),
        layer_table("horizon_sprite_material", materials)
    )
@@ -234,8 +286,9 @@ fn module(
    stage: &CheckedStage,
    tags: &[(u32, u32)],
    materials: &[(u32, u32)],
+    vertex: bool,
 ) -> Result<naga::Module, String> {
-    let text = shader_source(&stage.source, tags, materials);
+    let text = shader_source(&stage.source, tags, materials, vertex);
    naga::front::wgsl::parse_str(&text)
        .map_err(|e| format!("{}: {}", stage.file, e.emit_to_string(&text)))
 }
@@ -249,8 +302,10 @@ impl NativeMaterial {
        stage: &CheckedStage,
        constants: &[(String, f64)],
        fog: bool,
+        vertex: bool,
    ) -> Result<Self, String> {
-        let module = module(stage, shape.sprite_tags, shape.sprite_materials)?;
+        let writes_surface = horizon_shader_api::stages::calls_set_surface(&stage.source);
+        let module = module(stage, shape.sprite_tags, shape.sprite_materials, vertex)?;
        let mut constants = present_constants(&module, constants);
        let sprite_names = [
            "horizon_terrain_SPRITE_ARRAYS",
@@ -296,6 +351,18 @@ impl NativeMaterial {
                constants: &constants,
                ..Default::default()
            };
+            let solid_targets = [
+                Some(wgpu::ColorTargetState {
+                    format: shape.format,
+                    blend,
+                    write_mask: wgpu::ColorWrites::ALL,
+                }),
+                Some(wgpu::ColorTargetState {
+                    format: SURFACE_FORMAT,
+                    blend: None,
+                    write_mask: wgpu::ColorWrites::ALL,
+                }),
+            ];
            device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
                label: Some(&stage.label),
                layout: Some(layout),
@@ -321,11 +388,11 @@ impl NativeMaterial {
                    module: &module,
                    entry_point: Some(fragment),
                    compilation_options: options,
-                    targets: &[Some(wgpu::ColorTargetState {
-                        format: shape.format,
-                        blend,
-                        write_mask: wgpu::ColorWrites::ALL,
-                    })],
+                    targets: if fragment == "horizon_material_fs_solid" && writes_surface {
+                        &solid_targets
+                    } else {
+                        &solid_targets[..1]
+                    },
                }),
                multiview_mask: None,
                cache: None,
@@ -370,6 +437,7 @@ impl NativeMaterial {
            solid,
            translucent,
            flat,
+            writes_surface,
        })
    }
 }
@@ -424,7 +492,7 @@ mod tests {
        let tags = [(7, 1), (3, 1), (9, 2)];
        let materials = [(5, 1000)];
        assert!(layer_table("t", &tags).contains("case 3u, 7u: { return 1u; }"));
-        let module = module(&stage, &tags, &materials).unwrap();
+        let module = module(&stage, &tags, &materials, false).unwrap();
        let info = naga::valid::Validator::new(
            naga::valid::ValidationFlags::all(),
            naga::valid::Capabilities::all(),
@@ -433,7 +501,7 @@ mod tests {
        .unwrap_or_else(|e| {
            panic!(
                "{}",
-                e.emit_to_string(&shader_source(&stage.source, &tags, &materials))
+                e.emit_to_string(&shader_source(&stage.source, &tags, &materials, false))
            )
        });
        let entries: Vec<&str> = module
@@ -48,7 +48,17 @@ impl NativePack {
        let shadow = report
            .shadow
            .as_ref()
-            .map(|s| NativeShadow::new(device, terrain, &frame, &s.solid_materials))
+            .map(|s| {
+                let vertex = report.stages.iter().find(|s| s.kind == StageKind::Vertex);
+                NativeShadow::new(
+                    device,
+                    terrain,
+                    &frame,
+                    &s.solid_materials,
+                    vertex,
+                    constants,
+                )
+            })
            .transpose()?;
        // The mirror is drawn for a material that reads it, while `[reflection] option` is on.
        let option = report.reflection.as_ref().and_then(|r| r.option.as_ref());
@@ -91,6 +101,7 @@ impl NativePack {
            .iter()
            .find(|s| s.kind == StageKind::Weather)
            .map(|s| s.label.clone());
+        let has_vertex = report.stages.iter().any(|s| s.kind == StageKind::Vertex);
        let (post, others): (Vec<_>, Vec<_>) = report
            .stages
            .into_iter()
@@ -103,7 +114,9 @@ impl NativePack {
        let material = others
            .iter()
            .find(|s| s.kind == StageKind::Material)
-            .map(|stage| NativeMaterial::new(device, terrain, &frame, stage, constants, fog))
+            .map(|stage| {
+                NativeMaterial::new(device, terrain, &frame, stage, constants, fog, has_vertex)
+            })
            .transpose()?;
        let post = (!post.is_empty())
            .then(|| NativePost::new(device, post, &report.manifest, constants, format, &frame))
@@ -14,7 +14,7 @@ use super::Frame;
 const INTERMEDIATE: wgpu::TextureFormat = wgpu::TextureFormat::Rgba16Float;

 /// The world's colour and depth views a set of bind groups was made for.
-type WorldViews = (wgpu::TextureView, wgpu::TextureView);
+type WorldViews = (wgpu::TextureView, wgpu::TextureView, wgpu::TextureView);

 /// Where a post pass draws.
 #[derive(Clone, Copy, PartialEq)]
@@ -103,6 +103,9 @@ pub struct NativePost {
 /// The `frame` every stage of a pack reads (group 3, binding 0), written once a frame, and
 /// what the material stage reads besides.
 pub struct NativeFrame {
+    /// The solid terrain's second target, the post stage's `scene_surface`.
+    surface: wgpu::Texture,
+    pub surface_view: wgpu::TextureView,
    pub(super) buffer: wgpu::Buffer,
    /// Group 3 of the sky and material stages.
    pub layout: wgpu::BindGroupLayout,
@@ -270,6 +273,8 @@ impl NativeFrame {
            label: Some("Native shader pack frame"),
            entries: &entries,
        });
+        let surface = surface_target(device, [1, 1]);
+        let surface_view = surface.create_view(&Default::default());
        let opaque_depth = depth_copy(device, [1, 1]);
        let opaque_color = color_copy(device, [1, 1], wgpu::TextureFormat::Rgba8Unorm);
        let blank = copy_target(
@@ -332,6 +337,8 @@ impl NativeFrame {
            buffer,
            layout,
            group,
+            surface,
+            surface_view,
            opaque_depth,
            opaque_color,
            reflection: blank.clone(),
@@ -468,6 +475,14 @@ impl NativeFrame {
        self.regroup(device);
    }

+    /// Sizes the surface target: the world's while a material stage writes it, else a blank.
+    pub fn fit_surface(&mut self, device: &wgpu::Device, size: [u32; 2]) {
+        if [self.surface.width(), self.surface.height()] != size {
+            self.surface = surface_target(device, size);
+            self.surface_view = self.surface.create_view(&Default::default());
+        }
+    }
+
    /// Binds `view` as this frame's `reflection` (`None`: the blank). The mirror is drawn
    /// before the stages read it.
    pub fn set_reflection(&mut self, device: &wgpu::Device, view: Option<&wgpu::TextureView>) {
@@ -573,6 +588,24 @@ pub fn present_constants<'a>(
        .collect()
 }

+/// The solid terrain's surface target of `size`, drawn and read.
+fn surface_target(device: &wgpu::Device, size: [u32; 2]) -> wgpu::Texture {
+    device.create_texture(&wgpu::TextureDescriptor {
+        label: Some("Native shader pack surface"),
+        size: wgpu::Extent3d {
+            width: size[0],
+            height: size[1],
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: wgpu::TextureDimension::D2,
+        format: super::native_material::SURFACE_FORMAT,
+        usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+        view_formats: &[],
+    })
+}
+
 fn texture_entry(binding: u32, sample_type: wgpu::TextureSampleType) -> wgpu::BindGroupLayoutEntry {
    wgpu::BindGroupLayoutEntry {
        binding,
@@ -652,6 +685,7 @@ impl NativePost {
            texture_entry(8, float),
            texture_entry(9, wgpu::TextureSampleType::Depth),
            texture_entry(10, float),
+            texture_entry(11, wgpu::TextureSampleType::Float { filterable: false }),
        ];
        entries.extend(pack_texture_entries(frame.textures.len()));
        entries
@@ -757,7 +791,7 @@ impl NativePost {
    fn prepare(
        &mut self,
        device: &wgpu::Device,
-        world: (&wgpu::TextureView, &wgpu::TextureView),
+        world: (&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView),
        size: [u32; 2],
        history_reset: bool,
    ) {
@@ -830,8 +864,11 @@ impl NativePost {
        if self
            .groups
            .as_ref()
-            .is_some_and(|((color, depth), blank, _)| {
-                color == world.0 && depth == world.1 && *blank == blank_history
+            .is_some_and(|((color, depth, surface), blank, _)| {
+                color == world.0
+                    && depth == world.1
+                    && surface == world.2
+                    && *blank == blank_history
            })
        {
            return;
@@ -893,6 +930,10 @@ impl NativePost {
                        binding: 9,
                        resource: wgpu::BindingResource::TextureView(&self.shadow.2),
                    },
+                    wgpu::BindGroupEntry {
+                        binding: 11,
+                        resource: wgpu::BindingResource::TextureView(world.2),
+                    },
                    wgpu::BindGroupEntry {
                        binding: 10,
                        resource: wgpu::BindingResource::TextureView(&self.shadow.3),
@@ -920,7 +961,11 @@ impl NativePost {
                })
            })
            .collect();
-        self.groups = Some(((world.0.clone(), world.1.clone()), blank_history, groups));
+        self.groups = Some((
+            (world.0.clone(), world.1.clone(), world.2.clone()),
+            blank_history,
+            groups,
+        ));
    }

    /// Runs the passes over the world target `world` (colour, depth) of `size`, the last onto
@@ -929,7 +974,7 @@ impl NativePost {
        &mut self,
        device: &wgpu::Device,
        encoder: &mut wgpu::CommandEncoder,
-        world: (&wgpu::TextureView, &wgpu::TextureView),
+        world: (&wgpu::TextureView, &wgpu::TextureView, &wgpu::TextureView),
        screen: &wgpu::TextureView,
        size: [u32; 2],
        history_reset: bool,
@@ -1349,7 +1394,7 @@ mod tests {
        post.run(
            &device,
            &mut encoder,
-            (&color, &depth),
+            (&color, &depth, &frame.surface_view),
            &view,
            [4, 4],
            true,
@@ -1456,7 +1501,7 @@ file = \"b.wgsl\"
            post.run(
                &device,
                &mut encoder,
-                (&color, &depth),
+                (&color, &depth, &frame.surface_view),
                &view,
                [4, 4],
                history_reset,
@@ -6,6 +6,19 @@
 use super::Vertex;
 use super::pack_draw::EntitySpan;
 use glam::{DVec3, Mat4};
+use std::sync::atomic::{AtomicBool, Ordering};
+
+static MODS_BUILT_IN: AtomicBool = AtomicBool::new(false);
+
+/// The game was built with native mods (the game sets it at start): one of them may draw in
+/// [`native_world_drawn`], so the first-person hand keeps its own pass after it.
+pub fn set_mods_built_in(on: bool) {
+    MODS_BUILT_IN.store(on, Ordering::Relaxed);
+}
+/// Whether [`native_world_drawn`] may draw ([`set_mods_built_in`]).
+pub fn world_drawn_hooked() -> bool {
+    MODS_BUILT_IN.load(Ordering::Relaxed)
+}

 /// What a mod can draw with once the world is drawn: after the sky, terrain, entities,
 /// particles, weather and the world post pass, before the first-person hand, the HUD and the
@@ -41,17 +41,21 @@ fn horizon_shadow_vertex(pos: vec3<f32>, uv: vec2<f32>, layer: u32, color: vec4<
 }
@vertex fn horizon_shadow_vs(
    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>,
-    @location(2) layer: u32, @location(3) color: vec4<f32>,
+    @location(2) layer: u32, @location(3) color: vec4<f32>, @location(4) light: vec2<u32>,
    @location(5) origin: vec4<f32>) -> HorizonShadowOut {
-    return horizon_shadow_vertex(position + origin.xyz, horizon_terrain_terrain_uv(uv, origin.w), layer, color);
+    let atlas = horizon_terrain_terrain_uv(uv, origin.w);
+    let pos = horizon_material_displace(position + origin.xyz, atlas, layer, color, light);
+    return horizon_shadow_vertex(pos, atlas, layer, color);
 }
@vertex fn horizon_shadow_vs_flat(
    @builtin(vertex_index) index: u32,
    @location(0) position: vec3<f32>, @location(1) uv: vec2<u32>, @location(2) layer: u32,
-    @location(3) color: vec4<f32>
+    @location(3) color: vec4<f32>, @location(4) light: vec2<u32>
 ) -> HorizonShadowOut {
    let origin = horizon_terrain_slot_origins[horizon_terrain_block_slots[index >> 8u]];
-    return horizon_shadow_vertex(position + origin.xyz, horizon_terrain_terrain_uv(uv, origin.w), layer, color);
+    let atlas = horizon_terrain_terrain_uv(uv, origin.w);
+    let pos = horizon_material_displace(position + origin.xyz, atlas, layer, color, light);
+    return horizon_shadow_vertex(pos, atlas, layer, color);
 }
@fragment fn horizon_shadow_fs(in: HorizonShadowOut) {
    // Bit 15 of the layer marks opaque leaves (forceOpaque): no alpha cutout.
@@ -415,12 +419,24 @@ fn shadow_solid(materials: &[(u32, u32)], solid: &[u32]) -> String {

 /// The shadow pass's shader: the frame, Horizon's terrain, and the entries, with the layers
 /// `solid` of `shadow_solid`.
-fn shader_source(solid: &str) -> String {
+fn shader_source(solid: &str, vertex: Option<&str>, materials: &[(u32, u32)]) -> String {
+    let (head, displace) = match vertex {
+        Some(stage) => (
+            stage.to_owned()
+                + &super::native_material::layer_table("horizon_sprite_material", materials),
+            super::native_material::DISPLACE_PACK,
+        ),
+        None => (
+            format!(
+                "{}@group({GROUP}) @binding(0) var<uniform> frame: Frame;\n{}",
+                FrameInputs::WGSL.wgsl(),
+                horizon_shader_api::stages::SHADOW_HELPERS,
+            ),
+            super::native_material::DISPLACE_VANILLA,
+        ),
+    };
    format!(
-        "{}@group({GROUP}) @binding(0) var<uniform> frame: Frame;\n{}\
-         // Horizon's terrain (terrain.wgsl)\n{}{solid}{ENTRIES}",
-        FrameInputs::WGSL.wgsl(),
-        horizon_shader_api::stages::SHADOW_HELPERS,
+        "{head}// Horizon's terrain (terrain.wgsl)\n{}{solid}{displace}{ENTRIES}",
        prefixed(
            section(TERRAIN, "struct Globals {", "// Sky (SkyRenderer)"),
            PREFIX
@@ -434,14 +450,21 @@ impl NativeShadow {
        shape: &TerrainShape<'_>,
        frame: &super::native_post::NativeFrame,
        solid_materials: &[u32],
+        vertex: Option<&horizon_shader_api::check::CheckedStage>,
+        constants: &[(String, f64)],
    ) -> Result<Self, String> {
-        let text = shader_source(&shadow_solid(shape.sprite_materials, solid_materials));
+        let text = shader_source(
+            &shadow_solid(shape.sprite_materials, solid_materials),
+            vertex.map(|s| s.source.as_str()),
+            shape.sprite_materials,
+        );
        let module = naga::front::wgsl::parse_str(&text)
            .map_err(|e| format!("shadow pass: {}", e.emit_to_string(&text)))?;
-        let constants = [
+        let mut constants = super::native_post::present_constants(&module, constants);
+        constants.extend([
            ("horizon_terrain_SPRITE_ARRAYS", shape.sprites[0]),
            ("horizon_terrain_SPRITE_SPLIT", shape.sprites[1]),
-        ];
+        ]);
        let scope = device.push_error_scope(wgpu::ErrorFilter::Validation);
        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("Native shader pack shadow"),
@@ -593,7 +616,7 @@ mod tests {
    #[test]
    fn the_shadow_shader_validates() {
        for materials in [&[][..], &[(3, 7), (4, 8), (9, 7)][..]] {
-            let text = shader_source(&shadow_solid(materials, &[7]));
+            let text = shader_source(&shadow_solid(materials, &[7]), None, materials);
            let module = naga::front::wgsl::parse_str(&text).unwrap();
            naga::valid::Validator::new(
                naga::valid::ValidationFlags::all(),
@@ -0,0 +1,296 @@
+//! `centerDepthSmooth`'s input: `depthtex0` at the centre of the screen. A depth texture can
+//! only be copied whole, so each frame a one-pixel pass loads that texel into a 1x1 `R32Float`
+//! target, copied to one of a few small buffers and read back frames later without waiting for
+//! the GPU (as `timing.rs` reads its timestamps); `FrameUniforms` smooths the latest value.
+
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU8, Ordering};
+
+const SLOTS: usize = 3;
+const FREE: u8 = 0;
+/// Copied this frame: mapped once the frame is submitted.
+const COPIED: u8 = 1;
+const PENDING: u8 = 2;
+const MAPPED: u8 = 3;
+/// One row of a texture copy, the alignment wgpu asks of `bytes_per_row`.
+const ROW: u32 = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT;
+
+const SHADER: &str = "
+@group(0) @binding(0) var depth: texture_depth_2d;
+@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4<f32> {
+    let p = vec2<f32>(f32((i << 1u) & 2u), f32(i & 2u));
+    return vec4<f32>(p * 2.0 - 1.0, 0.0, 1.0);
+}
+@fragment fn fs() -> @location(0) vec4<f32> {
+    let centre = vec2<i32>(textureDimensions(depth) / 2u);
+    return vec4<f32>(textureLoad(depth, centre, 0), 0.0, 0.0, 1.0);
+}
+";
+
+struct Slot {
+    buffer: wgpu::Buffer,
+    state: Arc<AtomicU8>,
+}
+
+pub struct CenterDepth {
+    slots: Vec<Slot>,
+    pipeline: wgpu::RenderPipeline,
+    layout: wgpu::BindGroupLayout,
+    /// The 1x1 target the centre texel is loaded into.
+    texel: wgpu::Texture,
+    texel_view: wgpu::TextureView,
+    /// The bind group of the depth texture it reads, made again when that texture changes.
+    group: Option<(wgpu::Texture, wgpu::BindGroup)>,
+    /// The depth last read back: GL window depth, 0..1.
+    latest: Option<f32>,
+}
+
+impl CenterDepth {
+    pub fn new(device: &wgpu::Device) -> Self {
+        let slots = (0..SLOTS)
+            .map(|_| Slot {
+                buffer: device.create_buffer(&wgpu::BufferDescriptor {
+                    label: Some("Shader pack centre depth"),
+                    size: u64::from(ROW),
+                    usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+                    mapped_at_creation: false,
+                }),
+                state: Arc::new(AtomicU8::new(FREE)),
+            })
+            .collect();
+        let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("Shader pack centre depth"),
+            entries: &[wgpu::BindGroupLayoutEntry {
+                binding: 0,
+                visibility: wgpu::ShaderStages::FRAGMENT,
+                ty: wgpu::BindingType::Texture {
+                    sample_type: wgpu::TextureSampleType::Depth,
+                    view_dimension: wgpu::TextureViewDimension::D2,
+                    multisampled: false,
+                },
+                count: None,
+            }],
+        });
+        let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("Shader pack centre depth"),
+            source: wgpu::ShaderSource::Wgsl(SHADER.into()),
+        });
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("Shader pack centre depth"),
+            bind_group_layouts: &[Some(&layout)],
+            immediate_size: 0,
+        });
+        let format = wgpu::TextureFormat::R32Float;
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("Shader pack centre depth"),
+            layout: Some(&pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &module,
+                entry_point: Some("vs"),
+                compilation_options: Default::default(),
+                buffers: &[],
+            },
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            fragment: Some(wgpu::FragmentState {
+                module: &module,
+                entry_point: Some("fs"),
+                compilation_options: Default::default(),
+                targets: &[Some(format.into())],
+            }),
+            multiview_mask: None,
+            cache: None,
+        });
+        let texel = device.create_texture(&wgpu::TextureDescriptor {
+            label: Some("Shader pack centre depth"),
+            size: wgpu::Extent3d {
+                width: 1,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
+            view_formats: &[],
+        });
+        let texel_view = texel.create_view(&Default::default());
+        Self {
+            slots,
+            pipeline,
+            layout,
+            texel,
+            texel_view,
+            group: None,
+            latest: None,
+        }
+    }
+
+    /// Loads the centre texel of `depth` (a `Depth32Float` texture that can be bound) and
+    /// copies it into a free slot; with none free (the GPU is behind), this frame is skipped.
+    pub fn copy(
+        &mut self,
+        device: &wgpu::Device,
+        encoder: &mut wgpu::CommandEncoder,
+        depth: &wgpu::Texture,
+    ) {
+        let Some(slot) = self
+            .slots
+            .iter()
+            .find(|s| s.state.load(Ordering::Acquire) == FREE)
+        else {
+            return;
+        };
+        if self.group.as_ref().is_none_or(|(t, _)| t != depth) {
+            let view = depth.create_view(&Default::default());
+            let group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+                label: Some("Shader pack centre depth"),
+                layout: &self.layout,
+                entries: &[wgpu::BindGroupEntry {
+                    binding: 0,
+                    resource: wgpu::BindingResource::TextureView(&view),
+                }],
+            });
+            self.group = Some((depth.clone(), group));
+        }
+        let Some((_, group)) = &self.group else {
+            return;
+        };
+        {
+            let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("Shader pack centre depth"),
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &self.texel_view,
+                    depth_slice: None,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                ..Default::default()
+            });
+            pass.set_pipeline(&self.pipeline);
+            pass.set_bind_group(0, group, &[]);
+            pass.draw(0..3, 0..1);
+        }
+        encoder.copy_texture_to_buffer(
+            self.texel.as_image_copy(),
+            wgpu::TexelCopyBufferInfo {
+                buffer: &slot.buffer,
+                layout: wgpu::TexelCopyBufferLayout {
+                    offset: 0,
+                    bytes_per_row: Some(ROW),
+                    rows_per_image: Some(1),
+                },
+            },
+            self.texel.size(),
+        );
+        slot.state.store(COPIED, Ordering::Release);
+    }
+
+    /// After the frame's submission: start reading back what it copied.
+    pub fn submitted(&mut self) {
+        for slot in &self.slots {
+            if slot.state.load(Ordering::Acquire) != COPIED {
+                continue;
+            }
+            slot.state.store(PENDING, Ordering::Release);
+            let state = slot.state.clone();
+            slot.buffer
+                .slice(..)
+                .map_async(wgpu::MapMode::Read, move |result| {
+                    let next = if result.is_ok() { MAPPED } else { FREE };
+                    state.store(next, Ordering::Release);
+                });
+        }
+    }
+
+    /// The newest depth read back so far, `None` before the first arrives.
+    pub fn collect(&mut self, device: &wgpu::Device) -> Option<f32> {
+        let _ = device.poll(wgpu::PollType::Poll);
+        for slot in &self.slots {
+            if slot.state.load(Ordering::Acquire) != MAPPED {
+                continue;
+            }
+            let depth = slot
+                .buffer
+                .slice(..4)
+                .get_mapped_range()
+                .ok()
+                .map(|bytes| bytemuck::pod_read_unaligned::<f32>(&bytes[..4]));
+            slot.buffer.unmap();
+            slot.state.store(FREE, Ordering::Release);
+            if let Some(depth) = depth.filter(|d| d.is_finite()) {
+                self.latest = Some(depth.clamp(0.0, 1.0));
+            }
+        }
+        self.latest
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn test_device() -> Option<(wgpu::Device, wgpu::Queue)> {
+        let instance =
+            wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle().with_env());
+        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
+        pollster::block_on(adapter.request_device(&Default::default())).ok()
+    }
+
+    /// A depth texture cleared to a known depth comes back as that depth, a frame or more
+    /// later, without the frame waiting for it.
+    #[test]
+    fn the_centre_depth_comes_back() {
+        let Some((device, queue)) = test_device() else {
+            return;
+        };
+        let depth = device.create_texture(&wgpu::TextureDescriptor {
+            label: None,
+            size: wgpu::Extent3d {
+                width: 9,
+                height: 7,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::Depth32Float,
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING,
+            view_formats: &[],
+        });
+        let view = depth.create_view(&Default::default());
+        let mut center = CenterDepth::new(&device);
+        assert_eq!(center.collect(&device), None);
+        let mut encoder = device.create_command_encoder(&Default::default());
+        encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            depth_stencil_attachment: Some(wgpu::RenderPassDepthStencilAttachment {
+                view: &view,
+                depth_ops: Some(wgpu::Operations {
+                    load: wgpu::LoadOp::Clear(0.375),
+                    store: wgpu::StoreOp::Store,
+                }),
+                stencil_ops: None,
+            }),
+            ..Default::default()
+        });
+        center.copy(&device, &mut encoder, &depth);
+        queue.submit([encoder.finish()]);
+        center.submitted();
+        let _ = device.poll(wgpu::PollType::wait_indefinitely());
+        assert_eq!(center.collect(&device), Some(0.375));
+        // Its slot is free again: every slot can be used once more.
+        for _ in 0..SLOTS {
+            let mut encoder = device.create_command_encoder(&Default::default());
+            center.copy(&device, &mut encoder, &depth);
+            queue.submit([encoder.finish()]);
+            center.submitted();
+        }
+        let _ = device.poll(wgpu::PollType::wait_indefinitely());
+        assert_eq!(center.collect(&device), Some(0.375));
+    }
+}
@@ -512,6 +512,8 @@ pub struct PackPost {
    page_groups: HashMap<u32, (wgpu::Buffer, wgpu::BindGroup)>,
    /// GPU time of each pass, while the renderer asks for it (`pack_timing.rs`).
    pub timing: Option<super::pack_timing::PassTiming>,
+    /// `depthtex0` at the screen's centre, read back for `centerDepthSmooth`.
+    center_depth: Option<super::pack_center_depth::CenterDepth>,
    /// `shaders.properties`' custom uniforms, after the frame's in `uniforms.values`.
    custom: horizon_shaders::Custom,
    atlas: Option<wgpu::TextureView>,
@@ -2242,6 +2244,7 @@ impl PackPost {
            block_ids,
            page_groups: HashMap::new(),
            timing: None,
+            center_depth: None,
            custom,
            atlas: world.atlas.as_ref().map(|a| a.0.clone()),
            lightmap: world.lightmap,
@@ -2740,6 +2743,13 @@ impl PackPost {
                let rp = &mut open.as_mut().expect("open").0;
                rp.set_pipeline(pass.render());
                rp.set_bind_group(0, group, &[]);
+                // A sky program that reads the pack's SSBOs (Noble's `gbuffers_textured`, the
+                // sun's fallback) binds them, as the other passes do.
+                if pass.buffers
+                    && let Some(g) = &self.buffers.group
+                {
+                    rp.set_bind_group(4, g, &[]);
+                }
                sky.geometry.bind(rp, part.textured);
                open.as_mut().expect("open").1 = i;
            }
@@ -2896,6 +2906,13 @@ impl PackPost {
        }
    }

+    /// After the frame's submission: the centre depth it copied starts its way back.
+    pub fn submitted(&mut self) {
+        if let Some(center) = &mut self.center_depth {
+            center.submitted();
+        }
+    }
+
    /// Whether the pack draws entities or block entities itself.
    pub fn has_entities(&self) -> bool {
        self.entities.is_some()
@@ -3613,6 +3630,10 @@ impl PackPost {
        if let Some(t) = &mut self.timing {
            t.begin(device, queue);
        }
+        self.uniforms.center_depth_raw = self
+            .center_depth
+            .get_or_insert_with(|| super::pack_center_depth::CenterDepth::new(device))
+            .collect(device);
        self.uniforms.update(frame, inputs, size);
        // Until the camera's biome is known, `smooth` waits for the world's values.
        if !inputs.biome_known {
@@ -3851,6 +3872,10 @@ impl PackPost {
            self.draw_translucent(device, queue, encoder, size, terrain);
        }
        let targets = self.targets.as_ref().expect("resized");
+        // depthtex0 as the frame leaves it, for next frames' `centerDepthSmooth`.
+        if let Some(center) = &mut self.center_depth {
+            center.copy(device, encoder, &targets.depth_texture);
+        }
        let view = |m: u16, i: usize, alt: bool| {
            targets.color[i]
                .as_ref()
@@ -51,6 +51,12 @@ pub struct PackInputs {
    pub cloud_height: f32,
    /// The values native mods hand their packs (`frame.mods`, `native_shader_params`).
    pub mod_params: [[f32; 4]; 8],
+    /// The player's state, for Iris's status uniforms.
+    pub status: PlayerStatus,
+    /// The End flash: its intensity, 0..1 (0 outside the End), and its direction from the
+    /// camera in world space, of length 100 (`endFlashIntensity`, `endFlashPosition`).
+    pub end_flash: f32,
+    pub end_flash_direction: Vec3,
 }

 /// The `cloudHeight` uniform. Vanilla reads `visual/cloud_height` only while the cloud color
@@ -64,6 +70,35 @@ pub fn cloud_height(cloud_color_alpha: f32, height: f32) -> f32 {
    }
 }

+/// The local player's state behind Iris's status uniforms (`currentPlayerHealth`,
+/// `isSpectator`, `is_burning`...).
+#[derive(Clone, Copy, Debug, Default)]
+pub struct PlayerStatus {
+    /// Survival or adventure: the vitals are -1 in creative and spectator.
+    pub survival: bool,
+    pub health: f32,
+    pub max_health: f32,
+    pub food: f32,
+    /// Air supply ticks, of 300.
+    pub air: f32,
+    /// Armor points (the `armor` attribute).
+    pub armor: f32,
+    pub spectator: bool,
+    pub riding: bool,
+    pub feet_in_water: bool,
+    pub swimming: bool,
+    pub burning: bool,
+    pub hurt: bool,
+    pub invisible: bool,
+    pub sneaking: bool,
+    pub sprinting: bool,
+}
+
+/// `maxPlayerHunger`, `maxPlayerAir` and `maxPlayerArmor`: Minecraft's own maximums.
+const MAX_HUNGER: f32 = 20.0;
+const MAX_AIR: f32 = 300.0;
+const MAX_ARMOR: f32 = 50.0;
+
 /// One uniform's value: up to 16 floats or 3 integers.
 #[derive(Clone, Copy, Debug)]
 pub enum Value {
@@ -198,6 +233,26 @@ pub const NAMES: &[&str] = &[
    "playerLookVector",
    "playerBodyVector",
    "firstPersonCamera",
+    "currentPlayerHealth",
+    "maxPlayerHealth",
+    "currentPlayerHunger",
+    "maxPlayerHunger",
+    "currentPlayerAir",
+    "maxPlayerAir",
+    "currentPlayerArmor",
+    "maxPlayerArmor",
+    "isSpectator",
+    "isRiding",
+    "feetInWater",
+    "inSwimmingAnimation",
+    "is_burning",
+    "is_hurt",
+    "is_invisible",
+    "is_sneaking",
+    "is_sprinting",
+    "endFlashIntensity",
+    "endFlashPosition",
+    "centerDepthSmooth",
    "isRightHanded",
    "is_on_ground",
    "bedrockLevel",
@@ -220,6 +275,9 @@ pub struct FrameUniforms {
    previous: Option<(glam::DVec3, Mat4, Mat4)>,
    wetness: f32,
    eye_smooth: [f32; 2],
+    /// `depthtex0` at the screen's centre as last read back, and `centerDepthSmooth`.
+    pub center_depth_raw: Option<f32>,
+    center_depth: Option<f32>,
    /// The pack's shadow settings (7.1).
    pub shadow: Shadow,
 }
@@ -235,6 +293,8 @@ impl Default for FrameUniforms {
            previous: None,
            wetness: 0.0,
            eye_smooth: [0.0; 2],
+            center_depth_raw: None,
+            center_depth: None,
            shadow: Shadow::default(),
        }
    }
@@ -379,6 +439,15 @@ impl FrameUniforms {
        for (smoothed, target) in self.eye_smooth.iter_mut().zip(eye) {
            *smoothed = smooth(*smoothed, target, 10.0 / 20.0, dt);
        }
+        // `centerDepthHalflife`'s default, 1 tick (OptiFine's shaders.txt); the first value
+        // read back is taken as it is.
+        if let Some(raw) = self.center_depth_raw {
+            self.center_depth = Some(match self.center_depth {
+                Some(v) => smooth(v, raw, 1.0 / 20.0, dt),
+                None => raw,
+            });
+        }
+        let center_depth = self.center_depth.unwrap_or(1.0);
        // Vanilla fades by the stronger of two linear fogs; a pack gets one: the pair (start
        // and end together) of the one that is complete nearer (OQ-36). Mixing the nearer start
        // of one with the nearer end of the other made fog begin at the camera on clear days.
@@ -424,6 +493,8 @@ impl FrameUniforms {
                "eyeAltitude" => Value::f(&[frame.camera.y as f32]),
                "upPosition" => v3(to_view(Vec3::new(0.0, 100.0, 0.0))),
                "sunPosition" => v3(sun),
+                "endFlashPosition" => v3(to_view(inputs.end_flash_direction)),
+                "centerDepthSmooth" => Value::f(&[center_depth]),
                "moonPosition" => v3(moon),
                "shadowLightPosition" => v3(if day { sun } else { moon }),
                "sunAngle" => Value::f(&[sun_angle]),
@@ -483,7 +554,7 @@ impl FrameUniforms {
                "isElytraFlying" => Value::i(&[inputs.elytra_flying as i32]),
                "cloudHeight" => Value::f(&[inputs.cloud_height]),
                // renderStage is NONE outside gbuffers draws.
-                _ => Value::i(&[0]),
+                _ => status_value(name, inputs).unwrap_or(Value::i(&[0])),
            }
        };
        self.values.clear();
@@ -529,6 +600,46 @@ impl FrameUniforms {
    }
 }

+/// Iris's player status and dimension uniforms, from `inputs`: the vitals are fractions of
+/// their maximum, and -1 (with the maximums of health and air) in creative and spectator.
+fn status_value(name: &str, inputs: &PackInputs) -> Option<Value> {
+    let status = inputs.status;
+    let vital = |v: f32| {
+        Value::f(&[if status.survival {
+            v.clamp(0.0, 1.0)
+        } else {
+            -1.0
+        }])
+    };
+    let flag = |b: bool| Value::i(&[i32::from(b)]);
+    Some(match name {
+        "currentPlayerHealth" => vital(status.health / status.max_health.max(1.0)),
+        "maxPlayerHealth" => Value::f(&[if status.survival {
+            status.max_health
+        } else {
+            -1.0
+        }]),
+        "currentPlayerHunger" => vital(status.food / MAX_HUNGER),
+        "maxPlayerHunger" => Value::f(&[MAX_HUNGER]),
+        "currentPlayerAir" => vital(status.air / MAX_AIR),
+        "maxPlayerAir" => Value::f(&[if status.survival { MAX_AIR } else { -1.0 }]),
+        "currentPlayerArmor" => vital(status.armor / MAX_ARMOR),
+        "maxPlayerArmor" => Value::f(&[MAX_ARMOR]),
+        "isSpectator" => flag(status.spectator),
+        "isRiding" => flag(status.riding),
+        "feetInWater" => flag(status.feet_in_water),
+        "inSwimmingAnimation" => flag(status.swimming),
+        "is_burning" => flag(status.burning),
+        "is_hurt" => flag(status.hurt),
+        // Spectators count as invisible.
+        "is_invisible" => flag(status.invisible || status.spectator),
+        "is_sneaking" => flag(status.sneaking),
+        "is_sprinting" => flag(status.sprinting),
+        "endFlashIntensity" => Value::f(&[inputs.end_flash]),
+        _ => return None,
+    })
+}
+
 /// How many components the uniform `name` has (16 for a matrix).
 fn components(name: &str) -> usize {
    match name {
@@ -547,7 +658,8 @@ fn components(name: &str) -> usize {
        | "moonPosition"
        | "shadowLightPosition"
        | "fogColor"
-        | "skyColor" => 3,
+        | "skyColor"
+        | "endFlashPosition" => 3,
        "eyeBrightness" | "eyeBrightnessSmooth" | "atlasSize" => 2,
        n if n.starts_with("gbuffer") || n.starts_with("shadow") && n != "shadowAngle" => 16,
        _ => 1,
@@ -576,6 +688,77 @@ mod tests {
        assert_eq!(out[60..64], [0; 4], "a value past the block is dropped");
    }

+    /// Iris's status uniforms as its documentation defines them (shaders.properties, "Status").
+    #[test]
+    fn status_uniforms_follow_iris() {
+        let float = |name: &str, inputs: &PackInputs| match status_value(name, inputs) {
+            Some(Value::F(f)) => f[0],
+            other => panic!("{name}: {other:?}"),
+        };
+        let int = |name: &str, inputs: &PackInputs| match status_value(name, inputs) {
+            Some(Value::I(i)) => i[0],
+            other => panic!("{name}: {other:?}"),
+        };
+        let mut inputs = PackInputs {
+            status: PlayerStatus {
+                survival: true,
+                health: 15.0,
+                max_health: 20.0,
+                food: 10.0,
+                air: 150.0,
+                armor: 20.0,
+                sneaking: true,
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        // The vitals are fractions of their maximums.
+        assert_eq!(float("currentPlayerHealth", &inputs), 0.75);
+        assert_eq!(float("maxPlayerHealth", &inputs), 20.0);
+        assert_eq!(float("currentPlayerHunger", &inputs), 0.5);
+        assert_eq!(float("maxPlayerHunger", &inputs), 20.0);
+        assert_eq!(float("currentPlayerAir", &inputs), 0.5);
+        assert_eq!(float("maxPlayerAir", &inputs), 300.0);
+        assert_eq!(float("currentPlayerArmor", &inputs), 0.4);
+        assert_eq!(float("maxPlayerArmor", &inputs), 50.0);
+        assert_eq!(int("is_sneaking", &inputs), 1);
+        assert_eq!(int("is_invisible", &inputs), 0);
+        // Creative and spectator: -1 for the vitals and the maximums of health and air;
+        // spectators are invisible.
+        inputs.status.survival = false;
+        inputs.status.spectator = true;
+        for name in [
+            "currentPlayerHealth",
+            "maxPlayerHealth",
+            "currentPlayerHunger",
+            "currentPlayerAir",
+            "maxPlayerAir",
+            "currentPlayerArmor",
+        ] {
+            assert_eq!(float(name, &inputs), -1.0, "{name}");
+        }
+        assert_eq!(float("maxPlayerHunger", &inputs), 20.0);
+        assert_eq!(float("maxPlayerArmor", &inputs), 50.0);
+        assert_eq!(int("isSpectator", &inputs), 1);
+        assert_eq!(int("is_invisible", &inputs), 1);
+        // Each is provided, not left at zero for the pack.
+        for name in [
+            "currentPlayerHealth",
+            "isSpectator",
+            "is_sprinting",
+            "bedrockLevel",
+        ] {
+            assert!(index(name).is_some(), "{name} is not provided");
+        }
+        assert!(
+            NAMES
+                .iter()
+                .filter(|n| status_value(n, &inputs).is_some())
+                .count()
+                == 18
+        );
+    }
+
    #[test]
    fn cloud_height_needs_a_cloud_color() {
        assert_eq!(cloud_height(0.8, 192.33), 192.33);
@@ -0,0 +1,228 @@
+//! The frame's commands finished, submitted and presented on a thread of their own.
+//!
+//! wgpu records a pass's commands lazily: `CommandEncoder::finish` validates and
+//! encodes the whole frame (about 0.1 ms with the submit), work the window's thread
+//! would otherwise wait for before building the next frame. The renderer hands the
+//! frame's encoder to [`Queue::submit_later`] and goes on; every use of the queue
+//! ([`Deref`]) first waits for that frame to be submitted, so writes, copies and
+//! submissions keep the order they had on one thread.
+use std::ops::Deref;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Mutex, mpsc};
+
+/// Whether frames go to the submit thread, unless `HORIZON_SUBMIT_THREAD` says (`0` off, `1` on):
+/// on Linux, where it was measured faster (+32% FPS in a CPU-bound view on Vulkan, #5779). On
+/// macOS's Metal it stalled: offscreen at render distance 12, a tenth to a half of the frame rate
+/// with 20-180 ms p99 frames, against the same binary without it. Windows is not measured yet.
+pub fn wanted() -> bool {
+    match std::env::var("HORIZON_SUBMIT_THREAD").as_deref() {
+        Ok("0") => false,
+        Ok("1") => true,
+        _ => cfg!(target_os = "linux"),
+    }
+}
+
+/// Work to start right after a frame's submission (a readback's `map_async`).
+pub type AfterSubmit = Box<dyn FnOnce() + Send>;
+
+/// A frame for the submit thread: its commands and, in a window, the surface to present.
+pub struct Job {
+    pub encoder: wgpu::CommandEncoder,
+    pub surface: Option<wgpu::SurfaceTexture>,
+    pub after: Option<AfterSubmit>,
+}
+
+struct Thread {
+    jobs: Option<mpsc::Sender<Job>>,
+    handle: Option<std::thread::JoinHandle<()>>,
+}
+
+/// What the submit thread sent back, once it is taken in by [`Queue::wait`].
+struct Landing {
+    done: mpsc::Receiver<wgpu::SubmissionIndex>,
+    landed: Option<wgpu::SubmissionIndex>,
+}
+
+/// The device's queue, with frames submitted on the submit thread when it runs.
+pub struct Queue {
+    queue: wgpu::Queue,
+    thread: Option<Thread>,
+    /// A frame went to the submit thread and has not been waited for.
+    pending: AtomicBool,
+    landing: Mutex<Option<Landing>>,
+}
+
+impl Queue {
+    /// `threaded`: frames may go to a submit thread (the renderer asks [`wanted`]).
+    pub fn new(queue: wgpu::Queue, threaded: bool) -> Self {
+        let mut this = Self {
+            queue,
+            thread: None,
+            pending: AtomicBool::new(false),
+            landing: Mutex::new(None),
+        };
+        if !threaded {
+            return this;
+        }
+        let (jobs, job_rx) = mpsc::channel::<Job>();
+        let (done_tx, done) = mpsc::channel();
+        let queue = this.queue.clone();
+        let spawned = std::thread::Builder::new()
+            .name("Render submit".into())
+            .spawn(move || {
+                for job in job_rx {
+                    let commands = job.encoder.finish();
+                    let submission = queue.submit([commands]);
+                    if let Some(after) = job.after {
+                        after();
+                    }
+                    if let Some(surface) = job.surface {
+                        queue.present(surface);
+                    }
+                    if done_tx.send(submission).is_err() {
+                        break;
+                    }
+                }
+            });
+        match spawned {
+            Ok(handle) => {
+                this.thread = Some(Thread {
+                    jobs: Some(jobs),
+                    handle: Some(handle),
+                });
+                *this.lock() = Some(Landing { done, landed: None });
+            }
+            Err(e) => log::warn!("Horizon renderer: no submit thread ({e}); submitting in place"),
+        }
+        this
+    }
+    fn lock(&self) -> std::sync::MutexGuard<'_, Option<Landing>> {
+        self.landing
+            .lock()
+            .unwrap_or_else(std::sync::PoisonError::into_inner)
+    }
+    /// Whether frames can go to the submit thread.
+    pub fn threaded(&self) -> bool {
+        self.thread.is_some()
+    }
+    /// Finish, submit and present the frame on the submit thread, then run its `after`;
+    /// given back, with nothing done, when there is none.
+    pub fn submit_later(&self, job: Job) -> Result<(), Box<Job>> {
+        let Some(jobs) = self.thread.as_ref().and_then(|t| t.jobs.as_ref()) else {
+            return Err(Box::new(job));
+        };
+        self.wait();
+        match jobs.send(job) {
+            Ok(()) => {
+                self.pending.store(true, Ordering::Release);
+                Ok(())
+            }
+            Err(mpsc::SendError(job)) => Err(Box::new(job)),
+        }
+    }
+    /// Wait until the frame on the submit thread is submitted and presented.
+    pub fn wait(&self) {
+        if !self.pending.load(Ordering::Acquire) {
+            return;
+        }
+        let mut landing = self.lock();
+        if !self.pending.load(Ordering::Acquire) {
+            return;
+        }
+        if let Some(l) = landing.as_mut() {
+            // A thread that died (a wgpu panic on it) panics here, as it would have in place.
+            let submission = l
+                .done
+                .recv()
+                .expect("Horizon renderer: the submit thread stopped");
+            l.landed = Some(submission);
+        }
+        self.pending.store(false, Ordering::Release);
+    }
+    /// The submission of the frame [`submit_later`](Self::submit_later) took, once it is
+    /// made; `None` if it was taken already.
+    pub fn landed(&self) -> Option<wgpu::SubmissionIndex> {
+        self.wait();
+        self.lock().as_mut().and_then(|l| l.landed.take())
+    }
+}
+
+impl Deref for Queue {
+    type Target = wgpu::Queue;
+    fn deref(&self) -> &wgpu::Queue {
+        self.wait();
+        &self.queue
+    }
+}
+
+impl Drop for Queue {
+    fn drop(&mut self) {
+        self.wait();
+        if let Some(thread) = &mut self.thread {
+            thread.jobs.take();
+            if let Some(handle) = thread.handle.take() {
+                let _ = handle.join();
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn device() -> Option<(wgpu::Device, wgpu::Queue)> {
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+        let adapter = pollster::block_on(instance.request_adapter(&Default::default())).ok()?;
+        pollster::block_on(adapter.request_device(&Default::default())).ok()
+    }
+
+    fn buffer(device: &wgpu::Device, usage: wgpu::BufferUsages) -> wgpu::Buffer {
+        device.create_buffer(&wgpu::BufferDescriptor {
+            label: None,
+            size: 4,
+            usage,
+            mapped_at_creation: false,
+        })
+    }
+
+    #[test]
+    fn writes_after_a_frame_on_the_thread_land_after_it() {
+        let Some((device, queue)) = device() else {
+            return;
+        };
+        let queue = Queue::new(queue, true);
+        assert!(queue.threaded());
+        use wgpu::BufferUsages as U;
+        let source = buffer(&device, U::COPY_SRC | U::COPY_DST);
+        let copy = buffer(&device, U::COPY_SRC | U::COPY_DST);
+        let read = buffer(&device, U::MAP_READ | U::COPY_DST);
+        queue.write_buffer(&source, 0, &[1, 2, 3, 4]);
+        for frame in 0..3u8 {
+            // The frame copies `source`; the next frame's write must not reach that copy.
+            let mut encoder = device.create_command_encoder(&Default::default());
+            encoder.copy_buffer_to_buffer(&source, 0, &copy, 0, 4);
+            let job = Job {
+                encoder,
+                surface: None,
+                after: None,
+            };
+            assert!(queue.submit_later(job).is_ok());
+            queue.write_buffer(&source, 0, &[frame + 10; 4]);
+            assert!(queue.landed().is_some(), "frame {frame} submitted");
+            let mut encoder = device.create_command_encoder(&Default::default());
+            encoder.copy_buffer_to_buffer(&copy, 0, &read, 0, 4);
+            queue.submit([encoder.finish()]);
+            read.slice(..)
+                .map_async(wgpu::MapMode::Read, |r| r.unwrap());
+            device.poll(wgpu::PollType::wait_indefinitely()).unwrap();
+            let expected = if frame == 0 {
+                [1, 2, 3, 4]
+            } else {
+                [frame + 9; 4]
+            };
+            assert_eq!(*read.slice(..).get_mapped_range().unwrap(), expected);
+            read.unmap();
+        }
+    }
+}
@@ -299,6 +299,16 @@ impl Post {
        Mat4::from_translation(jitter.extend(0.0))
    }

+    /// This frame's jitter in rendered pixels, y down (FSR's `jitterOffset`); zero
+    /// without TAA.
+    pub fn jitter_pixels(&self) -> [f32; 2] {
+        let Some(size) = self.size().filter(|_| self.taa_on) else {
+            return [0.0; 2];
+        };
+        let j = self.taa_this_frame.jitter;
+        [j[0] * size[0] as f32 * 0.5, -j[1] * size[1] as f32 * 0.5]
+    }
+
    /// The world's colour and depth targets this frame, or `None` to draw
    /// it straight to the screen.
    /// `always`: a target even at scale 1 without anti-aliasing (a shader pack reads it).
@@ -507,7 +517,12 @@ impl Post {

 /// This frame's clip space to the previous frame's, for camera-relative projections:
 /// a point `camera - previous_camera` further from the previous camera than from this one.
-fn reprojection(previous: DMat4, previous_camera: DVec3, current: DMat4, camera: DVec3) -> DMat4 {
+pub(super) fn reprojection(
+    previous: DMat4,
+    previous_camera: DVec3,
+    current: DMat4,
+    camera: DVec3,
+) -> DMat4 {
    previous * DMat4::from_translation(camera - previous_camera) * current.inverse()
 }

@@ -79,6 +79,47 @@ impl Preset {
    }
 }

+/// Entity occlusion strategy. The synchronous mode preserves the original
+/// same-frame CPU test; asynchronous results only hide a mesh when their
+/// camera, bounds and occluder evidence still match.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum EntityCullingMode {
+    #[default]
+    Off,
+    Synchronous,
+    Asynchronous,
+}
+impl EntityCullingMode {
+    pub const ALL: [EntityCullingMode; 3] = [
+        EntityCullingMode::Off,
+        EntityCullingMode::Synchronous,
+        EntityCullingMode::Asynchronous,
+    ];
+    pub fn name(self) -> &'static str {
+        match self {
+            Self::Off => "off",
+            Self::Synchronous => "sync",
+            Self::Asynchronous => "async",
+        }
+    }
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Off => "Off",
+            Self::Synchronous => "Synchronous",
+            Self::Asynchronous => "Asynchronous",
+        }
+    }
+    fn parse(s: &str) -> Self {
+        match s {
+            // Keep graphics files written before the mode selector readable.
+            "true" | "synchronous" | "sync" => Self::Synchronous,
+            "false" | "off" => Self::Off,
+            "asynchronous" | "async" => Self::Asynchronous,
+            _ => Self::default(),
+        }
+    }
+}
+
 /// How the swapchain presents frames.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
 pub enum PresentMode {
@@ -246,6 +287,91 @@ impl FarDetail {
    }
 }

+/// Frame generation: a frame made between each two real ones.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum FrameGeneration {
+    #[default]
+    Off,
+    /// AMD FidelityFX Super Resolution 3.1's frame interpolation, ported to WGSL.
+    Fsr31,
+}
+impl FrameGeneration {
+    pub const ALL: [FrameGeneration; 2] = [FrameGeneration::Off, FrameGeneration::Fsr31];
+    pub fn name(self) -> &'static str {
+        match self {
+            FrameGeneration::Off => "off",
+            FrameGeneration::Fsr31 => "fsr3.1",
+        }
+    }
+    pub fn label(self) -> &'static str {
+        match self {
+            FrameGeneration::Off => "Off",
+            FrameGeneration::Fsr31 => "FSR 3.1",
+        }
+    }
+    fn parse(s: &str) -> Self {
+        Self::ALL
+            .into_iter()
+            .find(|f| f.name() == s)
+            .unwrap_or_default()
+    }
+}
+
+/// What the section mesher does with leaf faces inside a canopy. Terrain
+/// geometry only: entities, particles and block entities are untouched.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum LeafCullingMode {
+    /// Every leaf face, as vanilla's fancy leaves draw them.
+    #[default]
+    Off,
+    /// Leaves surrounded on all six sides by leaves or full opaque cubes draw
+    /// in the opaque layer, so their cutouts no longer show the layers behind.
+    Solid,
+    /// Like `Solid`, but a leaf with one open side draws opaque too: the
+    /// exposed shell thins by a layer and the canopy looks chunkier.
+    SolidAggressive,
+    /// Drops the faces two leaves share. Faces toward air, cavities, partial
+    /// models, unknown neighbours and section boundaries stay.
+    Hollow,
+}
+impl LeafCullingMode {
+    pub const ALL: [LeafCullingMode; 4] = [
+        LeafCullingMode::Off,
+        LeafCullingMode::Solid,
+        LeafCullingMode::SolidAggressive,
+        LeafCullingMode::Hollow,
+    ];
+    pub fn name(self) -> &'static str {
+        match self {
+            LeafCullingMode::Off => "off",
+            LeafCullingMode::Solid => "solid",
+            LeafCullingMode::SolidAggressive => "solid_aggressive",
+            LeafCullingMode::Hollow => "hollow",
+        }
+    }
+    pub fn label(self) -> &'static str {
+        match self {
+            LeafCullingMode::Off => "Off",
+            LeafCullingMode::Solid => "Solid",
+            LeafCullingMode::SolidAggressive => "Solid Aggressive",
+            LeafCullingMode::Hollow => "Hollow",
+        }
+    }
+    /// Whether this mode draws interior leaf faces in the solid layer.
+    pub fn is_interior(self) -> bool {
+        matches!(
+            self,
+            LeafCullingMode::Solid | LeafCullingMode::SolidAggressive
+        )
+    }
+    fn parse(s: &str) -> Self {
+        Self::ALL
+            .into_iter()
+            .find(|mode| mode.name() == s)
+            .unwrap_or_default()
+    }
+}
+
 /// TAA upscaling: the world renders this much smaller than the resolution scale's size,
 /// and TAA builds the full-size picture from the jittered frames (FSR's and DLSS's ratios).
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
@@ -361,6 +487,46 @@ impl Graphics {
    pub fn lod_distance_on(&self, info: &wgpu::AdapterInfo) -> u32 {
        lod_distance_capped(self.lod_distance, info)
    }
+    /// Whether the selected packs leave vanilla's block models in place.
+    /// Horizon's occlusion assumptions (entity and leaf culling) hold only
+    /// for those: a pack can replace an opaque cube's model or a leaf's.
+    pub fn vanilla_models(&self, resource_packs: &[String]) -> bool {
+        resource_packs.iter().all(|id| id == "vanilla")
+    }
+    /// The same check including packs overlaid by the connected server.
+    /// Their ids are namespaced as `server/...`, so an active server pack
+    /// disables model-dependent occlusion assumptions.
+    pub fn vanilla_models_with_server_packs<'a>(
+        &self,
+        resource_packs: impl IntoIterator<Item = &'a str>,
+        server_packs: impl IntoIterator<Item = &'a str>,
+    ) -> bool {
+        resource_packs
+            .into_iter()
+            .chain(server_packs)
+            .all(|id| id == "vanilla")
+    }
+    /// The leaf culling the mesher may apply. A pack that can replace leaf
+    /// models falls back to `Off`, which draws exactly vanilla's leaves.
+    pub fn leaf_culling_effective(&self, resource_packs: &[String]) -> LeafCullingMode {
+        if self.vanilla_models(resource_packs) {
+            self.leaf_culling
+        } else {
+            LeafCullingMode::Off
+        }
+    }
+    /// The effective mode when local and server resource packs are active.
+    pub fn leaf_culling_effective_with_server_packs<'a>(
+        &self,
+        resource_packs: impl IntoIterator<Item = &'a str>,
+        server_packs: impl IntoIterator<Item = &'a str>,
+    ) -> LeafCullingMode {
+        if self.vanilla_models_with_server_packs(resource_packs, server_packs) {
+            self.leaf_culling
+        } else {
+            LeafCullingMode::Off
+        }
+    }
 }
 #[derive(Clone, Debug, PartialEq)]
 pub struct Graphics {
@@ -371,8 +537,12 @@ pub struct Graphics {
    pub far_detail: FarDetail,
    /// Skip sections hidden behind closed ones (vanilla's occlusion graph).
    pub cave_culling: bool,
-    /// Skip drawing entities hidden behind opaque terrain.
-    pub entity_culling: bool,
+    /// Skip drawing entities hidden behind opaque terrain, synchronously or asynchronously.
+    pub entity_culling: EntityCullingMode,
+    /// Terrain leaf faces inside a canopy (see [`LeafCullingMode`]); `Off` draws
+    /// vanilla's fancy leaves. Ignored with a resource pack that may replace
+    /// the vanilla leaf models ([`Graphics::leaf_culling_effective`]).
+    pub leaf_culling: LeafCullingMode,
    /// Meshed sections uploaded per frame; 0 uploads all that are ready.
    pub chunk_updates: u32,
    /// Section mesh bytes uploaded per frame, in KiB; 0 is unlimited.
@@ -402,6 +572,8 @@ pub struct Graphics {
    pub upscaling: Upscaling,
    /// F2 screenshots at this many times the game's resolution: 1, 2, 4 or 8.
    pub screenshot_quality: u32,
+    /// Frame generation (Horizon setting), off by default.
+    pub frame_generation: FrameGeneration,
    /// HDR output (HDR10, or scRGB), where the display path offers it.
    pub hdr: bool,
    /// HDR paper white (where SDR white sits), in nits; 0 is Auto: the desktop's SDR
@@ -445,7 +617,8 @@ impl Default for Graphics {
            lod_distance: 0,
            far_detail: FarDetail::Full,
            cave_culling: true,
-            entity_culling: false,
+            entity_culling: EntityCullingMode::Off,
+            leaf_culling: LeafCullingMode::Off,
            chunk_updates: 0,
            upload_budget_kib: 0,
            texture_budget_mib: 0,
@@ -463,6 +636,7 @@ impl Default for Graphics {
            taa: false,
            upscaling: Upscaling::Native,
            screenshot_quality: 1,
+            frame_generation: FrameGeneration::Off,
            hdr: false,
            hdr_paper_white: 0,
            hdr_peak: 0,
@@ -514,7 +688,8 @@ impl Graphics {
                }
                "farDetail" => g.far_detail = FarDetail::parse(value),
                "caveCulling" => g.cave_culling = flag(g.cave_culling),
-                "entityCulling" => g.entity_culling = flag(g.entity_culling),
+                "entityCulling" => g.entity_culling = EntityCullingMode::parse(value),
+                "leafCulling" => g.leaf_culling = LeafCullingMode::parse(value),
                "chunkUpdates" => g.chunk_updates = number(g.chunk_updates).min(512),
                "uploadBudgetKiB" => g.upload_budget_kib = number(g.upload_budget_kib).min(65536),
                "textureBudgetMiB" => {
@@ -543,6 +718,7 @@ impl Graphics {
                        .filter(|q| SCREENSHOT_QUALITIES.contains(q))
                        .unwrap_or(1)
                }
+                "frameGeneration" => g.frame_generation = FrameGeneration::parse(value),
                "hdr" => g.hdr = flag(g.hdr),
                "hdrPaperWhite" => {
                    g.hdr_paper_white = match number(g.hdr_paper_white) {
@@ -580,12 +756,13 @@ impl Graphics {
    }
    pub fn serialize(&self) -> String {
        format!(
-            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\ntextureBudgetMiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\nditherCutoutMips:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nscreenshotQuality:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\ntranslucentBatching:{}\n",
+            "preset:{}\nlodDistance:{}\nfarDetail:{}\ncaveCulling:{}\nentityCulling:{}\nleafCulling:{}\nchunkUpdates:{}\nuploadBudgetKiB:{}\ntextureBudgetMiB:{}\nsky:{}\nfog:{}\nweather:{}\nanimatedTextures:{}\nditherCutoutMips:{}\npresentMode:{}\nframePacing:{}\nworkers:{}\noverlay:{}\nresolutionScale:{}\nfxaa:{}\ntaa:{}\nupscaling:{}\nscreenshotQuality:{}\nframeGeneration:{}\nhdr:{}\nhdrPaperWhite:{}\nhdrPeak:{}\nhdrBlackLevel:{}\nhdrUiBrightness:{}\nhdrKey:{}\nbatteryMode:{}\nshadowCache:{}\ngraphicsApi:{}\npickedShaderPack:{}\ntranslucentBatching:{}\n",
            self.preset.name(),
            self.lod_distance,
            self.far_detail.name(),
            bool_text(self.cave_culling),
-            bool_text(self.entity_culling),
+            self.entity_culling.name(),
+            self.leaf_culling.name(),
            self.chunk_updates,
            self.upload_budget_kib,
            self.texture_budget_mib,
@@ -610,6 +787,7 @@ impl Graphics {
            bool_text(self.taa),
            self.upscaling.name(),
            self.screenshot_quality,
+            self.frame_generation.name(),
            bool_text(self.hdr),
            self.hdr_paper_white,
            self.hdr_peak,
@@ -741,7 +919,8 @@ mod tests {
            lod_distance: 256,
            far_detail: FarDetail::Reduced,
            cave_culling: false,
-            entity_culling: true,
+            entity_culling: EntityCullingMode::Synchronous,
+            leaf_culling: LeafCullingMode::SolidAggressive,
            chunk_updates: 12,
            upload_budget_kib: 4096,
            texture_budget_mib: 1536,
@@ -759,6 +938,7 @@ mod tests {
            taa: true,
            upscaling: Upscaling::Balanced,
            screenshot_quality: 4,
+            frame_generation: FrameGeneration::Fsr31,
            hdr: true,
            hdr_paper_white: 240,
            hdr_peak: 1400,
@@ -772,6 +952,21 @@ mod tests {
            shader_pack: "Golden Hour".into(),
        };
        assert_eq!(Graphics::parse(&g.serialize()), g);
+        for mode in EntityCullingMode::ALL {
+            let graphics = Graphics {
+                entity_culling: mode,
+                ..Graphics::default()
+            };
+            assert_eq!(Graphics::parse(&graphics.serialize()), graphics);
+        }
+        assert_eq!(
+            Graphics::parse("entityCulling:true\n").entity_culling,
+            EntityCullingMode::Synchronous
+        );
+        assert_eq!(
+            Graphics::parse("entityCulling:false\n").entity_culling,
+            EntityCullingMode::Off
+        );
        assert_eq!(Graphics::parse(""), Graphics::default());
        // Translucent Batching is opt-in for now: only the file turns it on.
        assert!(!Graphics::default().translucent_batching);
@@ -801,11 +996,96 @@ mod tests {
            Graphics::default()
        );
        assert_eq!(
-            Graphics::parse("workers:abc\nsky:maybe\ncullLeaves:true\nentityCulling:maybe\n"),
+            Graphics::parse(
+                "workers:abc\nsky:maybe\ncullLeaves:true\nentityCulling:maybe\nleafCulling:maybe\n"
+            ),
            Graphics::default()
        );
    }

+    #[test]
+    fn leaf_culling_round_trips_its_stable_names() {
+        assert_eq!(Graphics::default().leaf_culling, LeafCullingMode::Off);
+        for mode in LeafCullingMode::ALL {
+            let g = Graphics {
+                leaf_culling: mode,
+                ..Graphics::default()
+            };
+            assert_eq!(Graphics::parse(&g.serialize()), g, "{mode:?}");
+            assert_eq!(
+                Graphics::parse(&format!("leafCulling:{}\n", mode.name())).leaf_culling,
+                mode
+            );
+        }
+        for text in [
+            "leafCulling:other\n",
+            "leafCulling:\n",
+            "leafCulling:SOLID\n",
+        ] {
+            assert_eq!(
+                Graphics::parse(text).leaf_culling,
+                LeafCullingMode::Off,
+                "{text:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn presets_keep_the_leaf_culling_choice() {
+        for mode in LeafCullingMode::ALL {
+            for preset in Preset::ALL {
+                let mut s = crate::settings::Settings::default();
+                s.horizon.leaf_culling = mode;
+                apply_preset(preset, &mut s);
+                assert_eq!(s.horizon.leaf_culling, mode, "{preset:?}");
+                assert_eq!(Graphics::parse(&s.horizon.serialize()), s.horizon);
+            }
+        }
+    }
+
+    #[test]
+    fn custom_packs_turn_leaf_culling_off() {
+        let g = Graphics {
+            leaf_culling: LeafCullingMode::Hollow,
+            ..Graphics::default()
+        };
+        assert!(g.vanilla_models(&["vanilla".into()]));
+        assert_eq!(
+            g.leaf_culling_effective(&["vanilla".into()]),
+            LeafCullingMode::Hollow
+        );
+        assert!(!g.vanilla_models(&["vanilla".into(), "My Pack".into()]));
+        assert_eq!(
+            g.leaf_culling_effective(&["vanilla".into(), "My Pack".into()]),
+            LeafCullingMode::Off
+        );
+        assert_eq!(g.leaf_culling_effective(&[]), LeafCullingMode::Hollow);
+    }
+
+    #[test]
+    fn server_pack_apply_disables_leaf_culling_and_removal_restores_it() {
+        let g = Graphics {
+            leaf_culling: LeafCullingMode::Solid,
+            ..Graphics::default()
+        };
+        let selected = ["vanilla"];
+        let applied_server_pack = ["server/0123456789abcdef/model-pack.zip"];
+
+        assert_eq!(
+            g.leaf_culling_effective_with_server_packs(selected, applied_server_pack),
+            LeafCullingMode::Off,
+            "an applied server pack can replace block models"
+        );
+        assert!(!g.vanilla_models_with_server_packs(selected, applied_server_pack));
+
+        assert_eq!(
+            g.leaf_culling_effective_with_server_packs(selected, []),
+            LeafCullingMode::Solid,
+            "removing the server pack restores the selected local mode"
+        );
+        assert!(g.vanilla_models_with_server_packs(selected, []));
+    }
+
    #[test]
    fn integrated_gpus_other_than_apple_cap_the_lod_distance() {
        let adapter = |name: &str, device_type| wgpu::AdapterInfo {
@@ -2,7 +2,10 @@
 //! they show, in what groups, with what description and cost, and their
 //! input. How they look comes from `graphics_style`.
 use crate::{
-    graphics::{FarDetail, GraphicsApi, Overlay, Pacing, PresentMode, Preset, Upscaling},
+    graphics::{
+        EntityCullingMode, FarDetail, FrameGeneration, GraphicsApi, LeafCullingMode, Overlay,
+        Pacing, PresentMode, Preset, Upscaling,
+    },
    graphics_style::{Cost, STYLE},
    hud::{HudAtlas, HudBatch},
    lang,
@@ -27,6 +30,7 @@ pub enum H {
    FarDetail,
    CaveCulling,
    EntityCulling,
+    LeafCulling,
    ChunkUpdates,
    UploadBudget,
    Sky,
@@ -42,6 +46,7 @@ pub enum H {
    Antialiasing,
    Upscaling,
    ScreenshotQuality,
+    FrameGeneration,
    Hdr,
    /// Opens `Level::Hdr`.
    HdrSettings,
@@ -187,6 +192,12 @@ pub fn rows(level: Level) -> Vec<Row> {
                Medium,
                "How far away mobs and items are drawn, as a share of normal.",
            ),
+            h(
+                H::ChunkUpdates,
+                Low,
+                "Meshed sections uploaded per frame. Lower is smoother while loading.",
+            ),
+            Row::Header("Culling"),
            h(
                H::CaveCulling,
                Saves,
@@ -195,12 +206,12 @@ pub fn rows(level: Level) -> Vec<Row> {
            h(
                H::EntityCulling,
                None,
-                "Hides models behind opaque blocks. Entities update. Off with custom packs.",
+                "Hides models behind opaque blocks. Async checks off-thread; entities tick.",
            ),
            h(
-                H::ChunkUpdates,
-                Low,
-                "Meshed sections uploaded per frame. Lower is smoother while loading.",
+                H::LeafCulling,
+                Saves,
+                "Draws or drops leaf faces inside canopies. Off keeps vanilla's fancy leaves.",
            ),
            Row::Header("Quality"),
            v(
@@ -291,6 +302,11 @@ pub fn rows(level: Level) -> Vec<Row> {
                None,
                "F2 screenshots at this many times the game's resolution. Higher takes longer.",
            ),
+            h(
+                H::FrameGeneration,
+                Medium,
+                "Shows a made-up frame between each two real ones: smoother, a little more lag.",
+            ),
            h(
                H::HdrSettings,
                None,
@@ -446,6 +462,16 @@ fn description(item: Item, s: &Settings, text: &'static str) -> &'static str {
        (Item::Horizon(H::HdrPeak | H::HdrPaperWhite), Setup::Automatic | Setup::Changed) => {
            "Set up for your display. Leave on Auto unless it looks wrong."
        }
+        (Item::Horizon(H::LeafCulling), _) => match s.horizon.leaf_culling {
+            LeafCullingMode::Off => "Every leaf face. Vanilla's fancy leaves.",
+            LeafCullingMode::Solid => {
+                "Leaves fully inside a canopy draw solid: fewer see-through layers."
+            }
+            LeafCullingMode::SolidAggressive => {
+                "Leaves with one open side draw solid too: faster, chunkier edges."
+            }
+            LeafCullingMode::Hollow => "Drops faces between leaves: faster, but gaps look through.",
+        },
        _ => text,
    }
 }
@@ -515,7 +541,8 @@ impl H {
            },
            H::FarDetail => labelled("Far Detail", g.far_detail.label()),
            H::CaveCulling => labelled("Cave Culling", on_off(g.cave_culling)),
-            H::EntityCulling => labelled("Entity Culling", on_off(g.entity_culling)),
+            H::EntityCulling => labelled("Entity Culling", g.entity_culling.label()),
+            H::LeafCulling => labelled("Leaf Culling", g.leaf_culling.label()),
            H::ChunkUpdates => match g.chunk_updates {
                0 => labelled("Chunk Updates", "Unlimited"),
                n => labelled("Chunk Updates", lang::tr("%s per frame", &[&n])),
@@ -560,6 +587,7 @@ impl H {
            H::ScreenshotQuality => {
                labelled("Screenshot Quality", format!("{}x", g.screenshot_quality))
            }
+            H::FrameGeneration => labelled("Frame Generation", g.frame_generation.label()),
            H::Hdr => labelled("HDR", on_off(g.hdr)),
            H::HdrSettings => Text::literal(lang::get("HDR Settings...")),
            H::HdrCalibrate => Text::literal(lang::get(match setup(s) {
@@ -590,7 +618,7 @@ impl H {
            ),
            H::HdrUiBrightness => labelled("UI Brightness", format!("{}%", g.hdr_ui_brightness)),
            H::HdrKey => {
-                Text::literal("Shortcut: ").append(crate::keybinds::display_name(&g.hdr_key))
+                Text::translate("Shortcut: %s", &[crate::keybinds::display_name(&g.hdr_key)])
            }
            H::BatteryMode => labelled("Battery Mode", on_off(g.battery)),
            H::ShadowCache => labelled("Shadow Cache", on_off(g.shadow_cache)),
@@ -648,7 +676,12 @@ impl H {
                g.far_detail = step(&[FarDetail::Full, FarDetail::Reduced], g.far_detail, back)
            }
            H::CaveCulling => g.cave_culling = !g.cave_culling,
-            H::EntityCulling => g.entity_culling = !g.entity_culling,
+            H::EntityCulling => {
+                g.entity_culling = step(&EntityCullingMode::ALL, g.entity_culling, back)
+            }
+            H::LeafCulling => {
+                g.leaf_culling = step(&LeafCullingMode::ALL, g.leaf_culling, back);
+            }
            H::Sky => g.sky = !g.sky,
            H::Fog => g.fog = !g.fog,
            H::Weather => g.weather = !g.weather,
@@ -678,6 +711,9 @@ impl H {
                    back,
                )
            }
+            H::FrameGeneration => {
+                g.frame_generation = step(&FrameGeneration::ALL, g.frame_generation, back)
+            }
            H::Hdr => g.hdr = !g.hdr,
            H::BatteryMode => g.battery = !g.battery,
            H::ShadowCache => g.shadow_cache = !g.shadow_cache,
@@ -736,7 +772,6 @@ impl Item {
        let g = &s.horizon;
        Some(match self {
            Item::Horizon(H::CaveCulling) => g.cave_culling,
-            Item::Horizon(H::EntityCulling) => g.entity_culling,
            Item::Horizon(H::Sky) => g.sky,
            Item::Horizon(H::Fog) => g.fog,
            Item::Horizon(H::Weather) => g.weather,
@@ -804,6 +839,7 @@ impl Item {
                    | H::Pacing
                    | H::PresentMode
                    | H::Workers
+                    | H::FrameGeneration
                    | H::BatteryMode
                    | H::ShadowCache
                    | H::GraphicsApi
@@ -1039,9 +1075,12 @@ impl GraphicsUi {
                    let mut label = item.label(s);
                    if item == Item::Horizon(H::HdrKey) && self.binding.is_some() {
                        // KeyBindsScreen: "> key <" while it waits.
-                        label = Text::literal("Shortcut: > ")
-                            .append(crate::keybinds::display_name(&s.horizon.hdr_key))
-                            .append(" <");
+                        label = Text::translate(
+                            "Shortcut: %s",
+                            &[Text::literal("> ")
+                                .append(crate::keybinds::display_name(&s.horizon.hdr_key))
+                                .append(" <")],
+                        );
                    }
                    let blocked = item.blocked(s);
                    let live = blocked.is_none();
@@ -1826,16 +1865,92 @@ mod tests {
    }

    #[test]
-    fn entity_culling_is_opt_in_and_toggles_from_advanced_graphics() {
+    fn leaf_culling_cycles_modes_in_the_advanced_culling_group() {
+        let mut s = Settings::default();
+        let item = Item::Horizon(H::LeafCulling);
+        assert_eq!(item.switch(&s), None);
+        assert_eq!(item.label(&s).plain(), "Leaf Culling: Off");
+        for label in ["Solid", "Solid Aggressive", "Hollow", "Off"] {
+            item.cycle(&mut s, false, [854, 480]);
+            assert_eq!(item.label(&s).plain(), format!("Leaf Culling: {label}"));
+            assert_eq!(
+                crate::graphics::Graphics::parse(&s.horizon.serialize()).leaf_culling,
+                s.horizon.leaf_culling
+            );
+        }
+        item.cycle(&mut s, true, [854, 480]);
+        assert_eq!(s.horizon.leaf_culling, LeafCullingMode::Hollow);
+
+        // The three culling settings share one group, below Rendering's chunk
+        // updates and above Quality.
+        let rows = rows(Level::Advanced);
+        let culling = rows
+            .iter()
+            .position(|row| matches!(row, Row::Header("Culling")))
+            .unwrap();
+        assert!(matches!(
+            rows.get(culling + 1),
+            Some(Row::Setting(setting)) if setting.item == Item::Horizon(H::CaveCulling)
+        ));
+        assert!(matches!(
+            rows.get(culling + 2),
+            Some(Row::Setting(setting)) if setting.item == Item::Horizon(H::EntityCulling)
+        ));
+        assert!(matches!(
+            rows.get(culling + 3),
+            Some(Row::Setting(setting)) if setting.item == item
+        ));
+        assert!(matches!(
+            rows.get(culling + 4),
+            Some(Row::Header("Quality"))
+        ));
+
+        // The description names what the picked mode does.
+        for mode in LeafCullingMode::ALL {
+            s.horizon.leaf_culling = mode;
+            let text = description(item, &s, "fallback");
+            assert_ne!(text, "fallback", "{mode:?}");
+            assert!(text.len() < 80, "{mode:?}: {text}");
+        }
+
+        // A click cycles it and leaves the preset, as the other quality
+        // settings do.
+        let mut ui = GraphicsUi::default();
+        let size = (480.0, 4000.0);
+        let (widgets, _, _) = ui.layout(Level::Advanced, &s, size.0, size.1);
+        let control = widgets
+            .iter()
+            .find(|w| matches!(w.target, Target::Item(i) if i == item))
+            .unwrap();
+        s.horizon.preset = Preset::Balanced;
+        s.horizon.leaf_culling = LeafCullingMode::Off;
+        assert_eq!(
+            ui.click(
+                Level::Advanced,
+                &mut s,
+                (control.x + 1.0, control.y + 1.0),
+                size,
+                [854, 480],
+                false,
+                false
+            ),
+            vec![Action::ButtonClick, Action::Changed]
+        );
+        assert_eq!(s.horizon.leaf_culling, LeafCullingMode::Solid);
+        assert_eq!(s.horizon.preset, Preset::Custom);
+    }
+
+    #[test]
+    fn entity_culling_modes_are_opt_in_and_cycle_from_advanced_graphics() {
        let mut s = Settings::default();
        let item = Item::Horizon(H::EntityCulling);
-        assert_eq!(item.switch(&s), Some(false));
+        assert_eq!(s.horizon.entity_culling, EntityCullingMode::Off);
        assert_eq!(item.label(&s).plain(), "Entity Culling: Off");
-        for enabled in [false, true] {
-            s.horizon.entity_culling = enabled;
+        for mode in EntityCullingMode::ALL {
+            s.horizon.entity_culling = mode;
            for preset in Preset::ALL {
                crate::graphics::apply_preset(preset, &mut s);
-                assert_eq!(s.horizon.entity_culling, enabled);
+                assert_eq!(s.horizon.entity_culling, mode);
            }
        }

@@ -1847,7 +1962,11 @@ mod tests {
            .find(|w| matches!(w.target, Target::Item(i) if i == item))
            .unwrap();
        let point = (switch.x + 1.0, switch.y + 1.0);
-        for enabled in [false, true] {
+        for mode in [
+            EntityCullingMode::Off,
+            EntityCullingMode::Synchronous,
+            EntityCullingMode::Asynchronous,
+        ] {
            s.horizon.preset = Preset::Balanced;
            assert_eq!(
                ui.click(
@@ -1861,10 +1980,10 @@ mod tests {
                ),
                vec![Action::ButtonClick, Action::Changed]
            );
-            assert_eq!(item.switch(&s), Some(enabled));
+            assert_eq!(s.horizon.entity_culling, mode);
            assert_eq!(s.horizon.preset, Preset::Custom);
        }
-        assert_eq!(item.label(&s).plain(), "Entity Culling: On");
+        assert_eq!(item.label(&s).plain(), "Entity Culling: Asynchronous");
    }

    #[test]
@@ -18,6 +18,7 @@
 //! or Escape leaves them as they were.
 use crate::{
    hud::{HudAtlas, HudBatch, rgba},
+    lang,
    settings::Settings,
    text::Text,
    ui,
@@ -64,14 +65,19 @@ impl Step {
            Step::PaperWhite => (10.0, 480.0, 10.0),
        }
    }
-    fn name(self) -> &'static str {
+    /// The English name, which is also its key in the language table.
+    fn name_key(self) -> &'static str {
        match self {
            Step::Black => "Black Level",
            Step::Peak => "Peak Brightness",
            Step::PaperWhite => "Paper White",
        }
    }
-    fn hint(self) -> &'static str {
+    fn name(self) -> String {
+        lang::get(self.name_key())
+    }
+    /// The English hint, which is also its key in the language table.
+    fn hint_key(self) -> &'static str {
        match self {
            Step::Black => "Lower it until the logo just disappears into the black.",
            Step::Peak => "Raise it until the logo just disappears into the bright square.",
@@ -139,10 +145,16 @@ impl Calibration {
    }
    fn label(&self) -> Text {
        let v = self.values[self.step];
-        Text::literal(match self.current() {
-            Step::Black => format!("Black Level: {v:.2} nits"),
-            step => format!("{}: {v:.0} nits", step.name()),
-        })
+        let step = self.current();
+        let nits = match step {
+            Step::Black => format!("{v:.2}"),
+            _ => format!("{v:.0}"),
+        };
+        Text::literal(format!(
+            "{}: {}",
+            step.name(),
+            lang::tr("%s nits", &[&nits])
+        ))
    }
    /// The step, its nits and where the controls start (a share of the height), for
    /// HDR output's test picture.
@@ -160,14 +172,12 @@ impl Calibration {
        batch.fill(atlas, 0.0, 0.0, w, h, rgba(0, 0, 0, 255));
        batch.fill(atlas, 0.0, l.top, w, h - l.top, rgba(24, 24, 24, 255));
        let step = self.current();
-        let title = Text::literal(format!(
-            "HDR Calibration {}/{}: {}",
-            self.step + 1,
-            STEPS.len(),
-            step.name()
+        let title = Text::literal(lang::tr(
+            "HDR Calibration %s/%s: %s",
+            &[&(self.step + 1), &STEPS.len(), &step.name()],
        ));
        ui::centered_text(batch, atlas, &title, 0.0, l.top + 6.0, w, u32::MAX);
-        let hint = Text::literal(step.hint());
+        let hint = Text::literal(lang::get(step.hint_key()));
        ui::centered_text(
            batch,
            atlas,
@@ -192,10 +202,12 @@ impl Calibration {
            self.dragging,
        );
        let last = self.step + 1 == STEPS.len();
+        let save = lang::get_or("selectWorld.edit.save", "Save");
+        let next = lang::get("Next");
        for (rect, label, active) in [
-            (l.cancel, "Cancel", true),
-            (l.back, "Back", self.step > 0),
-            (l.next, if last { "Save" } else { "Next" }, true),
+            (l.cancel, lang::get_or("gui.cancel", "Cancel"), true),
+            (l.back, lang::get_or("gui.back", "Back"), self.step > 0),
+            (l.next, if last { save } else { next }, true),
        ] {
            let hover = over(cursor, rect) && active;
            ui::button(
@@ -83,6 +83,8 @@ pub struct HudAtlas {
    /// A resource pack's own `core/text` shader for the GUI's text, translated;
    /// none draws the text natively.
    pub text_shader: Option<std::sync::Arc<horizon_shaders::CoreProgram>>,
+    /// The packs' OptiFine random entity textures, whose variants this atlas packs.
+    pub random_textures: horizon_optifine::random_textures::RandomTextures,
    white: Rect,
 }
 /// Atlas rows reserved for glyphs rasterized at run time.
@@ -118,6 +120,7 @@ pub fn decode(path: &Path) -> Result<(u32, u32, Vec<u8>)> {
 /// A PNG in memory as RGBA pixels.
 pub fn decode_bytes(data: &[u8]) -> Result<(u32, u32, Vec<u8>)> {
    let mut decoder = png::Decoder::new(std::io::Cursor::new(data));
+    decoder.ignore_checksums(true);
    decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
    let mut reader = decoder.read_info()?;
    let mut bytes = vec![0; reader.output_buffer_size().ok_or("image too large")?];
@@ -212,6 +215,28 @@ fn wrap_border((name, w, h, data): &PackedImage) -> PackedImage {
    }
    (name.clone(), bw, bh, out)
 }
+/// Folders of `assets/minecraft/textures/` that [`HudAtlas::pack`] walks for
+/// the full atlas. A pack may add others through `atlases/blocks.json`.
+const WALKED_TEXTURE_FOLDERS: &[&str] = &[
+    "gui",
+    "item",
+    "block",
+    "font",
+    "environment",
+    "misc",
+    "painting",
+    "entity",
+    "particle",
+    "mob_effect",
+    "map",
+];
+
+fn walked_minecraft_texture(name: &str) -> bool {
+    WALKED_TEXTURE_FOLDERS
+        .iter()
+        .any(|folder| name.starts_with(folder) && name.as_bytes().get(folder.len()) == Some(&b'/'))
+}
+
 /// Sprites the atlas definitions (`atlases/*.json`) add beyond the texture
 /// files already packed: generated ones (`paletted_permutations` such as the
 /// armour trim sprites, `unstitch` regions) and files listed under another id,
@@ -239,11 +264,13 @@ fn atlas_sprites(root: &Path, packed: &[PackedImage]) -> (Vec<PackedImage>, Vec<
            if have.contains(name.as_str()) {
                continue;
            }
-            // A vanilla file is packed under its own name already: only a
-            // renamed one is new. Other namespaces' files (content mods) are
-            // never in the walked directories.
+            // A file under a walked folder is packed under its own name already:
+            // only a renamed one is new. Other namespaces' files (content mods)
+            // are never in those folders, nor are extra directories a pack adds
+            // to the blocks atlas (`custom/...`).
            if let SpriteOrigin::File(texture) = &origin
                && texture.strip_prefix("minecraft:") == Some(name.as_str())
+                && walked_minecraft_texture(name.as_str())
            {
                continue;
            }
@@ -346,24 +373,7 @@ impl HudAtlas {
    /// The atlas of a resource root that layers packs over `defaults` (the
    /// game's own resources), whose textures give the sprites' GUI sizes.
    pub fn build_over(root: &Path, defaults: &Path) -> Result<Self> {
-        let mut atlas = Self::pack(
-            root,
-            defaults,
-            &[
-                "gui",
-                "item",
-                "block",
-                "font",
-                "environment",
-                "misc",
-                "painting",
-                "entity",
-                "particle",
-                "mob_effect",
-                "map",
-            ],
-            true,
-        )?;
+        let mut atlas = Self::pack(root, defaults, WALKED_TEXTURE_FOLDERS, true)?;
        atlas.text_shader = pack_text::load(root, defaults);
        Ok(atlas)
    }
@@ -479,6 +489,7 @@ impl HudAtlas {
            glint_armor: (vec![0; 4], 1, 1),
            white,
            text_shader: None,
+            random_textures: Default::default(),
        }
    }
    /// Shelf placements of `images` (tallest first) in the narrowest atlas
@@ -567,15 +578,41 @@ impl HudAtlas {
            let s = p.to_string_lossy();
            !s.contains("title/background") && !s.contains("realms") && !s.contains("presets")
        });
+        // OptiFine random entity variants, under the names their scan gives them (those
+        // outside `textures/` are `<ns>:optifine/random/...`).
+        let random_textures = if folders.contains(&"entity") {
+            horizon_optifine::random_textures::RandomTextures::scan(root)
+        } else {
+            Default::default()
+        };
+        let mut named: HashMap<PathBuf, String> = HashMap::new();
+        for (file, name) in random_textures.files() {
+            named.insert(root.join(file), name.to_owned());
+        }
+        if !named.is_empty() {
+            // Those beside their texture are walked already.
+            let walked: HashSet<&PathBuf> = files.iter().collect();
+            let mut extra: Vec<PathBuf> = named
+                .keys()
+                .filter(|p| !walked.contains(p))
+                .cloned()
+                .collect();
+            extra.sort();
+            files.extend(extra);
+        }
        type Decoded = (PackedImage, Option<TextureFlags>, Option<(u32, u32)>, bool);
        let decode_one = |path: &PathBuf| -> Option<Decoded> {
-            let name = match path.strip_prefix(&textures) {
-                Ok(rel) => rel.with_extension("").to_string_lossy().replace('\\', "/"),
-                Err(_) => {
-                    let rel = path.strip_prefix(&assets).ok()?.with_extension("");
-                    let rel = rel.to_string_lossy().replace('\\', "/");
-                    let (namespace, rest) = rel.split_once("/textures/")?;
-                    format!("{namespace}:{rest}")
+            let name = if let Some(name) = named.get(path) {
+                name.clone()
+            } else {
+                match path.strip_prefix(&textures) {
+                    Ok(rel) => rel.with_extension("").to_string_lossy().replace('\\', "/"),
+                    Err(_) => {
+                        let rel = path.strip_prefix(&assets).ok()?.with_extension("");
+                        let rel = rel.to_string_lossy().replace('\\', "/");
+                        let (namespace, rest) = rel.split_once("/textures/")?;
+                        format!("{namespace}:{rest}")
+                    }
                }
            };
            // LabPBR's maps beside a texture are the world's (sprites.rs), not images to draw.
@@ -777,6 +814,7 @@ impl HudAtlas {
            glint,
            glint_armor,
            text_shader: None,
+            random_textures,
            font,
            white,
        })
@@ -2121,6 +2159,40 @@ impl HudRenderer {
 mod tests {
    use super::*;

+    #[test]
+    fn decode_bytes_ignores_crc_checksum_error() {
+        let mut encoded = Vec::new();
+        {
+            let mut encoder = png::Encoder::new(&mut encoded, 2, 2);
+            encoder.set_color(png::ColorType::Rgba);
+            encoder.set_depth(png::BitDepth::Eight);
+            let mut writer = encoder.write_header().unwrap();
+            writer
+                .write_image_data(&[
+                    255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 255, 255, 255, 255, 255, 255,
+                ])
+                .unwrap();
+            writer.finish().unwrap();
+        }
+        let idat_pos = encoded
+            .windows(4)
+            .position(|w| w == b"IDAT")
+            .expect("IDAT chunk");
+        let len = u32::from_be_bytes([
+            encoded[idat_pos - 4],
+            encoded[idat_pos - 3],
+            encoded[idat_pos - 2],
+            encoded[idat_pos - 1],
+        ]) as usize;
+        let crc_pos = idat_pos + 4 + len;
+        encoded[crc_pos] ^= 0xFF;
+
+        let (w, h, rgba) = decode_bytes(&encoded).expect("should decode despite bad CRC");
+        assert_eq!(w, 2);
+        assert_eq!(h, 2);
+        assert_eq!(rgba.len(), 16);
+    }
+
    #[test]
    fn clip_since_keeps_the_visible_part_of_a_straddling_triangle() {
        let mut batch = HudBatch::new([320, 240]);
@@ -2333,6 +2405,33 @@ mod tests {
        assert_eq!(texel_at(&atlas, rect, 0, 0), [0, 255, 0, 255]);
    }
    #[test]
+    fn a_pack_directory_outside_the_walked_folders_still_packs() {
+        let root =
+            std::env::temp_dir().join(format!("horizon-atlas-custom-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&root);
+        let atlases = root.join("assets/minecraft/atlases");
+        let custom = root.join("assets/minecraft/textures/custom");
+        fs::create_dir_all(&atlases).unwrap();
+        fs::create_dir_all(&custom).unwrap();
+        fs::write(
+            atlases.join("blocks.json"),
+            r#"{"sources":[{"type":"directory","source":"custom","prefix":"custom/"}]}"#,
+        )
+        .unwrap();
+        write_strip(
+            &custom.join("test.png"),
+            16,
+            16,
+            &[[40, 180, 80, 255]],
+            None,
+        );
+        let atlas = HudAtlas::build(&root).unwrap();
+        let rect = atlas.sprites["custom/test"];
+        assert_eq!(rect.texels((atlas.width, atlas.height)), (16, 16));
+        assert_eq!(texel_at(&atlas, rect, 0, 0), [40, 180, 80, 255]);
+        let _ = fs::remove_dir_all(&root);
+    }
+    #[test]
    fn another_namespaces_animated_item_texture_packs_its_first_frame_and_animates() {
        let root =
            std::env::temp_dir().join(format!("horizon-atlas-ns-anim-{}", std::process::id()));
@@ -8,6 +8,7 @@ pub mod auth;
 pub mod ban_notice;
 pub mod bidi;
 pub mod biome;
+pub mod block_edit;
 pub mod block_entities;
 pub mod block_entity_anim;
 pub mod block_entity_render;
@@ -18,9 +19,11 @@ pub mod camera;
 pub mod chat;
 pub mod chunk;
 pub mod chunk_map;
+pub mod cit;
 pub mod clouds;
 pub mod collisions;
 pub mod command_block;
+pub mod connected;
 pub mod containers;
 pub mod crash;
 pub mod datapack;
@@ -592,18 +592,21 @@ pub fn apply_relighting(chunk: &mut Chunk, lights: Vec<Light>, changed: &mut Lig
    changed.keyed(chunk.layout());
    for (sy, (section, light)) in chunk.sections.iter_mut().zip(lights).enumerate() {
        let old = &section.light;
-        if let (Light::Uniform(a), Light::Uniform(b)) = (old, &light)
-            && a == b
-        {
-            continue;
-        }
-        let mut classes = 0;
-        for i in 0..4096 {
-            if old.get(i) != light.get(i) {
-                let (x, y, z) = (i as i32 & 15, (i >> 8) as i32, (i >> 4) as i32 & 15);
-                classes |= 1 << LightChanges::class(x, y, z);
+        let classes = match (old, &light) {
+            (Light::Uniform(a), Light::Uniform(b)) if a == b => continue,
+            // (most sections of a chunk relit for a neighbour's edit keep their light: one comparison of the whole)
+            (Light::Full(a), Light::Full(b)) => LightChanges::classes_differing(a, b),
+            _ => {
+                let mut classes = 0;
+                for i in 0..4096 {
+                    if old.get(i) != light.get(i) {
+                        let (x, y, z) = (i as i32 & 15, (i >> 8) as i32, (i >> 4) as i32 & 15);
+                        classes |= 1 << LightChanges::class(x, y, z);
+                    }
+                }
+                classes
            }
-        }
+        };
        if classes != 0 {
            changed.add((chunk.x, sy as i32, chunk.z), classes);
            Arc::make_mut(section).light = light;
@@ -847,7 +850,7 @@ pub struct LightChanges {
 impl LightChanges {
    /// Changes in chunks of `layout`: what the relighter or a light job adds
    /// after this (they all come from one level).
-    fn keyed(&mut self, layout: ColumnLayout) {
+    pub fn keyed(&mut self, layout: ColumnLayout) {
        debug_assert!(self.sections.is_empty() || self.layout == layout);
        self.layout = layout;
    }
@@ -858,7 +861,7 @@ impl LightChanges {
        *self.sections.entry(key).or_default() |= 1 << Self::class(x, y, z);
    }
    /// Cells of section `key` (x, section index, z) in the given classes.
-    fn add(&mut self, key: Pos, classes: u32) {
+    pub fn add(&mut self, key: Pos, classes: u32) {
        *self.sections.entry(key).or_default() |= classes;
    }
    /// The class of a cell in its section: per axis 0 on the low face, 1
@@ -871,6 +874,25 @@ impl LightChanges {
        };
        axis(x) + 3 * axis(y) + 9 * axis(z)
    }
+    /// The classes (bit `class`) of the cells, in a section's index order (`y << 8 | z << 4 | x`), where `a` and
+    /// `b` differ.
+    pub fn classes_differing<T: PartialEq>(a: &[T; 4096], b: &[T; 4096]) -> u32 {
+        let mut classes = 0;
+        // (a row of 16 along x at a time: the rows alike, most of them, cost one comparison)
+        let (rows_a, rows_b) = (a.as_chunks::<16>().0, b.as_chunks::<16>().0);
+        for (row, (ra, rb)) in rows_a.iter().zip(rows_b).enumerate() {
+            if ra == rb {
+                continue;
+            }
+            let (y, z) = ((row >> 4) as i32, (row & 15) as i32);
+            for x in 0..16 {
+                if ra[x] != rb[x] {
+                    classes |= 1 << Self::class(x as i32, y, z);
+                }
+            }
+        }
+        classes
+    }
    pub fn is_empty(&self) -> bool {
        self.sections.is_empty()
    }
@@ -1156,6 +1178,31 @@ mod tests {
    use super::*;
    use crate::chunk::{HEIGHT, MIN_Y, SECTIONS};

+    #[test]
+    fn changed_cells_dirty_only_the_sections_within_a_block() {
+        let dirty = |cells: &[(usize, usize, usize)]| {
+            let a = [0u8; 4096];
+            let mut b = a;
+            for &(x, y, z) in cells {
+                b[y << 8 | z << 4 | x] = 1;
+            }
+            let mut changes = LightChanges::default();
+            changes.add((0, 5, 0), LightChanges::classes_differing(&a, &b));
+            let mut out = Vec::new();
+            changes.dirty_sections(|p| out.push(p));
+            out.sort_unstable();
+            out
+        };
+        assert_eq!(dirty(&[]), Vec::<Pos>::new());
+        assert_eq!(dirty(&[(5, 5, 5), (9, 1, 14)]), vec![(0, 5, 0)]);
+        assert_eq!(dirty(&[(0, 5, 5)]), vec![(-1, 5, 0), (0, 5, 0)]);
+        assert_eq!(
+            dirty(&[(15, 15, 5)]),
+            vec![(0, 5, 0), (0, 6, 0), (1, 5, 0), (1, 6, 0)]
+        );
+        assert_eq!(dirty(&[(0, 0, 0)]).len(), 8);
+    }
+
    const AIR: u32 = 0;
    const STONE: u32 = 1;
    const TORCH: u32 = 2;
@@ -4,18 +4,22 @@
 //! cardinal shading, tint sources, block offsets; see `lighting`). Fluids
 //! follow `FluidRenderer` (see `fluid`).
 mod fluid;
+mod leaf_culling;
 mod lighting;
 mod sides;
+use crate::connected::{Pick, TileLayer};
 use crate::{
    assets::{Assets, RenderAssets},
    biome::Biomes,
    blocks::{BlockFacts, RenderShape},
    chunk::{Chunk, MIN_Y},
+    graphics::LeafCullingMode,
    models::catalog::BakedFace,
 };
 use horizon_core::{
    biome::BiomeZoom, geometry::Direction, position::BlockPos, random::position_seed,
 };
+use horizon_optifine::ctm::connect::Face as CtmFace;
 use horizon_world::{
    block_render::FaceVisibility,
    fluid::{FluidKind, FluidState},
@@ -470,6 +474,9 @@ struct Info {
    overlay: bool,
    /// `LeavesBlock`: with opaque leaves the faces between two leaf blocks are skipped.
    leaves: bool,
+    /// A full opaque cube: `RenderShape::Model`, `can_occlude`, `solid_render`
+    /// and a full collision shape. The only block leaf culling treats as solid.
+    opaque_cube: bool,
    blocks_flow: bool,
    ice: bool,
    sturdy: u8,
@@ -647,6 +654,12 @@ impl MeshTables {
                legacy_solid: s.legacy_solid,
                overlay: s.has_class("HalfTransparentBlock") || s.has_class("LeavesBlock"),
                leaves: s.has_class("LeavesBlock"),
+                opaque_cube: leaf_culling::opaque_cube(
+                    s.render_shape,
+                    s.can_occlude,
+                    s.solid_render,
+                    s.full_collision,
+                ),
                blocks_flow: assets.blocks_fluid_flow.contains(&*s.name),
                ice: s.has_class("IceBlock"),
                sturdy: s.sturdy_full,
@@ -686,6 +699,14 @@ impl MeshTables {
            tint_sources: i.tint_count,
        })
    }
+    /// Whether `state` is a full opaque cube: the only block leaf culling
+    /// treats as a solid neighbour. Glass, fluids, slabs, stairs and models
+    /// that only partly fill their block are not.
+    pub fn opaque_cube(&self, state: BlockStateId) -> bool {
+        self.info
+            .get(state.0 as usize)
+            .is_some_and(|i| i.opaque_cube)
+    }
    /// `BlockTintSource.color(state)`: block-model colour without a level.
    /// `grass` is `GrassColor.getDefaultColor()` from the active pack's colormap.
    /// Untinted faces, blank sources and invalid tint indices return `None`.
@@ -860,14 +881,18 @@ impl Padded {
    }
 }
 /// Per-worker temporary arrays. They never hold resource-pack references or
-/// geometry still owned by the renderer, and total about 88 KiB per worker.
+/// geometry still owned by the renderer, and total about 150 KiB per worker
+/// (the leaf mask adds 8,000 cells, depths and a queue).
 #[derive(Default)]
 pub(crate) struct MeshScratch {
    padded: Padded,
    own: Option<Box<[u32; 4096]>>,
    visibility: Vec<usize>,
+    leaf: leaf_culling::LeafMask,
 }
 #[cfg(test)]
+mod leaf_culling_tests;
+#[cfg(test)]
 mod reuse_tests;
 /// Set on a terrain vertex's sprite layer when its texture alpha must be ignored.
 pub const OPAQUE_LAYER: u16 = 1 << 15;
@@ -994,6 +1019,32 @@ impl<'a> Tints<'a> {
            layers: Default::default(),
        }
    }
+    /// The biome of block `(x, y, z)` (section-local x/z, y in 0..16), as `BiomeManager.getBiome`
+    /// picks it.
+    fn biome(&self, x: i32, y: i32, z: i32) -> &'a str {
+        let id = Self::biome_id(&self.zoom, self.region, self.plains, self.origin, [x, y, z]);
+        &self.biomes.get(id).name
+    }
+    /// `BiomeManager.getBiome` over the loaded chunks (plains where there is none), for block
+    /// `(x, y, z)` of the section at `origin`. Takes the fields it reads, so `get` can call it
+    /// while it holds a layer.
+    fn biome_id(
+        zoom: &BiomeZoom,
+        region: &[[Option<&Chunk>; 3]; 3],
+        plains: u16,
+        [cx, cz, base_y]: [i32; 3],
+        [x, y, z]: [i32; 3],
+    ) -> u16 {
+        let q = zoom.quart_at_block(BlockPos::new(cx * 16 + x, base_y + y, cz * 16 + z));
+        let (rx, rz) = ((q[0] >> 2) - cx + 1, (q[2] >> 2) - cz + 1);
+        if (0..3).contains(&rx) && (0..3).contains(&rz) {
+            region[rz as usize][rx as usize].map_or(plains, |c| {
+                c.biome((q[0] & 3) * 4, q[1] * 4, (q[2] & 3) * 4)
+            })
+        } else {
+            plains
+        }
+    }
    /// The blended tint of block `(x, y, z)` (section-local x/z, y in 0..16).
    fn get(&mut self, resolver: Resolver, x: i32, y: i32, z: i32) -> u32 {
        let r = self.radius;
@@ -1009,27 +1060,21 @@ impl<'a> Tints<'a> {
        if cached != UNSET {
            return cached;
        }
-        let [cx, cz, base_y] = self.origin;
-        let (bx, by, bz) = (cx * 16, base_y + y, cz * 16);
+        let [cx, cz, _] = self.origin;
+        let (bx, bz) = (cx * 16, cz * 16);
        let (mut red, mut green, mut blue) = (0, 0, 0);
        for dz in -r..=r {
            for dx in -r..=r {
                let cell = ((z + dz + r) as usize) * dim + (x + dx + r) as usize;
                let mut biome = layer.zoomed[cell];
                if biome == NO_BIOME {
-                    // BiomeManager.getBiome over the loaded chunks (plains
-                    // where there is none).
-                    let q = self
-                        .zoom
-                        .quart_at_block(BlockPos::new(bx + x + dx, by, bz + z + dz));
-                    let (rx, rz) = ((q[0] >> 2) - cx + 1, (q[2] >> 2) - cz + 1);
-                    biome = if (0..3).contains(&rx) && (0..3).contains(&rz) {
-                        self.region[rz as usize][rx as usize].map_or(self.plains, |c| {
-                            c.biome((q[0] & 3) * 4, q[1] * 4, (q[2] & 3) * 4)
-                        })
-                    } else {
-                        self.plains
-                    };
+                    biome = Self::biome_id(
+                        &self.zoom,
+                        self.region,
+                        self.plains,
+                        self.origin,
+                        [x + dx, y, z + dz],
+                    );
                    layer.zoomed[cell] = biome;
                }
                let c = match resolver {
@@ -1079,6 +1124,10 @@ pub struct Mesher<'a> {
    pub smooth_lighting: bool,
    /// The `cutoutLeaves` option (fancy graphics); off makes leaves opaque.
    pub cutout_leaves: bool,
+    /// Sprite layers a shader pack moves into the translucent pass, by layer.
+    pub translucent_layers: &'a [bool],
+    /// What the worker does with leaf faces inside a canopy.
+    pub leaf_culling: LeafCullingMode,
 }
 impl Mesher<'_> {
    /// `region[dz][dx]` are the chunks around the meshed column (centre 1,1).
@@ -1108,6 +1157,11 @@ impl Mesher<'_> {
        let pad = &scratch.padded;
        out.visibility = visibility_reusing(pad, &self.tables.info, &mut scratch.visibility);
        let base_y = center.min_y() + sy * 16;
+        if self.leaf_culling.is_interior() {
+            scratch
+                .leaf
+                .prepare(self.leaf_culling, pad, &self.tables.info, region, base_y);
+        }
        let mut tints = Tints::new(
            region,
            self.biomes,
@@ -1172,13 +1226,21 @@ impl Mesher<'_> {
                        None => [x as f32, y as f32, z as f32],
                    };
                    let mut visible = [false; 6];
+                    let interior_leaf = state.leaves
+                        && self.leaf_culling.is_interior()
+                        && scratch.leaf.interior(self.leaf_culling, x, y, z);
                    for d in Direction::ALL {
                        let [dx, dy, dz] = d.normal();
                        let neighbor = pad.blocks[pi(x + dx, y + dy, z + dz)];
                        let other = &info[neighbor as usize];
                        // LeavesBlock.skipRendering with opaque leaves.
                        let opaque_leaves = !self.cutout_leaves && state.leaves && other.leaves;
+                        let hollow_leaf = self.leaf_culling == LeafCullingMode::Hollow
+                            && state.leaves
+                            && other.leaves
+                            && leaf_culling::in_section(x + dx, y + dy, z + dz);
                        visible[d as usize] = !opaque_leaves
+                            && !hollow_leaf
                            && self
                                .visibility
                                .should_render_face(
@@ -1202,7 +1264,9 @@ impl Mesher<'_> {
                                origin,
                                face,
                                ao,
-                                state,
+                                (id, state),
+                                world,
+                                interior_leaf,
                            );
                        }
                    }
@@ -1240,7 +1304,9 @@ impl Mesher<'_> {
        origin: [f32; 3],
        face: &BakedFace,
        ao: bool,
-        state: &Info,
+        (id, state): (u32, &Info),
+        world: BlockPos,
+        interior_leaf: bool,
    ) {
        let q = &face.quad;
        // A quad's own light (a model's glowing part) may raise the tier; whether it
@@ -1267,39 +1333,265 @@ impl Mesher<'_> {
            ([lighting::gray(directional); 4], [coords; 4])
        };
        let tint = Self::tint(state, q.tint_index, tints, pos);
-        if self.tables.is_animated(face.layer as u16) {
-            out.note_sprite_layer(face.layer as u16);
-        }
-        let target = if face.translucent {
-            &mut out.translucent
+        // OptiFine connected textures: another sprite, or one per quarter.
+        let connected = &self.render.connected;
+        let pick = if connected.is_empty() {
+            Pick::Keep
        } else {
-            &mut out.solid
+            let tints = &*tints;
+            connected.pick(
+                id,
+                face.layer as u16,
+                CtmFace::ALL[q.facing as usize],
+                [world.x, world.y, world.z],
+                |[dx, dy, dz]| pad.blocks[pi(pos[0] + dx, pos[1] + dy, pos[2] + dz)],
+                || Some(tints.biome(pos[0], pos[1], pos[2])),
+            )
        };
-        for i in 0..4 {
+        let mut corners = [(TerrainVertex::new([0.0; 3], [0.0; 2], 0, 0, 0), [0.0; 2]); 4];
+        for (i, corner) in corners.iter_mut().enumerate() {
            let g = gray[i] as u32;
            let rgb = match tint {
                Some(t) => [16, 8, 0].map(|shift| g * (t >> shift & 255) / 255),
                None => [g; 3],
            };
            let p = q.positions[i];
-            target.push(TerrainVertex::new(
-                [p[0] + origin[0], p[1] + origin[1], p[2] + origin[2]],
+            *corner = (
+                TerrainVertex::new(
+                    [p[0] + origin[0], p[1] + origin[1], p[2] + origin[2]],
+                    q.uv[i],
+                    0,
+                    emitting(pack_rgb(rgb), tier),
+                    pack_coords(lighting::with_emission(coords[i], q.light_emission)),
+                ),
                q.uv[i],
-                // Opaque leaves (forceOpaque) and quads over opaque texels draw in the
-                // solid layer: no alpha cutout (a dirt path's side skips its clear top row).
-                if face.opaque && !face.translucent || !self.cutout_leaves && state.leaves {
-                    face.layer as u16 | OPAQUE_LAYER
-                } else {
-                    face.layer as u16
-                },
-                emitting(pack_rgb(rgb), tier),
-                pack_coords(lighting::with_emission(coords[i], q.light_emission)),
-            ));
+            );
+        }
+        // Opaque leaves (forceOpaque) and leaves a leaf-culling mode proved internal draw in the
+        // solid layer whatever their sprite.
+        let solid_leaves = !self.cutout_leaves && state.leaves || interior_leaf;
+        let own = TileLayer::Layer {
+            layer: face.layer as u16,
+            translucent: face.translucent,
+            opaque: face.opaque,
+        };
+        // A tile keeps the quad's forced translucency; `<skip>` and `<default>` are its own.
+        let tile = |t: TileLayer| match t {
+            TileLayer::Layer {
+                layer,
+                translucent,
+                opaque,
+            } => TileLayer::Layer {
+                layer,
+                translucent: translucent || q.material.force_translucent,
+                opaque,
+            },
+            TileLayer::Skip | TileLayer::Default => own,
+        };
+        match pick {
+            Pick::Keep => self.quad(out, solid_leaves, own, corners.map(|c| c.0)),
+            Pick::Tile(t) => self.quad(out, solid_leaves, tile(t), corners.map(|c| c.0)),
+            Pick::Quarters(tiles) => {
+                let cuts = cuts(&corners);
+                for s in cuts.windows(2) {
+                    for t in cuts.windows(2) {
+                        let piece = [(s[0], t[0]), (s[1], t[0]), (s[1], t[1]), (s[0], t[1])]
+                            .map(|(s, t)| bilinear(&corners, s, t));
+                        let quarter = quarter_of(&piece);
+                        self.quad(out, solid_leaves, tile(tiles[quarter]), piece.map(|c| c.0));
+                    }
+                }
+            }
        }
    }
+    /// One terrain quad with sprite `tile`, in the pass its alpha needs (`solid_leaves`: no
+    /// alpha cutout whatever the sprite).
+    fn quad(
+        &self,
+        out: &mut SectionMesh,
+        solid_leaves: bool,
+        tile: TileLayer,
+        mut v: [TerrainVertex; 4],
+    ) {
+        let TileLayer::Layer {
+            layer,
+            translucent,
+            opaque,
+        } = tile
+        else {
+            return;
+        };
+        if self.tables.is_animated(layer) {
+            out.note_sprite_layer(layer);
+        }
+        let translucent = translucent
+            || self
+                .translucent_layers
+                .get(usize::from(layer))
+                .copied()
+                .unwrap_or(false);
+        // Quads over opaque texels draw in the solid layer: no alpha cutout (a dirt path's side
+        // skips its clear top row). All four vertices share the layer.
+        let layer = if opaque && !translucent || solid_leaves {
+            layer | OPAQUE_LAYER
+        } else {
+            layer
+        };
+        let target = if translucent {
+            &mut out.translucent
+        } else {
+            &mut out.solid
+        };
+        for vertex in &mut v {
+            vertex.layer = layer;
+        }
+        target.extend(v);
+    }
+}
+/// The cuts of a `ctm_compact` face, in quad parameters, without allocating: the first `.1`
+/// of `.0`.
+struct Cuts([f32; 4], usize);
+impl std::ops::Deref for Cuts {
+    type Target = [f32];
+    fn deref(&self) -> &[f32] {
+        &self.0[..self.1]
+    }
+}
+/// Where a quad's edge from corner 0 to corner `to` (1 for `s`, 3 for `t`) crosses the sprite's
+/// middle line, the line its quarters meet on; `None` for an edge that stays on one side (a
+/// slab's side).
+fn crossing(c: &[(TerrainVertex, [f32; 2]); 4], to: usize) -> Option<f32> {
+    let (a, b) = (c[0].1, c[to].1);
+    // The UV the edge runs along.
+    let k = usize::from((b[1] - a[1]).abs() > (b[0] - a[0]).abs());
+    let at = (0.5 - a[k]) / (b[k] - a[k]);
+    (at > 0.0 && at < 1.0).then_some(at)
+}
+/// The cuts of a `ctm_compact` face, the same along `s` and `t`: both edges' crossings. Pieces
+/// on the quad's 0-2 diagonal are then square, so their own triangles lie on the quad's and a
+/// split face shades exactly like the whole one; the others lie on one side of it.
+fn cuts(c: &[(TerrainVertex, [f32; 2]); 4]) -> Cuts {
+    let mut out = Cuts([0.0; 4], 1);
+    let (mut s, mut t) = (crossing(c, 1), crossing(c, 3));
+    if s > t {
+        std::mem::swap(&mut s, &mut t);
+    }
+    for at in [s, t].into_iter().flatten().chain([1.0]) {
+        if out.0[out.1 - 1] < at {
+            out.0[out.1] = at;
+            out.1 += 1;
+        }
+    }
+    out
+}
+/// The quarter of the sprite (top-left, top-right, bottom-left, bottom-right) a piece of a
+/// quad lies in, by its UV centre (v grows downward).
+fn quarter_of(piece: &[(TerrainVertex, [f32; 2]); 4]) -> usize {
+    let [u, v] = [0, 1].map(|k| piece.iter().map(|c| c.1[k]).sum::<f32>() / 4.0);
+    usize::from(v >= 0.5) * 2 + usize::from(u >= 0.5)
+}
+/// The vertex at `(s, t)` across a quad's corners (`s` from corner 0 to 1, `t` from 0 to 3),
+/// with its UV in sprite units: a quarter of a `ctm_compact` face. Blended within the quad's
+/// two triangles (0-1-2 and 0-2-3), as the GPU blends the whole quad, so a split face shades
+/// like an unsplit one.
+fn bilinear(c: &[(TerrainVertex, [f32; 2]); 4], s: f32, t: f32) -> (TerrainVertex, [f32; 2]) {
+    let w = if s >= t {
+        [1.0 - s, s - t, t, 0.0]
+    } else {
+        [1.0 - t, 0.0, s, t - s]
+    };
+    let mix = |f: &dyn Fn(&(TerrainVertex, [f32; 2])) -> f32| {
+        (0..4).map(|i| w[i] * f(&c[i])).sum::<f32>()
+    };
+    // Packed bytes (colour, light) blend one by one.
+    let bytes = |field: fn(&TerrainVertex) -> u32, count: u32| {
+        (0..count)
+            .map(|k| (mix(&|c| (field(&c.0) >> (8 * k) & 255) as f32).round() as u32) << (8 * k))
+            .sum::<u32>()
+    };
+    let color = bytes(|v| v.color, 4);
+    let light = bytes(|v| u32::from(v.light), 2) as u16;
+    let pos = [0, 1, 2].map(|k| mix(&|c| c.0.pos[k]));
+    let uv = [0, 1].map(|k| mix(&|c| c.1[k]));
+    (TerrainVertex::new(pos, uv, 0, color, light), uv)
 }
 /// Snapshot of the 3x3 chunk neighbourhood used by a worker job.
 pub type Region = [[Option<Arc<Chunk>>; 3]; 3];
 pub fn borrow(region: &Region) -> [[Option<&Chunk>; 3]; 3] {
    std::array::from_fn(|z| std::array::from_fn(|x| region[z][x].as_deref()))
 }
+#[cfg(test)]
+mod quarter_tests {
+    use super::*;
+
+    fn corner(pos: [f32; 3], uv: [f32; 2], red: u32, light: u16) -> (TerrainVertex, [f32; 2]) {
+        (TerrainVertex::new(pos, uv, 0, 0xFF00_0000 | red, light), uv)
+    }
+
+    #[test]
+    fn quarters_blend_the_corners_by_triangle() {
+        // Only corner 2 is lit: the GPU's triangles (0-1-2, 0-2-3) put half of it in the
+        // middle, where a bilinear blend would put a quarter and the other diagonal none.
+        let c = [
+            corner([0.0, 0.0, 0.0], [0.0, 0.0], 0, 0),
+            corner([1.0, 0.0, 0.0], [1.0, 0.0], 0, 0),
+            corner([1.0, 1.0, 0.0], [1.0, 1.0], 200, 0x2010),
+            corner([0.0, 1.0, 0.0], [0.0, 1.0], 0, 0),
+        ];
+        let (centre, uv) = bilinear(&c, 0.5, 0.5);
+        assert_eq!(centre.pos, [0.5, 0.5, 0.0]);
+        assert_eq!(uv, [0.5, 0.5]);
+        assert_eq!(centre.color, 0xFF00_0000 | 100);
+        assert_eq!(centre.light, 0x1008, "sky and block light blend apart");
+        // Off the diagonal, on the 0-1-2 triangle: corner 2 weighs t.
+        assert_eq!(bilinear(&c, 0.75, 0.25).0.color & 255, 50);
+        assert_eq!(bilinear(&c, 0.5, 0.0).0.pos, [0.5, 0.0, 0.0]);
+    }
+
+    #[test]
+    fn compact_faces_cut_where_the_sprite_does() {
+        // A full face: cut in the middle both ways.
+        let full = [
+            corner([0.0, 1.0, 0.0], [0.0, 0.0], 0, 0),
+            corner([1.0, 1.0, 0.0], [1.0, 0.0], 0, 0),
+            corner([1.0, 0.0, 0.0], [1.0, 1.0], 0, 0),
+            corner([0.0, 0.0, 0.0], [0.0, 1.0], 0, 0),
+        ];
+        assert_eq!(*cuts(&full), [0.0, 0.5, 1.0]);
+        // A dirt path's side, v from 1/16: the sprite's middle is 7/15 of the way down; both
+        // directions are cut there and at the middle of u.
+        let mut path = full;
+        path[0].1 = [0.0, 1.0 / 16.0];
+        path[1].1 = [1.0, 1.0 / 16.0];
+        assert_eq!(
+            *cuts(&path),
+            [0.0, (0.5 - 1.0 / 16.0) / (15.0 / 16.0), 0.5, 1.0]
+        );
+        // A slab's lower side (v 0.5..1) crosses the middle only along u.
+        let mut slab = full;
+        slab[0].1 = [0.0, 0.5];
+        slab[1].1 = [1.0, 0.5];
+        assert_eq!(crossing(&slab, 3), None);
+        assert_eq!(*cuts(&slab), [0.0, 0.5, 1.0]);
+        // Quarters by UV centre: top-left, top-right, bottom-left, bottom-right.
+        let piece = |s0: f32, t0: f32| {
+            [
+                (s0, t0),
+                (s0 + 0.5, t0),
+                (s0 + 0.5, t0 + 0.5),
+                (s0, t0 + 0.5),
+            ]
+            .map(|(s, t)| bilinear(&full, s, t))
+        };
+        assert_eq!(
+            [
+                piece(0.0, 0.0),
+                piece(0.5, 0.0),
+                piece(0.0, 0.5),
+                piece(0.5, 0.5)
+            ]
+            .map(|p| quarter_of(&p)),
+            [0, 1, 2, 3]
+        );
+    }
+}
@@ -0,0 +1,656 @@
+//! Leaf culling: decides which leaf faces a section may draw solid or drop.
+//!
+//! The mask is built on the mesh worker from the same padded block snapshot the
+//! rest of the mesher reads, so a decision never needs a chunk lookup on the
+//! render thread. It classifies each padded cell as a leaf, a full opaque cube,
+//! open (air, fluids, partial models, anything else) or unknown (a missing
+//! chunk, a Y outside the column, or the mask's outer shell). Only leaves can
+//! hide or solidify anything; unknown and open cells always expose a face.
+//!
+//! `Solid` performs an immediate 6-neighbour occlusion check, solidifying fully
+//! enclosed leaves into the opaque layer without cutout testing. `Solid
+//! Aggressive` runs a multi-source breadth-first search from leaves touching
+//! openings, solidifying leaves with a single open face to thin the canopy shell
+//! by one layer. `Hollow` directly drops faces shared between two leaves within
+//! the section, preserving boundaries and cavity faces.
+
+use super::{B, Info, P, Padded, pi};
+use crate::{blocks::RenderShape, chunk::Chunk, graphics::LeafCullingMode};
+
+/// A cell of the padded snapshot, as far as leaf culling cares.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum Cell {
+    /// Air, a fluid, a partial model, glass or any other non-occluding block.
+    Open,
+    /// `LeavesBlock`.
+    Leaf,
+    /// A full opaque cube (see [`opaque_cube`]).
+    Opaque,
+    /// Missing chunk, missing section or the mask's outer shell.
+    Unknown,
+}
+
+/// Whether a state is a full opaque cube: `RenderShape::Model`, `can_occlude`,
+/// `solid_render` and a full collision shape. Glass, fluids, slabs, stairs,
+/// chests and models that only partly fill their block are not.
+pub(super) fn opaque_cube(
+    shape: RenderShape,
+    can_occlude: bool,
+    solid_render: bool,
+    full_collision: bool,
+) -> bool {
+    shape == RenderShape::Model && can_occlude && solid_render && full_collision
+}
+
+const UNVISITED: u8 = u8::MAX;
+
+const STRIDE_X: isize = 1;
+const STRIDE_Z: isize = P as isize;
+const STRIDE_Y: isize = (P * P) as isize;
+
+const ADJACENT_STRIDES: [isize; 6] = [
+    STRIDE_X, -STRIDE_X, STRIDE_Z, -STRIDE_Z, STRIDE_Y, -STRIDE_Y,
+];
+
+/// Per-worker leaf mask and BFS scratch. The vectors keep their capacity
+/// between sections and modes; `Off` does no work at all.
+#[derive(Default)]
+pub(super) struct LeafMask {
+    cells: Vec<Cell>,
+    depth: Vec<u8>,
+    queue: Vec<u16>,
+    active: bool,
+}
+
+impl LeafMask {
+    /// Classify the padded snapshot and, for the interior modes, measure how
+    /// deep each leaf sits below the canopy surface.
+    pub(super) fn prepare(
+        &mut self,
+        mode: LeafCullingMode,
+        pad: &Padded,
+        info: &[Info],
+        region: &[[Option<&Chunk>; 3]; 3],
+        base_y: i32,
+    ) {
+        self.active = mode != LeafCullingMode::Off;
+        if !self.active {
+            return;
+        }
+        // Most sections hold no leaves at all; do not classify 8,000 cells to
+        // learn that. The centre is the only part this mesh can change.
+        let mut leaves = false;
+        'scan: for y in 0..16 {
+            for z in 0..16 {
+                for x in 0..16 {
+                    if info
+                        .get(pad.blocks[pi(x, y, z)] as usize)
+                        .is_some_and(|state| state.leaves)
+                    {
+                        leaves = true;
+                        break 'scan;
+                    }
+                }
+            }
+        }
+        if !leaves {
+            self.active = false;
+            return;
+        }
+        if self.cells.len() != P * P * P {
+            self.cells.resize(P * P * P, Cell::Open);
+        }
+        for y in -B..16 + B {
+            for z in -B..16 + B {
+                for x in -B..16 + B {
+                    let i = pi(x, y, z);
+                    self.cells[i] = if !known(region, base_y, x, y, z) {
+                        Cell::Unknown
+                    } else {
+                        match info.get(pad.blocks[i] as usize) {
+                            None => Cell::Unknown,
+                            Some(state) if state.leaves => Cell::Leaf,
+                            Some(state) if state.opaque_cube => Cell::Opaque,
+                            Some(_) => Cell::Open,
+                        }
+                    };
+                }
+            }
+        }
+        // Solid is a purely local six-neighbour test. Reserve the breadth-first
+        // search for Solid Aggressive, whose one-open-side rule needs to know
+        // whether a leaf is connected to the canopy surface through other
+        // leaves.
+        if mode == LeafCullingMode::SolidAggressive {
+            self.depths();
+        }
+    }
+
+    /// Multi-source BFS from leaves that touch an opening. Opaque neighbours do
+    /// not expose a leaf: a leaf fully enclosed by stone is interior too.
+    fn depths(&mut self) {
+        if self.depth.len() != self.cells.len() {
+            self.depth.resize(self.cells.len(), UNVISITED);
+        } else {
+            self.depth.fill(UNVISITED);
+        }
+        self.queue.clear();
+        for y in -B..16 + B {
+            for z in -B..16 + B {
+                for x in -B..16 + B {
+                    let i = pi(x, y, z);
+                    if self.cells[i] != Cell::Leaf {
+                        continue;
+                    }
+                    let touches_open = ADJACENT_STRIDES.iter().any(|&stride| {
+                        let j = (i as isize + stride) as usize;
+                        matches!(self.cells[j], Cell::Open | Cell::Unknown)
+                    });
+                    if touches_open {
+                        self.depth[i] = 0;
+                        self.queue.push(i as u16);
+                    }
+                }
+            }
+        }
+        let mut head = 0;
+        while head < self.queue.len() {
+            let i = self.queue[head] as usize;
+            head += 1;
+            let next_depth = self.depth[i].saturating_add(1);
+            for stride in ADJACENT_STRIDES {
+                let j = (i as isize + stride) as usize;
+                if self.cells[j] == Cell::Leaf && self.depth[j] == UNVISITED {
+                    self.depth[j] = next_depth;
+                    self.queue.push(j as u16);
+                }
+            }
+        }
+    }
+
+    /// Whether the leaf at `(x, y, z)` may draw in the opaque layer.
+    ///
+    /// `Solid` wants a leaf with no open neighbour, which is exactly depth 1 or
+    /// more. `Solid Aggressive` also takes the next layer of the shell: a leaf
+    /// with a single open side joins the opaque core, so the cutout shell is
+    /// one layer thinner. Unknown neighbours never qualify, however many sides
+    /// they leave open. A leaf the search never reached sits inside a closed
+    /// volume: interior for both.
+    pub(super) fn interior(&self, mode: LeafCullingMode, x: i32, y: i32, z: i32) -> bool {
+        if !self.active {
+            return false;
+        }
+        let aggressive = match mode {
+            LeafCullingMode::Solid => false,
+            LeafCullingMode::SolidAggressive => true,
+            _ => return false,
+        };
+        // A section boundary is not proof of a closed volume: the neighbouring
+        // section may not be drawn yet, and its data is not ours to assume.
+        if !(1..15).contains(&x) || !(1..15).contains(&y) || !(1..15).contains(&z) {
+            return false;
+        }
+        let i = pi(x, y, z);
+        if self.cells.get(i) != Some(&Cell::Leaf) {
+            return false;
+        }
+        if !aggressive {
+            return ADJACENT_STRIDES.iter().all(|&stride| {
+                let j = (i as isize + stride) as usize;
+                matches!(self.cells[j], Cell::Leaf | Cell::Opaque)
+            });
+        }
+        let depth = self.depth[i];
+        if depth == UNVISITED || depth >= 1 {
+            return true;
+        }
+        let mut open = 0;
+        for stride in ADJACENT_STRIDES {
+            let j = (i as isize + stride) as usize;
+            match self.cells[j] {
+                Cell::Unknown => return false,
+                Cell::Open => {
+                    open += 1;
+                    if open > 1 {
+                        return false;
+                    }
+                }
+                Cell::Leaf | Cell::Opaque => {}
+            }
+        }
+        open == 1
+    }
+}
+
+/// The cells this section's mesh owns. A face on this boundary belongs to the
+/// neighbouring section as much as to this one; leaf culling leaves it alone.
+#[inline]
+pub(super) fn in_section(x: i32, y: i32, z: i32) -> bool {
+    (0..16).contains(&x) && (0..16).contains(&y) && (0..16).contains(&z)
+}
+
+/// Whether the padded cell `(x, y, z)` has real block data. A missing chunk
+/// does not count: `Padded::fill` copies the centre's edge column into it, which
+/// would make a canopy look enclosed. A Y outside the column counts as unknown
+/// for the same reason. The mask's outer shell is unknown too, so nothing is
+/// inferred past the data the worker snapshotted.
+fn known(region: &[[Option<&Chunk>; 3]; 3], base_y: i32, x: i32, y: i32, z: i32) -> bool {
+    if x <= -B || x >= 16 + B - 1 || y <= -B || y >= 16 + B - 1 || z <= -B || z >= 16 + B - 1 {
+        return false;
+    }
+    let chunk = region[((z + 16) >> 4) as usize][((x + 16) >> 4) as usize];
+    chunk.is_some_and(|chunk| chunk.section_index(base_y + y).is_some())
+}
+
+#[cfg(test)]
+impl LeafMask {
+    /// Whether `Hollow` drops the face of the leaf at `(x, y, z)` toward `d`.
+    /// Only a known leaf on the other side counts: open cells, partial models,
+    /// missing neighbours and the mask's edge stay visible.
+    pub(super) fn hides_face(
+        &self,
+        mode: LeafCullingMode,
+        x: i32,
+        y: i32,
+        z: i32,
+        d: horizon_core::geometry::Direction,
+    ) -> bool {
+        if !self.active || mode != LeafCullingMode::Hollow {
+            return false;
+        }
+        let [dx, dy, dz] = d.normal();
+        let (nx, ny, nz) = (x + dx, y + dy, z + dz);
+        if !in_section(x, y, z) || !in_section(nx, ny, nz) {
+            return false;
+        }
+        let i = pi(x, y, z);
+        let ni = pi(nx, ny, nz);
+        self.cells.get(i) == Some(&Cell::Leaf) && self.cells.get(ni) == Some(&Cell::Leaf)
+    }
+
+    #[inline]
+    fn cell(&self, x: i32, y: i32, z: i32) -> Cell {
+        checked(x, y, z)
+            .and_then(|i| self.cells.get(i))
+            .copied()
+            .unwrap_or(Cell::Unknown)
+    }
+}
+
+#[cfg(test)]
+#[inline]
+fn checked(x: i32, y: i32, z: i32) -> Option<usize> {
+    if (-B..16 + B).contains(&x) && (-B..16 + B).contains(&y) && (-B..16 + B).contains(&z) {
+        Some(pi(x, y, z))
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+#[inline]
+fn unpi(i: usize) -> (i32, i32, i32) {
+    let x = (i % P) as i32 - B;
+    let z = (i / P % P) as i32 - B;
+    let y = (i / (P * P)) as i32 - B;
+    (x, y, z)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{blocks::RenderShape, graphics::LeafCullingMode};
+    use horizon_core::geometry::Direction;
+    use horizon_world::fluid::FluidState;
+    use std::time::Instant;
+
+    fn info(leaves: bool, opaque: bool) -> Info {
+        Info {
+            solid: opaque,
+            full: opaque,
+            permeable: false,
+            shade: 1.0,
+            emission: 0,
+            tier: 0,
+            emissive: false,
+            fluid: FluidState::EMPTY,
+            model: true,
+            block_entity: false,
+            tints: [super::super::Tint::None; 2],
+            tint_count: 0,
+            offset: None,
+            legacy_solid: false,
+            overlay: leaves,
+            leaves,
+            opaque_cube: opaque,
+            blocks_flow: false,
+            ice: false,
+            sturdy: 0,
+            face: [0; 6],
+            cover: [0.0; 6],
+        }
+    }
+
+    /// State 0 is air, 1 leaves, 2 a full opaque cube, 3 a partial model.
+    fn states() -> Vec<Info> {
+        vec![
+            info(false, false),
+            info(true, false),
+            info(false, true),
+            info(false, false),
+        ]
+    }
+
+    fn padded(fill: impl Fn(i32, i32, i32) -> u32) -> Padded {
+        Padded {
+            blocks: (0..P * P * P)
+                .map(|i| {
+                    let (x, y, z) = unpi(i);
+                    fill(x, y, z)
+                })
+                .collect(),
+            light: vec![0; P * P * P],
+        }
+    }
+
+    fn cube(pad: &mut Padded, min: i32, max: i32, state: u32) {
+        for y in min..=max {
+            for z in min..=max {
+                for x in min..=max {
+                    pad.blocks[pi(x, y, z)] = state;
+                }
+            }
+        }
+    }
+
+    fn loaded() -> Chunk {
+        Chunk::empty(0, 0)
+    }
+
+    fn region(chunk: &Chunk) -> [[Option<&Chunk>; 3]; 3] {
+        [[Some(chunk); 3]; 3]
+    }
+
+    fn built(mode: LeafCullingMode, pad: &Padded, states: &[Info], chunk: &Chunk) -> LeafMask {
+        let mut mask = LeafMask::default();
+        mask.prepare(mode, pad, states, &region(chunk), 0);
+        mask
+    }
+
+    #[test]
+    fn only_a_full_model_cube_is_opaque() {
+        let combinations = [
+            (RenderShape::Model, true, true, true),
+            (RenderShape::Model, true, true, false),
+            (RenderShape::Model, true, false, true),
+            (RenderShape::Model, false, true, true),
+            (RenderShape::Model, false, false, false),
+            (RenderShape::Invisible, true, true, true),
+            (RenderShape::Animated, true, true, true),
+        ];
+        let (shape, can_occlude, solid_render, full_collision) = combinations[0];
+        assert!(opaque_cube(
+            shape,
+            can_occlude,
+            solid_render,
+            full_collision
+        ));
+        for &(shape, can_occlude, solid_render, full_collision) in &combinations[1..] {
+            assert!(
+                !opaque_cube(shape, can_occlude, solid_render, full_collision),
+                "{shape:?} {can_occlude} {solid_render} {full_collision}"
+            );
+        }
+    }
+
+    #[test]
+    fn solid_marks_the_cell_inside_a_three_cube() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        cube(&mut pad, 7, 9, 1);
+        let chunk = loaded();
+        let solid = built(LeafCullingMode::Solid, &pad, &states, &chunk);
+        assert!(!solid.interior(LeafCullingMode::Solid, 7, 8, 8));
+        assert!(solid.interior(LeafCullingMode::Solid, 8, 8, 8));
+        assert!(!solid.interior(LeafCullingMode::Solid, 8, 9, 8));
+        // Aggressive also takes the six face-centre leaves, whose only open
+        // side faces out of the cube. Corners and edges keep their cutout.
+        let aggressive = built(LeafCullingMode::SolidAggressive, &pad, &states, &chunk);
+        assert!(aggressive.interior(LeafCullingMode::SolidAggressive, 8, 8, 8));
+        assert!(aggressive.interior(LeafCullingMode::SolidAggressive, 7, 8, 8));
+        assert!(aggressive.interior(LeafCullingMode::SolidAggressive, 8, 8, 9));
+        assert!(!aggressive.interior(LeafCullingMode::SolidAggressive, 7, 7, 8));
+        assert!(!aggressive.interior(LeafCullingMode::SolidAggressive, 7, 7, 7));
+    }
+
+    #[test]
+    fn aggressive_takes_the_next_shell_layer() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        cube(&mut pad, 6, 10, 1);
+        let chunk = loaded();
+        let solid = built(LeafCullingMode::Solid, &pad, &states, &chunk);
+        let aggressive = built(LeafCullingMode::SolidAggressive, &pad, &states, &chunk);
+        let surface = |v: i32| v == 6 || v == 10;
+        for [x, y, z] in [
+            [6, 8, 8],
+            [10, 8, 8],
+            [6, 6, 8],
+            [6, 6, 6],
+            [7, 8, 8],
+            [8, 8, 8],
+            [7, 7, 7],
+            [8, 8, 7],
+        ] {
+            let expected = !surface(x) && !surface(y) && !surface(z);
+            assert_eq!(
+                solid.interior(LeafCullingMode::Solid, x, y, z),
+                expected,
+                "solid {x} {y} {z}"
+            );
+            let open = [x, y, z].iter().filter(|v| surface(**v)).count();
+            let expected = open <= 1;
+            assert_eq!(
+                aggressive.interior(LeafCullingMode::SolidAggressive, x, y, z),
+                expected,
+                "aggressive {x} {y} {z}"
+            );
+        }
+    }
+
+    #[test]
+    fn hollow_hides_only_leaf_to_leaf_faces() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        cube(&mut pad, 7, 9, 1);
+        // Glass (3, a partial model), water and a slab are open: their leaves
+        // must keep the face.
+        pad.blocks[pi(10, 8, 8)] = 3;
+        let chunk = loaded();
+        let hollow = built(LeafCullingMode::Hollow, &pad, &states, &chunk);
+        for d in Direction::ALL {
+            assert!(
+                hollow.hides_face(LeafCullingMode::Hollow, 8, 8, 8, d),
+                "{d:?}"
+            );
+        }
+        assert!(!hollow.hides_face(LeafCullingMode::Hollow, 9, 8, 8, Direction::East));
+        assert!(!hollow.hides_face(LeafCullingMode::Hollow, 7, 8, 8, Direction::West));
+        // The other modes never hide a quad.
+        for mode in [
+            LeafCullingMode::Off,
+            LeafCullingMode::Solid,
+            LeafCullingMode::SolidAggressive,
+        ] {
+            let mask = built(mode, &pad, &states, &chunk);
+            assert!(!mask.hides_face(mode, 8, 8, 8, Direction::Up));
+        }
+    }
+
+    #[test]
+    fn a_cavity_keeps_its_faces_and_its_rim_visible() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        cube(&mut pad, 6, 10, 1);
+        pad.blocks[pi(8, 8, 8)] = 0;
+        let chunk = loaded();
+        let hollow = built(LeafCullingMode::Hollow, &pad, &states, &chunk);
+        assert!(!hollow.hides_face(LeafCullingMode::Hollow, 7, 8, 8, Direction::East));
+        assert!(!hollow.hides_face(LeafCullingMode::Hollow, 8, 8, 7, Direction::South));
+        let solid = built(LeafCullingMode::Solid, &pad, &states, &chunk);
+        assert!(!solid.interior(LeafCullingMode::Solid, 7, 8, 8));
+        assert!(!solid.interior(LeafCullingMode::Solid, 6, 8, 8));
+        // The corner away from the cavity is still two layers in.
+        assert!(solid.interior(LeafCullingMode::Solid, 9, 9, 9));
+    }
+
+    #[test]
+    fn an_opaque_neighbour_does_not_expose_a_leaf() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        for (dx, dy, dz) in [
+            (1, 0, 0),
+            (-1, 0, 0),
+            (0, 1, 0),
+            (0, -1, 0),
+            (0, 0, 1),
+            (0, 0, -1),
+        ] {
+            pad.blocks[pi(8 + dx, 8 + dy, 8 + dz)] = 2;
+        }
+        pad.blocks[pi(8, 8, 8)] = 1;
+        let chunk = loaded();
+        for mode in [LeafCullingMode::Solid, LeafCullingMode::SolidAggressive] {
+            let mask = built(mode, &pad, &states, &chunk);
+            assert!(mask.interior(mode, 8, 8, 8), "{mode:?}");
+        }
+        let hollow = built(LeafCullingMode::Hollow, &pad, &states, &chunk);
+        for d in Direction::ALL {
+            assert!(
+                !hollow.hides_face(LeafCullingMode::Hollow, 8, 8, 8, d),
+                "{d:?}"
+            );
+        }
+    }
+
+    #[test]
+    fn a_leaf_inside_a_closed_volume_is_interior() {
+        let states = states();
+        // A leaf cube inside opaque rock: the search has no opening to start
+        // from, so every leaf stays unvisited and counts as interior.
+        let mut pad = padded(|_, _, _| 2);
+        cube(&mut pad, 7, 9, 1);
+        let chunk = loaded();
+        for mode in [LeafCullingMode::Solid, LeafCullingMode::SolidAggressive] {
+            let mask = built(mode, &pad, &states, &chunk);
+            if mode == LeafCullingMode::SolidAggressive {
+                assert_eq!(mask.depth[pi(8, 8, 8)], UNVISITED);
+            }
+            assert!(mask.interior(mode, 8, 8, 8), "{mode:?}");
+        }
+    }
+
+    #[test]
+    fn missing_chunks_and_sections_are_unknown() {
+        let states = states();
+        let pad = padded(|_, _, _| 1);
+        let chunk = loaded();
+        let mut around = [[Some(&chunk); 3]; 3];
+        around[1][2] = None; // east chunk
+        let mut mask = LeafMask::default();
+        mask.prepare(LeafCullingMode::Hollow, &pad, &states, &around, 0);
+        // The leaf at the edge keeps its face toward the missing chunk, even
+        // though `Padded::fill` copied the centre's edge leaf there.
+        assert!(!mask.hides_face(LeafCullingMode::Hollow, 15, 8, 8, Direction::East));
+        // A leaf one block inside is still between two known leaves.
+        assert!(mask.hides_face(LeafCullingMode::Hollow, 14, 8, 8, Direction::East));
+
+        // A section above the column is unknown too: the same leaf one
+        // section up has no data, so it can never be interior.
+        let short = Chunk::with_layout(0, 0, crate::chunk::ColumnLayout::new(0, 16).unwrap());
+        let mut mask = LeafMask::default();
+        mask.prepare(LeafCullingMode::Solid, &pad, &states, &region(&short), 16);
+        assert!(!mask.interior(LeafCullingMode::Solid, 8, 8, 8));
+
+        // The outer shell has no data beyond it.
+        let mut mask = LeafMask::default();
+        mask.prepare(LeafCullingMode::Hollow, &pad, &states, &region(&chunk), 0);
+        assert_eq!(mask.cell(-B, 0, 0), Cell::Unknown);
+        assert_eq!(mask.cell(16 + B - 1, 0, 0), Cell::Unknown);
+        assert_eq!(mask.cell(0, 0, 0), Cell::Leaf);
+
+        // A section boundary is never enclosed, even with every chunk loaded:
+        // the neighbouring section may not have been meshed yet.
+        let mut mask = LeafMask::default();
+        mask.prepare(LeafCullingMode::Solid, &pad, &states, &region(&chunk), 0);
+        assert!(!mask.interior(LeafCullingMode::Solid, 15, 8, 8));
+        assert!(mask.interior(LeafCullingMode::Solid, 14, 8, 8));
+    }
+
+    #[test]
+    fn off_does_no_work_and_hides_nothing() {
+        let states = states();
+        let mut pad = padded(|_, _, _| 0);
+        cube(&mut pad, 7, 9, 1);
+        let chunk = loaded();
+        let mut mask = LeafMask::default();
+        mask.prepare(LeafCullingMode::Off, &pad, &states, &region(&chunk), 0);
+        assert!(!mask.active);
+        assert!(mask.cells.is_empty());
+        assert!(!mask.interior(LeafCullingMode::Off, 8, 8, 8));
+        assert!(!mask.hides_face(LeafCullingMode::Off, 8, 8, 8, Direction::Up));
+    }
+
+    #[test]
+    fn a_reused_mask_reclassifies_every_cell() {
+        let states = states();
+        let chunk = loaded();
+        let mut mask = LeafMask::default();
+        let mut leaves = padded(|_, _, _| 0);
+        cube(&mut leaves, 7, 9, 1);
+        mask.prepare(
+            LeafCullingMode::Hollow,
+            &leaves,
+            &states,
+            &region(&chunk),
+            0,
+        );
+        assert_eq!(mask.cell(8, 8, 8), Cell::Leaf);
+        let mut other = padded(|_, _, _| 0);
+        cube(&mut other, 10, 12, 1);
+        mask.prepare(LeafCullingMode::Hollow, &other, &states, &region(&chunk), 0);
+        assert_eq!(mask.cell(8, 8, 8), Cell::Open);
+        assert_eq!(mask.cell(11, 11, 11), Cell::Leaf);
+    }
+
+    #[test]
+    #[ignore = "microbenchmark; run with --ignored --nocapture"]
+    fn mask_build_benchmark() {
+        let states = states();
+        let mut pad = padded(|x, y, z| {
+            // Alternating leaf slabs make the search visit most of the volume.
+            if (x / 2 + y / 2 + z / 2) % 3 == 0 {
+                1
+            } else {
+                0
+            }
+        });
+        cube(&mut pad, 6, 10, 1);
+        let chunk = loaded();
+        let region = region(&chunk);
+        let iterations = 1000;
+        for mode in [LeafCullingMode::Solid, LeafCullingMode::SolidAggressive] {
+            let mut mask = LeafMask::default();
+            let started = Instant::now();
+            for _ in 0..iterations {
+                mask.prepare(mode, &pad, &states, &region, 0);
+            }
+            let per = started.elapsed() / iterations;
+            println!("leaf mask {mode:?}: {per:?} per section ({iterations} iterations)");
+            assert!(mask.active);
+            if mode == LeafCullingMode::SolidAggressive {
+                assert_ne!(mask.depth[pi(8, 8, 8)], UNVISITED);
+            }
+        }
+    }
+}
@@ -0,0 +1,294 @@
+//! Leaf culling through the real mesher: face counts, the opaque layer and the
+//! conservative cases (cavities, partial neighbours, missing chunks, column
+//! ends). Needs prepared resources, like the other mesher geometry tests.
+use super::*;
+use crate::{
+    assets::{Assets, RenderAssets},
+    biome::Biomes,
+    blocks::BlockFacts,
+    chunk::{Chunk, ColumnLayout},
+    graphics::LeafCullingMode,
+    models,
+};
+
+struct Fixture {
+    assets: Assets,
+    biomes: Biomes,
+    render: RenderAssets,
+    visibility: horizon_world::block_render::FaceVisibility,
+    tables: MeshTables,
+}
+
+fn fixture() -> Fixture {
+    let root = std::env::var_os("HORIZON_MESH_TEST_RESOURCES")
+        .map(std::path::PathBuf::from)
+        .unwrap_or_else(|| {
+            std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+                .join("../../.local/horizon-client/26.3")
+        });
+    let assets = Assets::load(&root).unwrap();
+    let facts = BlockFacts::load(&root, assets.registry).unwrap();
+    let biomes = Biomes::load(&root).unwrap();
+    let render = assets.reload(&root).unwrap();
+    let visibility = models::load_visibility(&root, assets.registry).unwrap();
+    let tables = MeshTables::new(&assets, &render, &facts, visibility.clone()).unwrap();
+    Fixture {
+        assets,
+        biomes,
+        render,
+        visibility,
+        tables,
+    }
+}
+
+fn state(f: &Fixture, name: &str) -> u32 {
+    f.assets.registry.default_state(name).unwrap().0
+}
+
+fn leaves_cube(chunk: &mut Chunk, min: i32, max: i32, y: i32, state: u32) {
+    for z in min..=max {
+        for x in min..=max {
+            chunk.set(x, y, z, state);
+        }
+    }
+}
+
+fn leaf_cube(f: &Fixture, min: i32, max: i32, base: i32, name: &str) -> Chunk {
+    let mut chunk = Chunk::empty(0, 0);
+    let state = state(f, name);
+    for y in base..base + (max - min + 1) {
+        leaves_cube(&mut chunk, min, max, y, state);
+    }
+    chunk
+}
+
+fn mesh(
+    f: &Fixture,
+    _chunk: &Chunk,
+    region: [[Option<&Chunk>; 3]; 3],
+    sy: i32,
+    mode: LeafCullingMode,
+) -> SectionMesh {
+    let mut mesher = Mesher {
+        nether_shading: false,
+        shader_pack_lighting: false,
+        assets: &f.assets,
+        render: &f.render,
+        tables: &f.tables,
+        biomes: &f.biomes,
+        visibility: f.visibility.clone(),
+        zoom: BiomeZoom::new(0),
+        blend_radius: 0,
+        smooth_lighting: false,
+        cutout_leaves: true,
+        translucent_layers: &[],
+        leaf_culling: mode,
+    };
+    mesher.mesh(&region, sy)
+}
+
+fn around(chunk: &Chunk) -> [[Option<&Chunk>; 3]; 3] {
+    [[Some(chunk); 3]; 3]
+}
+
+/// (opaque, cutout) leaf quads, rejecting a quad whose four vertices disagree.
+fn quads(mesh: &SectionMesh) -> (usize, usize) {
+    let mut opaque = 0;
+    let mut cutout = 0;
+    for quad in mesh.solid.as_chunks::<4>().0 {
+        let flags = quad
+            .iter()
+            .map(|v| v.layer & OPAQUE_LAYER != 0)
+            .collect::<Vec<_>>();
+        assert!(
+            flags.iter().all(|flag| *flag == flags[0]),
+            "a quad mixed opaque and cutout vertices: {flags:?}"
+        );
+        if flags[0] {
+            opaque += 1;
+        } else {
+            cutout += 1;
+        }
+    }
+    assert_eq!(mesh.solid.len() % 4, 0);
+    (opaque, cutout)
+}
+
+const BASE: i32 = MIN_Y + 4;
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn off_draws_every_fancy_leaf_face() {
+    let f = fixture();
+    let chunk = leaf_cube(&f, 6, 8, BASE, "minecraft:oak_leaves");
+    let mesh = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Off);
+    // 27 blocks, six quads each: vanilla's fancy leaves keep the inside.
+    assert_eq!(quads(&mesh), (0, 162));
+    assert_eq!(mesh.translucent.len(), 0);
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn solid_draws_the_fully_enclosed_leaf_opaque() {
+    let f = fixture();
+    let chunk = leaf_cube(&f, 6, 8, BASE, "minecraft:oak_leaves");
+    let solid = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Solid);
+    // Only the centre has all six sides covered: its six quads go opaque.
+    assert_eq!(quads(&solid), (6, 156));
+
+    let aggressive = mesh(
+        &f,
+        &chunk,
+        around(&chunk),
+        0,
+        LeafCullingMode::SolidAggressive,
+    );
+    // Aggressive also takes the six face-centre leaves: seven blocks opaque.
+    assert_eq!(quads(&aggressive), (42, 120));
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn aggressive_solidifies_the_next_shell_layer_of_a_five_cube() {
+    let f = fixture();
+    let chunk = leaf_cube(&f, 5, 9, BASE, "minecraft:oak_leaves");
+    let solid = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Solid);
+    // The 3x3x3 inside the surface: 27 blocks, six quads each.
+    assert_eq!(quads(&solid), (162, 588));
+    let aggressive = mesh(
+        &f,
+        &chunk,
+        around(&chunk),
+        0,
+        LeafCullingMode::SolidAggressive,
+    );
+    // The 3x3x3 inside plus the 3x3 face centre of each of the six sides.
+    assert_eq!(quads(&aggressive), (486, 264));
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn hollow_drops_only_the_faces_two_leaves_share() {
+    let f = fixture();
+    let chunk = leaf_cube(&f, 6, 8, BASE, "minecraft:oak_leaves");
+    let hollow = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Hollow);
+    // 162 quads minus the 54 shared pairs' 108 faces: the 3x3x3 shell.
+    assert_eq!(quads(&hollow), (0, 54));
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn mixed_species_count_as_one_leaf_volume() {
+    let f = fixture();
+    let oak = state(&f, "minecraft:oak_leaves");
+    let birch = state(&f, "minecraft:birch_leaves");
+    let mut chunk = Chunk::empty(0, 0);
+    for y in BASE..BASE + 3 {
+        for z in 6..=8 {
+            for x in 6..=8 {
+                chunk.set(x, y, z, if (x + y + z) % 2 == 0 { oak } else { birch });
+            }
+        }
+    }
+    let solid = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Solid);
+    assert_eq!(quads(&solid), (6, 156));
+    let hollow = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Hollow);
+    assert_eq!(quads(&hollow), (0, 54));
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn a_cavity_keeps_its_six_faces_and_its_rim_stays_cutout() {
+    let f = fixture();
+    let mut chunk = leaf_cube(&f, 5, 9, BASE, "minecraft:oak_leaves");
+    chunk.set(7, BASE + 2, 7, 0);
+    let hollow = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Hollow);
+    // Five-cube shell (150) plus the six faces around the one-block cavity.
+    assert_eq!(quads(&hollow), (0, 156));
+    let solid = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Solid);
+    // The six leaves around the cavity are exposed, so they stay cutout; the
+    // other 20 inner leaves draw solid. The cavity block itself has no quads.
+    assert_eq!(quads(&solid), (120, 624));
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn section_boundary_faces_stay_with_a_loaded_neighbour() {
+    let f = fixture();
+    let leaf = state(&f, "minecraft:oak_leaves");
+    let chunk = leaf_cube(&f, 12, 15, BASE, "minecraft:oak_leaves");
+    // A loaded east chunk whose x=0 column continues the canopy.
+    let mut east = Chunk::empty(1, 0);
+    for y in BASE..BASE + 4 {
+        for z in 12..=15 {
+            east.set(0, y, z, leaf);
+        }
+    }
+    let mut region = around(&chunk);
+    region[1][2] = Some(&east);
+    let joined = mesh(&f, &chunk, region, 0, LeafCullingMode::Hollow);
+    let mut region = around(&chunk);
+    region[1][2] = None;
+    let missing = mesh(&f, &chunk, region, 0, LeafCullingMode::Hollow);
+    // The east faces of the x=15 leaves are on the section boundary: a loaded
+    // neighbour does not let Hollow drop them, and a missing one does not
+    // change the mesh either.
+    assert_eq!(joined.solid.len(), missing.solid.len());
+    let off = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Off);
+    assert!(joined.solid.len() < off.solid.len());
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn the_top_of_a_one_section_column_stays_visible() {
+    let f = fixture();
+    let leaf = state(&f, "minecraft:oak_leaves");
+    let layout = ColumnLayout::new(0, 16).unwrap();
+    let mut chunk = Chunk::with_layout(0, 0, layout);
+    for y in 13..16 {
+        leaves_cube(&mut chunk, 5, 7, y, leaf);
+    }
+    let hollow = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Hollow);
+    let solid = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Solid);
+    // y=15 is the column's top: the faces toward y=16 are unknown, so they
+    // stay, and the y=15 leaves are not enclosed.
+    assert!(!hollow.solid.is_empty());
+    assert!(solid.solid.iter().any(|v| v.pos[1] == 16.0));
+    assert!(
+        solid
+            .solid
+            .iter()
+            .filter(|v| v.pos[1] == 16.0)
+            .all(|v| v.layer & OPAQUE_LAYER == 0)
+    );
+}
+
+#[test]
+#[ignore = "requires prepared 26.3 resources (HORIZON_MESH_TEST_RESOURCES or .local/horizon-client/26.3)"]
+fn a_world_without_leaves_meshes_identically_in_every_mode() {
+    let f = fixture();
+    let mut chunk = Chunk::empty(0, 0);
+    for y in BASE..BASE + 3 {
+        leaves_cube(&mut chunk, 6, 8, y, state(&f, "minecraft:stone"));
+    }
+    let off = mesh(&f, &chunk, around(&chunk), 0, LeafCullingMode::Off);
+    for mode in LeafCullingMode::ALL {
+        let other = mesh(&f, &chunk, around(&chunk), 0, mode);
+        assert_eq!(off.solid.len(), other.solid.len(), "{mode:?}");
+        assert_eq!(off.translucent.len(), other.translucent.len(), "{mode:?}");
+        for (a, b) in off.solid.iter().zip(&other.solid) {
+            assert_eq!(
+                (a.pos, a.uv, a.layer, a.light, a.color),
+                (b.pos, b.uv, b.layer, b.light, b.color),
+                "{mode:?}"
+            );
+        }
+        for (a, b) in off.translucent.iter().zip(&other.translucent) {
+            assert_eq!(
+                (a.pos, a.uv, a.layer, a.light, a.color),
+                (b.pos, b.uv, b.layer, b.light, b.color),
+                "{mode:?}"
+            );
+        }
+    }
+}
@@ -81,6 +81,8 @@ fn a_shader_pack_lights_the_faces_itself() {
            blend_radius: 0,
            smooth_lighting: false,
            cutout_leaves: true,
+            translucent_layers: &[],
+            leaf_culling: LeafCullingMode::Off,
        };
        let mut colours: Vec<u32> = mesher
            .mesh(&region, 0)
@@ -156,6 +158,8 @@ fn reused_mesh_matches_fresh_geometry_across_sections_and_resource_reload() {
            blend_radius: 2,
            smooth_lighting: reload == 0,
            cutout_leaves: reload == 0,
+            translucent_layers: &[],
+            leaf_culling: LeafCullingMode::Off,
        };
        for (case, (center, east)) in [
            (&empty, None),
@@ -88,6 +88,7 @@ fn info(solid: bool) -> Info {
        legacy_solid: false,
        overlay: false,
        leaves: false,
+        opaque_cube: solid,
        blocks_flow: false,
        ice: false,
        sturdy: 0,
@@ -219,10 +219,24 @@ impl StateModels {
                models.block_library_or_missing(root, names)?
            }
        };
+        let resolved: Vec<_> = variants
+            .iter()
+            .map(|(name, ..)| library.resolve(name))
+            .collect();
+        // Every texture the models name, decoded side by side before the bake adds them one
+        // by one in its own order.
+        sprites.prefetch(
+            root,
+            resolved
+                .iter()
+                .flatten()
+                .flat_map(|model| model.textures.values())
+                .map(|material| material.sprite.as_str()),
+        );
        let mut baked = Vec::with_capacity(variants.len());
        let mut index = BTreeMap::new();
-        for (name, turns, lock) in variants {
-            let model = library.resolve(&name)?;
+        for ((name, turns, lock), model) in variants.into_iter().zip(resolved) {
+            let model = model?;
            let particle = model
                .material("particle")?
                .map(|material| sprites.insert(root, &material.sprite))
@@ -1801,7 +1801,7 @@ fn tooltip_text(s: &Settings, wd: &Widget) -> Option<Text> {
    };
    let mut tip = None;
    if let Act::Extra(item) = act {
-        tip = Some(Text::literal(item.description()));
+        tip = Some(Text::literal(item.description_text()));
    }
    if let Act::Push(page) = act
        && let Some(text) = horizon_page_tooltip(*page)
@@ -1976,7 +1976,7 @@ fn pairs(opts: &[Opt]) -> Vec<Row> {
 impl OptionsUi {
    /// A switch of `horizon-extras.txt` as the Extras page draws it: "Caption: On".
    fn extra_button(&self, s: &Settings, item: crate::extras::Item) -> Widget {
-        let label = format!("{}: {}", item.caption(), item.value(&s.extras));
+        let label = format!("{}: {}", item.caption_text(), item.value(&s.extras));
        button(0.0, 0.0, 150.0, Text::literal(label), Act::Extra(item))
    }
    fn settings_search_active(&self) -> bool {
@@ -2274,7 +2274,7 @@ impl OptionsUi {
                // Each section's switches two to a row, as vanilla's
                // OptionsList.addSmall lays out an options screen.
                let extra = |item: crate::extras::Item| {
-                    let value = format!("{}: {}", item.caption(), item.value(&s.extras));
+                    let value = format!("{}: {}", item.caption_text(), item.value(&s.extras));
                    let label = if item.key_name().is_some() && self.selected_key == item.key_name()
                    {
                        Text::literal(format!("> {value} <")).with_color(text::YELLOW)
@@ -4941,6 +4941,24 @@ impl OptionsUi {
 mod tests {
    use super::*;

+    /// The window allows the input method only while `typing` says a search
+    /// box has the focus (`Game::text_field_focused`), so a page without one
+    /// must not claim the keys: the movement and menu keys keep working there.
+    #[test]
+    fn only_a_focused_search_box_takes_text() {
+        let mut ui = OptionsUi::default();
+        assert!(!ui.typing(), "the main page has no text box");
+        ui.show(Page::Language);
+        assert!(ui.typing(), "the language list's search takes the keys");
+        ui.show(Page::Video);
+        assert!(!ui.typing(), "the settings search is not focused");
+        ui.settings_search.focused = true;
+        assert!(ui.typing(), "the settings search, once focused, does");
+        ui.settings_search.focused = false;
+        ui.show(Page::Packs);
+        assert!(!ui.typing(), "the pack screen's search is not open yet");
+    }
+
    #[test]
    fn accessibility_sliders_and_toggles_survive_options_round_trip() {
        let mut s = Settings::default();
@@ -695,18 +695,20 @@ fn build_overlay_uncached(
            merged.insert(name.clone(), bytes);
        }
    }
+    /// A zip entry to write: its pack, its name in the zip and where it goes.
+    type Extract<'a> = (usize, &'a str, PathBuf);
    #[allow(clippy::too_many_arguments)]
-    fn mirror(
+    fn mirror<'a>(
        rel: &str,
        vanilla: &Path,
        out: &Path,
        touched: &BTreeSet<String>,
        hidden: &BTreeSet<String>,
-        files: &BTreeMap<String, (usize, Provided)>,
+        files: &'a BTreeMap<String, (usize, Provided)>,
        merged: &BTreeMap<String, Vec<u8>>,
        filters: &[&Filter],
-        zips: &[Option<Zip>],
        dependencies: &mut cache::Dependencies,
+        extract: &mut Vec<Extract<'a>>,
    ) -> io::Result<()> {
        let src = if rel.is_empty() {
            vanilla.to_path_buf()
@@ -733,7 +735,13 @@ fn build_overlay_uncached(
        } else {
            format!("{rel}/")
        };
-        for f in files.keys().filter_map(|f| f.strip_prefix(&prefix)) {
+        // The files under this directory are one run of the sorted map: walking only that run
+        // keeps a pack of tens of thousands of files in thousands of folders from being
+        // scanned once per folder.
+        for f in files
+            .range(prefix.clone()..)
+            .map_while(|(f, _)| f.strip_prefix(&prefix))
+        {
            names.insert(f.split('/').next().unwrap_or("").to_owned());
        }
        for name in names {
@@ -747,19 +755,8 @@ fn build_overlay_uncached(
                let target = out.join(&child);
                match path {
                    Some(p) => link(p, &target)?,
-                    None => {
-                        if let Some(Some(z)) = zips.get(*owner) {
-                            // One unreadable entry costs that file, not the
-                            // pack: an error here failed the build and the
-                            // reload dropped every server pack in the stack.
-                            match z.read(inner) {
-                                Ok(bytes) => fs::write(&target, bytes)?,
-                                Err(e) => log::warn!(
-                                    "Horizon: skipping unreadable pack entry {inner}: {e}"
-                                ),
-                            }
-                        }
-                    }
+                    // Inflated and written after the walk, on every thread.
+                    None => extract.push((*owner, inner.as_str(), target)),
                }
            } else if filters.is_empty()
                && !touched.contains(&child)
@@ -783,8 +780,8 @@ fn build_overlay_uncached(
                    files,
                    merged,
                    filters,
-                    zips,
                    dependencies,
+                    extract,
                )?;
            } else if filters.iter().any(|f| f.blocks(&child)) {
                // Hidden by a pack's filter.
@@ -798,6 +795,7 @@ fn build_overlay_uncached(
        }
        Ok(())
    }
+    let mut extract = Vec::new();
    mirror(
        "",
        vanilla,
@@ -807,9 +805,27 @@ fn build_overlay_uncached(
        &files,
        &merged,
        &filters,
-        &zips,
        dependencies,
-    )
+        &mut extract,
+    )?;
+    // Inflating and writing a big pack's files one by one was most of a cold build; its
+    // folders all exist by now.
+    crate::par::par_map(&extract, |(owner, inner, target)| {
+        let Some(Some(z)) = zips.get(*owner) else {
+            return Ok(());
+        };
+        // One unreadable entry costs that file, not the pack: an error here
+        // failed the build and the reload dropped every server pack in the stack.
+        match z.read(inner) {
+            Ok(bytes) => fs::write(target, bytes),
+            Err(e) => {
+                log::warn!("Horizon: skipping unreadable pack entry {inner}: {e}");
+                Ok(())
+            }
+        }
+    })
+    .into_iter()
+    .collect()
 }
 /// Files vanilla loads from every pack in turn (`getResourceStack`) rather
 /// than from the top pack only.
@@ -1489,6 +1505,72 @@ mod tests {
        let _ = fs::remove_dir_all(base);
    }
    #[test]
+    fn every_file_of_a_big_stack_comes_from_its_top_pack() {
+        use std::io::Write as _;
+        let base = std::env::temp_dir().join(format!("horizon-pack-stack-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&base);
+        let vanilla = base.join("vanilla");
+        // Folders whose names start alike (`item`, `item_extra`, `item2`) and files beside
+        // folders of almost their name: what a prefix lookup could mix up.
+        let names: Vec<String> = (0..400)
+            .map(|i| {
+                let folder = ["item", "item_extra", "item2", "item/sub", "block"][i % 5];
+                format!("assets/ns{}/textures/{folder}/f{i}.png", i % 3)
+            })
+            .chain(["assets/ns0/textures/item.png".to_owned()])
+            .collect();
+        let mut expected: BTreeMap<String, Vec<u8>> = BTreeMap::new();
+        for name in names.iter().step_by(4) {
+            let path = vanilla.join(name);
+            fs::create_dir_all(path.parent().unwrap()).unwrap();
+            fs::write(&path, format!("vanilla {name}")).unwrap();
+            expected.insert(name.clone(), format!("vanilla {name}").into_bytes());
+        }
+        let meta = br#"{"pack":{"description":"d","pack_format":97}}"#;
+        // Packs a and b are zips, c a folder; each provides a different part of the names.
+        fs::create_dir_all(base.join("packs/c")).unwrap();
+        fs::write(base.join("packs/c/pack.mcmeta"), meta).unwrap();
+        for (pack, every) in [("a", 2), ("b", 3)] {
+            let file = fs::File::create(base.join(format!("packs/{pack}.zip"))).unwrap();
+            let mut zip = zip::ZipWriter::new(file);
+            zip.start_file("pack.mcmeta", zip::write::SimpleFileOptions::default())
+                .unwrap();
+            zip.write_all(meta).unwrap();
+            for name in names.iter().step_by(every) {
+                zip.start_file(name, zip::write::SimpleFileOptions::default())
+                    .unwrap();
+                zip.write_all(format!("{pack} {name}").as_bytes()).unwrap();
+                expected.insert(name.clone(), format!("{pack} {name}").into_bytes());
+            }
+            zip.finish().unwrap();
+        }
+        for name in names.iter().skip(1).step_by(5) {
+            let path = base.join("packs/c").join(name);
+            fs::create_dir_all(path.parent().unwrap()).unwrap();
+            fs::write(&path, format!("c {name}")).unwrap();
+            expected.insert(name.clone(), format!("c {name}").into_bytes());
+        }
+        let all = folder(&base.join("packs"), RESOURCE_FORMAT);
+        let ids = ["file/a.zip", "file/b.zip", "file/c"].map(String::from);
+        let out = base.join("overlay");
+        build_overlay(&vanilla, &enabled(&all, &ids), &out).unwrap();
+        fn walk(dir: &Path, root: &Path, out: &mut BTreeMap<String, Vec<u8>>) {
+            for entry in fs::read_dir(dir).unwrap().flatten() {
+                let path = entry.path();
+                if path.is_dir() {
+                    walk(&path, root, out);
+                } else {
+                    let name = path.strip_prefix(root).unwrap().to_string_lossy();
+                    out.insert(name.replace('\\', "/"), fs::read(&path).unwrap());
+                }
+            }
+        }
+        let mut built = BTreeMap::new();
+        walk(&out.join("assets"), &out, &mut built);
+        assert_eq!(built, expected);
+        let _ = fs::remove_dir_all(base);
+    }
+    #[test]
    fn zip_entries_never_leave_the_overlay() {
        use std::io::Write as _;
        let base = std::env::temp_dir().join(format!("horizon-pack-escape-{}", std::process::id()));
@@ -926,6 +926,8 @@ impl PostEffects {
        let mut decoder = png::Decoder::new(std::io::BufReader::new(
            std::fs::File::open(&file).map_err(|e| format!("{}: {e}", file.display()))?,
        ));
+        // As the other resource-pack images: stb_image never checks chunk CRCs.
+        decoder.ignore_checksums(true);
        decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
        let mut reader = decoder.read_info().map_err(|e| e.to_string())?;
        let mut data = vec![0; reader.output_buffer_size().ok_or("a huge image")?];
@@ -827,6 +827,14 @@ impl TextField {
                );
            }
        }
+        if self.focused {
+            // `TextInputManager.setTextInputArea`, in GUI pixels: the caret
+            // the input method's composition and its candidate window go to.
+            // The chat and in-bed chat boxes and the pack screen's search are
+            // `TextField`s; the other fields are an `EditBox` or a multiline
+            // box, which report their own.
+            crate::preedit::report_caret(cursor_x as f32, ty as f32, 10.0);
+        }
    }
 }

@@ -68,6 +68,9 @@ pub enum Ticking {
    /// `RidingEntitySoundInstance` for the player riding a happy ghast
    /// (`underwater_sound` false) or a nautilus (true).
    RidingEntity { entity: u32, underwater_sound: bool },
+    /// A native mod's music layer (`MusicLayers`), whose volume its owner
+    /// sets each tick.
+    MusicLayer,
 }
 /// What a minecart's sound instances read about it.
 #[derive(Clone, Copy, Debug)]
@@ -233,6 +236,25 @@ impl SoundInstance {
            true,
        )
    }
+    /// A native mod's music layer: a looping, unattenuated track on the music
+    /// source that starts silent (`MusicLayers` fades it in).
+    pub fn for_music_layer(id: &str, random: LegacyRandom) -> Self {
+        let mut s = Self::new(
+            id,
+            MUSIC,
+            0.0,
+            1.0,
+            random,
+            true,
+            0,
+            Attenuation::None,
+            [0.0; 3],
+            true,
+        );
+        s.can_start_silent = true;
+        s.ticking = Ticking::MusicLayer;
+        s
+    }
    /// `SimpleSoundInstance.forJukeboxSong`.
    pub fn for_jukebox_song(id: &str, at: [f64; 3], random: LegacyRandom) -> Self {
        Self::new(
@@ -522,7 +544,7 @@ impl SoundInstance {
    /// `TickableSoundInstance.tick`.
    pub fn tick(&mut self, ctx: &TickContext) {
        match &mut self.ticking {
-            Ticking::No => {}
+            Ticking::No | Ticking::MusicLayer => {}
            Ticking::BiomeLoop { fade, direction } => {
                let stop = *fade < 0;
                *fade += *direction;
@@ -13,6 +13,11 @@ use crate::{
    ui,
 };

+/// A string of this page: the language table's, or the English text.
+fn tr(key: &str, english: &str) -> String {
+    lang::get_or(key, english)
+}
+
 /// Leave room for navigation, creation and cancellation in a 240-pixel menu.
 const SHOWN: usize = 4;
 pub mod store;
@@ -132,7 +137,12 @@ impl SplitProfiles {
        };
        if let Some(name) = &self.forgetting {
            return vec![
-                button(120.0, "Forget".into(), self.editable(name), Target::Forget),
+                button(
+                    120.0,
+                    tr("horizon.splitscreen.profiles.forget", "Forget"),
+                    self.editable(name),
+                    Target::Forget,
+                ),
                button(
                    144.0,
                    lang::get_or("gui.cancel", "Cancel"),
@@ -147,7 +157,12 @@ impl SplitProfiles {
            let ok = valid_name(name) && !self.names.iter().any(|n| n.eq_ignore_ascii_case(name));
            let top = field_top(h);
            return vec![
-                button(top + 25.0, "Create".into(), ok, Target::Create),
+                button(
+                    top + 25.0,
+                    tr("horizon.splitscreen.profiles.create", "Create"),
+                    ok,
+                    Target::Create,
+                ),
                button(
                    top + 50.0,
                    lang::get_or("gui.back", "Back"),
@@ -166,7 +181,7 @@ impl SplitProfiles {
        {
            let mut label = name.clone();
            if self.current.as_ref() == Some(name) {
-                label.push_str(" - you");
+                label.push_str(&tr("horizon.splitscreen.profiles.you", " - you"));
            }
            let y = 44.0 + (i % SHOWN) as f32 * 24.0;
            buttons.push((
@@ -177,7 +192,8 @@ impl SplitProfiles {
            ));
            buttons.push((
                [x + 180.0, y, 20.0, 20.0],
-                format!("Forget {name}"),
+                tr("horizon.splitscreen.profiles.forget_named", "Forget %s")
+                    .replacen("%s", name, 1),
                self.editable(name),
                Target::Remove(i),
            ));
@@ -186,19 +202,24 @@ impl SplitProfiles {
        if self.names.len() > SHOWN {
            buttons.push((
                [x, y, 98.0, 20.0],
-                "Previous".into(),
+                tr("horizon.splitscreen.profiles.previous", "Previous"),
                self.page() > 0,
                Target::Previous,
            ));
            buttons.push((
                [x + 102.0, y, 98.0, 20.0],
-                "Next".into(),
+                tr("horizon.splitscreen.profiles.next", "Next"),
                (self.page() + 1) * SHOWN < self.names.len(),
                Target::Next,
            ));
            y += 24.0;
        }
-        buttons.push(button(y, "New Profile...".into(), true, Target::New));
+        buttons.push(button(
+            y,
+            tr("horizon.splitscreen.profiles.new_button", "New Profile..."),
+            true,
+            Target::New,
+        ));
        let cancel = lang::get_or("gui.cancel", "Cancel");
        buttons.push(button(y + 24.0, cancel, true, Target::Cancel));
        buttons
@@ -220,30 +241,71 @@ impl SplitProfiles {
        };
        let buttons = self.buttons(w, h);
        if let Some(name) = &self.forgetting {
-            STYLE.title(batch, atlas, &Text::literal("Forget profile?"));
+            STYLE.title(
+                batch,
+                atlas,
+                &Text::literal(tr(
+                    "horizon.splitscreen.profiles.forget_title",
+                    "Forget profile?",
+                )),
+            );
            line(batch, name, 52.0, u32::MAX);
-            line(batch, "It leaves this instance's list.", 76.0, grey);
-            line(batch, "World progress and settings are kept.", 90.0, grey);
+            line(
+                batch,
+                &tr(
+                    "horizon.splitscreen.profiles.forget_leaves",
+                    "It leaves this instance's list.",
+                ),
+                76.0,
+                grey,
+            );
+            line(
+                batch,
+                &tr(
+                    "horizon.splitscreen.profiles.forget_kept",
+                    "World progress and settings are kept.",
+                ),
+                90.0,
+                grey,
+            );
            if let Some(why) = &self.refused {
                line(batch, why, 176.0, rgba(255, 85, 85, 255));
            }
        } else if let Some(field) = &mut self.new {
-            STYLE.title(batch, atlas, &Text::literal("New Profile"));
+            STYLE.title(
+                batch,
+                atlas,
+                &Text::literal(tr("horizon.splitscreen.profiles.new_title", "New Profile")),
+            );
            let (x, top) = ((w / 2.0).floor() - 100.0, field_top(h));
-            let label = "Name (3 to 16 letters, digits, _)";
-            batch.text(atlas, label, x, top - 14.0, grey, true);
+            let label = tr(
+                "horizon.splitscreen.profiles.name_hint",
+                "Name (3 to 16 letters, digits, _)",
+            );
+            batch.text(atlas, &label, x, top - 14.0, grey, true);
            (field.x, field.y, field.width, field.height) = (x, top, 200.0, 20.0);
            field.draw(batch, atlas, None);
        } else {
            let title = match self.current {
-                Some(_) => "Switch profile",
-                None => "Who's playing?",
+                Some(_) => tr(
+                    "horizon.splitscreen.profiles.switch_title",
+                    "Switch profile",
+                ),
+                None => tr("horizon.pages.split_profiles", "Who's playing?"),
            };
            STYLE.title(batch, atlas, &Text::literal(title));
            self.draw_bumpers(batch, atlas, style);
            // Under Cancel: where offline profiles live.
            let y = buttons.last().map_or(0.0, |b| b.0[1] + 30.0);
-            line(batch, "Offline profiles belong to this instance", y, grey);
+            line(
+                batch,
+                &tr(
+                    "horizon.splitscreen.profiles.offline_note",
+                    "Offline profiles belong to this instance",
+                ),
+                y,
+                grey,
+            );
            // Why the last pick can't play, wrapped to the view (a quarter of a window is narrow).
            let width = |text: &str| HudBatch::text_width(atlas, text).ceil();
            let why = self.refused.as_deref().unwrap_or_default();
@@ -308,8 +370,12 @@ impl SplitProfiles {
    fn draw_bumpers(&self, batch: &mut HudBatch, atlas: &HudAtlas, style: GlyphStyle) {
        let width = |text: &str| HudBatch::text_width(atlas, text).ceil();
        let words = match &self.place {
-            Some(place) => format!("Move where you play: {place}"),
-            None => "Move where you play".to_owned(),
+            Some(place) => tr(
+                "horizon.splitscreen.profiles.move_place",
+                "Move where you play: %s",
+            )
+            .replacen("%s", place, 1),
+            None => tr("horizon.splitscreen.profiles.move", "Move where you play"),
        };
        let keys = [PadButton::LeftBumper, PadButton::RightBumper];
        let key_width = |b: PadButton| width(b.label(style)) + 4.0;
@@ -99,6 +99,9 @@ pub struct Sprites {
    still: std::collections::HashMap<(Vec<u8>, u64, u32, [u32; 2], [bool; 4]), u32>,
    /// Decoded textures kept on disk between launches ([`Sprites::with_disk_cache`]).
    disk: Option<crate::sprite_cache::SpriteCache>,
+    /// Textures [`Sprites::prefetch`] decoded ahead of their insert, by sprite name or
+    /// resource path.
+    ready: std::collections::HashMap<String, crate::sprite_cache::Decoded>,
 }
 /// Edge length of vanilla's block textures: the smallest array layer.
 pub const SPRITE_SIZE: u32 = 16;
@@ -242,6 +245,8 @@ impl Sprites {
        self.lay_out(false);
    }
    fn lay_out(&mut self, pixels: bool) {
+        // Prefetched textures nothing inserted.
+        self.ready = Default::default();
        let layers = self.native.len().max(1) as u64;
        let largest = self.native.iter().map(|n| n.0).max().unwrap_or(SPRITE_SIZE);
        self.minimum_size = self.native.iter().map(|n| n.0).min().unwrap_or(SPRITE_SIZE);
@@ -335,12 +340,45 @@ impl Sprites {
            }
        }
    }
+    /// Decode on every thread the textures about to be inserted: sprite names, or resource
+    /// paths outside `textures/` (as [`Sprites::insert_file`] takes them). A loader that adds
+    /// many (the block models, an OptiFine pack's tiles) calls this first and then inserts
+    /// them in its own order, so the layers are the same as without it. What is already a
+    /// layer or in the disk cache is skipped; what fails to decode is left for the insert,
+    /// which reports it.
+    pub fn prefetch<'a>(&mut self, root: &Path, names: impl IntoIterator<Item = &'a str>) {
+        let names: Vec<&str> = names
+            .into_iter()
+            .filter(|name| {
+                !self.layers.contains_key(*name)
+                    && !self.ready.contains_key(*name)
+                    && self.disk.as_ref().is_none_or(|d| d.get(name).is_none())
+            })
+            .collect::<std::collections::BTreeSet<_>>()
+            .into_iter()
+            .collect();
+        let decoded = crate::par::par_map(&names, |name| {
+            if name.contains(':') {
+                Self::decode(root, name).ok()
+            } else {
+                Self::decode_file(&root.join(name), name).ok()
+            }
+        });
+        for (name, decoded) in names.into_iter().zip(decoded) {
+            if let Some(decoded) = decoded {
+                self.ready.insert(name.to_owned(), decoded);
+            }
+        }
+    }
    fn load(&mut self, root: &Path, name: &str) -> Result<u32> {
        let cached = self.disk.as_ref().and_then(|d| d.get(name)).cloned();
        let decoded = match cached {
            Some(decoded) => decoded,
            None => {
-                let decoded = Self::decode(root, name)?;
+                let decoded = match self.ready.remove(name) {
+                    Some(decoded) => decoded,
+                    None => Self::decode(root, name)?,
+                };
                if let Some(disk) = &mut self.disk {
                    disk.insert(name, decoded.clone());
                }
@@ -349,10 +387,29 @@ impl Sprites {
        };
        self.register(root, name, decoded)
    }
+    /// The layer of a texture outside `textures/` (an OptiFine pack's connected-texture tile),
+    /// named by its resource path and added on first use. Unlike [`Sprites::insert`], a texture
+    /// that does not load is an error: the caller drops what needed it. Such files bypass the
+    /// disk cache, whose fingerprint covers only `textures/`.
+    pub fn insert_file(&mut self, root: &Path, resource: &str) -> Result<u32> {
+        if let Some(layer) = self.layers.get(resource) {
+            return Ok(*layer);
+        }
+        let decoded = match self.ready.remove(resource) {
+            Some(decoded) => decoded,
+            None => Self::decode_file(&root.join(resource), resource)?,
+        };
+        self.register(root, resource, decoded)
+    }
    /// Read and decode one texture and its `.mcmeta`.
    fn decode(root: &Path, name: &str) -> Result<crate::sprite_cache::Decoded> {
        let (namespace, path) = name.split_once(':').ok_or("invalid sprite identifier")?;
-        let path = root.join(format!("assets/{namespace}/textures/{path}.png"));
+        Self::decode_file(
+            &root.join(format!("assets/{namespace}/textures/{path}.png")),
+            name,
+        )
+    }
+    fn decode_file(path: &Path, name: &str) -> Result<crate::sprite_cache::Decoded> {
        let metadata = match fs::read_to_string(path.with_extension("png.mcmeta")) {
            Ok(text) => Some(serde_json::from_str::<
                BTreeMap<String, Box<serde_json::value::RawValue>>,
@@ -368,7 +425,7 @@ impl Sprites {
            .as_deref()
            .map(AnimationMetadata::from_json)
            .transpose()?;
-        let (png_width, png_height, pixels) = read_rgba(&path)?;
+        let (png_width, png_height, pixels) = read_rgba(path)?;
        let (width, height) = if let Some(animation) = &animation {
            let [width, height] =
                animation.frame_size(i32::try_from(png_width)?, i32::try_from(png_height)?);
@@ -512,6 +569,7 @@ impl Sprites {
 /// A PNG's width, height and pixels as RGBA.
 fn read_rgba(path: &Path) -> Result<(u32, u32, Vec<u8>)> {
    let mut decoder = png::Decoder::new(BufReader::new(File::open(path)?));
+    decoder.ignore_checksums(true);
    decoder.set_transformations(png::Transformations::EXPAND | png::Transformations::STRIP_16);
    let mut reader = decoder.read_info()?;
    let mut bytes = vec![
@@ -662,6 +720,106 @@ mod tests {
        }
    }
    #[test]
+    fn files_outside_textures_load_by_path() {
+        let root = std::env::temp_dir().join(format!("horizon-sprite-file-{}", std::process::id()));
+        let tile = "assets/minecraft/optifine/ctm/glass/0.png";
+        fs::create_dir_all(root.join(tile).parent().unwrap()).unwrap();
+        let mut encoder = png::Encoder::new(File::create(root.join(tile)).unwrap(), 16, 16);
+        encoder.set_color(png::ColorType::Rgba);
+        encoder.set_depth(png::BitDepth::Eight);
+        let pixels: Vec<u8> = (0..256).flat_map(|i| [i as u8, 0, 0, 128]).collect();
+        encoder
+            .write_header()
+            .unwrap()
+            .write_image_data(&pixels)
+            .unwrap();
+        let mut sprites = Sprites::default();
+        let layer = sprites.insert_file(&root, tile).unwrap();
+        assert_eq!(sprites.insert_file(&root, tile).unwrap(), layer);
+        assert!(sprites.translucent[layer as usize]);
+        // A missing tile is an error, not the missing texture.
+        assert!(
+            sprites
+                .insert_file(&root, "assets/minecraft/optifine/ctm/glass/1.png")
+                .is_err()
+        );
+        assert_eq!(sprites.count(), 1);
+        fs::remove_dir_all(&root).unwrap();
+    }
+    #[test]
+    fn prefetched_textures_take_the_layers_inserting_alone_gives() {
+        let root =
+            std::env::temp_dir().join(format!("horizon-sprite-prefetch-{}", std::process::id()));
+        let png = |path: &str, side: u32, seed: u8| {
+            let file = root.join(path);
+            fs::create_dir_all(file.parent().unwrap()).unwrap();
+            let mut encoder = png::Encoder::new(File::create(file).unwrap(), side, side);
+            encoder.set_color(png::ColorType::Rgba);
+            encoder.set_depth(png::BitDepth::Eight);
+            let pixels: Vec<u8> = (0..side * side)
+                .flat_map(|i| {
+                    [
+                        seed,
+                        i as u8,
+                        (i >> 8) as u8,
+                        if i % 3 == 0 { 0 } else { 255 },
+                    ]
+                })
+                .collect();
+            encoder
+                .write_header()
+                .unwrap()
+                .write_image_data(&pixels)
+                .unwrap();
+        };
+        for i in 0..40u8 {
+            png(
+                &format!("assets/minecraft/textures/block/b{i}.png"),
+                16 << (i % 3),
+                i,
+            );
+        }
+        // Two textures alike share a layer; a tile outside `textures/`, a broken file and a
+        // missing one take the paths they take without prefetching.
+        png("assets/minecraft/textures/block/same.png", 16, 3);
+        png("assets/minecraft/optifine/ctm/glass/0.png", 32, 77);
+        fs::write(
+            root.join("assets/minecraft/textures/block/broken.png"),
+            b"no png",
+        )
+        .unwrap();
+        let names: Vec<String> = (0..40)
+            .map(|i| format!("minecraft:block/b{}", (i * 7) % 40))
+            .chain(["minecraft:block/same", "minecraft:block/broken"].map(String::from))
+            .chain(["minecraft:block/missing", "minecraft:block/b3"].map(String::from))
+            .collect();
+        let tile = "assets/minecraft/optifine/ctm/glass/0.png";
+        let load = |prefetch: bool| {
+            let mut sprites = Sprites::default();
+            if prefetch {
+                sprites.prefetch(&root, names.iter().map(String::as_str).chain([tile]));
+            }
+            let mut layers: Vec<u32> = names
+                .iter()
+                .map(|name| sprites.insert(&root, name).unwrap())
+                .collect();
+            layers.push(sprites.insert_file(&root, tile).unwrap());
+            sprites.finish();
+            (
+                layers,
+                sprites.layers,
+                sprites.pixels,
+                sprites.translucent,
+                sprites.size,
+            )
+        };
+        let alone = load(false);
+        assert_eq!(load(true), alone);
+        // The textures alike and the broken one's missing texture: fewer layers than names.
+        assert!(alone.1.values().max().unwrap() + 1 < names.len() as u32);
+        fs::remove_dir_all(&root).unwrap();
+    }
+    #[test]
    fn identical_still_textures_share_a_layer() {
        let root =
            std::env::temp_dir().join(format!("horizon-sprite-share-{}", std::process::id()));
@@ -6,6 +6,7 @@ use crate::fast_hash::{FxHashMap, FxHashSet};
 use crate::section_mask::SectionMask;
 use crate::{
    chunk::Chunk,
+    graphics::LeafCullingMode,
    light::{LightChanges, LightTables, apply_lighting, apply_relighting, light_chunk},
    mesher::{MeshScratch, MeshTables, Mesher, Region, SectionMesh, borrow},
    world::World,
@@ -196,7 +197,7 @@ impl<G: ChunkGenerator> Saves for G {
    }
 }
 /// Per-job mesher inputs that change with the dimension or the options.
-#[derive(Clone, Copy)]
+#[derive(Clone)]
 struct MeshSettings {
    nether: bool,
    shader_pack_lighting: bool,
@@ -204,6 +205,8 @@ struct MeshSettings {
    blend_radius: i32,
    smooth_lighting: bool,
    cutout_leaves: bool,
+    translucent_layers: Arc<[bool]>,
+    leaf_culling: LeafCullingMode,
 }
 enum Job {
    Generate(i32, i32),
@@ -438,6 +441,11 @@ pub struct Streaming {
    /// The `ao` and `cutoutLeaves` options.
    pub smooth_lighting: bool,
    pub cutout_leaves: bool,
+    /// Sprite layers a shader pack draws in the translucent pass (`[[materials]]
+    /// translucent`), by layer; empty without one.
+    pub translucent_layers: Arc<[bool]>,
+    /// What the mesher does with leaf faces inside a canopy (`LeafCullingMode`).
+    pub leaf_culling: LeafCullingMode,
    /// Incremental relighting of block edits on lit chunks (see `light::relight`).
    light_tables: Arc<LightTables>,
    /// Applied edits by sequence, replayed onto light jobs snapshotted before them.
@@ -772,6 +780,8 @@ impl Streaming {
                                        blend_radius: settings.blend_radius,
                                        smooth_lighting: settings.smooth_lighting,
                                        cutout_leaves: settings.cutout_leaves,
+                                        translucent_layers: &settings.translucent_layers,
+                                        leaf_culling: settings.leaf_culling,
                                        assets: &context.assets,
                                        render: &context.render,
                                        tables: &context.tables,
@@ -853,6 +863,8 @@ impl Streaming {
            biome_blend: 2,
            smooth_lighting: true,
            cutout_leaves: true,
+            translucent_layers: Arc::from([]),
+            leaf_culling: LeafCullingMode::Off,
            light_tables,
            light_log: Vec::new(),
            light_edit_sequence: 0,
@@ -904,9 +916,56 @@ impl Streaming {
            }
        }
    }
+    /// A resident column a server sent again whole (it changed it in bulk):
+    /// its new blocks taken, the sections that did not change kept as they
+    /// were, and its light and its neighbours' worked out again here, off
+    /// the game thread, as light is for the blocks a server changes one at a
+    /// time; the sections that changed remesh (with theirs) once lit. Until
+    /// then the sections that changed show the light the packet carried (a
+    /// Horizon server sends the light from before its relight, then the
+    /// new light; another server's is already right, which matters where
+    /// the neighbours this light needs aren't all here).
+    pub fn replace_remote(&mut self, world: &mut World, mut chunk: Chunk) {
+        let key = (chunk.x, chunk.z);
+        let Some(old) = world.chunks.get(&key).cloned() else {
+            return self.insert_remote(world, chunk);
+        };
+        if !self.lit.contains(&key) {
+            return self.insert_remote(world, chunk);
+        }
+        // The cells whose blocks changed, by section: they remesh with the neighbours within a block of them (as
+        // vanilla's `setBlocksDirty`), not every section round each section changed (which, for the few blocks a
+        // section often changes in a bulk edit, is mostly sections that did not).
+        let mut cells = crate::light::LightChanges::default();
+        cells.keyed(world.layout());
+        let kept = keep_unchanged_sections(&old, &mut chunk, &mut cells);
+        chunk.light_loaded = old.light_loaded;
+        chunk.lit = true;
+        world.chunks.insert(key, Arc::new(chunk));
+        world.revision = world.revision.wrapping_add(1);
+        // A section with new biomes and the same blocks remeshes now (its tint), with its neighbours, whose tint
+        // blends across the border: above and below too, as a block's tint can sample the biome quart of the
+        // section next to it (`BiomeManager.getBiome`'s zoom reaches a quart beyond the block).
+        Self::light_updated(world, key.0, key.1, &kept.biomes);
+        // A section with the same blocks and new light takes the packet's light (vanilla's
+        // `handleLevelChunkWithLight` always applies it) and remeshes as a light update would.
+        Self::light_updated(world, key.0, key.1, &kept.light);
+        if !kept.blocks {
+            return;
+        }
+        for dz in -1..=1 {
+            for dx in -1..=1 {
+                world.dirty_light.insert((key.0 + dx, key.1 + dz));
+            }
+        }
+        cells.dirty_sections(|section| {
+            world.dirty_sections.insert(section);
+        });
+    }
    /// A server's light update for a resident column: the sections whose
    /// light changed and their neighbours remesh
-    /// (`setSectionDirtyWithNeighbors`).
+    /// (`setSectionDirtyWithNeighbors`). A resent column's sections with new
+    /// biomes remesh the same way.
    pub fn light_updated(world: &mut World, x: i32, z: i32, sections: &[usize]) {
        for &sy in sections {
            for dz in -1..=1 {
@@ -1712,6 +1771,8 @@ impl Streaming {
                            blend_radius: self.biome_blend,
                            smooth_lighting: self.smooth_lighting,
                            cutout_leaves: self.cutout_leaves,
+                            translucent_layers: self.translucent_layers.clone(),
+                            leaf_culling: self.leaf_culling,
                        },
                    ),
                );
@@ -2363,10 +2424,136 @@ fn nearest_first<T: Ord>(candidates: &mut Vec<T>, room: usize) {
    }
    candidates.sort_unstable();
 }
+/// What `keep_unchanged_sections` found changed.
+#[derive(Debug, Default, PartialEq)]
+struct Resent {
+    /// Any section's blocks changed (in a way light or the mesher sees).
+    blocks: bool,
+    /// The sections whose blocks did not change but whose biomes did.
+    biomes: Vec<usize>,
+    /// The sections whose blocks did not change but whose light the packet changes.
+    light: Vec<usize>,
+}
+/// `new`, a resident column `old` sent again, takes `old`'s sections whose
+/// blocks it holds unchanged, with `new`'s biomes and light; the sections whose blocks
+/// changed keep `old`'s light (until lit again) and their cells' classes go in
+/// `cells`.
+fn keep_unchanged_sections(
+    old: &Chunk,
+    new: &mut Chunk,
+    cells: &mut crate::light::LightChanges,
+) -> Resent {
+    let (mut a, mut b) = (Box::new([0u32; 4096]), Box::new([0u32; 4096]));
+    let mut out = Resent::default();
+    let (x, z) = (new.x, new.z);
+    for s in 0..new.sections.len().min(old.sections.len()) {
+        // (sections stored alike hold the same blocks: most of a column sent again, found without unpacking)
+        let same = old.sections[s].blocks.same_storage(&new.sections[s].blocks) || {
+            old.sections[s].unpack(&mut a);
+            new.sections[s].unpack(&mut b);
+            let classes = crate::light::LightChanges::classes_differing(&a, &b);
+            if classes != 0 {
+                cells.add((x, s as i32, z), classes);
+            }
+            classes == 0
+        };
+        if !same {
+            out.blocks = true;
+            continue;
+        }
+        let biomes = new.sections[s].biomes.clone();
+        let changed = !same_values(&old.sections[s].biomes, &biomes);
+        let light = (!same_light(&old.sections[s].light, &new.sections[s].light))
+            .then(|| new.sections[s].light.clone());
+        new.sections[s] = old.sections[s].clone();
+        if changed {
+            Arc::make_mut(&mut new.sections[s]).biomes = biomes;
+            out.biomes.push(s);
+        }
+        if let Some(light) = light {
+            Arc::make_mut(&mut new.sections[s]).light = light;
+            out.light.push(s);
+        }
+    }
+    out
+}
+/// Whether two sections' packed light (4,096 cells) holds the same values.
+fn same_light(a: &crate::chunk::Light, b: &crate::chunk::Light) -> bool {
+    use crate::chunk::Light;
+    match (a, b) {
+        (Light::Uniform(x), Light::Uniform(y)) => x == y,
+        (Light::Full(x), Light::Full(y)) => x == y,
+        (Light::Uniform(v), Light::Full(f)) | (Light::Full(f), Light::Uniform(v)) => {
+            f.iter().all(|c| c == v)
+        }
+    }
+}
+/// Whether two biome containers (64 cells) hold the same values.
+fn same_values(
+    a: &horizon_core::paletted::PalettedContainer,
+    b: &horizon_core::paletted::PalettedContainer,
+) -> bool {
+    if a.same_storage(b) {
+        return true;
+    }
+    let (mut x, mut y) = ([0u32; 64], [0u32; 64]);
+    a.unpack(&mut x);
+    b.unpack(&mut y);
+    x == y
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;

+    #[test]
+    fn a_resent_column_keeps_its_sections_but_takes_new_biomes() {
+        let mut old = Chunk::empty(2, -3);
+        old.set(1, 10, 1, 1);
+        old.set(1, 40, 1, 1);
+        old.set_biome_cell(0, 0, 0, 1);
+        let mut new = old.clone();
+        // a new biome under the same blocks (section 0), and a block changed (section 6)
+        new.set_biome_cell(0, 0, 0, 3);
+        new.set(1, 40, 1, 2);
+        let mut cells = crate::light::LightChanges::default();
+        cells.keyed(crate::chunk::ColumnLayout::VANILLA);
+        let kept = keep_unchanged_sections(&old, &mut new, &mut cells);
+        assert_eq!(
+            kept,
+            Resent {
+                blocks: true,
+                biomes: vec![0],
+                light: vec![],
+            }
+        );
+        assert_eq!(new.biome(0, -64, 0), 3);
+        assert_eq!(new.block(1, -54, 1).0, 0);
+        assert_eq!(new.block(1, 40, 1).0, 2);
+        // the sections alike are shared with the old column
+        assert!(Arc::ptr_eq(&new.sections[1], &old.sections[1]));
+        assert!(!Arc::ptr_eq(&new.sections[0], &old.sections[0]));
+        // nothing changed: nothing to do
+        let mut same = old.clone();
+        let kept = keep_unchanged_sections(&old, &mut same, &mut cells);
+        assert_eq!(kept, Resent::default());
+        assert!(Arc::ptr_eq(&same.sections[0], &old.sections[0]));
+        // the same blocks under new light: the packet's light, as vanilla applies it
+        let mut lit = old.clone();
+        Arc::make_mut(&mut lit.sections[2]).light = crate::chunk::Light::Uniform(0xF0);
+        Arc::make_mut(&mut old.sections[2]).light = crate::chunk::Light::Uniform(0x50);
+        let kept = keep_unchanged_sections(&old, &mut lit, &mut cells);
+        assert_eq!(
+            kept,
+            Resent {
+                light: vec![2],
+                ..Resent::default()
+            }
+        );
+        assert_eq!(lit.sections[2].light.get(0), 0xF0);
+        assert!(Arc::ptr_eq(&lit.sections[1], &old.sections[1]));
+    }
+
    #[test]
    fn mesh_pool_reuses_capacity_with_clean_geometry_state() {
        let mut mesh = SectionMesh::default();
@@ -591,6 +591,11 @@ fn sky_along_ray(d: vec3<f32>) -> vec3<f32> {
@fragment fn fs_sky(in: SkyOut) -> @location(0) vec4<f32> {
    return vec4(sky_along_ray(view_ray(in.ndc)), 1.0);
 }
+// The first-person hand's depth clear inside the world pass: `vs_sky`'s triangle lies at the
+// far plane, written over the whole depth target with no colour.
+@fragment fn fs_depth_reset(in: SkyOut) -> @location(0) vec4<f32> {
+    return vec4(0.0);
+}
@fragment fn fs_dark_disc(in: SkyOut) -> @location(0) vec4<f32> {
    let d = view_ray(in.ndc);
    let dist = disc_distance(d, -4.0);
@@ -100,6 +100,9 @@ pub struct World {
    /// for `ServerLevel.sendBlockUpdated`'s path recomputing; kept only while
    /// the mobs of this world tick (`game/creatures.rs`).
    pub path_writes: Option<Vec<((i32, i32, i32), u32, u32)>>,
+    /// The chunks changed in bulk (`edit_runs`) since the log was last
+    /// drained, kept while `block_log` is: sent to the players whole.
+    pub bulk_log: FxHashSet<(i32, i32)>,
    /// The sections whose light changed since the log was last drained, as
    /// a bit per section of each column, kept while `block_log` is
    /// (`ChunkHolder.sectionLightChanged`).
@@ -208,6 +211,7 @@ impl World {
            weather: Weather::default(),
            block_log: None,
            path_writes: None,
+            bulk_log: Default::default(),
            light_log: None,
            moving_piston_fallback: Vec::new(),
            moving_pistons: Vec::new(),
@@ -6,8 +6,12 @@ edition.workspace = true
 license.workspace = true
 rust-version = "1.90"
 description = "Horizon native development client"
+autobins = false
+autoexamples = false
+autotests = false

 [dependencies]
+horizon-client-lib = { path = "../horizon-client-lib", default-features = false }
 horizon-assets = { path = "../horizon-assets" }
 horizon-client-core = { path = "../horizon-client-core" }
 horizon-client-input = { path = "../horizon-client-input" }
@@ -15,8 +19,9 @@ horizon-client-render = { path = "../horizon-client-render" }
 horizon-command = { path = "../horizon-command" }
 horizon-items = { path = "../horizon-items" }
 horizon-core = { path = "../horizon-core" }
-# The server thread ahead of the workers (MinecraftServer.spin's Thread.setPriority).
+# OptiFine-format pack files: custom entity models, random entity textures.
 horizon-optifine = { path = "../horizon-optifine" }
+# The server thread ahead of the workers (MinecraftServer.spin's Thread.setPriority).
 horizon-threads = { path = "../horizon-threads" }
 horizon-hdr = { path = "../horizon-hdr" }
 horizon-world = { path = "../horizon-world" }
@@ -104,20 +109,23 @@ winresource = "0.1"
 default = ["audio", "controllers"]
 # Sound output. Without it (and `controllers`) the program links neither libasound nor libudev on
 # Linux: the server build (`--no-default-features`, released as horizon-engine; docs/server.md).
-audio = ["horizon-client-render/audio"]
+audio = ["horizon-client-render/audio", "horizon-client-lib/audio"]
 # Controllers: gilrs, and the DualSense's own output. Without it only `horizon-ctl pad`'s virtual pad.
-controllers = ["dep:gilrs", "dep:horizon-dualsense", "horizon-client-input/controllers"]
+controllers = ["horizon-client-lib/controllers", "dep:gilrs", "dep:horizon-dualsense", "horizon-client-input/controllers"]
 # Records the call sites of mob random draws (`mob_ai_probe` traces).
-rng-trace = ["horizon-core/rng-trace"]
+rng-trace = ["horizon-core/rng-trace", "horizon-client-lib/rng-trace"]
 # Compatibility with earlier experiment commands: main already uses mimalloc.
 windows-mimalloc = []
 # Opt-in Windows heap experiment; see docs/windows-allocators.md.
 windows-segment-heap = []

-# Its own name, not `probe`: Cargo copies every crate's examples into one target/<profile>/examples.
-[[example]]
-name = "client_probe"
-path = "examples/probe/main.rs"
+[[bin]]
+name = "horizon-client"
+path = "src/main.rs"
+
+[[test]]
+name = "launch_api"
+path = "tests/launch_api.rs"

 [lints]
 workspace = true
@@ -0,0 +1,293 @@
+{
+  "horizon.options.controller": "Controller",
+  "horizon.options.vibration": "Vibration",
+  "horizon.options.adaptive_triggers": "Adaptive Trigger",
+  "horizon.options.lightbar": "Lightbar",
+  "horizon.options.look_sensitivity": "Blickempfindlichkeit",
+  "horizon.options.invert_x": "Blick-X-Achse umkehren",
+  "horizon.options.invert_y": "Blick-Y-Achse umkehren",
+  "horizon.options.sneak_button": "Schleichtaste",
+  "horizon.options.move_deadzone": "Totzone der Bewegung",
+  "horizon.options.look_deadzone": "Totzone des Blicks",
+  "horizon.options.button_glyphs": "Tastensymbole",
+  "horizon.options.menu_navigation": "Menünavigation",
+  "horizon.options.on_screen_keyboard": "Bildschirmtastatur",
+  "horizon.options.chat_delay": "Chatverzögerung",
+  "horizon.options.lightbar.health": "Gesundheit",
+  "horizon.options.lightbar.dimension": "Dimension",
+  "horizon.options.glyphs.auto": "Auto",
+  "horizon.options.glyphs.xbox": "Xbox",
+  "horizon.options.glyphs.playstation": "PlayStation",
+  "horizon.options.glyphs.nintendo": "Nintendo",
+  "horizon.options.menu_focus": "Fokus",
+  "horizon.options.menu_pointer": "Zeiger",
+  "horizon.options.keyboard.auto": "Auto",
+  "horizon.options.keyboard.horizon": "Horizon",
+  "horizon.options.keyboard.steam": "Steam",
+  "horizon.options.unavailable": "Diese Funktion ist in Horizon noch nicht verfügbar.",
+  "horizon.options.search": "Einstellungen durchsuchen …",
+  "horizon.pages.mods": "Mods",
+  "horizon.pages.shader_packs": "Shader-Pakete",
+  "horizon.pages.shader_options": "Shader-Optionen",
+  "horizon.pages.controller": "Controller-Einstellungen",
+  "horizon.pages.controller_binds": "Controller-Tastenbelegung",
+  "horizon.pages.extras": "Horizon-Extras",
+  "horizon.pages.settings": "Horizon-Einstellungen",
+  "horizon.pages.agent": "KI-Agent",
+  "horizon.pages.split_profiles": "Wer spielt?",
+  "horizon.pages.settings.tooltip": "Horizons eigene Einstellungen: Grafik, Controller, Extras und Mods.",
+  "horizon.pages.graphics.tooltip": "Grafik, einfach: Jede Einstellung zeigt, was sie kostet.",
+  "horizon.pages.graphics_advanced.tooltip": "Alle Grafikeinstellungen, auch die von Horizon, mit den Kosten jeder einzelnen.",
+  "horizon.pages.controller.tooltip": "Controller: ihre Tasten, Sticks, Vibration und Menünavigation.",
+  "horizon.pages.extras.tooltip": "Optionale Zusätze, alle standardmäßig aus: Das Spiel bleibt Vanilla, bis du einen einschaltest.",
+  "horizon.pages.agent.tooltip": "Lass deinen eigenen KI-Agenten spielen: horizon-ctl und MCP-Clients auf diesem Computer.",
+  "horizon.pages.split_profiles.tooltip": "Wer spielt: ein Profil, das in diesem Spielordner gespeichert ist.",
+  "horizon.pages.shader_packs.tooltip": "Shader-Pakete aus dem Ordner shaderpacks: die von Horizon selbst und die im Format shaders/. Es läuft immer nur eines.",
+  "horizon.pages.mods.tooltip": "Mods für Horizon aus dem Ordner horizon-mods. Jede läuft in einer Sandbox und bleibt aus, bis du sie einschaltest.",
+  "horizon.pages.open.graphics": "Grafik …",
+  "horizon.pages.open.graphics_advanced": "Erweiterte Grafik …",
+  "horizon.pages.open.shader_packs": "Shader-Pakete …",
+  "horizon.pages.open.controller": "Controller-Einstellungen …",
+  "horizon.pages.open.extras": "Extras …",
+  "horizon.pages.open.mods": "Mods …",
+  "horizon.pages.open.agent": "KI-Agent …",
+  "horizon.pages.open.horizon_graphics": "Horizon-Grafik …",
+  "horizon.pages.open.controller_binds": "Controller-Belegung …",
+  "horizon.pages.open.horizon_settings": "Horizon-Einstellungen …",
+  "horizon.mods.empty": "Keine Mods: Lege .hmod-Dateien in den Ordner horizon-mods",
+  "horizon.mods.stopped": " (angehalten)",
+  "horizon.mods.not_built": " (nicht gebaut)",
+  "horizon.mods.dev": " (Entwicklung)",
+  "horizon.mods.settings": "Einstellungen",
+  "horizon.mods.open_folder": "Modordner öffnen",
+  "horizon.shader_packs.empty": "Keine Shader-Pakete: Lege sie in den Ordner shaderpacks",
+  "horizon.shader_packs.kind_horizon": " (Horizon)",
+  "horizon.shader_options.open": "Shader-Optionen …",
+  "horizon.shader_options.profile": "Profil",
+  "horizon.shader_options.loading": "Optionen des Shader-Pakets werden gelesen …",
+  "horizon.agent.copy_details": "Verbindungsdaten kopieren",
+  "horizon.multiplayer.join": "Beitreten",
+  "horizon.multiplayer.cancel_reconnecting": "Neuverbindung abbrechen",
+  "horizon.multiplayer.join_friend": "Freund beitreten",
+  "horizon.multiplayer.invite_code": "Einladungscode",
+  "horizon.multiplayer.relay": "Relay (optional)",
+  "Preset": "Preset",
+  "LOD Distance": "LOD-Weite",
+  "Far Detail": "Ferndetails",
+  "Cave Culling": "Höhlen-Culling",
+  "Entity Culling": "Objekt-Culling",
+  "Chunk Updates": "Chunk-Updates",
+  "Upload Budget": "Upload-Budget",
+  "Sky": "Himmel",
+  "Fog": "Nebel",
+  "Weather": "Wetter",
+  "Animated Textures": "Animierte Texturen",
+  "Present Mode": "Ausgabemodus",
+  "Frame Pacing": "Bildtakt",
+  "Worker Threads": "Arbeitsthreads",
+  "Resolution Scale": "Auflösungsskalierung",
+  "Anti-aliasing": "Kantenglättung",
+  "Upscaling": "Upscaling",
+  "HDR Settings...": "HDR-Einstellungen …",
+  "Paper White": "Papierweiß",
+  "Peak Brightness": "Spitzenhelligkeit",
+  "Black Level": "Schwarzwert",
+  "UI Brightness": "GUI-Helligkeit",
+  "Battery Mode": "Akkumodus",
+  "Graphics API": "Grafik-API",
+  "Performance Overlay": "Leistungsanzeige",
+  "Full Detail Distance": "Detailweite",
+  "On": "An",
+  "Off": "Aus",
+  "Unlimited": "Unbegrenzt",
+  "Auto": "Auto",
+  "Custom": "Benutzerdefiniert",
+  "Performance": "Leistung",
+  "Balanced": "Ausgewogen",
+  "Quality": "Qualität",
+  "Ultra": "Ultra",
+  "Ultra Performance": "Ultra-Leistung",
+  "Native": "Nativ",
+  "Full": "Voll",
+  "Reduced": "Reduziert",
+  "Efficient": "Sparsam",
+  "Precise": "Präzise",
+  "Auto (VSync)": "Auto (VSync)",
+  "FIFO": "FIFO",
+  "Mailbox": "Mailbox",
+  "Immediate": "Immediate",
+  "Vulkan": "Vulkan",
+  "DirectX 12": "DirectX 12",
+  "OpenGL": "OpenGL",
+  "FPS and Graph": "FPS und Diagramm",
+  "FPS": "FPS",
+  "TAA": "TAA",
+  "FXAA": "FXAA",
+  "No cost": "Keine Kosten",
+  "Low cost": "Geringe Kosten",
+  "Medium cost": "Mittlere Kosten",
+  "High cost": "Hohe Kosten",
+  "Saves time": "Spart Zeit",
+  "Rendering": "Rendering",
+  "Display": "Anzeige",
+  "Preferences": "Präferenzen",
+  "Overlay": "Einblendung",
+  "HDR": "HDR",
+  "Graphics": "Grafik",
+  "Graphics: Advanced": "Grafik: Erweitert",
+  "Graphics: HDR": "Grafik: HDR",
+  "Advanced...": "Erweitert …",
+  "Simple...": "Einfach …",
+  "Done": "Fertig",
+  "This feature is not yet available in Horizon.": "Diese Funktion ist in Horizon noch nicht verfügbar.",
+  "Your display or system doesn't offer HDR output.": "Dein Bildschirm oder System unterstützt keine HDR-Ausgabe.",
+  "Turn HDR on to use it.": "Schalte HDR ein, um es zu nutzen.",
+  "%s chunks": "%s Chunks",
+  "%s per frame": "%s pro Bild",
+  "%s MiB/frame": "%s MiB/Bild",
+  "%s KiB/frame": "%s KiB/Bild",
+  "%s nits": "%s Nits",
+  "Auto (%s)": "Auto (%s)",
+  "Auto (%s nits)": "Auto (%s Nits)",
+  "%.2f nits": "%.2f Nits",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Gelände mit vollen Details. Die LOD-Entfernung reicht weiter.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Grobes fernes Gelände in lokalen Welten. Integrierte GPUs: max. 128.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Reduziert: fernes Gelände gröber, schneller auf dieser GPU.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Reduziert: fernes Gelände gröber, für GPUs, die sonst bremsen.",
+  "Field of view. Wider shows more terrain at once.": "Sichtfeld. Ein größeres zeigt mehr Gelände auf einmal.",
+  "Caps frames per second; a cap saves power and heat.": "Begrenzt die Bilder pro Sekunde; spart Strom und Wärme.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Wartet auf den Bildaufbau: kein Tearing, etwas Latenz.",
+  "Size of menus and the HUD.": "Größe der Menüs und des HUDs.",
+  "Sets the options below together. Changing one makes it Custom.": "Stellt Optionen darunter ein. Änderung = „Benutzerdefiniert“.",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Lava, Feuer, Sonne heller als Weiß. Braucht HDR-Bildschirm.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Das dunkelste Schwarz deines Bildschirms. 0 für OLED; LCDs leuchten ein wenig.",
+  "How bright highlights get. Auto: the peak your system reports.": "Wie hell Lichter werden. Auto: der Spitzenwert, den dein System meldet.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Wie hell weißes Papier und Menüs aussehen. Auto: das Weiß deines Desktops.",
+  "How bright the HUD and menus are, against paper white.": "Wie hell HUD und Menüs im Vergleich zu Papierweiß sind.",
+  "How far mobs, crops and machines keep working. CPU time.": "Wie weit Kreaturen, Pflanzen und Maschinen weiterarbeiten. Kostet CPU-Zeit.",
+  "How far away mobs and items are drawn, as a share of normal.": "Zeichenweite für Kreaturen und Gegenstände, anteilig zur Norm.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Überspringt Gelände hinter geschlossenen Abschnitten. Aus kostet viel.",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Versteckt Modelle hinter Blöcken. Bei eigenen Paketen ausschalten.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Mesh-Abschnitte pro Bild. Weniger: flüssigeres Laden.",
+  "Soft shadows in corners. Costs chunk building time only.": "Weiche Schatten in Ecken. Kostet nur Zeit beim Chunk-Aufbau.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Kleinere Textur-Kopien für fernes Gelände: weniger Flimmern.",
+  "Blends grass and water colours across biomes when building chunks.": "Mischt Gras- und Wasserfarben über Biome hinweg beim Chunk-Aufbau.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Wolkenschicht: aus, flach (schnell) oder 3D (schön).",
+  "How far clouds reach, in chunks.": "Wie weit Wolken reichen, in Chunks.",
+  "Draws the sky, sun, moon and stars.": "Zeichnet Himmel, Sonne, Mond und Sterne.",
+  "Distance fog. Off shows the edge of the loaded world.": "Nebel in der Ferne. Aus zeigt den Rand der geladenen Welt.",
+  "Draws rain and snow.": "Zeichnet Regen und Schnee.",
+  "How far rain and snow fall around you.": "Wie weit um dich herum Regen und Schnee fallen.",
+  "How many particles effects spawn.": "Wie viele Partikel Effekte erzeugen.",
+  "Round shadows under mobs and items.": "Runde Schatten unter Kreaturen und Gegenständen.",
+  "Leaves with see-through gaps. Off draws them solid.": "Laub mit durchsichtigen Lücken. Aus zeichnet es massiv.",
+  "Sorts water and glass more exactly behind each other.": "Sortiert Wasser und Glas hintereinander genauer.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Welche Chunk-Neuaufbauten auf das Bild warten: keine, nahe oder deine.",
+  "Animates water, lava, fire and other moving textures.": "Animiert Wasser, Lava, Feuer und andere bewegte Texturen.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Weltpixel pro Bildschirmpixel. Unter 100 % ist es auf der GPU schneller.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Glättet Kanten. FXAA: weicher. TAA: am glattesten, evtl. Schlieren.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Rendert die Welt kleiner und baut sie mit TAA wieder auf. Schneller, weicher.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "HDR-Ausgabe auf HDR-Bildschirm: Lava, Feuer, Sonne heller.",
+  "How frames reach the screen while VSync is off.": "Wie Bilder auf den Bildschirm gelangen, wenn VSync aus ist.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Sparsam schläft bis zum nächsten Bild; Präzise wartet aktiv, wie in Vanilla.",
+  "Fills the screen (borderless).": "Füllt den Bildschirm (randlos).",
+  "Brightens dark places.": "Hellt dunkle Orte auf.",
+  "Lowers the frame rate when minimised, or idle too.": "Senkt die Bildrate bei Minimierung oder auch bei Inaktivität.",
+  "Sways the view while walking.": "Lässt die Ansicht beim Gehen schwanken.",
+  "Fades newly loaded chunks in.": "Blendet neu geladene Chunks ein.",
+  "Darkens the screen's edges.": "Dunkelt die Bildschirmränder ab.",
+  "Shows when the world saves.": "Zeigt an, wann die Welt gespeichert wird.",
+  "Shows attack cooldown.": "Zeigt die Angriffsabklingzeit an.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "60 FPS (30 im Menü/ohne Fokus), halb so viele Worker: spart Strom.",
+  "Threads that generate, light and mesh chunks. Next start.": "Threads für Erzeugung, Licht und Mesh der Chunks. Nach Neustart.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, sonst DirectX 12 (Windows) oder OpenGL (Linux). Nach Neustart.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Pro Bild an die GPU gesendete Mesh-Daten. Weniger ist flüssiger beim Laden.",
+  "Frame rate and frame times over the game, with a graph.": "Bildrate und Bildzeiten über dem Spiel, mit Diagramm.",
+  "horizon.multiplayer.finding_friend": "Die Welt deines Freundes wird gesucht …",
+  "horizon.loading.opening_world": "Welt wird geöffnet",
+  "horizon.loading.cancelling_world": "Wird abgebrochen",
+  "horizon.title.not_affiliated": "Nicht mit Mojang oder Microsoft verbunden",
+  "horizon.extras.header.lighting": "Beleuchtung",
+  "horizon.extras.header.third_person": "Dritte Person",
+  "horizon.extras.header.inventory": "Inventar",
+  "horizon.extras.header.multiplayer": "Mehrspieler",
+  "horizon.extras.fullbright": "Maximale Helligkeit",
+  "horizon.extras.dynamic_lights": "Dynamisches Licht",
+  "horizon.extras.own_name_tag": "Eigenes Namensschild",
+  "horizon.extras.auto_reconnect": "Neu verbinden",
+  "horizon.extras.mouse_tweaks": "Mouse Tweaks",
+  "horizon.extras.mouse_tweaks_wheel": "Mausrad-Verschieben",
+  "horizon.extras.sort": "Sortier-Schaltflächen",
+  "horizon.extras.sort_key": "Sortiertaste",
+  "horizon.extras.no_ai": "Keine KI",
+  "horizon.extras.agent_control": "Agentensteuerung",
+  "horizon.extras.discord_presence": "Discord Rich Presence",
+  "horizon.extras.fullbright.tooltip": "Zeigt Blöcke und Objekte bei vollem Licht, selbst an dunklen Orten.",
+  "horizon.extras.dynamic_lights.tooltip": "Fackeln und andere Lichtquellen, die gehalten, fallen gelassen werden oder brennen, beleuchten die Blöcke um sich herum.",
+  "horizon.extras.own_name_tag.tooltip": "Zeigt deinen Namen in der dritten Person über deinem Kopf an, so wie andere Spieler ihn sehen. Versteckt, wenn der Server die Namen deines Teams verbirgt oder du unsichtbar bist.",
+  "horizon.extras.auto_reconnect.tooltip": "Verbindet nach einem Verbindungsabbruch oder Neustart erneut mit dem Server, nie nach einem Rauswurf oder Bann.",
+  "horizon.extras.mouse_tweaks.tooltip": "Mit Rechtsklick ziehen legt je einen pro Feld ab, mit Linksklick ziehen sammelt den gehaltenen Gegenstand, Umschalt + Linksklick ziehen verschiebt jedes Feld.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Nach unten schickt einen Gegenstand des Feldes auf die andere Seite, nach oben holt einen zurück.",
+  "horizon.extras.sort.tooltip": "Sortiert Inventar, Truhen, Fässer, Endertruhen und Shulker-Kisten in der Reihenfolge der Kreativ-Tabs und fasst Stapel zusammen.",
+  "horizon.extras.sort_key.tooltip": "Sortiert den Bereich unter dem Mauszeiger. Klicke, dann drücke eine Taste; Esc hebt die Belegung auf.",
+  "horizon.extras.no_ai.tooltip": "Blendet alle KI-Funktionen aus und schaltet sie ab: Agentensteuerung, horizon-ctl und die MCP-Server. Auch den Schalter des Launchers.",
+  "horizon.extras.agent_control.tooltip": "Dein eigener KI-Agent kann dieses Spiel über horizon-ctl oder einen MCP-Client spielen, nur auf diesem Computer.",
+  "horizon.extras.discord_presence.tooltip": "Zeigt „Spielt Horizon“ in deinem Discord-Profil an, solange Discord läuft: Menüs, Einzel- oder Mehrspielermodus, die Dimension und die Spielzeit. Nie den Namen einer Welt oder die Adresse eines Servers.",
+  "Calibrate...": "Kalibrieren …",
+  "Calibrate Anyway...": "Trotzdem kalibrieren …",
+  "Use Automatic Setup": "Automatische Einrichtung verwenden",
+  "Shortcut: %s": "Tastenkürzel: %s",
+  "Next": "Weiter",
+  "HDR Calibration %s/%s: %s": "HDR-Kalibrierung %s/%s: %s",
+  "Sets the three below full screen, one test picture at a time.": "Stellt die drei Werte darunter im Vollbild ein, jeweils mit einem Testbild.",
+  "A key that opens this screen from the game. Not bound at first.": "Eine Taste, die diesen Bildschirm im Spiel öffnet. Zunächst nicht belegt.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "Bildschirm meldete keine Helligkeit: zum Einrichten kalibrieren.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Bereits eingerichtet. Nur kalibrieren, wenn HDR falsch aussieht.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Stellt Spitzenhelligkeit und Papierweiß des Bildschirms wieder her.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Für den Bildschirm eingerichtet. Auto lassen, wenn es passt.",
+  "Lower it until the logo just disappears into the black.": "Verringere den Wert, bis das Logo gerade im Schwarz verschwindet.",
+  "Raise it until the logo just disappears into the bright square.": "Erhöhe den Wert, bis das Logo gerade im hellen Quadrat verschwindet.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Wähle ein Weiß, das bei deinem Licht lange angenehm ist.",
+  "horizon.splitscreen.profiles.forget": "Entfernen",
+  "horizon.splitscreen.profiles.create": "Erstellen",
+  "horizon.splitscreen.profiles.you": " - du",
+  "horizon.splitscreen.profiles.forget_named": "%s entfernen",
+  "horizon.splitscreen.profiles.previous": "Zurück",
+  "horizon.splitscreen.profiles.next": "Weiter",
+  "horizon.splitscreen.profiles.new_button": "Neues Profil …",
+  "horizon.splitscreen.profiles.forget_title": "Profil entfernen?",
+  "horizon.splitscreen.profiles.forget_leaves": "Es verschwindet aus der Liste dieser Instanz.",
+  "horizon.splitscreen.profiles.forget_kept": "Weltfortschritt und Einstellungen bleiben erhalten.",
+  "horizon.splitscreen.profiles.new_title": "Neues Profil",
+  "horizon.splitscreen.profiles.name_hint": "Name (3 bis 16 Buchstaben, Ziffern, _)",
+  "horizon.splitscreen.profiles.switch_title": "Profil wechseln",
+  "horizon.splitscreen.profiles.offline_note": "Offline-Profile gehören zu dieser Instanz",
+  "horizon.splitscreen.profiles.move": "Spielort wechseln",
+  "horizon.splitscreen.profiles.move_place": "Spielort wechseln: %s",
+  "horizon.friends.title": "Mit Freunden spielen",
+  "horizon.friends.hint": "Freunde fügen den Code nach dem Freunde-Knopf des Titelbildschirms ein, bei „Direktverbindung“ oder auf der Spielen-Seite des Launchers.",
+  "horizon.friends.copied": "Kopiert",
+  "horizon.friends.copy_code": "Code kopieren",
+  "horizon.friends.stop_sharing": "Teilen beenden",
+  "horizon.friends.none_yet": "Noch keine Freunde hier.",
+  "horizon.friends.here_now": "Gerade hier: %s",
+  "horizon.friends.share_intro": "Teile diese Welt mit einem Einladungscode: Sie wird im LAN geöffnet, und Freunde im Internet treten mit dem Code bei. Es ist kein Server von uns beteiligt.",
+  "horizon.friends.start_sharing": "Teilen starten",
+  "horizon.friends.troubleshooting": "Fehlerbehebung …",
+  "horizon.friends.stopped": "Das Teilen des Einladungscodes wurde beendet.",
+  "horizon.friends.short_code_changed": "Jemand hat immer wieder einen falschen Kurzcode versucht, deshalb wurde er geändert.",
+  "horizon.friends.wrong_code": "Jemand hat einen falschen Code versucht.",
+  "horizon.friends.code_ready": "Dein Einladungscode ist bereit: Spielmenü, Mit Freunden spielen. Kopiere ihn und schicke ihn an deine Freunde.",
+  "horizon.friends.share_failed": "Die Welt konnte nicht geteilt werden: %s",
+  "horizon.friends.finding_route": "Es wird ermittelt, wie Freunde dich erreichen können …",
+  "horizon.osk.shift": "Umschalt",
+  "horizon.osk.space": "Leertaste",
+  "horizon.osk.delete": "Löschen",
+  "horizon.osk.type": "Eingeben",
+  "horizon.osk.symbols": "Symbole",
+  "horizon.osk.close": "Schließen",
+  "horizon.multiplayer.not_signed_in": "Dieser Server läuft im Online-Modus. Melde dich im Horizon-Launcher mit deinem Microsoft-Konto an, um ihm beizutreten.",
+  "horizon.multiplayer.invalid_address": "Ungültige Serveradresse: %s",
+  "horizon.multiplayer.connected_friend_direct": "Direkt mit deinem Freund verbunden …",
+  "horizon.multiplayer.connected_friend_relay": "Über das Relay mit deinem Freund verbunden …"
+}
@@ -213,5 +213,98 @@
  "horizon.multiplayer.not_signed_in": "This server is in online mode. Sign in with your Microsoft account in the Horizon launcher to join it.",
  "horizon.multiplayer.invalid_address": "Invalid server address: %s",
  "horizon.multiplayer.connected_friend_direct": "Connected straight to your friend...",
-  "horizon.multiplayer.connected_friend_relay": "Connected to your friend through the relay..."
+  "horizon.multiplayer.connected_friend_relay": "Connected to your friend through the relay...",
+  "horizon.title.not_affiliated": "Not affiliated with Mojang or Microsoft",
+  "horizon.extras.header.lighting": "Lighting",
+  "horizon.extras.header.third_person": "Third person",
+  "horizon.extras.header.particles": "Particles",
+  "horizon.extras.header.inventory": "Inventory",
+  "horizon.extras.header.chat": "Chat",
+  "horizon.extras.header.multiplayer": "Multiplayer",
+  "horizon.extras.header.sound": "Sound",
+  "horizon.extras.fullbright": "Fullbright",
+  "horizon.extras.dynamic_lights": "Dynamic lights",
+  "horizon.extras.own_name_tag": "Own name tag",
+  "horizon.extras.hide_block_particles": "Hide block-break particles",
+  "horizon.extras.auto_reconnect": "Auto-reconnect",
+  "horizon.extras.ui_sound_reserve": "Keep channels for UI sounds",
+  "horizon.extras.mouse_tweaks": "Mouse Tweaks controls",
+  "horizon.extras.mouse_tweaks_wheel": "Scroll wheel moves items",
+  "horizon.extras.sort": "Sort buttons",
+  "horizon.extras.sort_key": "Sort key",
+  "horizon.extras.no_ai": "No AI",
+  "horizon.extras.agent_control": "Agent Control",
+  "horizon.extras.discord_presence": "Discord Rich Presence",
+  "horizon.extras.splitscreen": "Splitscreen",
+  "horizon.extras.chat_animation": "Smooth chat",
+  "horizon.extras.chat_indicator": "Message indicator",
+  "horizon.extras.fullbright.tooltip": "Show blocks and entities at full light, even in dark areas.",
+  "horizon.extras.dynamic_lights.tooltip": "Torches and other light sources held, dropped or on fire light the blocks around them.",
+  "horizon.extras.own_name_tag.tooltip": "Shows your name above your head in third person, as other players see it. Hidden when the server hides your team's names or you're invisible.",
+  "horizon.extras.hide_block_particles.tooltip": "Hides the debris particles that burst from a broken block and crumble off the one you mine. Other particles stay.",
+  "horizon.extras.auto_reconnect.tooltip": "Rejoins a server after a lost connection or a restart, never after a kick or ban.",
+  "horizon.extras.ui_sound_reserve.tooltip": "Sounds in the world leave 16 of the 247 sound channels free, so a flood of them (a big explosion) can't silence menu clicks.",
+  "horizon.extras.mouse_tweaks.tooltip": "Right-drag places one per slot, left-drag gathers the held item, Shift + left-drag moves every slot.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Down sends one item of the slot to the other side, up brings one back.",
+  "horizon.extras.sort.tooltip": "Sorts the inventory, chests, barrels, ender chests and shulker boxes in creative tab order, merging stacks.",
+  "horizon.extras.sort_key.tooltip": "Sorts the part under the cursor. Click, then press a key; Escape unbinds it.",
+  "horizon.extras.no_ai.tooltip": "Hides and turns off every AI feature: agent control, horizon-ctl and the MCP servers. The launcher's switch too.",
+  "horizon.extras.agent_control.tooltip": "Your own AI agent can play this game through horizon-ctl or an MCP client, on this computer only.",
+  "horizon.extras.discord_presence.tooltip": "Shows Playing Horizon on your Discord profile while Discord runs: menus, single player or multiplayer, the dimension and the time played. Never a world's name or a server's address.",
+  "Calibrate...": "Calibrate...",
+  "Calibrate Anyway...": "Calibrate Anyway...",
+  "Use Automatic Setup": "Use Automatic Setup",
+  "Shortcut: %s": "Shortcut: %s",
+  "Next": "Next",
+  "HDR Calibration %s/%s: %s": "HDR Calibration %s/%s: %s",
+  "Sets the three below full screen, one test picture at a time.": "Sets the three below full screen, one test picture at a time.",
+  "A key that opens this screen from the game. Not bound at first.": "A key that opens this screen from the game. Not bound at first.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "Your display didn't say how bright it gets: calibrate to set it up.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Already set up for your display. Only calibrate if HDR looks wrong.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Puts Peak Brightness and Paper White back to your display's setup.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Set up for your display. Leave on Auto unless it looks wrong.",
+  "Lower it until the logo just disappears into the black.": "Lower it until the logo just disappears into the black.",
+  "Raise it until the logo just disappears into the bright square.": "Raise it until the logo just disappears into the bright square.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Make the card a white that's comfortable to look at for a long time, in the light you play in.",
+  "horizon.splitscreen.profiles.forget": "Forget",
+  "horizon.splitscreen.profiles.create": "Create",
+  "horizon.splitscreen.profiles.you": " - you",
+  "horizon.splitscreen.profiles.forget_named": "Forget %s",
+  "horizon.splitscreen.profiles.previous": "Previous",
+  "horizon.splitscreen.profiles.next": "Next",
+  "horizon.splitscreen.profiles.new_button": "New Profile...",
+  "horizon.splitscreen.profiles.forget_title": "Forget profile?",
+  "horizon.splitscreen.profiles.forget_leaves": "It leaves this instance's list.",
+  "horizon.splitscreen.profiles.forget_kept": "World progress and settings are kept.",
+  "horizon.splitscreen.profiles.new_title": "New Profile",
+  "horizon.splitscreen.profiles.name_hint": "Name (3 to 16 letters, digits, _)",
+  "horizon.splitscreen.profiles.switch_title": "Switch profile",
+  "horizon.splitscreen.profiles.offline_note": "Offline profiles belong to this instance",
+  "horizon.splitscreen.profiles.move": "Move where you play",
+  "horizon.splitscreen.profiles.move_place": "Move where you play: %s",
+  "horizon.friends.title": "Play with Friends",
+  "horizon.friends.hint": "Friends paste the code after the title screen's Friends button, in Direct Connection, or on the launcher's Play page.",
+  "horizon.friends.copied": "Copied",
+  "horizon.friends.copy_code": "Copy Code",
+  "horizon.friends.stop_sharing": "Stop Sharing",
+  "horizon.friends.none_yet": "No friends here yet.",
+  "horizon.friends.here_now": "Here now: %s",
+  "horizon.friends.share_intro": "Share this world behind an invite code: it opens to LAN, and friends on the internet join with the code. No server of ours is involved.",
+  "horizon.friends.start_sharing": "Start Sharing",
+  "horizon.friends.troubleshooting": "Troubleshooting...",
+  "horizon.friends.stopped": "Stopped sharing the invite code.",
+  "horizon.friends.short_code_changed": "Someone kept trying a wrong short code, so it changed.",
+  "horizon.friends.wrong_code": "Someone tried a wrong code.",
+  "horizon.friends.code_ready": "Your invite code is ready: Game Menu, Play with Friends. Copy it and send it to your friends.",
+  "horizon.friends.share_failed": "Couldn't share the world: %s",
+  "horizon.friends.finding_route": "Finding how friends can reach you…",
+  "horizon.osk.shift": "Shift",
+  "horizon.osk.space": "Space",
+  "horizon.osk.delete": "Delete",
+  "horizon.osk.type": "Type",
+  "horizon.osk.symbols": "Symbols",
+  "horizon.osk.close": "Close",
+  "horizon.extras.chat_animation.tooltip": "A new chat line slides in from the left while it fades in, instead of appearing whole.",
+  "horizon.extras.chat_indicator.tooltip": "The coloured bar at the left of a chat line.",
+  "horizon.extras.splitscreen.tooltip": "In a world, another controller can join as a new player: press A when it asks, then pick a profile and where to play."
 }
@@ -203,5 +203,11 @@
  "horizon.multiplayer.not_signed_in": "Este servidor está en modo en línea. Inicia sesión con tu cuenta de Microsoft en el launcher de Horizon para unirte.",
  "horizon.multiplayer.invalid_address": "Dirección de servidor no válida: %s",
  "horizon.multiplayer.connected_friend_direct": "Conectado directamente con tu amigo…",
-  "horizon.multiplayer.connected_friend_relay": "Conectado con tu amigo a través del relé…"
+  "horizon.multiplayer.connected_friend_relay": "Conectado con tu amigo a través del relé…",
+  "horizon.pages.shader_options": "Opciones de sombreadores",
+  "horizon.pages.split_profiles": "¿Quién juega?",
+  "horizon.pages.split_profiles.tooltip": "Quién juega: un perfil guardado en esta carpeta del juego.",
+  "horizon.shader_options.open": "Opciones de sombreadores…",
+  "horizon.shader_options.profile": "Perfil",
+  "horizon.shader_options.loading": "Leyendo las opciones del paquete de sombreadores…"
 }
@@ -0,0 +1,293 @@
+{
+  "horizon.options.controller": "Manette",
+  "horizon.options.vibration": "Vibrations",
+  "horizon.options.adaptive_triggers": "Gâchettes adaptatives",
+  "horizon.options.lightbar": "Barre lumineuse",
+  "horizon.options.look_sensitivity": "Sensibilité de la vue",
+  "horizon.options.invert_x": "Inverser l'axe X de la vue",
+  "horizon.options.invert_y": "Inverser l'axe Y de la vue",
+  "horizon.options.sneak_button": "Bouton pour s'accroupir",
+  "horizon.options.move_deadzone": "Zone morte du déplacement",
+  "horizon.options.look_deadzone": "Zone morte de la vue",
+  "horizon.options.button_glyphs": "Symboles des boutons",
+  "horizon.options.menu_navigation": "Navigation dans les menus",
+  "horizon.options.on_screen_keyboard": "Clavier à l'écran",
+  "horizon.options.chat_delay": "Délai du tchat",
+  "horizon.options.lightbar.health": "Santé",
+  "horizon.options.lightbar.dimension": "Dimension",
+  "horizon.options.glyphs.auto": "Auto",
+  "horizon.options.glyphs.xbox": "Xbox",
+  "horizon.options.glyphs.playstation": "PlayStation",
+  "horizon.options.glyphs.nintendo": "Nintendo",
+  "horizon.options.menu_focus": "Focus",
+  "horizon.options.menu_pointer": "Pointeur",
+  "horizon.options.keyboard.auto": "Auto",
+  "horizon.options.keyboard.horizon": "Horizon",
+  "horizon.options.keyboard.steam": "Steam",
+  "horizon.options.unavailable": "Cette fonction n'est pas encore disponible dans Horizon.",
+  "horizon.options.search": "Rechercher une option...",
+  "horizon.pages.mods": "Mods",
+  "horizon.pages.shader_packs": "Packs de shaders",
+  "horizon.pages.shader_options": "Options des shaders",
+  "horizon.pages.controller": "Options de la manette",
+  "horizon.pages.controller_binds": "Assignation des boutons de la manette",
+  "horizon.pages.extras": "Extras Horizon",
+  "horizon.pages.settings": "Options Horizon",
+  "horizon.pages.agent": "Agent IA",
+  "horizon.pages.split_profiles": "Qui joue ?",
+  "horizon.pages.settings.tooltip": "Les options propres à Horizon : graphismes, manettes, extras et mods.",
+  "horizon.pages.graphics.tooltip": "Les graphismes, simplement : chaque réglage indique son coût.",
+  "horizon.pages.graphics_advanced.tooltip": "Tous les réglages graphiques, y compris ceux d'Horizon, avec le coût de chacun.",
+  "horizon.pages.controller.tooltip": "Les manettes : leurs boutons, leurs sticks, les vibrations et la navigation dans les menus.",
+  "horizon.pages.extras.tooltip": "Ajouts facultatifs, tous désactivés par défaut : le jeu reste vanilla tant que vous n'en activez pas un.",
+  "horizon.pages.agent.tooltip": "Laissez votre propre agent IA jouer : horizon-ctl et les clients MCP sur cet ordinateur.",
+  "horizon.pages.split_profiles.tooltip": "Qui joue : un profil conservé dans ce dossier de jeu.",
+  "horizon.pages.shader_packs.tooltip": "Packs de shaders du dossier shaderpacks : ceux d'Horizon et ceux au format shaders/. Un seul fonctionne à la fois.",
+  "horizon.pages.mods.tooltip": "Mods conçus pour Horizon, du dossier horizon-mods. Chacun s'exécute dans un bac à sable et reste désactivé tant que vous ne l'activez pas.",
+  "horizon.pages.open.graphics": "Graphismes...",
+  "horizon.pages.open.graphics_advanced": "Graphismes avancés...",
+  "horizon.pages.open.shader_packs": "Packs de shaders...",
+  "horizon.pages.open.controller": "Options de la manette...",
+  "horizon.pages.open.extras": "Extras...",
+  "horizon.pages.open.mods": "Mods...",
+  "horizon.pages.open.agent": "Agent IA...",
+  "horizon.pages.open.horizon_graphics": "Graphismes Horizon...",
+  "horizon.pages.open.controller_binds": "Boutons manette...",
+  "horizon.pages.open.horizon_settings": "Options Horizon...",
+  "horizon.mods.empty": "Aucun mod : placez des fichiers .hmod dans le dossier horizon-mods",
+  "horizon.mods.stopped": " (arrêté)",
+  "horizon.mods.not_built": " (non compilé)",
+  "horizon.mods.dev": " (dév.)",
+  "horizon.mods.settings": "Options",
+  "horizon.mods.open_folder": "Ouvrir le dossier des mods",
+  "horizon.shader_packs.empty": "Aucun pack de shaders : placez-les dans le dossier shaderpacks",
+  "horizon.shader_packs.kind_horizon": " (Horizon)",
+  "horizon.shader_options.open": "Options des shaders...",
+  "horizon.shader_options.profile": "Profil",
+  "horizon.shader_options.loading": "Lecture des options du pack de shaders...",
+  "horizon.agent.copy_details": "Copier les détails de connexion",
+  "horizon.multiplayer.join": "Rejoindre",
+  "horizon.multiplayer.cancel_reconnecting": "Annuler la reconnexion",
+  "horizon.multiplayer.join_friend": "Rejoindre un ami",
+  "horizon.multiplayer.invite_code": "Code d'invitation",
+  "horizon.multiplayer.relay": "Relais (facultatif)",
+  "Preset": "Préréglage",
+  "LOD Distance": "Distance LOD",
+  "Far Detail": "Détails lointains",
+  "Cave Culling": "Occlusion des grottes",
+  "Entity Culling": "Occlusion des entités",
+  "Chunk Updates": "MàJ chunks",
+  "Upload Budget": "Transfert",
+  "Sky": "Ciel",
+  "Fog": "Brouillard",
+  "Weather": "Météo",
+  "Animated Textures": "Textures animées",
+  "Present Mode": "Présentation",
+  "Frame Pacing": "Rythme des images",
+  "Worker Threads": "Threads",
+  "Resolution Scale": "Échelle de résolution",
+  "Anti-aliasing": "Anticrénelage",
+  "Upscaling": "Upscaling",
+  "HDR Settings...": "Options HDR...",
+  "Paper White": "Point blanc",
+  "Peak Brightness": "Luminosité max.",
+  "Black Level": "Niveau de noir",
+  "UI Brightness": "Luminosité UI",
+  "Battery Mode": "Mode batterie",
+  "Graphics API": "API graphique",
+  "Performance Overlay": "Infos de perfs",
+  "Full Detail Distance": "Dist. détail",
+  "On": "Oui",
+  "Off": "Non",
+  "Unlimited": "Illimité",
+  "Auto": "Auto",
+  "Custom": "Personnalisé",
+  "Performance": "Performances",
+  "Balanced": "Équilibré",
+  "Quality": "Qualité",
+  "Ultra": "Ultra",
+  "Ultra Performance": "Ultra perfs",
+  "Native": "Native",
+  "Full": "Complet",
+  "Reduced": "Réduit",
+  "Efficient": "Économe",
+  "Precise": "Précis",
+  "Auto (VSync)": "Auto (VSync)",
+  "FIFO": "FIFO",
+  "Mailbox": "Mailbox",
+  "Immediate": "Immediate",
+  "Vulkan": "Vulkan",
+  "DirectX 12": "DirectX 12",
+  "OpenGL": "OpenGL",
+  "FPS and Graph": "FPS et graphique",
+  "FPS": "FPS",
+  "TAA": "TAA",
+  "FXAA": "FXAA",
+  "No cost": "Aucun coût",
+  "Low cost": "Coût faible",
+  "Medium cost": "Coût moyen",
+  "High cost": "Coût élevé",
+  "Saves time": "Fait gagner du temps",
+  "Rendering": "Rendu",
+  "Display": "Affichage",
+  "Preferences": "Préférences",
+  "Overlay": "Surimpression",
+  "HDR": "HDR",
+  "Graphics": "Graphismes",
+  "Graphics: Advanced": "Graphismes : avancés",
+  "Graphics: HDR": "Graphismes : HDR",
+  "Advanced...": "Avancé...",
+  "Simple...": "Simple...",
+  "Done": "Terminé",
+  "This feature is not yet available in Horizon.": "Cette fonction n'est pas encore disponible dans Horizon.",
+  "Your display or system doesn't offer HDR output.": "Votre écran ou votre système ne propose pas de sortie HDR.",
+  "Turn HDR on to use it.": "Activez le HDR pour l'utiliser.",
+  "%s chunks": "%s chunks",
+  "%s per frame": "%s par image",
+  "%s MiB/frame": "%s MiB/image",
+  "%s KiB/frame": "%s KiB/image",
+  "%s nits": "%s nits",
+  "Auto (%s)": "Auto (%s)",
+  "Auto (%s nits)": "Auto (%s nits)",
+  "%.2f nits": "%.2f nits",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Terrain en détail complet. La distance LOD va plus loin.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Terrain lointain simplifié, mondes locaux. GPU intégrés : 128 max.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Réduit : terrain lointain simplifié, plus rapide sur ce GPU.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Réduit : terrain simplifié, pour les GPU qui ralentissent.",
+  "Field of view. Wider shows more terrain at once.": "Champ de vision. Plus large, il montre plus de terrain à la fois.",
+  "Caps frames per second; a cap saves power and heat.": "Limite les images par seconde ; économise énergie et chaleur.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Attend l'écran : pas de déchirure, un peu de latence.",
+  "Size of menus and the HUD.": "Taille des menus et de l'interface (HUD).",
+  "Sets the options below together. Changing one makes it Custom.": "Règle les options ci-dessous. Modifier une : « Personnalisé ».",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Lave, feu et soleil plus vifs que le blanc. Écran HDR requis.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Noir le plus profond de l'écran. 0 pour OLED, les LCD brillent.",
+  "How bright highlights get. Auto: the peak your system reports.": "La luminosité des hautes lumières. Auto : le pic indiqué par votre système.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Luminosité du blanc et des menus. Auto : blanc du bureau.",
+  "How bright the HUD and menus are, against paper white.": "La luminosité du HUD et des menus, par rapport au blanc papier.",
+  "How far mobs, crops and machines keep working. CPU time.": "Portée d'activité des créatures, cultures, machines. Coût : CPU.",
+  "How far away mobs and items are drawn, as a share of normal.": "Distance des créatures et objets, en part de la normale.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Ignore le terrain caché. Désactiver coûte cher.",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Masque les modèles derrière les blocs. Éteindre avec packs.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Sections maillées par image. Moins : chargement plus fluide.",
+  "Soft shadows in corners. Costs chunk building time only.": "Ombres douces dans les coins. Coût : construction des chunks.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Textures réduites au loin : moins de scintillement.",
+  "Blends grass and water colours across biomes when building chunks.": "Fond les couleurs d'herbe et d'eau entre les biomes.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Couche de nuages : désactivée, plate (rapide) ou 3D (détaillée).",
+  "How far clouds reach, in chunks.": "Jusqu'où s'étendent les nuages, en chunks.",
+  "Draws the sky, sun, moon and stars.": "Dessine le ciel, le soleil, la lune et les étoiles.",
+  "Distance fog. Off shows the edge of the loaded world.": "Brouillard lointain. Désactivé, il montre le bord du monde chargé.",
+  "Draws rain and snow.": "Dessine la pluie et la neige.",
+  "How far rain and snow fall around you.": "Jusqu'où la pluie et la neige tombent autour de vous.",
+  "How many particles effects spawn.": "Combien de particules les effets génèrent.",
+  "Round shadows under mobs and items.": "Ombres rondes sous les créatures et les objets.",
+  "Leaves with see-through gaps. Off draws them solid.": "Feuilles avec des trous transparents. Désactivé, elles sont pleines.",
+  "Sorts water and glass more exactly behind each other.": "Trie plus précisément l'eau et le verre les uns derrière les autres.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Quels chunks attendent l'image : aucun, proches ou les vôtres.",
+  "Animates water, lava, fire and other moving textures.": "Anime l'eau, la lave, le feu et les autres textures mobiles.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Pixels du monde par pixel d'écran. Sous 100 %, GPU plus rapide.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Lisse les bords. FXAA : doux. TAA : lisse, traînées possibles.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Rendu réduit, reconstruit par TAA. Plus rapide, plus doux.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "Sortie HDR sur écran HDR : lave, feu et soleil plus vifs.",
+  "How frames reach the screen while VSync is off.": "Comment les images arrivent à l'écran sans synchro verticale.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Économe attend l'image suivante ; Précis tourne en boucle.",
+  "Fills the screen (borderless).": "Remplit l'écran (sans bordure).",
+  "Brightens dark places.": "Éclaircit les endroits sombres.",
+  "Lowers the frame rate when minimised, or idle too.": "Réduit les FPS si la fenêtre est réduite, ou aussi inactive.",
+  "Sways the view while walking.": "Fait osciller la vue pendant la marche.",
+  "Fades newly loaded chunks in.": "Fait apparaître en fondu les chunks nouvellement chargés.",
+  "Darkens the screen's edges.": "Assombrit les bords de l'écran.",
+  "Shows when the world saves.": "Indique quand le monde est sauvegardé.",
+  "Shows attack cooldown.": "Affiche le délai de recharge de l'attaque.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "60 FPS max (30 en menu/sans focus), moitié de threads : économie.",
+  "Threads that generate, light and mesh chunks. Next start.": "Threads de génération, lumière et maillage. Au redémarrage.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, sinon DirectX 12 (Windows) ou OpenGL (Linux). Au redémarrage.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Données de maillage vers le GPU par image. Moins : plus fluide.",
+  "Frame rate and frame times over the game, with a graph.": "Fréquence et temps d'image par-dessus le jeu, avec un graphique.",
+  "horizon.multiplayer.finding_friend": "Recherche du monde de votre ami...",
+  "horizon.loading.opening_world": "Ouverture du monde",
+  "horizon.loading.cancelling_world": "Annulation en cours",
+  "horizon.title.not_affiliated": "Non affilié à Mojang ou à Microsoft",
+  "horizon.extras.header.lighting": "Éclairage",
+  "horizon.extras.header.third_person": "Troisième personne",
+  "horizon.extras.header.inventory": "Inventaire",
+  "horizon.extras.header.multiplayer": "Multijoueur",
+  "horizon.extras.fullbright": "Pleine luminosité",
+  "horizon.extras.dynamic_lights": "Lumières dynamiques",
+  "horizon.extras.own_name_tag": "Mon pseudo",
+  "horizon.extras.auto_reconnect": "Reconnexion auto",
+  "horizon.extras.mouse_tweaks": "Mouse Tweaks",
+  "horizon.extras.mouse_tweaks_wheel": "Déplacer à la molette",
+  "horizon.extras.sort": "Boutons de tri",
+  "horizon.extras.sort_key": "Touche de tri",
+  "horizon.extras.no_ai": "Sans IA",
+  "horizon.extras.agent_control": "Contrôle par agent",
+  "horizon.extras.discord_presence": "Discord Rich Presence",
+  "horizon.extras.fullbright.tooltip": "Affiche les blocs et les entités en pleine lumière, même dans les zones sombres.",
+  "horizon.extras.dynamic_lights.tooltip": "Les torches et autres sources de lumière tenues en main, jetées ou en feu éclairent les blocs autour d'elles.",
+  "horizon.extras.own_name_tag.tooltip": "Affiche votre nom au-dessus de votre tête à la troisième personne, comme les autres joueurs le voient. Masqué quand le serveur masque les noms de votre équipe ou que vous êtes invisible.",
+  "horizon.extras.auto_reconnect.tooltip": "Rejoint de nouveau un serveur après une perte de connexion ou un redémarrage, jamais après une expulsion ou un bannissement.",
+  "horizon.extras.mouse_tweaks.tooltip": "Glisser avec le clic droit en place un par case, glisser avec le clic gauche rassemble l'objet tenu, Maj + glisser avec le clic gauche déplace chaque case.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Vers le bas, envoie un objet de la case de l'autre côté ; vers le haut, en ramène un.",
+  "horizon.extras.sort.tooltip": "Trie l'inventaire, les coffres, les tonneaux, les coffres de l'Ender et les boîtes de Shulker selon l'ordre des onglets du mode créatif, en fusionnant les piles.",
+  "horizon.extras.sort_key.tooltip": "Trie la zone sous le curseur. Cliquez, puis appuyez sur une touche ; Échap retire l'assignation.",
+  "horizon.extras.no_ai.tooltip": "Masque et désactive toutes les fonctions d'IA : contrôle par agent, horizon-ctl et les serveurs MCP. Le commutateur du lanceur aussi.",
+  "horizon.extras.agent_control.tooltip": "Votre propre agent IA peut jouer à ce jeu via horizon-ctl ou un client MCP, uniquement sur cet ordinateur.",
+  "horizon.extras.discord_presence.tooltip": "Affiche « Joue à Horizon » sur votre profil Discord tant que Discord fonctionne : menus, solo ou multijoueur, la dimension et le temps de jeu. Jamais le nom d'un monde ni l'adresse d'un serveur.",
+  "Calibrate...": "Calibrer...",
+  "Calibrate Anyway...": "Calibrer quand même...",
+  "Use Automatic Setup": "Utiliser la configuration automatique",
+  "Shortcut: %s": "Raccourci : %s",
+  "Next": "Suivant",
+  "HDR Calibration %s/%s: %s": "Calibrage HDR %s/%s : %s",
+  "Sets the three below full screen, one test picture at a time.": "Règle les trois valeurs ci-dessous en plein écran, une image test à la fois.",
+  "A key that opens this screen from the game. Not bound at first.": "Une touche qui ouvre cet écran depuis le jeu. Non assignée au départ.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "Votre écran n'a pas indiqué sa luminosité : calibrez-le.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Déjà configuré. Calibrez seulement si le HDR semble incorrect.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Rétablit Luminosité max. et Point blanc de votre écran.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Configuré pour votre écran. Laissez Auto si tout va bien.",
+  "Lower it until the logo just disappears into the black.": "Baissez-le jusqu'à ce que le logo disparaisse tout juste dans le noir.",
+  "Raise it until the logo just disappears into the bright square.": "Augmentez jusqu'à ce que le logo se fonde dans le carré clair.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Un blanc agréable à regarder longtemps, selon votre éclairage.",
+  "horizon.splitscreen.profiles.forget": "Oublier",
+  "horizon.splitscreen.profiles.create": "Créer",
+  "horizon.splitscreen.profiles.you": " - vous",
+  "horizon.splitscreen.profiles.forget_named": "Oublier %s",
+  "horizon.splitscreen.profiles.previous": "Précédent",
+  "horizon.splitscreen.profiles.next": "Suivant",
+  "horizon.splitscreen.profiles.new_button": "Nouveau profil...",
+  "horizon.splitscreen.profiles.forget_title": "Oublier le profil ?",
+  "horizon.splitscreen.profiles.forget_leaves": "Il quitte la liste de cette instance.",
+  "horizon.splitscreen.profiles.forget_kept": "La progression des mondes et les options sont conservées.",
+  "horizon.splitscreen.profiles.new_title": "Nouveau profil",
+  "horizon.splitscreen.profiles.name_hint": "Nom (3 à 16 lettres, chiffres ou _)",
+  "horizon.splitscreen.profiles.switch_title": "Changer de profil",
+  "horizon.splitscreen.profiles.offline_note": "Les profils hors ligne appartiennent à cette instance",
+  "horizon.splitscreen.profiles.move": "Changer d'emplacement de jeu",
+  "horizon.splitscreen.profiles.move_place": "Changer d'emplacement de jeu : %s",
+  "horizon.friends.title": "Jouer avec des amis",
+  "horizon.friends.hint": "Vos amis collent le code après le bouton Amis de l'écran titre, dans « Connexion rapide » ou sur la page Jouer du lanceur.",
+  "horizon.friends.copied": "Copié",
+  "horizon.friends.copy_code": "Copier le code",
+  "horizon.friends.stop_sharing": "Arrêter le partage",
+  "horizon.friends.none_yet": "Aucun ami pour l'instant.",
+  "horizon.friends.here_now": "Présents : %s",
+  "horizon.friends.share_intro": "Partagez ce monde avec un code d'invitation : il s'ouvre au LAN, et vos amis sur internet le rejoignent avec le code. Aucun serveur de notre part n'est impliqué.",
+  "horizon.friends.start_sharing": "Commencer le partage",
+  "horizon.friends.troubleshooting": "Dépannage...",
+  "horizon.friends.stopped": "Le partage du code d'invitation est arrêté.",
+  "horizon.friends.short_code_changed": "Quelqu'un a essayé plusieurs fois un mauvais code court, il a donc été changé.",
+  "horizon.friends.wrong_code": "Quelqu'un a essayé un mauvais code.",
+  "horizon.friends.code_ready": "Votre code d'invitation est prêt : Menu du jeu, Jouer avec des amis. Copiez-le et envoyez-le à vos amis.",
+  "horizon.friends.share_failed": "Impossible de partager le monde : %s",
+  "horizon.friends.finding_route": "Recherche de la manière dont vos amis peuvent vous joindre…",
+  "horizon.osk.shift": "Maj.",
+  "horizon.osk.space": "Espace",
+  "horizon.osk.delete": "Effacer",
+  "horizon.osk.type": "Saisir",
+  "horizon.osk.symbols": "Symboles",
+  "horizon.osk.close": "Fermer",
+  "horizon.multiplayer.not_signed_in": "Ce serveur est en mode en ligne. Connectez-vous avec votre compte Microsoft dans le lanceur Horizon pour le rejoindre.",
+  "horizon.multiplayer.invalid_address": "Adresse de serveur invalide : %s",
+  "horizon.multiplayer.connected_friend_direct": "Connecté directement à votre ami...",
+  "horizon.multiplayer.connected_friend_relay": "Connecté à votre ami via le relais..."
+}
@@ -12,11 +12,282 @@
  "horizon.options.button_glyphs": "Symbole przycisków",
  "horizon.options.menu_navigation": "Nawigacja po menu",
  "horizon.options.on_screen_keyboard": "Klawiatura ekranowa",
+  "horizon.options.chat_delay": "Opóźnienie czatu",
+  "horizon.options.lightbar.health": "Zdrowie",
+  "horizon.options.lightbar.dimension": "Wymiar",
+  "horizon.options.glyphs.auto": "Auto",
+  "horizon.options.glyphs.xbox": "Xbox",
+  "horizon.options.glyphs.playstation": "PlayStation",
+  "horizon.options.glyphs.nintendo": "Nintendo",
+  "horizon.options.menu_focus": "Fokus",
+  "horizon.options.menu_pointer": "Wskaźnik",
+  "horizon.options.keyboard.auto": "Auto",
+  "horizon.options.keyboard.horizon": "Horizon",
+  "horizon.options.keyboard.steam": "Steam",
+  "horizon.options.unavailable": "Ta funkcja nie jest jeszcze dostępna w Horizon.",
+  "horizon.options.search": "Szukaj ustawień…",
+  "horizon.pages.mods": "Mody",
+  "horizon.pages.shader_packs": "Paczki shaderów",
+  "horizon.pages.shader_options": "Ustawienia shaderów",
+  "horizon.pages.controller": "Ustawienia kontrolera",
+  "horizon.pages.controller_binds": "Przypisane przyciski kontrolera",
+  "horizon.pages.extras": "Dodatki Horizon",
+  "horizon.pages.settings": "Ustawienia Horizon",
+  "horizon.pages.agent": "Agent AI",
+  "horizon.pages.split_profiles": "Kto gra?",
+  "horizon.pages.settings.tooltip": "Własne ustawienia Horizon: grafika, kontrolery, dodatki i mody.",
+  "horizon.pages.graphics.tooltip": "Grafika w prostej formie: każde ustawienie podaje swój koszt.",
+  "horizon.pages.graphics_advanced.tooltip": "Wszystkie ustawienia grafiki, także te z Horizon, wraz z kosztem każdego z nich.",
+  "horizon.pages.controller.tooltip": "Kontrolery: ich przyciski, drążki, wibracje i nawigacja po menu.",
+  "horizon.pages.extras.tooltip": "Opcjonalne dodatki, wszystkie domyślnie wyłączone: gra pozostaje vanilla, dopóki nie włączysz któregoś.",
+  "horizon.pages.agent.tooltip": "Pozwól własnemu agentowi AI grać: horizon-ctl i klienci MCP na tym komputerze.",
+  "horizon.pages.split_profiles.tooltip": "Kto gra: profil przechowywany w tym folderze gry.",
+  "horizon.pages.shader_packs.tooltip": "Paczki shaderów z folderu shaderpacks: własne paczki Horizon i te w formacie shaders/. Naraz działa jedna.",
+  "horizon.pages.mods.tooltip": "Mody stworzone dla Horizon, z folderu horizon-mods. Każdy działa w piaskownicy i pozostaje wyłączony, dopóki go nie włączysz.",
+  "horizon.pages.open.graphics": "Grafika…",
+  "horizon.pages.open.graphics_advanced": "Zaawansowana grafika…",
+  "horizon.pages.open.shader_packs": "Paczki shaderów…",
+  "horizon.pages.open.controller": "Ustawienia kontrolera…",
+  "horizon.pages.open.extras": "Dodatki…",
+  "horizon.pages.open.mods": "Mody…",
+  "horizon.pages.open.agent": "Agent AI…",
+  "horizon.pages.open.horizon_graphics": "Grafika Horizon…",
+  "horizon.pages.open.controller_binds": "Przyciski kontrolera…",
+  "horizon.pages.open.horizon_settings": "Ustawienia Horizon…",
+  "horizon.mods.empty": "Brak modów: umieść pliki .hmod w folderze horizon-mods",
+  "horizon.mods.stopped": " (zatrzymany)",
+  "horizon.mods.not_built": " (niezbudowany)",
+  "horizon.mods.dev": " (dev)",
+  "horizon.mods.settings": "Ustawienia",
+  "horizon.mods.open_folder": "Otwórz folder z modami",
+  "horizon.shader_packs.empty": "Brak paczek shaderów: umieść je w folderze shaderpacks",
+  "horizon.shader_packs.kind_horizon": " (Horizon)",
+  "horizon.shader_options.open": "Ustawienia shaderów…",
+  "horizon.shader_options.profile": "Profil",
+  "horizon.shader_options.loading": "Wczytywanie ustawień paczki shaderów…",
+  "horizon.agent.copy_details": "Kopiuj dane połączenia",
+  "horizon.multiplayer.join": "Dołącz",
+  "horizon.multiplayer.cancel_reconnecting": "Anuluj ponowne łączenie",
+  "horizon.multiplayer.join_friend": "Dołącz do znajomego",
+  "horizon.multiplayer.invite_code": "Kod zaproszenia",
+  "horizon.multiplayer.relay": "Przekaźnik (opcjonalnie)",
+  "Preset": "Profil",
+  "LOD Distance": "Zasięg LOD",
+  "Far Detail": "Dalekie detale",
+  "Cave Culling": "Pomijanie jaskiń",
+  "Entity Culling": "Pomijanie bytów",
+  "Chunk Updates": "Aktual. chunków",
+  "Upload Budget": "Wysyłka",
+  "Sky": "Niebo",
+  "Fog": "Mgła",
+  "Weather": "Pogoda",
+  "Animated Textures": "Animowane tekstury",
+  "Present Mode": "Prezentacja",
+  "Frame Pacing": "Tempo klatek",
+  "Worker Threads": "Wątki robocze",
+  "Resolution Scale": "Skala rozdzielczości",
+  "Anti-aliasing": "Antyaliasing",
+  "Upscaling": "Skalowanie",
+  "HDR Settings...": "Ustawienia HDR…",
+  "Paper White": "Punkt bieli",
+  "Peak Brightness": "Jasność maks.",
+  "Black Level": "Poziom czerni",
+  "UI Brightness": "Jasność interfejsu",
+  "Battery Mode": "Tryb baterii",
+  "Graphics API": "API grafiki",
+  "Performance Overlay": "Nakładka wydajności",
+  "Full Detail Distance": "Zasięg detali",
+  "On": "Wł.",
+  "Off": "Wył.",
+  "Unlimited": "Bez limitu",
+  "Auto": "Auto",
+  "Custom": "Własne",
+  "Performance": "Wydajność",
+  "Balanced": "Zrównoważone",
+  "Quality": "Jakość",
+  "Ultra": "Ultra",
+  "Ultra Performance": "Ultra wydajność",
+  "Native": "Natywna",
+  "Full": "Pełne",
+  "Reduced": "Ograniczone",
+  "Efficient": "Oszczędne",
+  "Precise": "Dokładne",
+  "Auto (VSync)": "Auto (VSync)",
+  "FIFO": "FIFO",
+  "Mailbox": "Mailbox",
+  "Immediate": "Immediate",
+  "Vulkan": "Vulkan",
+  "DirectX 12": "DirectX 12",
+  "OpenGL": "OpenGL",
+  "FPS and Graph": "FPS i wykres",
+  "FPS": "FPS",
+  "TAA": "TAA",
+  "FXAA": "FXAA",
+  "No cost": "Bez kosztu",
+  "Low cost": "Niski koszt",
+  "Medium cost": "Średni koszt",
+  "High cost": "Wysoki koszt",
+  "Saves time": "Oszczędza czas",
+  "Rendering": "Renderowanie",
+  "Display": "Wyświetlanie",
+  "Preferences": "Preferencje",
+  "Overlay": "Nakładka",
+  "HDR": "HDR",
+  "Graphics": "Grafika",
+  "Graphics: Advanced": "Grafika: zaawansowane",
+  "Graphics: HDR": "Grafika: HDR",
+  "Advanced...": "Zaawansowane…",
+  "Simple...": "Proste…",
+  "Done": "Gotowe",
+  "This feature is not yet available in Horizon.": "Ta funkcja nie jest jeszcze dostępna w Horizon.",
+  "Your display or system doesn't offer HDR output.": "Twój wyświetlacz lub system nie obsługuje wyjścia HDR.",
+  "Turn HDR on to use it.": "Włącz HDR, aby tego użyć.",
+  "%s chunks": "%s chunków",
+  "%s per frame": "%s na klatkę",
+  "%s MiB/frame": "%s MiB/klatka",
+  "%s KiB/frame": "%s KiB/klatka",
+  "%s nits": "%s nitów",
+  "Auto (%s)": "Auto (%s)",
+  "Auto (%s nits)": "Auto (%s nitów)",
+  "%.2f nits": "%.2f nitów",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Zasięg terenu w pełnych szczegółach. Zasięg LOD sięga dalej.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Uproszczony odległy teren w światach lokalnych. Zintegr. GPU: do 128.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Ograniczone: odległy teren rysowany prościej, szybciej na tym GPU.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Ograniczone: odległy teren prościej, dla GPU, które zwalniają.",
+  "Field of view. Wider shows more terrain at once.": "Pole widzenia. Szersze pokazuje naraz więcej terenu.",
+  "Caps frames per second; a cap saves power and heat.": "Ogranicza klatki na sekundę; limit oszczędza energię i ciepło.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Czeka na odświeżenie ekranu: bez rozrywania obrazu, z niewielkim opóźnieniem.",
+  "Size of menus and the HUD.": "Rozmiar menu i interfejsu HUD.",
+  "Sets the options below together. Changing one makes it Custom.": "Ustawia razem poniższe opcje. Zmiana jednej zmienia na „Własne”.",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Lawa, ogień i słońce świecą jaśniej niż biel. Wymaga ekranu HDR.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Najciemniejsza czerń twojego wyświetlacza. 0 dla OLED; LCD trochę się świecą.",
+  "How bright highlights get. Auto: the peak your system reports.": "Jak jasne mogą być światła. Auto: szczyt zgłaszany przez system.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Jak jasny wygląda biały papier i menu. Auto: biel twojego pulpitu.",
+  "How bright the HUD and menus are, against paper white.": "Jak jasne są HUD i menu w stosunku do bieli papieru.",
+  "How far mobs, crops and machines keep working. CPU time.": "Jak daleko stworzenia, uprawy i maszyny nadal działają. Czas procesora.",
+  "How far away mobs and items are drawn, as a share of normal.": "Odległość rysowania stworzeń i przedmiotów, jako ułamek normy.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Pomija teren ukryty za zamkniętymi sekcjami. Wyłączone dużo kosztuje.",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Ukrywa modele za pełnymi blokami. Wył. przy własnych paczkach.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Liczba sekcji siatki wysyłanych na klatkę. Mniej to płynniej podczas ładowania.",
+  "Soft shadows in corners. Costs chunk building time only.": "Miękkie cienie w narożnikach. Kosztuje tylko czas budowania chunków.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Mniejsze kopie tekstur bloków dla odległego terenu: mniej migotania.",
+  "Blends grass and water colours across biomes when building chunks.": "Przenika kolory trawy i wody między biomami podczas budowania chunków.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Warstwa chmur: wyłączona, płaska (szybka) lub 3D (dokładna).",
+  "How far clouds reach, in chunks.": "Jak daleko sięgają chmury, w chunkach.",
+  "Draws the sky, sun, moon and stars.": "Rysuje niebo, słońce, księżyc i gwiazdy.",
+  "Distance fog. Off shows the edge of the loaded world.": "Mgła w oddali. Wyłączona pokazuje krawędź załadowanego świata.",
+  "Draws rain and snow.": "Rysuje deszcz i śnieg.",
+  "How far rain and snow fall around you.": "Jak daleko wokół ciebie pada deszcz i śnieg.",
+  "How many particles effects spawn.": "Ile cząstek tworzą efekty.",
+  "Round shadows under mobs and items.": "Okrągłe cienie pod stworzeniami i przedmiotami.",
+  "Leaves with see-through gaps. Off draws them solid.": "Liście z prześwitami. Wyłączone rysuje je jako pełne.",
+  "Sorts water and glass more exactly behind each other.": "Dokładniej sortuje wodę i szkło jedno za drugim.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Które przebudowy chunków czekają na klatkę: żadne, pobliskie lub twoje.",
+  "Animates water, lava, fire and other moving textures.": "Animuje wodę, lawę, ogień i inne ruchome tekstury.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Piksele świata na piksel ekranu. Poniżej 100% GPU działa szybciej.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Wygładza krawędzie. FXAA: miękko. TAA: najgładziej, możliwe smugi.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Renderuje mniejszy świat, odtwarza przez TAA. Szybciej, miękko.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "Wyjście HDR na ekranie HDR: lawa, ogień i słońce świecą jaśniej.",
+  "How frames reach the screen while VSync is off.": "Jak klatki trafiają na ekran, gdy VSync jest wyłączony.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "Oszczędne usypia do następnej klatki; Dokładne czeka aktywnie.",
+  "Fills the screen (borderless).": "Wypełnia ekran (bez ramki).",
+  "Brightens dark places.": "Rozjaśnia ciemne miejsca.",
+  "Lowers the frame rate when minimised, or idle too.": "Obniża liczbę klatek po zminimalizowaniu, a także podczas bezczynności.",
+  "Sways the view while walking.": "Kołysze widokiem podczas chodzenia.",
+  "Fades newly loaded chunks in.": "Płynnie pokazuje nowo załadowane chunki.",
+  "Darkens the screen's edges.": "Przyciemnia krawędzie ekranu.",
+  "Shows when the world saves.": "Pokazuje, kiedy świat się zapisuje.",
+  "Shows attack cooldown.": "Pokazuje czas odnowienia ataku.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "Limit 60 FPS (30 w menu/bez fokusu), połowa wątków: mniej energii.",
+  "Threads that generate, light and mesh chunks. Next start.": "Wątki generujące, oświetlające i meshujące chunki. Po restarcie.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, awaryjnie DirectX 12 (Windows) / OpenGL (Linux). Po restarcie.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Dane siatki wysyłane do GPU na klatkę. Mniej to płynniej podczas ładowania.",
+  "Frame rate and frame times over the game, with a graph.": "Liczba klatek i czasy klatek nad grą, z wykresem.",
  "horizon.multiplayer.finding_friend": "Szukanie świata znajomego…",
  "horizon.loading.opening_world": "Otwieranie świata",
  "horizon.loading.cancelling_world": "Anulowanie",
  "horizon.multiplayer.not_signed_in": "Ten serwer działa w trybie online. Zaloguj się kontem Microsoft w launcherze Horizon, aby dołączyć.",
  "horizon.multiplayer.invalid_address": "Nieprawidłowy adres serwera: %s",
  "horizon.multiplayer.connected_friend_direct": "Połączono bezpośrednio ze znajomym…",
-  "horizon.multiplayer.connected_friend_relay": "Połączono ze znajomym przez przekaźnik…"
+  "horizon.multiplayer.connected_friend_relay": "Połączono ze znajomym przez przekaźnik…",
+  "horizon.title.not_affiliated": "Niepowiązane z Mojang ani Microsoft",
+  "horizon.extras.header.lighting": "Oświetlenie",
+  "horizon.extras.header.third_person": "Widok z trzeciej osoby",
+  "horizon.extras.header.inventory": "Ekwipunek",
+  "horizon.extras.header.multiplayer": "Tryb wieloosobowy",
+  "horizon.extras.fullbright": "Pełna jasność",
+  "horizon.extras.dynamic_lights": "Dynamiczne światła",
+  "horizon.extras.own_name_tag": "Własny nick",
+  "horizon.extras.auto_reconnect": "Ponowne łączenie",
+  "horizon.extras.mouse_tweaks": "Mouse Tweaks",
+  "horizon.extras.mouse_tweaks_wheel": "Przenoszenie kółkiem",
+  "horizon.extras.sort": "Przyciski sortowania",
+  "horizon.extras.sort_key": "Klawisz sort.",
+  "horizon.extras.no_ai": "Bez AI",
+  "horizon.extras.agent_control": "Sterowanie agentem",
+  "horizon.extras.discord_presence": "Discord Rich Presence",
+  "horizon.extras.fullbright.tooltip": "Pokazuje bloki i byty w pełnym oświetleniu, nawet w ciemnych miejscach.",
+  "horizon.extras.dynamic_lights.tooltip": "Pochodnie i inne źródła światła trzymane w dłoni, upuszczone lub płonące oświetlają otaczające bloki.",
+  "horizon.extras.own_name_tag.tooltip": "Pokazuje twój nick nad głową w widoku z trzeciej osoby, tak jak widzą go inni gracze. Ukryty, gdy serwer ukrywa nazwy twojej drużyny lub jesteś niewidzialny.",
+  "horizon.extras.auto_reconnect.tooltip": "Ponownie dołącza do serwera po utracie połączenia lub restarcie, nigdy po wyrzuceniu lub banie.",
+  "horizon.extras.mouse_tweaks.tooltip": "Przeciąganie prawym przyciskiem układa po jednym na pole, lewym zbiera trzymany przedmiot, Shift + lewy przycisk przenosi każde pole.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Przewinięcie w dół wysyła jeden przedmiot z pola na drugą stronę, w górę przywraca jeden.",
+  "horizon.extras.sort.tooltip": "Sortuje ekwipunek, skrzynie, beczki, skrzynie Endu i shulkerowe skrzynie w kolejności kart trybu kreatywnego, łącząc stosy.",
+  "horizon.extras.sort_key.tooltip": "Sortuje część pod kursorem. Kliknij, a potem naciśnij klawisz; Escape usuwa przypisanie.",
+  "horizon.extras.no_ai.tooltip": "Ukrywa i wyłącza wszystkie funkcje AI: sterowanie agentem, horizon-ctl i serwery MCP. Także przełącznik w launcherze.",
+  "horizon.extras.agent_control.tooltip": "Twój własny agent AI może grać w tę grę przez horizon-ctl lub klienta MCP, tylko na tym komputerze.",
+  "horizon.extras.discord_presence.tooltip": "Pokazuje „Gra w Horizon” w twoim profilu Discord, gdy Discord jest uruchomiony: menu, tryb jednoosobowy lub wieloosobowy, wymiar i czas gry. Nigdy nazwy świata ani adresu serwera.",
+  "Calibrate...": "Kalibruj…",
+  "Calibrate Anyway...": "Kalibruj mimo to…",
+  "Use Automatic Setup": "Użyj automatycznej konfiguracji",
+  "Shortcut: %s": "Skrót: %s",
+  "Next": "Dalej",
+  "HDR Calibration %s/%s: %s": "Kalibracja HDR %s/%s: %s",
+  "Sets the three below full screen, one test picture at a time.": "Ustawia trzy wartości poniżej na pełnym ekranie, na obrazie testowym.",
+  "A key that opens this screen from the game. Not bound at first.": "Klawisz otwierający ten ekran z poziomu gry. Na początku nieprzypisany.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "Wyświetlacz nie podał jasności: skalibruj go, aby go skonfigurować.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Już skonfigurowane. Kalibruj tylko, gdy HDR wygląda źle.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Przywraca Jasność maks. i Punkt bieli do ustawień wyświetlacza.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Skonfigurowane dla twojego wyświetlacza. Zostaw Auto, chyba że wygląda źle.",
+  "Lower it until the logo just disappears into the black.": "Zmniejszaj, aż logo właśnie zniknie w czerni.",
+  "Raise it until the logo just disappears into the bright square.": "Zwiększaj, aż logo właśnie zniknie w jasnym kwadracie.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Ustaw biel, na którą wygodnie patrzeć długo, w twoim oświetleniu.",
+  "horizon.splitscreen.profiles.forget": "Zapomnij",
+  "horizon.splitscreen.profiles.create": "Utwórz",
+  "horizon.splitscreen.profiles.you": " - ty",
+  "horizon.splitscreen.profiles.forget_named": "Zapomnij %s",
+  "horizon.splitscreen.profiles.previous": "Poprzednia",
+  "horizon.splitscreen.profiles.next": "Dalej",
+  "horizon.splitscreen.profiles.new_button": "Nowy profil…",
+  "horizon.splitscreen.profiles.forget_title": "Zapomnieć profil?",
+  "horizon.splitscreen.profiles.forget_leaves": "Znika z listy tej instancji.",
+  "horizon.splitscreen.profiles.forget_kept": "Postępy w świecie i ustawienia zostają zachowane.",
+  "horizon.splitscreen.profiles.new_title": "Nowy profil",
+  "horizon.splitscreen.profiles.name_hint": "Nazwa (3–16 liter, cyfr lub _)",
+  "horizon.splitscreen.profiles.switch_title": "Zmień profil",
+  "horizon.splitscreen.profiles.offline_note": "Profile offline należą do tej instancji",
+  "horizon.splitscreen.profiles.move": "Zmień miejsce gry",
+  "horizon.splitscreen.profiles.move_place": "Zmień miejsce gry: %s",
+  "horizon.friends.title": "Graj ze znajomymi",
+  "horizon.friends.hint": "Znajomi wklejają kod po kliknięciu przycisku Znajomi na ekranie tytułowym, w Połączeniu bezpośrednim lub na stronie Graj w launcherze.",
+  "horizon.friends.copied": "Skopiowano",
+  "horizon.friends.copy_code": "Kopiuj kod",
+  "horizon.friends.stop_sharing": "Przestań udostępniać",
+  "horizon.friends.none_yet": "Nie ma jeszcze żadnych znajomych.",
+  "horizon.friends.here_now": "Obecnie: %s",
+  "horizon.friends.share_intro": "Udostępnij ten świat za pomocą kodu zaproszenia: otwiera się w sieci LAN, a znajomi przez internet dołączają za pomocą kodu. Nie korzystamy z żadnego naszego serwera.",
+  "horizon.friends.start_sharing": "Zacznij udostępniać",
+  "horizon.friends.troubleshooting": "Rozwiązywanie problemów…",
+  "horizon.friends.stopped": "Przestano udostępniać kod zaproszenia.",
+  "horizon.friends.short_code_changed": "Ktoś wciąż wpisywał zły krótki kod, więc został zmieniony.",
+  "horizon.friends.wrong_code": "Ktoś wpisał zły kod.",
+  "horizon.friends.code_ready": "Twój kod zaproszenia jest gotowy: Menu gry, Graj ze znajomymi. Skopiuj go i wyślij znajomym.",
+  "horizon.friends.share_failed": "Nie udało się udostępnić świata: %s",
+  "horizon.friends.finding_route": "Sprawdzanie, jak znajomi mogą się z tobą połączyć…",
+  "horizon.osk.shift": "Shift",
+  "horizon.osk.space": "Spacja",
+  "horizon.osk.delete": "Usuń",
+  "horizon.osk.type": "Wpisz",
+  "horizon.osk.symbols": "Symbole",
+  "horizon.osk.close": "Zamknij"
 }
@@ -202,5 +202,11 @@
  "horizon.multiplayer.not_signed_in": "Этот сервер работает в онлайн-режиме. Войдите с помощью аккаунта Microsoft в лаунчере Horizon, чтобы присоединиться.",
  "horizon.multiplayer.invalid_address": "Недействительный адрес сервера: %s",
  "horizon.multiplayer.connected_friend_direct": "Установлено прямое соединение с другом…",
-  "horizon.multiplayer.connected_friend_relay": "Соединение с другом через релей…"
+  "horizon.multiplayer.connected_friend_relay": "Соединение с другом через релей…",
+  "horizon.pages.shader_options": "Настройки шейдеров",
+  "horizon.pages.split_profiles": "Кто играет?",
+  "horizon.pages.split_profiles.tooltip": "Кто играет: профиль, хранимый в этой папке игры.",
+  "horizon.shader_options.open": "Настройки шейдеров…",
+  "horizon.shader_options.profile": "Профиль",
+  "horizon.shader_options.loading": "Чтение настроек набора шейдеров…"
 }
@@ -196,5 +196,11 @@
  "Threads that generate, light and mesh chunks. Next start.": "Parçaları oluşturan, aydınlatan ve ağ verilerini hazırlayan iş parçacıklarının sayısı. Değişiklikler sonraki başlatmada uygulanır.",
  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Önce Vulkan kullanılır. Çalışmazsa Windows'ta DirectX 12, Linux'ta OpenGL denenir. Değişiklikler sonraki başlatmada uygulanır.",
  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Her karede GPU'ya gönderilen ağ verisi miktarı. Daha düşük değerler yükleme sırasında daha akıcı bir deneyim sağlar.",
-  "Frame rate and frame times over the game, with a graph.": "Oyun ekranında FPS değerini ve kare sürelerini grafikle birlikte gösterir."
+  "Frame rate and frame times over the game, with a graph.": "Oyun ekranında FPS değerini ve kare sürelerini grafikle birlikte gösterir.",
+  "horizon.pages.shader_options": "Gölgelendirici Seçenekleri",
+  "horizon.pages.split_profiles": "Kim oynuyor?",
+  "horizon.pages.split_profiles.tooltip": "Kim oynuyor: bu oyun klasöründe tutulan bir profil.",
+  "horizon.shader_options.open": "Gölgelendirici Seçenekleri…",
+  "horizon.shader_options.profile": "Profil",
+  "horizon.shader_options.loading": "Gölgelendirici paketinin seçenekleri okunuyor…"
 }
@@ -12,11 +12,282 @@
  "horizon.options.button_glyphs": "Значки кнопок",
  "horizon.options.menu_navigation": "Навігація в меню",
  "horizon.options.on_screen_keyboard": "Екранна клавіатура",
+  "horizon.options.chat_delay": "Затримка чату",
+  "horizon.options.lightbar.health": "Здоров’я",
+  "horizon.options.lightbar.dimension": "Вимір",
+  "horizon.options.glyphs.auto": "Авто",
+  "horizon.options.glyphs.xbox": "Xbox",
+  "horizon.options.glyphs.playstation": "PlayStation",
+  "horizon.options.glyphs.nintendo": "Nintendo",
+  "horizon.options.menu_focus": "Фокус",
+  "horizon.options.menu_pointer": "Курсор",
+  "horizon.options.keyboard.auto": "Авто",
+  "horizon.options.keyboard.horizon": "Horizon",
+  "horizon.options.keyboard.steam": "Steam",
+  "horizon.options.unavailable": "Ця функція ще недоступна в Horizon.",
+  "horizon.options.search": "Шукати налаштування…",
+  "horizon.pages.mods": "Моди",
+  "horizon.pages.shader_packs": "Пакети шейдерів",
+  "horizon.pages.shader_options": "Налаштування шейдерів",
+  "horizon.pages.controller": "Налаштування геймпада",
+  "horizon.pages.controller_binds": "Призначення кнопок геймпада",
+  "horizon.pages.extras": "Додатки Horizon",
+  "horizon.pages.settings": "Налаштування Horizon",
+  "horizon.pages.agent": "ШІ-агент",
+  "horizon.pages.split_profiles": "Хто грає?",
+  "horizon.pages.settings.tooltip": "Власні налаштування Horizon: графіка, геймпади, додатки та моди.",
+  "horizon.pages.graphics.tooltip": "Графіка просто: кожен параметр показує, чого він коштує.",
+  "horizon.pages.graphics_advanced.tooltip": "Усі параметри графіки, зокрема з Horizon, із зазначенням витрат кожного.",
+  "horizon.pages.controller.tooltip": "Геймпади: їхні кнопки, стіки, вібрація та навігація в меню.",
+  "horizon.pages.extras.tooltip": "Необов’язкові додатки, усі типово вимкнені: гра лишається ванільною, доки ви не ввімкнете якийсь.",
+  "horizon.pages.agent.tooltip": "Дозвольте власному ШІ-агентові грати: horizon-ctl і MCP-клієнти на цьому комп’ютері.",
+  "horizon.pages.split_profiles.tooltip": "Хто грає: профіль, що зберігається в цій теці гри.",
+  "horizon.pages.shader_packs.tooltip": "Пакети шейдерів із теки shaderpacks: власні пакети Horizon і пакети у форматі shaders/. Одночасно працює один.",
+  "horizon.pages.mods.tooltip": "Моди, створені для Horizon, із теки horizon-mods. Кожен працює в ізольованому середовищі й залишається вимкненим, доки ви його не ввімкнете.",
+  "horizon.pages.open.graphics": "Графіка…",
+  "horizon.pages.open.graphics_advanced": "Розширена графіка…",
+  "horizon.pages.open.shader_packs": "Пакети шейдерів…",
+  "horizon.pages.open.controller": "Налаштування геймпада…",
+  "horizon.pages.open.extras": "Додатки…",
+  "horizon.pages.open.mods": "Моди…",
+  "horizon.pages.open.agent": "ШІ-агент…",
+  "horizon.pages.open.horizon_graphics": "Графіка Horizon…",
+  "horizon.pages.open.controller_binds": "Кнопки геймпада…",
+  "horizon.pages.open.horizon_settings": "Налаштування Horizon…",
+  "horizon.mods.empty": "Немає модів: покладіть файли .hmod у теку horizon-mods",
+  "horizon.mods.stopped": " (зупинено)",
+  "horizon.mods.not_built": " (не зібрано)",
+  "horizon.mods.dev": " (розробка)",
+  "horizon.mods.settings": "Налаштування",
+  "horizon.mods.open_folder": "Відкрити теку з модами",
+  "horizon.shader_packs.empty": "Немає пакетів шейдерів: покладіть їх у теку shaderpacks",
+  "horizon.shader_packs.kind_horizon": " (Horizon)",
+  "horizon.shader_options.open": "Налаштування шейдерів…",
+  "horizon.shader_options.profile": "Профіль",
+  "horizon.shader_options.loading": "Читання налаштувань набору шейдерів…",
+  "horizon.agent.copy_details": "Копіювати дані з’єднання",
+  "horizon.multiplayer.join": "Приєднатися",
+  "horizon.multiplayer.cancel_reconnecting": "Скасувати перепідключення",
+  "horizon.multiplayer.join_friend": "Приєднатися до друга",
+  "horizon.multiplayer.invite_code": "Код запрошення",
+  "horizon.multiplayer.relay": "Ретранслятор (необов’язково)",
+  "Preset": "Шаблон",
+  "LOD Distance": "Дальність LOD",
+  "Far Detail": "Деталі вдалині",
+  "Cave Culling": "Відсікання печер",
+  "Entity Culling": "Відсік. сутностей",
+  "Chunk Updates": "Оновл. чанків",
+  "Upload Budget": "Вивантаження",
+  "Sky": "Небо",
+  "Fog": "Туман",
+  "Weather": "Погода",
+  "Animated Textures": "Анімовані текстури",
+  "Present Mode": "Виведення",
+  "Frame Pacing": "Темп кадрів",
+  "Worker Threads": "Робочі потоки",
+  "Resolution Scale": "Масштаб зображення",
+  "Anti-aliasing": "Згладжування",
+  "Upscaling": "Апскейлінг",
+  "HDR Settings...": "Налаштування HDR…",
+  "Paper White": "Біла точка",
+  "Peak Brightness": "Пік яскравості",
+  "Black Level": "Рівень чорного",
+  "UI Brightness": "Яскравість UI",
+  "Battery Mode": "Режим батареї",
+  "Graphics API": "API графіки",
+  "Performance Overlay": "Накладка швидкодії",
+  "Full Detail Distance": "Дальність деталей",
+  "On": "Увімк.",
+  "Off": "Вимк.",
+  "Unlimited": "Без обмежень",
+  "Auto": "Авто",
+  "Custom": "Власний",
+  "Performance": "Продуктивність",
+  "Balanced": "Збалансований",
+  "Quality": "Якість",
+  "Ultra": "Ультра",
+  "Ultra Performance": "Ультрапродукт.",
+  "Native": "Нативна",
+  "Full": "Повна",
+  "Reduced": "Знижена",
+  "Efficient": "Економний",
+  "Precise": "Точний",
+  "Auto (VSync)": "Авто (VSync)",
+  "FIFO": "FIFO",
+  "Mailbox": "Mailbox",
+  "Immediate": "Immediate",
+  "Vulkan": "Vulkan",
+  "DirectX 12": "DirectX 12",
+  "OpenGL": "OpenGL",
+  "FPS and Graph": "FPS і графік",
+  "FPS": "FPS",
+  "TAA": "TAA",
+  "FXAA": "FXAA",
+  "No cost": "Без витрат",
+  "Low cost": "Низькі витрати",
+  "Medium cost": "Середні витрати",
+  "High cost": "Високі витрати",
+  "Saves time": "Заощаджує час",
+  "Rendering": "Промальовування",
+  "Display": "Дисплей",
+  "Preferences": "Уподобання",
+  "Overlay": "Накладка",
+  "HDR": "HDR",
+  "Graphics": "Графіка",
+  "Graphics: Advanced": "Графіка: розширені",
+  "Graphics: HDR": "Графіка: HDR",
+  "Advanced...": "Розширені…",
+  "Simple...": "Прості…",
+  "Done": "Готово",
+  "This feature is not yet available in Horizon.": "Ця функція ще недоступна в Horizon.",
+  "Your display or system doesn't offer HDR output.": "Ваш дисплей або система не підтримує вивід HDR.",
+  "Turn HDR on to use it.": "Увімкніть HDR, щоб користуватися цим.",
+  "%s chunks": "%s чанків",
+  "%s per frame": "%s на кадр",
+  "%s MiB/frame": "%s MiB/кадр",
+  "%s KiB/frame": "%s KiB/кадр",
+  "%s nits": "%s ніт",
+  "Auto (%s)": "Авто (%s)",
+  "Auto (%s nits)": "Авто (%s ніт)",
+  "%.2f nits": "%.2f ніт",
+  "Full-detail terrain range. LOD Distance can extend local worlds farther.": "Дальність повних деталей. Дальність LOD сягає далі.",
+  "Coarse distant terrain in local worlds. Integrated GPUs stop at 128 chunks.": "Спрощена далека місцевість локальних світів. Інтегр. GPU: до 128.",
+  "Reduced draws far terrain coarser: faster on this integrated GPU.": "Знижена: далека місцевість простіша, швидше на цьому GPU.",
+  "Reduced draws far terrain coarser, for GPUs it slows down.": "Знижена: простіша далека місцевість для повільних GPU.",
+  "Field of view. Wider shows more terrain at once.": "Поле зору. Ширше показує більше місцевості одночасно.",
+  "Caps frames per second; a cap saves power and heat.": "Обмежує к/с; обмеження заощаджує енергію й зменшує нагрів.",
+  "Waits for the display's refresh: no tearing, a little latency.": "Чекає на оновлення дисплея: без розривів, невелика затримка.",
+  "Size of menus and the HUD.": "Розмір меню та HUD.",
+  "Sets the options below together. Changing one makes it Custom.": "Задає параметри нижче разом. Зміна одного дає «Власний».",
+  "Lava, fire and sunlight shine brighter than white. Needs an HDR display.": "Лава, вогонь і сонце світліші за білий. Потрібен HDR.",
+  "Your display's darkest black. 0 for OLED; LCDs glow a little.": "Найтемніший чорний вашого дисплея. 0 для OLED; LCD трохи світяться.",
+  "How bright highlights get. Auto: the peak your system reports.": "Наскільки яскравими бувають відблиски. Авто: пік, який повідомляє система.",
+  "How bright white paper and menus look. Auto: your desktop's white.": "Яскравість білого паперу та меню. Авто: білий вашого стола.",
+  "How bright the HUD and menus are, against paper white.": "Наскільки яскраві HUD і меню відносно білого паперу.",
+  "How far mobs, crops and machines keep working. CPU time.": "Як далеко працюють моби, посіви й механізми. Витрачає CPU.",
+  "How far away mobs and items are drawn, as a share of normal.": "Відстань малювання мобів і предметів, у частці від норми.",
+  "Skips terrain hidden behind closed sections. Off costs a lot.": "Пропускає приховану місцевість. Вимкнення коштує дорого.",
+  "Hides models behind opaque blocks. Entities update. Off with custom packs.": "Ховає моделі за блоками. Вимкніть із власними пакетами.",
+  "Meshed sections uploaded per frame. Lower is smoother while loading.": "Секцій сітки за кадр. Менше — плавніше під час завантаження.",
+  "Soft shadows in corners. Costs chunk building time only.": "М’які тіні в кутах. Витрачає лише час на побудову чанків.",
+  "Smaller copies of block textures for distant terrain: less shimmer.": "Менші копії текстур блоків для віддаленої місцевості: менше мерехтіння.",
+  "Blends grass and water colours across biomes when building chunks.": "Змішує кольори трави та води між біомами під час побудови чанків.",
+  "Cloud layer: off, flat (fast) or 3D (fancy).": "Шар хмар: вимкнено, пласкі (швидкі) або 3D (красиві).",
+  "How far clouds reach, in chunks.": "Як далеко сягають хмари, у чанках.",
+  "Draws the sky, sun, moon and stars.": "Малює небо, сонце, місяць і зірки.",
+  "Distance fog. Off shows the edge of the loaded world.": "Туман на відстані. Вимкнений показує межу завантаженого світу.",
+  "Draws rain and snow.": "Малює дощ і сніг.",
+  "How far rain and snow fall around you.": "Як далеко навколо вас падають дощ і сніг.",
+  "How many particles effects spawn.": "Скільки частинок створюють ефекти.",
+  "Round shadows under mobs and items.": "Круглі тіні під мобами та предметами.",
+  "Leaves with see-through gaps. Off draws them solid.": "Листя з просвітами. Вимкнено — малюється суцільним.",
+  "Sorts water and glass more exactly behind each other.": "Точніше сортує воду та скло одне за одним.",
+  "Which chunk rebuilds wait for the frame: none, nearby or yours.": "Які перебудови чанків чекають на кадр: жодні, найближчі чи ваші.",
+  "Animates water, lava, fire and other moving textures.": "Анімує воду, лаву, вогонь та інші рухомі текстури.",
+  "World pixels per screen pixel. Below 100% is faster on the GPU.": "Пікселі світу на піксель екрана. Нижче 100% — швидше для GPU.",
+  "Smooths jagged edges. FXAA: softer. TAA: smoothest, moving things may trail.": "Згладжує краї. FXAA: м’якше. TAA: найгладше, можливі шлейфи.",
+  "Renders the world smaller and rebuilds it with TAA. Faster, softer.": "Менший рендер, відновлення через TAA. Швидше, м’якше.",
+  "HDR output on an HDR display: lava, fire and sunlight shine brighter.": "Вивід HDR на HDR-дисплеї: лава, вогонь і сонце яскравіші.",
+  "How frames reach the screen while VSync is off.": "Як кадри потрапляють на екран, коли VSync вимкнено.",
+  "Efficient sleeps until the next frame; Precise spins, like vanilla.": "«Економний» спить до наступного кадру; «Точний» чекає активно.",
+  "Fills the screen (borderless).": "Заповнює екран (без рамки).",
+  "Brightens dark places.": "Освітлює темні місця.",
+  "Lowers the frame rate when minimised, or idle too.": "Знижує частоту кадрів при згортанні, а також при бездіяльності.",
+  "Sways the view while walking.": "Розхитує вид під час ходьби.",
+  "Fades newly loaded chunks in.": "Плавно показує щойно завантажені чанки.",
+  "Darkens the screen's edges.": "Затемнює краї екрана.",
+  "Shows when the world saves.": "Показує, коли світ зберігається.",
+  "Shows attack cooldown.": "Показує перезарядку атаки.",
+  "60 FPS cap (30 in menus or unfocused), half the workers: less power.": "60 FPS (30 у меню/без фокуса), половина потоків: економія.",
+  "Threads that generate, light and mesh chunks. Next start.": "Потоки генерації, світла й сітки чанків. Після перезапуску.",
+  "Vulkan, then DirectX 12 (Windows) or OpenGL (Linux) where it fails. Next start.": "Vulkan, інакше DirectX 12 (Windows)/OpenGL (Linux). Після рестарту.",
+  "Mesh data sent to the GPU per frame. Lower is smoother while loading.": "Дані сітки до GPU за кадр. Менше — плавніше завантаження.",
+  "Frame rate and frame times over the game, with a graph.": "Частота та час кадрів поверх гри, з графіком.",
  "horizon.multiplayer.finding_friend": "Шукаємо світ друга…",
  "horizon.loading.opening_world": "Відкриття світу",
  "horizon.loading.cancelling_world": "Скасування",
  "horizon.multiplayer.not_signed_in": "Цей сервер працює в онлайн-режимі. Увійдіть за допомогою акаунта Microsoft у лаунчері Horizon, щоб приєднатися.",
  "horizon.multiplayer.invalid_address": "Недійсна адреса сервера: %s",
  "horizon.multiplayer.connected_friend_direct": "Пряме з'єднання з другом встановлено…",
-  "horizon.multiplayer.connected_friend_relay": "З'єднання з другом через ретранслятор…"
+  "horizon.multiplayer.connected_friend_relay": "З'єднання з другом через ретранслятор…",
+  "horizon.title.not_affiliated": "Не пов’язано з Mojang чи Microsoft",
+  "horizon.extras.header.lighting": "Освітлення",
+  "horizon.extras.header.third_person": "Вигляд від третьої особи",
+  "horizon.extras.header.inventory": "Інвентар",
+  "horizon.extras.header.multiplayer": "Гра в мережі",
+  "horizon.extras.fullbright": "Повна яскравість",
+  "horizon.extras.dynamic_lights": "Динамічне світло",
+  "horizon.extras.own_name_tag": "Власний нік",
+  "horizon.extras.auto_reconnect": "Перепідключення",
+  "horizon.extras.mouse_tweaks": "Mouse Tweaks",
+  "horizon.extras.mouse_tweaks_wheel": "Перенос коліщатком",
+  "horizon.extras.sort": "Кнопки сортування",
+  "horizon.extras.sort_key": "Сортувати",
+  "horizon.extras.no_ai": "Без ШІ",
+  "horizon.extras.agent_control": "Керування агентом",
+  "horizon.extras.discord_presence": "Discord Rich Presence",
+  "horizon.extras.fullbright.tooltip": "Показує блоки та сутності при повному освітленні, навіть у темних місцях.",
+  "horizon.extras.dynamic_lights.tooltip": "Смолоскипи та інші джерела світла, які тримають у руках, викинуті чи палаючі, освітлюють блоки навколо.",
+  "horizon.extras.own_name_tag.tooltip": "Показує ваше ім’я над головою від третьої особи, як його бачать інші гравці. Приховано, коли сервер ховає імена вашої команди або ви невидимі.",
+  "horizon.extras.auto_reconnect.tooltip": "Знову приєднується до сервера після втрати з’єднання чи перезапуску, але ніколи після вигнання чи блокування.",
+  "horizon.extras.mouse_tweaks.tooltip": "Перетягування ПКМ кладе по одному в комірку, ЛКМ збирає утримуваний предмет, Shift + ЛКМ переміщує кожну комірку.",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "Прокрутка вниз надсилає один предмет із комірки на інший бік, вгору — повертає один назад.",
+  "horizon.extras.sort.tooltip": "Сортує інвентар, скрині, діжки, скрині Енду та шалкерові коробки в порядку вкладок творчого режиму, об’єднуючи стеки.",
+  "horizon.extras.sort_key.tooltip": "Сортує частину під курсором. Натисніть, а потім клавішу; Escape скасовує призначення.",
+  "horizon.extras.no_ai.tooltip": "Приховує та вимикає всі функції ШІ: керування агентом, horizon-ctl і MCP-сервери. Також перемикач у лаунчері.",
+  "horizon.extras.agent_control.tooltip": "Ваш власний ШІ-агент може грати в цю гру через horizon-ctl або MCP-клієнт, лише на цьому комп’ютері.",
+  "horizon.extras.discord_presence.tooltip": "Показує «Грає в Horizon» у вашому профілі Discord, поки Discord запущено: меню, одиночна чи мережева гра, вимір і час гри. Ніколи не назву світу чи адресу сервера.",
+  "Calibrate...": "Калібрувати…",
+  "Calibrate Anyway...": "Все одно калібрувати…",
+  "Use Automatic Setup": "Використати автоналаштування",
+  "Shortcut: %s": "Гаряча клавіша: %s",
+  "Next": "Далі",
+  "HDR Calibration %s/%s: %s": "Калібрування HDR %s/%s: %s",
+  "Sets the three below full screen, one test picture at a time.": "Три значення нижче налаштовуються на повному екрані.",
+  "A key that opens this screen from the game. Not bound at first.": "Клавіша, що відкриває цей екран із гри. Спершу не призначена.",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "Дисплей не повідомив яскравість: відкалібруйте його.",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "Уже налаштовано. Калібруйте, лише якщо HDR виглядає погано.",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "Повертає Пік яскравості й Білу точку до налаштувань дисплея.",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "Налаштовано для дисплея. Залишайте «Авто», якщо все гаразд.",
+  "Lower it until the logo just disappears into the black.": "Зменшуйте, доки логотип не зникне в чорному.",
+  "Raise it until the logo just disappears into the bright square.": "Збільшуйте, доки логотип не зникне в яскравому квадраті.",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "Білий, на який комфортно довго дивитися за вашого світла.",
+  "horizon.splitscreen.profiles.forget": "Забути",
+  "horizon.splitscreen.profiles.create": "Створити",
+  "horizon.splitscreen.profiles.you": " - ви",
+  "horizon.splitscreen.profiles.forget_named": "Забути %s",
+  "horizon.splitscreen.profiles.previous": "Назад",
+  "horizon.splitscreen.profiles.next": "Далі",
+  "horizon.splitscreen.profiles.new_button": "Новий профіль…",
+  "horizon.splitscreen.profiles.forget_title": "Забути профіль?",
+  "horizon.splitscreen.profiles.forget_leaves": "Він зникне зі списку цього екземпляра.",
+  "horizon.splitscreen.profiles.forget_kept": "Прогрес у світі та налаштування зберігаються.",
+  "horizon.splitscreen.profiles.new_title": "Новий профіль",
+  "horizon.splitscreen.profiles.name_hint": "Ім’я (3–16 літер, цифр або _)",
+  "horizon.splitscreen.profiles.switch_title": "Змінити профіль",
+  "horizon.splitscreen.profiles.offline_note": "Офлайн-профілі належать цьому екземпляру",
+  "horizon.splitscreen.profiles.move": "Змінити місце гри",
+  "horizon.splitscreen.profiles.move_place": "Змінити місце гри: %s",
+  "horizon.friends.title": "Грати з друзями",
+  "horizon.friends.hint": "Друзі вставляють код після кнопки «Друзі» на головному екрані, у «Пряме з’єднання» або на сторінці «Грати» в лаунчері.",
+  "horizon.friends.copied": "Скопійовано",
+  "horizon.friends.copy_code": "Копіювати код",
+  "horizon.friends.stop_sharing": "Припинити поширення",
+  "horizon.friends.none_yet": "Друзів тут поки немає.",
+  "horizon.friends.here_now": "Зараз тут: %s",
+  "horizon.friends.share_intro": "Поділіться цим світом за допомогою коду запрошення: він відкривається для LAN, а друзі з інтернету приєднуються за кодом. Жоден наш сервер не залучається.",
+  "horizon.friends.start_sharing": "Почати поширення",
+  "horizon.friends.troubleshooting": "Усунення несправностей…",
+  "horizon.friends.stopped": "Поширення коду запрошення припинено.",
+  "horizon.friends.short_code_changed": "Хтось раз за разом вводив неправильний короткий код, тож його змінено.",
+  "horizon.friends.wrong_code": "Хтось ввів неправильний код.",
+  "horizon.friends.code_ready": "Ваш код запрошення готовий: Ігрове меню, Грати з друзями. Скопіюйте його та надішліть друзям.",
+  "horizon.friends.share_failed": "Не вдалося поділитися світом: %s",
+  "horizon.friends.finding_route": "З’ясовуємо, як друзі можуть до вас під’єднатися…",
+  "horizon.osk.shift": "Shift",
+  "horizon.osk.space": "Пробіл",
+  "horizon.osk.delete": "Видалити",
+  "horizon.osk.type": "Ввести",
+  "horizon.osk.symbols": "Символи",
+  "horizon.osk.close": "Закрити"
 }
@@ -203,5 +203,108 @@
  "horizon.multiplayer.not_signed_in": "该服务器为在线模式服务器。请先在 Horizon 启动器中登录 Microsoft 账户再加入。",
  "horizon.multiplayer.invalid_address": "无效的服务器地址：%s",
  "horizon.multiplayer.connected_friend_direct": "已直连好友的世界…",
-  "horizon.multiplayer.connected_friend_relay": "已通过中继连接好友的世界…"
+  "horizon.multiplayer.connected_friend_relay": "已通过中继连接好友的世界…",
+  "horizon.pages.shader_options": "光影选项",
+  "horizon.pages.split_profiles": "谁在玩？",
+  "horizon.pages.split_profiles.tooltip": "谁在玩：保存在此游戏文件夹中的一份档案。",
+  "horizon.shader_options.open": "光影选项…",
+  "horizon.shader_options.profile": "档案",
+  "horizon.shader_options.loading": "正在读取光影包的选项…",
+  "horizon.pages.split_settings": "分屏设置",
+  "horizon.pages.split_setup": "分屏",
+  "horizon.pages.split_setup.tooltip": "在本机游玩的玩家：手柄可以加入你的世界。",
+  "horizon.pages.open.split_setup": "分屏…",
+  "horizon.title.not_affiliated": "与 Mojang 或 Microsoft 无关",
+  "horizon.extras.header.lighting": "光照",
+  "horizon.extras.header.third_person": "第三人称",
+  "horizon.extras.header.particles": "粒子",
+  "horizon.extras.header.inventory": "物品栏",
+  "horizon.extras.header.chat": "聊天",
+  "horizon.extras.header.multiplayer": "多人游戏",
+  "horizon.extras.header.sound": "声音",
+  "horizon.extras.fullbright": "全亮",
+  "horizon.extras.dynamic_lights": "动态光源",
+  "horizon.extras.own_name_tag": "自己的名字标签",
+  "horizon.extras.hide_block_particles": "隐藏方块破坏粒子",
+  "horizon.extras.auto_reconnect": "自动重连",
+  "horizon.extras.ui_sound_reserve": "为界面音效保留声道",
+  "horizon.extras.mouse_tweaks": "鼠标调整控制",
+  "horizon.extras.mouse_tweaks_wheel": "滚轮移动物品",
+  "horizon.extras.sort": "排序按钮",
+  "horizon.extras.sort_key": "排序快捷键",
+  "horizon.extras.no_ai": "关闭 AI",
+  "horizon.extras.agent_control": "代理控制",
+  "horizon.extras.discord_presence": "Discord 动态状态",
+  "horizon.extras.splitscreen": "分屏",
+  "horizon.extras.chat_animation": "平滑聊天",
+  "horizon.extras.chat_indicator": "消息指示条",
+  "horizon.extras.fullbright.tooltip": "即使在黑暗区域也以全亮显示方块和实体。",
+  "horizon.extras.dynamic_lights.tooltip": "手持、掉落或燃烧中的火把等光源会照亮周围方块。",
+  "horizon.extras.own_name_tag.tooltip": "在第三人称视角中把名字显示在头顶，与其它玩家看到的一致。当服务器隐藏团队名字或你处于隐身状态时不显示。",
+  "horizon.extras.hide_block_particles.tooltip": "隐藏方块被破坏时迸出的碎屑粒子，以及挖掘时掉落的碎屑。其它粒子仍会显示。",
+  "horizon.extras.auto_reconnect.tooltip": "连接中断或服务器重启后自动重新加入，被踢出或封禁后不会。",
+  "horizon.extras.ui_sound_reserve.tooltip": "世界中的声音会为界面音效留出 247 个声道中的 16 个，这样大量声音（比如一次大爆炸）不会把菜单点击音挤掉。",
+  "horizon.extras.mouse_tweaks.tooltip": "右键拖动每次放一个物品，左键拖动合并手持物品，Shift + 左键拖动移动所有槽位。",
+  "horizon.extras.mouse_tweaks_wheel.tooltip": "向下把槽位中的一个物品送到另一侧，向上取回一个。",
+  "horizon.extras.sort.tooltip": "按创造模式标签页顺序排序物品栏、箱子、木桶、末影箱和潜影盒，并合并堆叠。",
+  "horizon.extras.sort_key.tooltip": "排序光标下的部分。点击后按一个键；按 Escape 取消绑定。",
+  "horizon.extras.no_ai.tooltip": "隐藏并关闭所有 AI 功能：代理控制、horizon-ctl 和 MCP 服务器。启动器中的开关也一样。",
+  "horizon.extras.agent_control.tooltip": "你自己的 AI 代理可以通过 horizon-ctl 或 MCP 客户端玩这个游戏，仅限本机。",
+  "horizon.extras.discord_presence.tooltip": "Discord 运行时在你的 Discord 资料上显示“正在玩 Horizon”：菜单、单人、多人、维度以及游玩时长。绝不显示世界名称或服务器地址。",
+  "Calibrate...": "校准…",
+  "Calibrate Anyway...": "仍要校准…",
+  "Use Automatic Setup": "使用自动设置",
+  "Shortcut: %s": "快捷键：%s",
+  "Next": "下一步",
+  "HDR Calibration %s/%s: %s": "HDR 校准 %s/%s：%s",
+  "Sets the three below full screen, one test picture at a time.": "以全屏方式逐张显示测试图，来设置下面三项。",
+  "A key that opens this screen from the game. Not bound at first.": "在游戏中打开此界面的按键。初始未绑定。",
+  "Your display didn't say how bright it gets: calibrate to set it up.": "显示器没有报告自身亮度：需要通过校准来设置。",
+  "Already set up for your display. Only calibrate if HDR looks wrong.": "已按你的显示器设置好。只有在 HDR 显示异常时才需要校准。",
+  "Puts Peak Brightness and Paper White back to your display's setup.": "将峰值亮度和纸白亮度恢复为你的显示器设置。",
+  "Set up for your display. Leave on Auto unless it looks wrong.": "已按你的显示器设置。除非显示异常，否则保持“自动”。",
+  "Lower it until the logo just disappears into the black.": "调低，直到标志刚好没入黑色背景。",
+  "Raise it until the logo just disappears into the bright square.": "调高，直到标志刚好没入亮色方块。",
+  "Make the card a white that's comfortable to look at for a long time, in the light you play in.": "在你游玩时的光照环境下，把卡片调成长时间观看也舒适的白色。",
+  "horizon.splitscreen.profiles.forget": "忘记",
+  "horizon.splitscreen.profiles.create": "创建",
+  "horizon.splitscreen.profiles.you": " - 你",
+  "horizon.splitscreen.profiles.forget_named": "忘记 %s",
+  "horizon.splitscreen.profiles.previous": "上一个",
+  "horizon.splitscreen.profiles.next": "下一个",
+  "horizon.splitscreen.profiles.new_button": "新建档案…",
+  "horizon.splitscreen.profiles.forget_title": "忘记档案？",
+  "horizon.splitscreen.profiles.forget_leaves": "该档案将从此实例的列表中移除。",
+  "horizon.splitscreen.profiles.forget_kept": "世界进度和设置会保留。",
+  "horizon.splitscreen.profiles.new_title": "新建档案",
+  "horizon.splitscreen.profiles.name_hint": "名称（3 到 16 个字母、数字或 _）",
+  "horizon.splitscreen.profiles.switch_title": "切换档案",
+  "horizon.splitscreen.profiles.offline_note": "离线档案属于此实例",
+  "horizon.splitscreen.profiles.move": "移动游玩位置",
+  "horizon.splitscreen.profiles.move_place": "把游玩位置移到：%s",
+  "horizon.friends.title": "与好友一起玩",
+  "horizon.friends.hint": "好友可以在标题画面的“好友”按钮后、直连界面或启动器的“开始游戏”页粘贴该代码。",
+  "horizon.friends.copied": "已复制",
+  "horizon.friends.copy_code": "复制代码",
+  "horizon.friends.stop_sharing": "停止共享",
+  "horizon.friends.none_yet": "还没有好友加入。",
+  "horizon.friends.here_now": "当前在线：%s",
+  "horizon.friends.share_intro": "通过邀请码共享这个世界：它会开放到局域网，互联网上的好友可以用代码加入。不经过我们的任何服务器。",
+  "horizon.friends.start_sharing": "开始共享",
+  "horizon.friends.troubleshooting": "疑难解答…",
+  "horizon.friends.stopped": "已停止共享邀请码。",
+  "horizon.friends.short_code_changed": "有人反复尝试错误的短代码，因此已更换。",
+  "horizon.friends.wrong_code": "有人尝试了错误的代码。",
+  "horizon.friends.code_ready": "你的邀请码已就绪：游戏菜单 → 与好友一起玩。复制后发给好友。",
+  "horizon.friends.share_failed": "无法共享世界：%s",
+  "horizon.friends.finding_route": "正在寻找好友连接你的方式…",
+  "horizon.osk.shift": "Shift",
+  "horizon.osk.space": "空格",
+  "horizon.osk.delete": "删除",
+  "horizon.osk.type": "输入",
+  "horizon.osk.symbols": "符号",
+  "horizon.osk.close": "关闭",
+  "horizon.extras.chat_animation.tooltip": "新聊天行从左侧滑入并淡入，而不是整行直接出现。",
+  "horizon.extras.chat_indicator.tooltip": "聊天行左侧的彩色竖条。",
+  "horizon.extras.splitscreen.tooltip": "在世界中，另一个手柄可以以新玩家身份加入：提示时按 A，然后选择档案和游玩位置。"
 }
@@ -12,11 +12,13 @@
 //! this thread's CPU time in `Mesher::mesh`, the best of `--rounds`, so other
 //! work on the machine changes it less. The checksum of the meshes shows that an
 //! A/B pair of builds made the same ones.
+extern crate horizon_client_lib as horizon_client;
 use horizon_client::{
    assets::Assets,
    biome::Biomes,
    blocks::BlockFacts,
    chunk::HEIGHT,
+    graphics::LeafCullingMode,
    light::LightTables,
    mesher::{MeshTables, Mesher, Region, borrow},
    models,
@@ -139,6 +141,8 @@ fn main() -> Result<(), Error> {
            blend_radius: 2,
            smooth_lighting: true,
            cutout_leaves: true,
+            translucent_layers: &[],
+            leaf_culling: LeafCullingMode::Off,
            assets: &context.assets,
            render: &context.render,
            tables: &context.tables,
@@ -1,6 +1,7 @@
 //! Profile the two mandatory passes over gameplay-facts.json independently.
 //! Build with `cargo build --release -p horizon-client --example gameplay_decode_profile`.
 //! Each invocation runs one phase in a separate process for CPU/RSS measurements.
+extern crate horizon_client_lib as horizon_client;
 #[allow(dead_code)]
 #[path = "../../horizon-items/src/blocks/decode.rs"]
 mod decode;
@@ -1,5 +1,6 @@
 //! Compare the read + Value parse stages in BlockFacts::load and Assets::load.
 //! Usage: json_load_bench RESOURCE_ROOT [REPETITIONS]; see tools/json_load_fixtures.py.
+extern crate horizon_client_lib as horizon_client;
 use serde_json::Value;
 use std::{
    fs::{self, File},
@@ -7,6 +7,7 @@
 //!
 //! WORK is a `horizon-port-pack` work folder: `oracle/facts.json` and
 //! `mods/<id>/carry/`. The root is built in `WORK/horizon-root`.
+extern crate horizon_client_lib as horizon_client;
 use horizon_client::{
    Result,
    assets::Assets,
@@ -2,6 +2,7 @@
 //! for live requested heap bytes; leave it unset for latency measurements.
 //! cargo run --profile fast -p horizon-client --example model_library_bench -- ROOT [--parity]
 //! Run fresh processes, warm up twice, then compare multiple alternating baseline/candidate runs.
+extern crate horizon_client_lib as horizon_client;
 use horizon_client::{assets::Assets, item_render::ItemRenderer};
 use std::{
    alloc::{GlobalAlloc, Layout, System},
@@ -1,5 +1,6 @@
 //! Compare the old two-parse loading path with catalog construction from shared facts.
 //! Run: cargo run -p horizon-client --profile fast --example model_states_bench -- 15
+extern crate horizon_client_lib as horizon_client;
 use horizon_client::{Result, models::StateModels, sprites::Sprites};
 use horizon_core::position::BlockPos;
 use horizon_world::{
@@ -5,6 +5,7 @@
 //! generated around them blend with them (`Blender.of`).
 //!
 //! old_world_fixture <source world> <destination world> <x0,z0,x1,z1>
+extern crate horizon_client_lib as horizon_client;
 use horizon_core::position::ChunkPos;
 use horizon_world::{
    nbt::{Limits, Tag},
@@ -2,6 +2,7 @@
 //! entity reaches, with the per-tick palette map against the resident cache.
 //! Run with prepared client resources:
 //! cargo run --profile fast -p horizon-client --example portal_scan_bench -- RESOURCES
+extern crate horizon_client_lib as horizon_client;
 use horizon_client::{
    blocks::BlockFacts,
    chunk::{Chunk, MIN_Y, SECTIONS, Section},
@@ -328,5 +328,5 @@ fn chat(c: &Value, h: i32, atlas: &HudAtlas) -> Vec<GuiDraw> {
    if let Some(n) = c["scroll"].as_i64() {
        chat.scroll_by(n as i32, focused);
    }
-    chat.layout(h, c["now"].as_u64().unwrap_or(0), focused)
+    chat.layout(h, c["now"].as_f64().unwrap_or(0.0) as f32, focused)
 }
@@ -4,6 +4,7 @@
 //!
 //! This file only lists the probes, so that adding one reruns no harness: tools/parity.py leaves it out of
 //! their dependencies. How a probe runs is in dispatch.rs.
+extern crate horizon_client_lib as horizon_client;
 #[macro_use]
 mod dispatch;

@@ -1182,6 +1182,7 @@ pub fn main() -> horizon_client::Result<()> {
                    thundering: s.thunder,
                    nether: false,
                    block_tags: &items.block_tags,
+                    landing: &motion.landing,
                    biomes: &biomes,
                    mob_griefing: true,
                    universal_anger: false,
@@ -7,6 +7,7 @@ use horizon_client::{
    biome::{BiomeInfo, Biomes, GrassModifier},
    blocks::BlockFacts,
    chunk::{Chunk, Light, MIN_Y, index},
+    graphics::LeafCullingMode,
    mesher::{EMISSION_BITS, FLUID_FACE_BITS, MeshTables, Mesher, OPAQUE_LAYER, TerrainVertex},
    models,
 };
@@ -137,6 +138,8 @@ fn scene(
        blend_radius,
        smooth_lighting,
        cutout_leaves,
+        translucent_layers: &[],
+        leaf_culling: LeafCullingMode::Off,
    };
    let section_y = int(&row["section_y"])?;
    let started = Instant::now();
@@ -1,5 +1,6 @@
 //! Selection cost only (not block simulation). Run with prepared client resources.
 //! cargo run --profile fast -p horizon-client --example random_tick_eligibility_bench -- RESOURCES
+extern crate horizon_client_lib as horizon_client;
 use horizon_client::{
    blocks::BlockFacts,
    chunk::{Chunk, MIN_Y, Section},
@@ -9,6 +9,7 @@
 //! and the process RSS (what the allocator holds on to). On macOS it ends
 //! with `footprint`'s physical footprint, the number the OS charges: RSS also
 //! counts freed pages the allocator marked reusable.
+extern crate horizon_client_lib as horizon_client;
 use horizon_client::{
    assets::Assets, biome::Biomes, blocks::BlockFacts, collisions, crafting::Recipes, items::Items,
    light::LightTables, mesher::MeshTables, models, motion::MotionResources,
@@ -2,6 +2,7 @@
 //! full chunk NBT encoder. Run with `cargo run --profile fast -p horizon-client
 //! --example save_batch_bench`. Add `-- --nbt` to also time serialization.
 //! Exact NBT equality is always validated. No GPU, compression or disk I/O timed.
+extern crate horizon_client_lib as horizon_client;
 use horizon_client::{
    biome::Biomes,
    chunk::{Chunk, block_strategy},
@@ -2,6 +2,7 @@
 //! Run each mode in a separate process to capture CPU usage and peak RSS.
 //! The deferred mode evaluates both phases contiguously for fair loader comparison;
 //! actual client startup performs other initialization between these phases.
+extern crate horizon_client_lib as horizon_client;
 use horizon_client::{assets::Assets, blocks::BlockFacts};
 use horizon_world::level::Behaviours;
 use std::{path::Path, time::Instant};
@@ -2,6 +2,7 @@
 //! to the ones decoded from the PNGs. Deletes the cache file in ROOT, loads (decodes
 //! and writes it), loads again (reads it) and compares the sprite arrays.
 //! cargo run --profile fast -p horizon-client --example sprite_cache_parity -- ROOT
+extern crate horizon_client_lib as horizon_client;
 use horizon_client::assets::{Assets, RenderAssets};
 use std::{
    hash::{DefaultHasher, Hash, Hasher},
@@ -2,6 +2,7 @@
 //! progress (`PlayerAdvancements`) and the predicates criteria test
 //! (`EntityPredicate`, `ItemPredicate`, `LocationPredicate`, the loot
 //! conditions advancements use).
+use horizon_world::lazy_json::LazyJson;
 use serde_json::Value;
 use std::{
    collections::{BTreeMap, BTreeSet, HashMap},
@@ -30,7 +31,9 @@ pub struct Display {
 pub struct Criterion {
    pub name: String,
    pub trigger: String,
-    pub conditions: Value,
+    /// Read on first test: ~1,300 recipe advancements' criteria, most never
+    /// tested in a game, took ~4 MB as `Value`s.
+    pub conditions: LazyJson,
 }
 #[derive(Clone, Debug, Default)]
 pub struct Rewards {
@@ -154,7 +157,8 @@ impl Tree {
            .into_iter()
            .flatten()
        {
-            match self.list[ai].criteria[ci].conditions["recipes"].as_str() {
+            // `read`: the index alone keeps none of the criteria read.
+            match self.list[ai].criteria[ci].conditions.read()["recipes"].as_str() {
                Some(r) => self
                    .by_recipe
                    .entry(r.to_owned())
@@ -208,7 +212,8 @@ impl InventoryIndex {
            return index;
        };
        for &(ai, ci) in list {
-            let items = &tree.list[ai].criteria[ci].conditions["items"];
+            let conditions = tree.list[ai].criteria[ci].conditions.read();
+            let items = &conditions["items"];
            // `id_matches`: only a string or a list limits the items.
            let limited = items.as_array().and_then(|a| {
                a.iter()
@@ -266,7 +271,7 @@ fn parse(id: &str, v: &Value) -> Option<Advancement> {
        .map(|(name, c)| Criterion {
            name: name.clone(),
            trigger: c["trigger"].as_str().unwrap_or("").to_owned(),
-            conditions: c["conditions"].clone(),
+            conditions: LazyJson::new(&c["conditions"]),
        })
        .collect();
    let requirements = match v["requirements"].as_array() {
@@ -1606,7 +1611,7 @@ mod tests {
                criteria: vec![Criterion {
                    name: "c".into(),
                    trigger: "minecraft:inventory_changed".into(),
-                    conditions,
+                    conditions: LazyJson::new(&conditions),
                }],
                requirements: vec![vec!["c".into()]],
                rewards: Rewards::default(),
@@ -1655,7 +1660,7 @@ mod tests {
                criteria: vec![Criterion {
                    name: "c".into(),
                    trigger: "minecraft:recipe_unlocked".into(),
-                    conditions,
+                    conditions: LazyJson::new(&conditions),
                }],
                requirements: vec![vec!["c".into()]],
                rewards: Rewards::default(),
@@ -32,8 +32,8 @@ use horizon_world::{
 use std::{collections::HashSet, fmt};

 /// `EntityType.ARROW` (and tipped/spectral arrows): 0.5 x 0.5, eyes at 0.13.
-const WIDTH: f32 = 0.5;
-const HEIGHT: f32 = 0.5;
+pub const WIDTH: f32 = 0.5;
+pub const HEIGHT: f32 = 0.5;
 const EYE_HEIGHT: f32 = 0.13;

 /// `AbstractArrow.Pickup`.
@@ -505,6 +505,24 @@ fn signum(v: f64) -> f64 {
 /// entity stops there and is not kept: the game hands it to
 /// `finish_entity_hit` once it has hurt the entity.
 pub fn tick(p: &mut Projectile, scene: &ArrowScene, targets: &[(Who, Aabb)]) -> (bool, Hit) {
+    tick_with(p, scene, targets, true)
+}
+/// One arrow tick whose hit is canceled (`ProjectileImpactEvent`): the arrow
+/// moves on to where it would have hit, as `AbstractArrow.stepMoveAndHit` leaves
+/// it when the event is canceled, and flies on: not stuck, nothing hurt, no hit.
+pub fn tick_through(
+    p: &mut Projectile,
+    scene: &ArrowScene,
+    targets: &[(Who, Aabb)],
+) -> (bool, Hit) {
+    tick_with(p, scene, targets, false)
+}
+fn tick_with(
+    p: &mut Projectile,
+    scene: &ArrowScene,
+    targets: &[(Who, Aabb)],
+    impact: bool,
+) -> (bool, Hit) {
    let Some(mut st) = p.arrow.take() else {
        return (false, Hit::None);
    };
@@ -517,7 +535,7 @@ pub fn tick(p: &mut Projectile, scene: &ArrowScene, targets: &[(Who, Aabb)]) ->
        st: &mut st,
        scene,
    }
-    .tick(targets);
+    .tick(targets, impact);
    p.stuck = st.in_ground;
    let keep = !st.removed && !matches!(hit, Hit::Entity { .. });
    p.arrow = Some(st);
@@ -600,7 +618,7 @@ impl Ticker<'_, '_, '_, '_> {
    fn trident(&self) -> bool {
        matches!(self.p.kind, ProjectileKind::Trident)
    }
-    fn tick(&mut self, targets: &[(Who, Aabb)]) -> Hit {
+    fn tick(&mut self, targets: &[(Who, Aabb)], impact: bool) -> Hit {
        // ThrownTrident.tick.
        if self.trident() && self.st.in_ground_time > 4 {
            self.st.dealt_damage = true;
@@ -711,7 +729,7 @@ impl Ticker<'_, '_, '_, '_> {
            original.z + movement.z,
        );
        if physics {
-            hit = self.step_move_and_hit(original, end, targets);
+            hit = self.step_move_and_hit(original, end, targets, impact);
            if matches!(hit, Hit::Entity { .. }) {
                return hit;
            }
@@ -795,7 +813,13 @@ impl Ticker<'_, '_, '_, '_> {
    /// `AbstractArrow.stepMoveAndHit`: the nearest entity on the way, else the
    /// block. A piercing arrow that hits an entity here goes on from it next
    /// tick (`finish_entity_hit`); vanilla's loop goes on within the same tick.
-    fn step_move_and_hit(&mut self, from: Vec3, to: Vec3, targets: &[(Who, Aabb)]) -> Hit {
+    fn step_move_and_hit(
+        &mut self,
+        from: Vec3,
+        to: Vec3,
+        targets: &[(Who, Aabb)],
+        impact: bool,
+    ) -> Hit {
        let block = self.scene.clip(from, to);
        let end = block.map_or(to, |b| b.0);
        // findHitEntities: ProjectileUtil.computeMargin and the search box.
@@ -828,6 +852,10 @@ impl Ticker<'_, '_, '_, '_> {
        self.p.position = next;
        self.apply_effects_from_blocks(from, next);
        if let Some((who, at, _)) = best {
+            // A canceled impact ends the search, the arrow where it would have hit.
+            if !impact {
+                return Hit::None;
+            }
            // AbstractArrow.onHitEntity: past pierce level + 1 entities the
            // arrow is discarded before it hurts the next one.
            if self.st.pierce > 0 {
@@ -849,6 +877,9 @@ impl Ticker<'_, '_, '_, '_> {
        if self.scene.is_air(state) {
            return Hit::None;
        }
+        if !impact {
+            return Hit::None;
+        }
        self.on_hit_block(pos, state);
        Hit::Block {
            pos: [pos.x, pos.y, pos.z],
@@ -1,6 +1,7 @@
 //! horizon-ctl: play and script a running Horizon client through its control
 //! socket, from a shell, a script or an AI agent (`horizon-ctl mcp`).
 #![forbid(unsafe_code)]
+extern crate horizon_client_lib as horizon_client;
 mod commands;
 mod launch;
 mod mcp;
@@ -0,0 +1,130 @@
+//! Breathing for native mods: `LivingEntity.baseTick`'s air supply, the part
+//! that raises or lowers it. A player (`motion/environment.rs`) and a mob
+//! (`mobs/ai.rs`) work out what vanilla does this tick, `breathe` lets the
+//! mods change it (`native_living_breathe`, NeoForge's `LivingBreatheEvent`),
+//! and the caller applies the answer. Servers only: the callers keep it off a
+//! client's prediction.
+
+/// One tick of breathing: whether the entity can breathe, how much air it
+/// loses when it cannot and how much it gains when it can.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Breath {
+    pub can_breathe: bool,
+    /// `decreaseAirSupply`: 1, or 0 by the oxygen bonus's chance, for an
+    /// entity that drowns; 1 for one that would not.
+    pub consume: i32,
+    /// `increaseAirSupply`: 4 for one that can breathe, 0 for one that drowns
+    /// or is held under by the nautilus' breath.
+    pub refill: i32,
+}
+
+/// An entity's breathing this tick (`LivingBreatheEvent`, posted from
+/// `LivingEntity.baseTick` every tick for a living entity with the generic
+/// air logic): `entity` is its ID and `kind` its type (`minecraft:player`,
+/// `minecraft:zombie`). `can_breathe`, `consume` and `refill` come in as
+/// Horizon does it today (a mod-free game changes nothing); set them to
+/// change this tick. With `can_breathe` the air rises by `refill`, up to its
+/// maximum (300); without, it falls by `consume`, and at -20 it is set to 0
+/// and the entity takes 2 drowning damage. Negative amounts count as 0.
+/// Asked on servers for players and for mobs, except those with a
+/// `WaterAnimal`'s or an axolotl's own air logic. API @API:living_breathe@.
+#[inline(never)]
+pub fn native_living_breathe(
+    entity: u32,
+    kind: &str,
+    can_breathe: &mut bool,
+    consume: &mut i32,
+    refill: &mut i32,
+) {
+    let _ = (entity, kind, can_breathe, consume, refill);
+}
+
+/// `vanilla`'s breathing after the mods have had their say.
+pub fn breathe(entity: u32, kind: &str, vanilla: Breath) -> Breath {
+    let mut now = vanilla;
+    native_living_breathe(
+        entity,
+        kind,
+        &mut now.can_breathe,
+        &mut now.consume,
+        &mut now.refill,
+    );
+    Breath {
+        can_breathe: now.can_breathe,
+        consume: now.consume.max(0),
+        refill: now.refill.max(0),
+    }
+}
+
+/// The air supply after `breath`: raised up to `max` when it can breathe,
+/// lowered otherwise. The second is whether the entity now drowns
+/// (`LivingEntity.shouldTakeDrowningDamage`: -20 or less), and its air is
+/// then 0.
+pub fn apply(air: i32, max: i32, breath: Breath) -> (i32, bool) {
+    if breath.can_breathe {
+        return (air.max((air + breath.refill).min(max)), false);
+    }
+    let air = air - breath.consume;
+    if air <= -20 { (0, true) } else { (air, false) }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const VANILLA: Breath = Breath {
+        can_breathe: true,
+        consume: 1,
+        refill: 4,
+    };
+
+    #[test]
+    fn air_refills_up_to_the_maximum() {
+        assert_eq!(apply(100, 300, VANILLA), (104, false));
+        assert_eq!(apply(299, 300, VANILLA), (300, false));
+        assert_eq!(apply(300, 300, VANILLA), (300, false));
+        // A refill of 0 leaves it, as does one that would pass the maximum.
+        let held = Breath {
+            refill: 0,
+            ..VANILLA
+        };
+        assert_eq!(apply(120, 300, held), (120, false));
+    }
+
+    #[test]
+    fn air_runs_down_and_drowns_at_minus_twenty() {
+        let drowning = Breath {
+            can_breathe: false,
+            consume: 1,
+            refill: 0,
+        };
+        assert_eq!(apply(300, 300, drowning), (299, false));
+        assert_eq!(apply(-18, 300, drowning), (-19, false));
+        assert_eq!(apply(-19, 300, drowning), (0, true));
+        // The oxygen bonus can spare a tick, and a mod can take more.
+        let spared = Breath {
+            consume: 0,
+            ..drowning
+        };
+        assert_eq!(apply(-19, 300, spared), (-19, false));
+        let gas = Breath {
+            consume: 30,
+            ..drowning
+        };
+        assert_eq!(apply(20, 300, gas), (-10, false));
+        assert_eq!(apply(10, 300, gas), (0, true));
+    }
+
+    #[test]
+    fn nothing_changes_without_a_mod() {
+        assert_eq!(breathe(1, "minecraft:zombie", VANILLA), VANILLA);
+        let negative = Breath {
+            can_breathe: false,
+            consume: -3,
+            refill: -2,
+        };
+        // Mods only ever answer with their own values, so what comes back is clamped.
+        assert_eq!(breathe(1, "minecraft:player", negative).consume, 0);
+        assert_eq!(breathe(1, "minecraft:player", negative).refill, 0);
+    }
+}
@@ -325,10 +325,73 @@ pub fn interact(
    }
 }

+/// What `interact` would answer for `held`, changing nothing: a client's
+/// `useItemOn`, where every interaction checks the same conditions and acts
+/// only `if (!level.isClientSide())`.
+pub fn outcome(
+    cauldron: &BlockState,
+    under_water: bool,
+    removes_dye: bool,
+    held: &ItemStack,
+) -> Outcome {
+    struct Dry(Option<ItemStack>);
+    impl Player for Dry {
+        fn creative(&self) -> bool {
+            false
+        }
+        fn hand(&mut self) -> &mut Option<ItemStack> {
+            &mut self.0
+        }
+        fn add(&mut self, _: &mut ItemStack) -> bool {
+            true
+        }
+        fn contains(&self, _: &ItemStack) -> bool {
+            false
+        }
+        fn drop_stack(&mut self, _: ItemStack) {}
+    }
+    interact(
+        cauldron,
+        under_water,
+        removes_dye,
+        &mut Dry(Some(held.clone())),
+    )
+    .outcome
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;

+    #[test]
+    fn a_client_sees_the_bucket_taken_without_acting() {
+        let empty = state("minecraft:cauldron", None);
+        let water = |l| state("minecraft:water_cauldron", Some(l));
+        let stack = |id| ItemStack::new(id, 1);
+        let outcome = |c: &BlockState, under_water, id| outcome(c, under_water, false, &stack(id));
+        assert_eq!(
+            outcome(&empty, false, "minecraft:water_bucket"),
+            Outcome::Success
+        );
+        assert_eq!(
+            outcome(&empty, false, "minecraft:lava_bucket"),
+            Outcome::Success
+        );
+        // fillLavaInteraction under water: CONSUME, the bucket kept.
+        assert_eq!(
+            outcome(&empty, true, "minecraft:lava_bucket"),
+            Outcome::Consume
+        );
+        assert_eq!(
+            outcome(&water(3), false, "minecraft:bucket"),
+            Outcome::Success
+        );
+        // fillBucket needs a full cauldron.
+        assert_eq!(outcome(&water(2), false, "minecraft:bucket"), Outcome::Pass);
+        assert_eq!(outcome(&empty, false, "minecraft:bucket"), Outcome::Pass);
+        assert_eq!(outcome(&empty, false, "minecraft:stone"), Outcome::Pass);
+    }
+
    #[test]
    fn a_burning_entity_lowers_water_and_melts_powder_snow() {
        let water = |l| state("minecraft:water_cauldron", Some(l));
@@ -0,0 +1,164 @@
+//! Horizon native client: resources, world streaming, rendering and the
+//! bindings between the validated simulation pieces and the game loop.
+#![forbid(unsafe_code)]
+extern crate self as horizon_client;
+pub mod advancements;
+pub mod ambience;
+pub mod animate_tick;
+pub mod arrows;
+pub mod block_contact;
+pub use horizon_client_render::{
+    assets, atlas_sources, audio, auth, ban_notice, bidi, biome, block_edit, block_entities,
+    block_entity_anim, block_entity_render, border_render, breaking, brewing, camera, chat, chunk,
+    chunk_map, cit, clouds, collisions, command_block, containers, crash, datapack, dynamic_light,
+    effects, environment, extras, fast_hash, fog, font, gfx, graphics, graphics_style, graphics_ui,
+    hdr_calibration, hud, hud_layout, hud_overlays, inventory_effects, java_text, jigsaw_block,
+    level_loading, light, lod, logging, menu_blur, mesher, minimap, mipmap, mod_list,
+    model_library, models, multiline_edit, native_emissive, options_file, options_fixes,
+    options_ui, overlay, pack_screen, packs, par, particles, poi_sections, post_chain,
+    potent_sulfur, preedit, providers, screen_draw, screen_effects, sculk, section_mask, settings,
+    shader_options, shader_pack_list, signs, skins, sound_engine, sound_events, sound_preview,
+    spans, split_layout, split_profiles, sprites, streaming, structure_block, tab_list, telemetry,
+    test_block, test_instance_block, testgen, title_edition, trims, ui, vault, weather, widgets,
+    world, worldborder, zip,
+};
+pub mod attack_strength;
+pub mod attribute_updates;
+pub mod auto_jump;
+pub mod banner;
+pub mod beehive;
+pub mod benchmark;
+pub mod block_entity_item;
+pub mod block_pattern;
+pub mod block_transform;
+pub mod boss_overlay;
+pub mod breathing;
+pub mod cauldron;
+pub mod chunk_io;
+pub mod clock;
+pub mod command_storage;
+pub mod confirm_screen;
+pub mod container_screen;
+pub mod content_identity;
+pub mod control;
+pub mod crafting;
+pub mod creative;
+pub mod cushion;
+pub mod data_cmd;
+pub mod debug_chart;
+pub mod debug_entries;
+pub mod debug_keys;
+pub mod debug_overlay;
+pub mod debugworld;
+pub mod dialog;
+pub mod dialog_screen;
+pub mod discord_presence;
+pub mod end_crystal;
+pub mod end_gateway;
+pub mod entities;
+pub mod entity_culling;
+pub mod entity_nbt;
+pub mod extras_hud;
+pub mod falling_block;
+pub mod fire_render;
+pub mod first_person;
+pub mod flatgen;
+pub mod friends_screen;
+pub mod furnace;
+pub mod game_mode_switcher;
+pub mod game_rules_screen;
+pub mod gizmos;
+pub mod gossip;
+pub mod health;
+pub mod heartbeat;
+pub mod hotbar;
+pub mod hunger;
+pub mod inv_sort;
+pub mod item_activation;
+pub mod item_render;
+pub mod item_sync;
+pub mod item_tooltip;
+pub mod lan;
+pub mod landing;
+pub mod locator_bar;
+pub mod lod_net;
+pub mod menu;
+pub mod merchant;
+pub mod mobs;
+pub mod mod_content;
+pub mod motion;
+pub mod multiplayer;
+pub mod music;
+pub mod native_data;
+pub mod net;
+pub mod nether_portal;
+pub mod no_resources;
+pub mod offline_name;
+pub mod old_world;
+pub mod osk;
+pub mod patrol;
+pub mod perf_overlay;
+pub mod pick_item;
+pub mod player_sync;
+pub mod portal_sections;
+pub mod pose;
+pub mod pregen;
+pub mod projectiles;
+pub mod raid;
+pub mod ram_limit;
+pub mod random_tick_sections;
+pub mod recipe_book;
+pub mod recipe_book_screen;
+pub mod reconnect;
+pub mod save;
+pub mod scoreboard_cmd;
+pub mod screen_layout;
+pub mod screen_narrator;
+pub mod social_screen;
+pub use horizon_server_files as server;
+pub mod server_packs;
+pub mod shadows;
+pub mod spear;
+pub mod spectator_menu;
+pub mod sprint;
+pub mod stations;
+pub mod stopwatches;
+pub mod structure_blocks;
+pub mod text_display;
+pub mod tick_chunk_membership;
+pub mod ticket_levels;
+pub mod title;
+pub mod toasts;
+pub mod ui_theme;
+pub mod vanillagen;
+pub mod win_screen;
+pub mod world_spawn;
+pub use horizon_client_core::Result;
+pub use horizon_client_core::block_entity_nbt;
+pub use horizon_client_core::bossbar;
+pub use horizon_client_core::component;
+pub use horizon_client_core::fastutil_order;
+pub use horizon_client_core::gamerules;
+pub use horizon_client_core::lang;
+pub use horizon_client_core::nbt_path;
+pub use horizon_client_core::scoreboard;
+pub use horizon_client_core::snbt;
+pub use horizon_client_core::text;
+pub use horizon_client_input::clipboard;
+pub use horizon_client_input::gamepad;
+pub use horizon_client_input::input;
+pub use horizon_client_input::interaction_input;
+pub use horizon_client_input::key_names;
+pub use horizon_client_input::keybinds;
+pub use horizon_client_input::keymapping;
+pub use horizon_client_input::mouse;
+pub use horizon_client_input::window;
+pub use horizon_command as command;
+pub use horizon_items::blocks;
+pub use horizon_items::bundle;
+pub use horizon_items::cooldowns;
+pub use horizon_items::enchant;
+pub use horizon_items::flowers;
+pub use horizon_items::item_data;
+pub use horizon_items::items;
+pub use horizon_items::random_sequences;