Launcher: version 0.70-linux.5

The header came with Hunter's Atlas (6621a1f0) and holds the build
description of the Windows release it was taken from (windows-v1.8.1).
No source, script or test includes it or reads BB_ATLAS_BUILD_JSON; the
build and the tests are the same without it.

build.sh

@@ -149,4 +149,7 @@ if [[ ${1:-} == --test ]]; then
     rm -rf out/atlas-features && out/atlas-features-test out/atlas-features
     "${CXX:-c++}" "${atlas_cxx[@]}" tests/test_atlas_i18n.cpp -o out/atlas-i18n-test
     out/atlas-i18n-test
+    # When a mirror is made again over its valid blocks only (gpu/layer/layer_mirror_policy.h).
+    "${CXX:-c++}" -std=c++20 -O2 -g -UNDEBUG -Wall -Wextra -Werror -Igpu tests/test_layer_mirror_policy.cpp -o out/layer-mirror-policy-test
+    out/layer-mirror-policy-test
 fi

docs/CREDITS.md

@@ -49,7 +49,10 @@ Obrikash and noelmiller. What each one did:
   motion vectors without NaN.
 - **[Classmg22](https://github.com/Classmg22)** (CLS_AMG): BBSC, Seamless Co-op.
 - **[Wozzardman](https://github.com/Wozzardman)**: the server for a group's own co-op, and BBSC's seamless summon.
-- **[droogie](https://github.com/droogie)**: The Hunter's Dream server, and fast loading (bbhost).
+- **[droogie](https://github.com/droogie)**: The Hunter's Dream server, fast loading, and the L3 run-jump patch (Kyo's) as bbhost carries it.
+- **[Asanilo](https://github.com/Asanilo)**: two GPU fixes: work submission counts, and samplers freed after the frame that uses them.
+- **[AlexanderDzhoganov](https://github.com/AlexanderDzhoganov)**: BBSC: the guest no longer stays a spectator after a boss wipe.
+- **[nullsumlabs](https://github.com/nullsumlabs)**: an unknown system value (sysctl) no longer stops the game.
 - **[fhody125-web](https://github.com/fhody125-web)**: NoDreamForHunter, the base of BBSC's game server.
 - **[MikeTat1988](https://github.com/MikeTat1988)**: Hunter's Atlas, the fullscreen in-game map.
 - **[IFreemz](https://github.com/IFreemz)**: the FSR 4 model without trails.
@@ -67,7 +70,8 @@ Obrikash and noelmiller. What each one did:
 - **[Mrsuss60](https://github.com/Mrsuss60)**: the gestures menu from the keyboard, a deleted
   image's slot, and the log of failed memory reservations.
 - **[SrShadowy](https://github.com/SrShadowy)**: the on-screen keyboard for the character's name,
-  and the shader compiling notice.
+  the shader compiling notice, and compacting the memory copies in VRAM.
+- **[Wooloomooloo2](https://github.com/Wooloomooloo2)**: the game starting on integrated Intel Arc/Xe GPUs.
 - **[Qiming-Liu](https://github.com/Qiming-Liu)**: the Simplified Chinese translation.
 - **[andrecabralgit](https://github.com/andrecabralgit)**: the game's audio at full level.
 - **[Jgamrot](https://github.com/Jgamrot)**: the in-game menu's checkboxes and sliders.
@@ -98,7 +102,7 @@ Obrikash and noelmiller. What each one did:
 - **[n3vrs0ft](https://github.com/n3vrs0ft)**: the "Transaction failed" crash on Seamless Hunt, the logs that stopped a BBSC guest from following a stranger's world, and testing BBSC 0.0.2 with a Windows player.
 - **[cappp](https://github.com/cappp)**: the "Transaction failed" crash on Seamless Hunt.
 - **[simo1730](https://github.com/simo1730)**: the Trophies page not finding the dump's files.
-- **[Nahnahchi](https://github.com/Nahnahchi)**: logs and tests of a GPU freeze in a boss fight on NVIDIA, a crash in Yahar'gul, stretched models, a crash on the Steam Deck, effects turning black, rainbow textures and crashes in the game's memory manager.
+- **[Nahnahchi](https://github.com/Nahnahchi)**: logs and tests of a GPU freeze in a boss fight on NVIDIA, a crash in Yahar'gul, stretched models, a crash on the Steam Deck, effects turning black, rainbow textures, crashes in the game's memory manager, frame rate drops on NVIDIA, and Exit to Desktop with online play.
 - **[thomasgarafano1](https://github.com/thomasgarafano1)**: Hunter's Atlas not preparing the map with a GOTY dump, and testing the fix.
 - **[TacticalBill](https://github.com/TacticalBill)**: marking trophies already earned on the PS4.
 - **[holydingus](https://github.com/holydingus)**: BBSC's items not given to a new character.
@@ -107,3 +111,6 @@ Obrikash and noelmiller. What each one did:
 - **[BlazinKarp](https://github.com/BlazinKarp)**: the Steam overlay in the game.
 - **[molnar-a](https://github.com/molnar-a)**: a crash on the Steam Deck after lamp travel, and testing the fix.
 - **[Aman9das](https://github.com/Aman9das)**: asking for bbport 0.6's keyboard layout.
+- **[eberhardweber](https://github.com/eberhardweber)**: logs and tests of AMD FX processors, fullscreen on Wayland with several monitors, and the AppImage's version in Gear Lever.
+- **[GitBire](https://github.com/GitBire)**: the storage box with keyboard and mouse.
+- **[npc-xc](https://github.com/npc-xc)**: logs of frame rate drops on NVIDIA.

docs/ENVIRONMENT.md

@@ -319,7 +319,7 @@ Defaults to change on a machine where they misbehave, workarounds, and switches
 | `BB_MIRROR_POOL_MB` | =N: retired mirrors kept for new ones |
 | `BB_MIRROR_REPROMOTE_SECONDS` | =N (default 0): blocks sent back are not copied again that soon |
 | `BB_MIRROR_UNBOUND_SECONDS` | =N (0 never): blocks no binding named for N seconds leave VRAM |
-| `BB_MIRROR_VRAM_ONLY` | =1: mirrors in VRAM or not at all |
+| `BB_MIRROR_VRAM_ONLY` | =1 / 0: mirrors in VRAM or not at all, or in system memory too when VRAM is full (default: VRAM only on cards over 4 GiB) |
 | `BB_MOTION_LARGE` | =0: bone palettes of 16-64 KiB (the large beasts) get camera motion vectors only, not object motion |
 | `BB_MOTION_VERTICES_MI` | =N (1-8): object motion vertex buffer in Mi vertices |
 | `BB_NET_MODULE` | =path: the online module to load (default gpu/libbbnet20.so beside bb-probe) |

docs/TROUBLESHOOTING.md

@@ -51,6 +51,27 @@ On a 6 GB card the texture cache can run out of video memory: the log then repea
 a lower output resolution, lower **Model detail** in the game's *Display* settings, and close
 other programs that use the GPU (browsers, video players, other games).
 
+## The frame rate drops in some places and stays low until a reload
+
+Seen mostly on NVIDIA cards (#42): the game runs at its usual rate, then in some places drops
+(to 17-35 FPS) and stays there until a lamp travel or a restart. When video memory was full, a
+copy of the game's memory could land in system memory and stay there, and the GPU read it over
+the bus. From 0.70-linux.4, on cards with more than 4 GB those copies stay in video memory, and
+one that does not fit is made again later; the log says so at start (`Layer memory: mirrors in
+VRAM only`). `BB_MIRROR_VRAM_ONLY=0` under **Advanced → Developer → Extra variables** brings the
+old behaviour back, and `=1` turns it on for a card of 4 GB or less.
+
+A place that is simply heavy is different: it is slower from the moment you get there, and the
+same after a reload. If a drop stays until a reload, turn on **Save the log and statistics to a
+file** and attach the log of that whole session to the issue.
+
+## Keyboard and mouse in the game's menus
+
+In the game's menus the mouse points at items and the **left button** chooses them. The other
+buttons keep what they do in play, as the game's own prompts show: the **right button** is L2
+(the storage box switches to the storage with it), the side buttons R2 and L1. **Escape** goes
+back.
+
 ## The picture is stretched on an ultrawide screen
 
 Choose the screen's shape in **Graphics → Display → Aspect ratio** (*Auto* follows the output

gpu/CMakeLists.txt

@@ -337,6 +337,13 @@ add_executable(camera-matrices-test EXCLUDE_FROM_ALL ../tests/test_camera_matric
 target_compile_options(camera-matrices-test PRIVATE -UNDEBUG -Wall -Wextra -Werror)
 target_include_directories(camera-matrices-test PRIVATE ..)
 
+# When a mirror is made again over its valid blocks only (gpu/layer/layer_mirror_policy.h). Pure,
+# no Vulkan device: the regression test for the default run of 0.7 that compacted nothing at all.
+# From the SrShadowy fork.
+add_executable(layer-mirror-policy-test EXCLUDE_FROM_ALL ../tests/test_layer_mirror_policy.cpp)
+target_compile_options(layer-mirror-policy-test PRIVATE -UNDEBUG -Wall -Wextra -Werror)
+target_include_directories(layer-mirror-policy-test PRIVATE .)
+
 add_executable(scene-resolution-test EXCLUDE_FROM_ALL ../tests/test_scene_resolution.cpp ../tests/test_gpu_runtime_stubs.cpp)
 target_include_directories(scene-resolution-test PRIVATE . shim ${SHADER_INCLUDE} third_party/gcn/include)
 # The test's Vulkan-Hpp inline methods have a different set of platform extensions

gpu/bbnet20/bbsc/core/bloodborne_re.cpp

@@ -8535,7 +8535,31 @@ void TickBbscSpectate() {
         LOG_INFO(Debug, "BBSC spectate: a partner said dead and then alive while we were down - "
                         "it reloaded after a wipe, the guest follows");
     }
-    if (session_alive && LivingPartnerExists()) {
+    // Second wipe signal: the host's own position reports. It says nothing while it loads, so a
+    // report after a silence means it came out of a load while we were down, with the boss not
+    // killed: it reloaded after a wipe. The life packets above can miss this (the host was already
+    // dead when our death began, or it woke in another map), which left the guest spectating until
+    // the safety limit, with its world unloaded around it (BBSC issue #44).
+    BbscFollowMessage host_report{};
+    {
+        std::scoped_lock lock{bbsc_follow_mutex};
+        host_report = bbsc_follow_latest;
+    }
+    const bool host_report_fresh =
+        host_report.received_ms != 0 && now - host_report.received_ms < BbscFollowStaleMs;
+    const bool host_came_back = session_state == 6 && host_report_fresh &&
+                                host_report.arrival_by_load &&
+                                host_report.arrival_ms >= bbsc_spectate_since_ms &&
+                                bbsc_boss_killed_ms < bbsc_spectate_since_ms &&
+                                !BbscAllPartnersReportDead();
+    if (host_came_back && !bbsc_spectate_saw_wipe) {
+        bbsc_spectate_saw_wipe = true;
+        BBSC_TIMELINE("SPECTATE", "the host came out of a load in map {:#x} while we were down - "
+                                  "the guest follows",
+                      host_report.packed_map);
+    }
+    // A host that woke in another map has no character here, so LivingPartnerExists can't see it.
+    if (session_alive && (LivingPartnerExists() || host_came_back)) {
         std::string_view respawn_why;
         const u64 chr = GetLocalPlayerCharacter();
         if (bbsc_death_mode == BbscDeathMode::RespawnNow) {
@@ -8558,13 +8582,39 @@ void TickBbscSpectate() {
                                  ? real_host
                                  : FindLivingPartnerCharacter();
             const auto host_transform = ReadCharacterTransform(host);
-            if (host_transform.has_value()) {
-                SummonPlacementDescriptor to{};
-                to.packed_region = GetCurrentPackedMap();
+            const u32 here = GetCurrentPackedMap();
+            SummonPlacementDescriptor to{};
+            bool have_target = false;
+            if (host_report_fresh && host_report.packed_map != here) {
+                // The host's coordinates only mean something in its own map: load that map, with
+                // its world state, as a follow does.
+                to.packed_region = host_report.packed_map;
+                to.x = host_report.x + 1.0f;
+                to.y = host_report.y;
+                to.z = host_report.z;
+                to.heading = host_report.heading;
+                have_target = true;
+                if (BbscHostWorldFlagsReady(to.packed_region)) {
+                    ApplyBbscHostWorldFlags(to.packed_region, "before the wipe load");
+                }
+                ApplyBbscHostTime("before the wipe load");
+                ApplyBbscGuestLootView(to.packed_region, "before the wipe load");
+                if (to.packed_region == BbscDreamStateMap) {
+                    ApplyBbscHostDreamState("before the wipe load");
+                } else {
+                    RestoreBbscOwnDreamState("following the host after the wipe");
+                }
+            } else if (host_transform.has_value()) {
+                to.packed_region = here;
                 to.x = host_transform->position[0] + 1.0f;
                 to.y = host_transform->position[1];
                 to.z = host_transform->position[2];
                 to.heading = host_transform->rotation[1];
+                have_target = true;
+            }
+            if (have_target) {
+                BBSC_TIMELINE("SPECTATE", "wipe: reloading beside the host in map {:#x}",
+                              to.packed_region);
                 if (RequestBbscSessionWarp(GetGlobalState(), to, "wipe")) {
                     return; // the load builds a new character: "a load ended the boss fight"
                 }

gpu/buffers/buffer_cache.h

@@ -550,7 +550,8 @@ private:
     void LayerProcessIdle();
     /// VRAM near the texture collector's critical mark: idle mirrors go back in place.
     void LayerYieldToImages(u32 now);
-    /// Makes mirrors with memory left without valid blocks again over those blocks only.
+    /// Makes mirrors with memory left without valid blocks again over those blocks only
+    /// (gpu/layer/layer_mirror_policy.h: the per-mirror threshold and the segments).
     u64 LayerCompactMirrors(u64 wanted);
     /// The GPU writes [address, address + size) in the submission being recorded (write ticks).
     void NoteWriteTick(VAddr address, u64 size);

gpu/cp/command_processor.cpp

@@ -664,12 +664,14 @@ void CommandProcessor::SubmitGfx(std::span<const u32> dcb, std::span<const u32>
         BbFreeCheck::NoteSubmit(work->seq, work->copy ? work->copy->guest_dcb : dcb.data(),
                                 dcb.size_bytes());
         queue.works.push_back(std::move(work));
+        // Visible only once counted: the decoder reads this queue under the same lock,
+        // so the count it tests must be published before the task can be seen.
+        std::scoped_lock submit_lock{submit_mutex};
+        ++num_submits;
+        ++submissions_total;
+        BbTimeline::Note(BbTimeline::GuestSubmit, 0, submissions_total);
+        work_retired = false;
     }
-    std::scoped_lock lock{submit_mutex};
-    ++num_submits;
-    ++submissions_total;
-    BbTimeline::Note(BbTimeline::GuestSubmit, 0, submissions_total);
-    work_retired = false;
     submit_cv.notify_one();
 }
 
@@ -684,12 +686,12 @@ void CommandProcessor::SubmitAsc(u32 gnm_vqid, std::span<const u32> acb) {
         std::scoped_lock lock{queue.mutex};
         work->stamp = BbStats::guest_submit_stamp.fetch_add(1, std::memory_order_acq_rel) + 1;
         queue.works.push_back(std::move(work));
+        std::scoped_lock submit_lock{submit_mutex};
+        num_mapped_queues = std::max(num_mapped_queues, gnm_vqid + 1);
+        ++num_submits;
+        ++submissions_total;
+        work_retired = false;
     }
-    std::scoped_lock lock{submit_mutex};
-    num_mapped_queues = std::max(num_mapped_queues, gnm_vqid + 1);
-    ++num_submits;
-    ++submissions_total;
-    work_retired = false;
     submit_cv.notify_one();
 }
 

gpu/games/bloodborne_menu_pointer.cpp

@@ -46,6 +46,9 @@
 #include "bbport_toggles.h"
 #include "common/types.h"
 
+// bb-probe (runtime_services.c); weak: the GPU library's tests link without it.
+extern "C" void runtime_quit_at_title(void) __attribute__((weak));
+
 namespace BbMenuPointer {
 namespace {
 
@@ -437,6 +440,12 @@ bool InputBlocked() {
     return block && Get<std::uint32_t>(block + 0x2e4);
 }
 
+/// The game's title menu (the menu flow's +0xb11 zero), as InMenu reads it.
+bool AtTitle() {
+    const Addr flow = Get<Addr>(At(MenuFlow));
+    return flow && !Get<std::uint8_t>(flow + 0xb11, 1);
+}
+
 bool InMenu() {
     const Addr flow = Get<Addr>(At(MenuFlow));
     const bool title = flow && !Get<std::uint8_t>(flow + 0xb11, 1);
@@ -705,6 +714,17 @@ void ReadTestFile() {
 /// The pad state the game reads (pad thread): the pointer's presses, each held long enough for
 /// the game to see it, with a gap after.
 void OnPad(std::uint32_t* buttons, const std::uint8_t* sticks) {
+    // Exit to desktop (runtime_services.c): the game going from the world to its title menu is the
+    // title it waits for. Issue #46: with online play on, the game came back to the title without
+    // opening the intro logos or looking its title menu's texts up again, and closed only when a
+    // new game was started from there. Only the change counts (the flag is also set at start);
+    // runtime_quit_at_title does nothing unless Exit to desktop is armed.
+    static bool was_title = true;
+    const bool title = AtTitle();
+    if (title && !was_title && runtime_quit_at_title) {
+        runtime_quit_at_title();
+    }
+    was_title = title;
     const auto off_centre = [](std::uint8_t v) { return v < 64 || v > 192; };
     pad_steering.store((*buttons & (Up | Right | Down | Left)) || off_centre(sticks[0]) ||
                            off_centre(sticks[1]),

gpu/games/bloodborne_menu_pointer.h

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 // Bloodborne (1.09): the mouse as a pointer in the game's own menus (Scaleform lists: the title
 // menu, the inventory, the shops, the options). The item under the pointer gets the game's cursor,
-// a click presses the confirm button on it (or the slider's arrow it is on), the right button goes
-// back, the wheel moves up and down. bloodborne_menu_pointer.cpp has the reverse engineering.
+// a click presses the confirm button on it (or the slider's arrow it is on), the other buttons keep
+// their bindings (the right one L2), the wheel moves up and down. bloodborne_menu_pointer.cpp has the reverse engineering.
 #pragma once
 
 namespace BbMenuPointer {

gpu/layer/buffer_cache_layer.cpp

@@ -44,6 +44,7 @@
 #include "bblayer_gpu_memory.h"
 #include "bblayer_write_traps.h"
 #include "layer/buffer_cache_layer_internal.h"
+#include "layer/layer_mirror_policy.h"
 
 namespace VideoCore {
 
@@ -347,6 +348,7 @@ bool BufferCache::LayerMergeAcross(u64 first, u64 end) {
             BbStats::residency_alloc_bytes.fetch_sub(old.size, std::memory_order_relaxed);
             layer_retired.push_back({std::move(node.mapped()), scheduler.CurrentTick()});
         }
+        layer_mirror_born.erase(old.base); // it is gone: its start may be reused by another mirror
     }
     Layer().AddMirror(start, bytes, merged->Handle(), merged->BufferDeviceAddress(), merged.get());
     layer_mirrors.emplace(start, std::move(merged));
@@ -416,6 +418,7 @@ u64 BufferCache::LayerPromoteInto(u64 first, u64 end, u64 lo, u64 hi,
                 BbStats::residency_alloc_bytes.fetch_sub(old.size, std::memory_order_relaxed);
                 layer_retired.push_back({std::move(node.mapped()), scheduler.CurrentTick()});
             }
+            layer_mirror_born.erase(old.base); // it is gone: its start may be reused by another mirror
         }
         Layer().AddMirror(start, bytes, target->Handle(), target->BufferDeviceAddress(), target);
         layer_mirrors.emplace(start, std::move(mirror));
@@ -555,6 +558,7 @@ void BufferCache::LayerDemote(u64 first, u64 end, bool copy_back, int reason) {
             BbStats::residency_alloc_bytes.fetch_sub(mirror.size, std::memory_order_relaxed);
             layer_retired.push_back({std::move(node.mapped()), scheduler.CurrentTick()});
         }
+        layer_mirror_born.erase(mirror.base); // it is gone: its start may be reused by another mirror
     }
     ++layer_generation;
 }
@@ -637,10 +641,22 @@ std::unique_ptr<Buffer> BufferCache::LayerNewMirror(VAddr start, u64 bytes) {
         }
         ++mirror_pool_misses;
     }
-    // BB_MIRROR_VRAM_ONLY=1: VRAM or none (VMA puts "mirrors" in system memory when VRAM is full).
-    // Off by default: VMA's budget check refused them at 1.5-1.65 GB of a 1.77-1.83 GB budget on
-    // the 2 GB laptop, the geometry was read over the bus and the game fell to 8-29 FPS (2026-10-26).
-    static const bool system_ok = !bb_env_on("BB_MIRROR_VRAM_ONLY");
+    // VRAM or none: without it VMA puts a mirror in system memory when VRAM is full, and there it
+    // stays until its blocks are retired, so the GPU reads that geometry over the bus until a
+    // reload (#42: an RTX 4060 at 17-27 FPS in the same places; BB_MIRROR_VRAM_ONLY=1 fixed it).
+    // A mirror refused instead is made again later, when there is room. On by default on cards
+    // with more than 4 GiB; small cards keep the fallback: VMA's budget check refused mirrors at
+    // 1.5-1.65 GB of a 1.77-1.83 GB budget on the 2 GB laptop, the geometry was read over the bus
+    // and the game fell to 8-29 FPS (2026-10-26). BB_MIRROR_VRAM_ONLY=1 / 0 forces either.
+    static const bool system_ok = [this] {
+        const bool vram_only = bb_env_on("BB_MIRROR_VRAM_ONLY")    ? true
+                               : bb_env_off("BB_MIRROR_VRAM_ONLY") ? false
+                               : instance.GetTotalMemoryBudget() > (u64{4} << 30);
+        std::printf("Layer memory: mirrors %s (BB_MIRROR_VRAM_ONLY)\n",
+                    vram_only ? "in VRAM only, made again later when it is full"
+                              : "in system memory too when VRAM is full");
+        return !vram_only;
+    }();
     std::optional<VramOnlyScope> vram_only;
     if (!system_ok) {
         vram_only.emplace();
@@ -756,11 +772,15 @@ void BufferCache::LayerMaintain() {
         return u32(std::max<long>(env && *env ? std::strtol(env, nullptr, 10) : 1, 1));
     }();
     static u32 compacted_second = 0;
-    // Waste no compaction could free (valid blocks closer than its Bridge): not tried again until
-    // more of it comes (the mirrors were made again every second, 0 MiB freed).
+    // Waste no compaction could free last time: it is not tried again until more of it comes,
+    // or kRetrySeconds pass. The time matters because the mirrors that were too young (or whose
+    // waste sits between their valid blocks) become eligible as they grow older and lose blocks;
+    // without it a run with nothing to compact rescanned every mirror every second for nothing.
     static u64 stuck_waste = 0;
+    static u32 retry_after = 0;
     if (const u32 second = BbStats::coarse_second.load(std::memory_order_relaxed);
         compact_at != 0 && second - compacted_second >= compact_every) {
+        const bool retry_due = second >= retry_after;
         compacted_second = second;
         u64 waste = 0;
         for (const auto& [start, mirror] : layer_mirrors) {
@@ -769,11 +789,23 @@ void BufferCache::LayerMaintain() {
                                  [&](u64 a, u64 b) { valid += b - a; });
             waste += mirror->SizeBytes() - (valid << block_shift);
         }
+        // The floor only goes down with the waste: the growth is what justifies another look.
         if (waste < stuck_waste) {
             stuck_waste = waste;
         }
-        if (waste >= compact_at && waste >= stuck_waste + compact_at / 2) {
-            stuck_waste = LayerCompactMirrors(waste) == 0 ? waste : 0;
+        // Either more waste came (compact_at / 2 of it), or the retry is due: the same waste
+        // seen again later may now be in mirrors old enough to be made again.
+        if (waste >= compact_at &&
+            (retry_due || waste >= stuck_waste + compact_at / 2)) {
+            // One call takes a bounded share of the waste: the copies it costs then spread over
+            // the seconds that follow instead of landing in one long frame.
+            if (LayerCompactMirrors(LayerPolicy::CompactBudget(waste)) == 0) {
+                stuck_waste = waste;
+                retry_after = second + LayerPolicy::kRetrySeconds;
+            } else {
+                stuck_waste = 0;
+                retry_after = 0;
+            }
         }
     }
     // Retired mirrors the GPU is done with. BB_LAYER_CHECK=1: no page table entry may still point
@@ -1106,10 +1138,11 @@ void BufferCache::NoteDirectUse(VAddr address, u64 size) {
 
 u64 BufferCache::LayerCompactMirrors(u64 wanted) {
     // Mirror memory without valid blocks (sent back in place, unmapped, handed out anew, the room
-    // to grow) stays allocated as long as its mirror lives. Mirrors with at least MinWaste of it,
-    // the most first, are made again over their valid blocks only: one new mirror per run of
-    // valid blocks (runs closer than Bridge stay in one), their data copied over, the old mirror
-    // retired as in a merge. No copy is lost.
+    // to grow) stays allocated as long as its mirror lives. Mirrors with enough of it, the most
+    // first, are made again over their valid blocks only: one new mirror per run of valid blocks
+    // (the heads and tails always come off; a hole between two runs pays for the mirror it needs,
+    // see LayerPolicy::MirrorSegments), their data copied over, the old mirror retired as in a
+    // merge. No copy is lost.
     // Mirrors younger than BB_MIRROR_COMPACT_AGE seconds (30) are left alone unless VRAM is past the
     // texture collector's critical mark: on the 2 GB laptop compaction cut the room a mirror had
     // just grown, the next run grew it again (80, 52, 112, 64 MiB within seconds), 411 mirrors of
@@ -1122,19 +1155,30 @@ u64 BufferCache::LayerCompactMirrors(u64 wanted) {
     const u64 critical = BbStats::gc_critical_bytes.load(std::memory_order_relaxed);
     const bool emergency =
         critical != 0 && BbStats::gc_used_bytes.load(std::memory_order_relaxed) >= critical;
-    constexpr u64 MinWaste = 8_MB, Bridge = 4_MB;
     std::vector<std::pair<u64, VAddr>> wasteful; // bytes without valid blocks, start
+    // Why a pass could not act, for the log: a default run that compacts nothing has to say which
+    // filter stopped it (the age gate, the per-mirror threshold, waste between valid blocks, no
+    // room), or every acceptance run ends in the same guess.
+    size_t young = 0, below = 0, whole = 0, noroom = 0;
+    u32 oldest_young = 0; // the age of the mirror the age gate held back the longest
     for (const auto& [start, mirror] : layer_mirrors) {
         if (const auto born = layer_mirror_born.find(start);
             !emergency && born != layer_mirror_born.end() && now - born->second < min_age) {
+            ++young;
+            oldest_young = std::max(oldest_young, now - born->second);
             continue;
         }
-        const u64 lo = start >> block_shift, hi = (start + mirror->SizeBytes()) >> block_shift;
+        const u64 size = mirror->SizeBytes();
+        const u64 lo = start >> block_shift, hi = (start + size) >> block_shift;
         u64 valid = 0;
         Layer().ForEachValid(lo, hi, [&](u64 a, u64 b) { valid += b - a; });
-        const u64 waste = mirror->SizeBytes() - (valid << block_shift);
-        if (waste >= MinWaste) {
+        const u64 waste = size - (valid << block_shift);
+        // The threshold follows the mirror's size: a fixed 8 MiB was more than a whole mirror of
+        // the default run (7.8 MiB), so nothing was ever compacted there.
+        if (waste >= LayerPolicy::MirrorMinWaste(size)) {
             wasteful.emplace_back(waste, start);
+        } else {
+            ++below;
         }
     }
     std::ranges::sort(wasteful, std::greater{});
@@ -1146,20 +1190,19 @@ u64 BufferCache::LayerCompactMirrors(u64 wanted) {
         }
         const u64 old_size = layer_mirrors.at(start)->SizeBytes();
         const u64 lo = start >> block_shift, hi = (start + old_size) >> block_shift;
-        std::vector<std::pair<u64, u64>> segments;
-        u64 remade = 0;
-        Layer().ForEachValid(lo, hi, [&](u64 a, u64 b) {
-            if (!segments.empty() && ((a - segments.back().second) << block_shift) < Bridge) {
-                segments.back().second = b;
-            } else {
-                segments.emplace_back(a, b);
-            }
-        });
-        for (const auto& [a, b] : segments) {
-            remade += (b - a) << block_shift;
-        }
-        if (old_size - remade < MinWaste) {
-            continue; // its waste lies between valid blocks: copies for nothing
+        std::vector<LayerPolicy::Segment> runs;
+        Layer().ForEachValid(lo, hi, [&](u64 a, u64 b) { runs.push_back({a, b}); });
+        const auto segments = LayerPolicy::MirrorSegments(
+            runs, block_shift, LayerPolicy::MirrorMinHole(old_size),
+            LayerPolicy::kMaxSegmentsPerMirror);
+        const u64 remade = LayerPolicy::SegmentsBytes(segments, block_shift);
+        // What it would actually free. The per-mirror threshold is asked again here: a mirror
+        // whose waste lies between its valid blocks comes back whole (the head and the tail are
+        // all it can drop), and copying it for a few KiB is the failure of 2026-10-25 (411
+        // mirrors in 8 minutes for 0.4 GB of data on the 2 GB laptop).
+        if (old_size - remade < LayerPolicy::MirrorMinWaste(old_size)) {
+            ++whole;
+            continue;
         }
         // The new mirrors first: without room in VRAM for all of them this one stays as it is.
         std::vector<std::unique_ptr<Buffer>> made;
@@ -1173,6 +1216,7 @@ u64 BufferCache::LayerCompactMirrors(u64 wanted) {
             made.push_back(std::move(mirror));
         }
         if (made.size() != segments.size()) {
+            ++noroom;
             continue;
         }
         auto node = layer_mirrors.extract(start);
@@ -1213,6 +1257,19 @@ u64 BufferCache::LayerCompactMirrors(u64 wanted) {
         std::printf("Layer memory: %zu mirrors made again over their valid blocks, "
                     "%llu MiB freed\n",
                     compacted, (unsigned long long)(freed >> 20));
+    } else if (!layer_mirrors.empty()) {
+        // Nothing came back, and the run needs to say why instead of leaving it to the next
+        // acceptance run to guess: too young (the age gate), under the per-mirror threshold, waste
+        // all between valid blocks (it would come back whole), or no room for the new mirrors.
+        // Rate limited: the VRAM pressure path can call this every frame while it is short.
+        static u32 printed = 0; // coarse seconds; 0 = not yet
+        if (printed == 0 || now - printed >= 10) {
+            printed = now;
+            std::printf("Layer memory: nothing compacted: %zu young (age gate %u s, oldest %u s), "
+                        "%zu under the per-mirror waste, %zu waste between valid blocks, %zu without "
+                        "room\n",
+                        young, min_age, oldest_young, below, whole, noroom);
+        }
     }
     return freed;
 }

gpu/layer/layer_mirror_policy.h

@@ -0,0 +1,130 @@
+// SPDX-FileCopyrightText: Copyright 2026 bbport contributors
+// SPDX-License-Identifier: GPL-2.0-or-later
+// bbport: when a mirror is worth making again over its valid blocks only (BufferCache::
+// LayerCompactMirrors), and from which of its valid runs. Pure: no Vulkan, no guest, no
+// environment, so the tests cover it without a device (tests/test_layer_mirror_policy.cpp).
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <vector>
+
+#include "common/types.h"
+
+namespace VideoCore::LayerPolicy {
+
+/// A run of blocks: [first, end), both in the layer's blocks.
+struct Segment {
+    u64 first = 0;
+    u64 end = 0;
+
+    bool operator==(const Segment&) const = default;
+};
+
+/// The waste (bytes without valid blocks) a mirror of `bytes` must have before it is made again:
+/// a quarter of it, between 1 and 8 MiB. A mirror of 4 MiB therefore needs 1 MiB of waste, one of
+/// 8 MiB needs 2 MiB, and from 32 MiB up it is 8 MiB.
+///
+/// The fixed 8 MiB of 0.7 was the size of a whole mirror on the run it was chosen for: 223-225
+/// mirrors of 1,750 MiB (7.8 MiB each) held 612 MiB of waste between them (2.7 MiB each), so not
+/// one of them ever reached it and nothing was compacted in the whole run (default run without any
+/// BB_MIRROR_* variable, 2026-11-05).
+inline u64 MirrorMinWaste(u64 bytes) {
+    return std::clamp<u64>(bytes / 4, 1_MB, 8_MB);
+}
+
+/// A hole (bytes without valid blocks between two valid runs of a mirror) is only split out into
+/// a mirror of its own when it is worth one: a thirty-second of the mirror, between 256 KiB and
+/// 4 MiB. Below that the copy into the extra mirror costs more than the hole frees -- the run of
+/// 2026-10-25 made 411 mirrors in 8 minutes for 0.4 GB of data that way.
+inline u64 MirrorMinHole(u64 bytes) {
+    return std::clamp<u64>(bytes / 32, 256_KB, 4_MB);
+}
+
+/// The most mirrors one compacted mirror becomes. The holes that have to be kept to stay under it
+/// are the smallest ones: a mirror split into a hundred pieces costs more to bind than its waste.
+constexpr u32 kMaxSegmentsPerMirror = 8;
+
+/// The waste one extra mirror has to free to be worth making: below it the split costs (a copy of
+/// the data and one more binding range) more than it gives back.
+constexpr u64 kSegmentPays = 1_MB;
+
+/// The segments a mirror is made again from, given its valid runs.
+///
+/// `runs` must be sorted and must not overlap. The heads and tails (the waste before the first run
+/// and after the last) are always dropped: that costs no extra mirror, only the copy it already
+/// makes. A hole between two runs is split out when it is at least `min_hole`, while the pieces
+/// stay under `max_segments`, and only when the waste freed pays for the extra mirrors
+/// (`kSegmentPays` each). So a mirror whose waste is scattered in small holes between its data
+/// comes back as one segment and the caller sees no gain -- which is the right answer: it would
+/// have been copies for nothing.
+///
+/// The smallest holes are the ones kept when a limit is reached.
+inline std::vector<Segment> MirrorSegments(const std::vector<Segment>& runs, u64 shift,
+                                           u64 min_hole, u32 max_segments) {
+    std::vector<Segment> segments;
+    if (runs.empty()) {
+        return segments;
+    }
+    // The head and the tail are dropped for free: they come off without an extra mirror.
+    const std::size_t holes = runs.size() - 1;
+    const auto gap = [&](std::size_t i) {
+        return (runs[i + 1].first - runs[i].end) << shift;
+    };
+    const u32 limit = std::max<u32>(max_segments, 1);
+    // Holes worth a mirror of their own, smallest first when some have to go back.
+    std::vector<std::size_t> candidates;
+    for (std::size_t i = 0; i < holes; ++i) {
+        if (gap(i) >= min_hole) {
+            candidates.push_back(i);
+        }
+    }
+    std::ranges::sort(candidates, {}, gap);
+    // The biggest holes first, each as long as the waste it frees pays for the extra mirror it
+    // costs (kSegmentPays each). The head and the tail are free: they come off without one.
+    std::vector<bool> split(holes, false);
+    u64 freed = 0;
+    u32 pieces = 1;
+    for (auto it = candidates.rbegin(); it != candidates.rend(); ++it) {
+        const u32 next = pieces + 1;
+        if (next > limit || freed + gap(*it) < u64(next - 1) * kSegmentPays) {
+            break; // sorted biggest first: nothing after this one pays either
+        }
+        split[*it] = true;
+        freed += gap(*it);
+        pieces = next;
+    }
+    Segment current{runs.front().first, runs.front().end};
+    for (std::size_t i = 0; i < holes; ++i) {
+        if (split[i]) {
+            segments.push_back(current);
+            current = Segment{runs[i + 1].first, runs[i + 1].end};
+        } else {
+            current.end = runs[i + 1].end;
+        }
+    }
+    segments.push_back(current);
+    return segments;
+}
+
+/// The bytes the segments hold, to compare with the mirror's size.
+inline u64 SegmentsBytes(const std::vector<Segment>& segments, u64 shift) {
+    u64 bytes = 0;
+    for (const auto& segment : segments) {
+        bytes += (segment.end - segment.first) << shift;
+    }
+    return bytes;
+}
+
+/// After a compaction that freed nothing, the next attempt waits this long: the mirrors it looked
+/// at could not be made again (their waste all lies between valid blocks, or they are too young),
+/// and rescanning them every second changes nothing while costing the whole scan.
+constexpr u32 kRetrySeconds = 30;
+
+/// The waste one compaction call takes, so the copies it costs are spread over the seconds that
+/// follow instead of landing in one long frame. The pressure path passes its own need instead.
+inline u64 CompactBudget(u64 waste) {
+    return std::min<u64>(waste, 32_MB);
+}
+
+} // namespace VideoCore::LayerPolicy

gpu/shim/bb_env_vars.def

@@ -261,7 +261,7 @@ BB_ENV(BB_MIRROR_MERGE_GROWTH, TUNING, "=0: a mirror made over neighbours grows
 BB_ENV(BB_MIRROR_POOL_MB, TUNING, "=N: retired mirrors kept for new ones")
 BB_ENV(BB_MIRROR_REPROMOTE_SECONDS, TUNING, "=N (default 0): blocks sent back are not copied again that soon")
 BB_ENV(BB_MIRROR_UNBOUND_SECONDS, TUNING, "=N (0 never): blocks no binding named for N seconds leave VRAM")
-BB_ENV(BB_MIRROR_VRAM_ONLY, TUNING, "=1: mirrors in VRAM or not at all")
+BB_ENV(BB_MIRROR_VRAM_ONLY, TUNING, "=1 / 0: mirrors in VRAM or not at all, or in system memory too when VRAM is full (default: VRAM only on cards over 4 GiB)")
 BB_ENV(BB_MOTION_LARGE, TUNING, "=0: bone palettes of 16-64 KiB (the large beasts) get camera motion vectors only, not object motion")
 BB_ENV(BB_MOTION_VERTICES_MI, TUNING, "=N (1-8): object motion vertex buffer in Mi vertices")
 BB_ENV(BB_NET_MODULE, TUNING, "=path: the online module to load (default gpu/libbbnet20.so beside bb-probe)")

gpu/shim/bbport_menu_i18n.h

@@ -759,6 +759,13 @@ inline const char* MenuTranslation(MenuLanguage language, const char* english) {
       "Ragdoll-Physik wie in Dark Souls",
       "Física ragdoll de Dark Souls",
       "黑暗之魂的布娃娃物理"}},
+    {"L3 jumps while running",
+     {"L3 salta al correr",
+      "L3 salta durante la corsa",
+      "L3 saute en courant",
+      "L3 springt beim Rennen",
+      "L3 pula ao correr",
+      "奔跑时按 L3 跳跃"}},
     // The game's System menu pages (bbport_game_menu.cpp).
     {"Display",
      {"Imagen",
@@ -1069,13 +1076,13 @@ inline const char* MenuTranslation(MenuLanguage language, const char* english) {
       "%.0f FPS  %.1f ms",
       "%.0f FPS  %.1f ms",
       "%.0f FPS  %.1f 毫秒"}},
-    {"  VRAM -%u MB (other apps)",
-     {"  VRAM -%u MB (otras aplicaciones)",
-      "  VRAM -%u MB (altre app)",
-      "  VRAM -%u Mo (autres applications)",
-      "  VRAM -%u MB (andere Programme)",
-      "  VRAM -%u MB (outros apps)",
-      "  VRAM -%u MB（其他程序）"}},
+    {"  VRAM: %u MB taken by other apps",
+     {"  VRAM: %u MB ocupados por otras aplicaciones",
+      "  VRAM: %u MB occupati da altre app",
+      "  VRAM : %u Mo pris par d'autres applications",
+      "  VRAM: %u MB von anderen Programmen belegt",
+      "  VRAM: %u MB ocupados por outros apps",
+      "  显存：其他程序占用 %u MB"}},
     {"Bloodborne - Graphics  (Insert / hold L3+R3)###bbport_settings",
      {"Bloodborne - Gráficos  (Insert / mantener L3+R3)###bbport_settings",
       "Bloodborne - Grafica  (Insert / tieni premuto L3+R3)###bbport_settings",

gpu/shim/bbport_overlay.cpp

@@ -313,11 +313,13 @@ std::string FpsText() {
         std::snprintf(text, sizeof(text), BbSettings::MenuText("%.0f FPS  %.1f ms", "%.0f FPS  %.1f мс"),
                       shown, frame_ms_avg);
     }
-    // Other programs took video memory from the game (BufferCache::VramPromotionsPaused).
+    // Other programs took video memory from the game (BufferCache::VramPromotionsPaused): how much
+    // less the budget is than the most it was this session. It read "VRAM -552 MB", which looked
+    // like a negative figure.
     if (const u32 lost = BbStats::vram_budget_lost_mb.load(std::memory_order_relaxed); lost >= 150) {
         const size_t used = std::strlen(text);
         std::snprintf(text + used, sizeof(text) - used,
-                      BbSettings::MenuText("  VRAM -%u MB (other apps)", "  VRAM −%u МБ (другие программы)"),
+                      BbSettings::MenuText("  VRAM: %u MB taken by other apps", "  VRAM: %u МБ заняты другими программами"),
                       lost);
     }
     return text;
@@ -1396,6 +1398,10 @@ bool MenuOpen() {
     return menu_open || (AtlasOn() && initialized && BbAtlasMenu::Interacting());
 }
 
+bool TextPromptOpen() {
+    return prompt_active.load(std::memory_order_relaxed);
+}
+
 bool CapturesInput() {
     // The text dialog too: keys typed into it (Backspace is the touchpad) stay out of the game.
     // Hunter's Atlas: its open map and its controller shortcut while it is being held.

gpu/shim/bbport_overlay.h

@@ -51,6 +51,8 @@ uint32_t RoutePad(uint32_t buttons, uint8_t lx, uint8_t ly, uint8_t rx, uint8_t
 /// The settings menu is open, or Hunter's Atlas's map or quick-menu tile uses the pointer: the
 /// window lets the mouse go and shows the system cursor over it.
 bool MenuOpen();
+/// Any thread: the game's text dialog (ImeDialog, the character's name) is open.
+bool TextPromptOpen();
 
 /// Window thread: the game's text dialog (ImeDialog) state, drawn as a box over the frame.
 void SetTextPrompt(bool active, const std::string& prompt, const std::string& text);

gpu/shim/bbport_settings.h

@@ -84,6 +84,7 @@ inline constexpr Effect Effects[] = {
     {"tweak_no_camera_rotation", "No camera auto-rotation", "Без автоповорота камеры", false},
     {"tweak_easy_run", "Run with less stick tilt", "Бег с меньшим наклоном стика", false},
     {"tweak_ragdoll", "Dark Souls ragdoll physics", "Физика тел как в Dark Souls", false},
+    {"tweak_l3_run_jump", "L3 jumps while running", "L3: прыжок на бегу", false},
 };
 inline constexpr int EffectCount = int(sizeof(Effects) / sizeof(Effects[0]));
 /// The game's own anti-aliasing effect (Effects index), derived from anti_aliasing.

gpu/shim/window.cpp

@@ -27,7 +27,11 @@ std::array<std::atomic<BbGpuEventFilter>, 4> event_filters{};
 extern "C" int runtime_pad_steam_only(void) __attribute__((weak));
 
 /// A keyboard or mouse event the game must not take (runtime_pad_steam_only): the gamepad's own
-/// presses again. The port's menu (the overlay) keeps them, the trackpad as its pointer.
+/// presses again. The port's menu (the overlay) keeps them, the trackpad as its pointer, and so
+/// does the game's text dialog (the character's name): Steam's on-screen keyboard types into it
+/// as text input and a keyboard plugged into the Deck as keys, and both were dropped there, so the
+/// name could not be typed in Game Mode (upstream issue #443). The port's own on-screen keyboard
+/// (bbport_overlay.cpp) still takes the gamepad.
 bool SteamPadEcho(const SDL_Event& event) {
     switch (event.type) {
     case SDL_EVENT_KEY_DOWN:
@@ -37,7 +41,8 @@ bool SteamPadEcho(const SDL_Event& event) {
     case SDL_EVENT_MOUSE_BUTTON_DOWN:
     case SDL_EVENT_MOUSE_BUTTON_UP:
     case SDL_EVENT_MOUSE_WHEEL:
-        return runtime_pad_steam_only && runtime_pad_steam_only() && !BbOverlay::MenuOpen();
+        return runtime_pad_steam_only && runtime_pad_steam_only() && !BbOverlay::MenuOpen() &&
+               !BbOverlay::TextPromptOpen();
     default:
         return false;
     }

gpu/textures/texture_cache_memory.cpp

@@ -426,8 +426,13 @@ void TextureCache::GarbageCollectSamplers() {
             return true;
         }
         --deletions;
-        sampler_lru.Free(samplers.at(key).lru_id);
+        auto& sampler = samplers.at(key);
+        const auto lru_id = sampler.lru_id;
+        // LRU age can select a sampler still referenced by render work (including age zero).
+        // Retain its owner through the current scheduler tick before destroying the VkSampler.
+        scheduler.DeferOperation([retired = std::move(sampler)] { (void)retired; });
         samplers.erase(key);
+        sampler_lru.Free(lru_id);
         return false;
     };
     configure(false);

launcher/bbport_i18n.py

@@ -619,6 +619,8 @@ EN = {
     "Бег примерно с 70% наклона стика вместо 90%": "Run from about 70% stick tilt instead of 90%",
     "Физика тел как в Dark Souls": "Dark Souls ragdoll physics",
     "Тела и предметы разлетаются от ударов": "Corpses and objects fly around when hit",
+    'L3: прыжок на бегу': 'L3 jumps while running',
+    'На бегу с зажатым кругом L3 прыгает, как повторное нажатие круга. Патч Kyo (из bbhost)': "While running with Circle held, L3 jumps as pressing Circle again does. Kyo's patch (from bbhost)",
     # Add to Steam
     "Добавить в Steam": "Add to Steam",
     "Игра в библиотеке Steam запускается сразу, с настройками этого лаунчера": "From the Steam library the game starts straight away, with this launcher's settings",
@@ -863,8 +865,11 @@ EN = {
     'Вылеты при загрузке областей': 'Crashes while loading areas',
     'Интерфейс, пропадавший не в 1080p, векторы движения больших чудовищ и ошибка памяти': 'The interface vanishing outside 1080p, motion vectors for the large beasts and a memory fault',
     'Вылеты при загрузке некоторых карт, меню жестов с клавиатуры и изменения изображения для апскейлера': 'Crashes when loading some maps, the gestures menu from the keyboard, and image changes for the upscaler',
-    'Экранная клавиатура для имени персонажа и уведомление о компиляции шейдеров': "The on-screen keyboard for the character's name and the shader compiling notice",
-    "Быстрая загрузка после смерти и перемещения (bbhost) и сервер The Hunter's Dream": "Fast loading after a death or travel (bbhost) and The Hunter's Dream server",
+    'Экранная клавиатура для имени персонажа, уведомление о компиляции шейдеров и уплотнение копий памяти в видеопамяти': "The on-screen keyboard for the character's name, the shader compiling notice and compacting the memory copies in VRAM",
+    "Быстрая загрузка после смерти и перемещения, прыжок L3 на бегу (bbhost) и сервер The Hunter's Dream": "Fast loading after a death or travel, L3 run-jump (bbhost) and The Hunter's Dream server",
+    'Два исправления GPU: счётчики отправленной работы и сэмплеры, освобождаемые после их кадра': 'Two GPU fixes: work submission counts, and samplers freed after their frame',
+    'BBSC: гость больше не остаётся зрителем после гибели группы у босса': 'BBSC: the guest no longer stays a spectator after a boss wipe',
+    'Неизвестный системный параметр (sysctl) больше не останавливает игру': 'An unknown system value (sysctl) no longer stops the game',
     'Сетевые библиотеки игры по сети и сервер для своего кооператива': 'The online play libraries and the server for your own co-op',
     'Основа поддержки DLSS и модель FSR 4 без шлейфов за персонажами': 'The groundwork for DLSS, and the FSR 4 model without trails behind characters',
     'Апскейлер FSR 3.1': 'The FSR 3.1 upscaler',
@@ -890,7 +895,11 @@ EN = {
     'Вылет «Transaction failed» на Seamless Hunt': 'The "Transaction failed" crash on Seamless Hunt',
     'Вылет «Transaction failed» на Seamless Hunt, журналы, по которым гость BBSC перестал следовать за чужим хозяином, и проверки BBSC 0.0.2 с игроком на Windows': 'The "Transaction failed" crash on Seamless Hunt, the logs that stopped a BBSC guest from following a stranger\'s world, and testing BBSC 0.0.2 with a Windows player',
     'Страница трофеев, не находившая файлы дампа': "The Trophies page not finding the dump's files",
-    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры и вылеты в менеджере памяти игры': "Logs and tests: a GPU freeze in a boss fight on NVIDIA, a crash in Yahar'gul, stretched models, a crash on the Steam Deck, effects turning black, rainbow textures and crashes in the game's memory manager",
+    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры, вылеты в менеджере памяти игры, падения частоты кадров на NVIDIA и выход на рабочий стол при игре по сети': "Logs and tests: a GPU freeze in a boss fight on NVIDIA, a crash in Yahar'gul, stretched models, a crash on the Steam Deck, effects turning black, rainbow textures, crashes in the game's memory manager, frame rate drops on NVIDIA and Exit to Desktop with online play",
+    'Запуск игры на встроенных видеокартах Intel Arc/Xe': 'The game starting on integrated Intel Arc/Xe GPUs',
+    'Журналы и проверки: процессоры AMD FX, полноэкранный режим в Wayland с несколькими мониторами и версия AppImage в Gear Lever': "Logs and tests: AMD FX processors, fullscreen on Wayland with several monitors and the AppImage's version in Gear Lever",
+    'Хранилище с клавиатурой и мышью': 'The storage box with keyboard and mouse',
+    'Журналы падения частоты кадров на NVIDIA': 'Logs of frame rate drops on NVIDIA',
     'Отметка трофеев, уже полученных на PS4': 'Marking trophies already earned on the PS4',
     'Предметы BBSC, которые не выдавались новому персонажу': "BBSC's items not given to a new character",
     'Пустое окно лаунчера при запуске': "The launcher's blank window at start",
@@ -1529,6 +1538,8 @@ PT_BR = {
     "Бег примерно с 70% наклона стика вместо 90%": "Corre com cerca de 70% de inclinação do analógico em vez de 90%",
     "Физика тел как в Dark Souls": "Física de corpos como em Dark Souls",
     "Тела и предметы разлетаются от ударов": "Corpos e objetos voam ao serem atingidos",
+    'L3: прыжок на бегу': 'L3 pula ao correr',
+    'На бегу с зажатым кругом L3 прыгает, как повторное нажатие круга. Патч Kyo (из bbhost)': 'Correndo com o círculo pressionado, L3 pula como apertar o círculo de novo. Patch de Kyo (do bbhost)',
     # Add to Steam
     "Добавить в Steam": "Adicionar ao Steam",
     "Игра в библиотеке Steam запускается сразу, с настройками этого лаунчера": "Na biblioteca do Steam o jogo inicia direto, com as configurações deste launcher",
@@ -1949,8 +1960,11 @@ PT_BR = {
     'Вылеты при загрузке областей': 'Travamentos ao carregar áreas',
     'Интерфейс, пропадавший не в 1080p, векторы движения больших чудовищ и ошибка памяти': 'A interface que sumia fora de 1080p, vetores de movimento das grandes feras e uma falha de memória',
     'Вылеты при загрузке некоторых карт, меню жестов с клавиатуры и изменения изображения для апскейлера': 'Travamentos ao carregar alguns mapas, o menu de gestos pelo teclado e mudanças de imagem para o upscaler',
-    'Экранная клавиатура для имени персонажа и уведомление о компиляции шейдеров': 'O teclado na tela para o nome do personagem e o aviso de compilação de shaders',
-    "Быстрая загрузка после смерти и перемещения (bbhost) и сервер The Hunter's Dream": "Carregamento rápido após morrer ou viajar (bbhost) e o servidor The Hunter's Dream",
+    'Экранная клавиатура для имени персонажа, уведомление о компиляции шейдеров и уплотнение копий памяти в видеопамяти': 'O teclado na tela para o nome do personagem, o aviso de compilação de shaders e a compactação das cópias de memória na VRAM',
+    "Быстрая загрузка после смерти и перемещения, прыжок L3 на бегу (bbhost) и сервер The Hunter's Dream": "Carregamento rápido após morrer ou viajar, pulo com L3 correndo (bbhost) e o servidor The Hunter's Dream",
+    'Два исправления GPU: счётчики отправленной работы и сэмплеры, освобождаемые после их кадра': 'Duas correções da GPU: contagem do trabalho enviado e samplers liberados após o seu quadro',
+    'BBSC: гость больше не остаётся зрителем после гибели группы у босса': 'BBSC: o convidado não fica mais como espectador após uma derrota no chefe',
+    'Неизвестный системный параметр (sysctl) больше не останавливает игру': 'Um valor de sistema desconhecido (sysctl) não para mais o jogo',
     'Сетевые библиотеки игры по сети и сервер для своего кооператива': 'As bibliotecas do jogo online e o servidor para o seu próprio cooperativo',
     'Основа поддержки DLSS и модель FSR 4 без шлейфов за персонажами': 'A base do suporte a DLSS e o modelo do FSR 4 sem rastros atrás dos personagens',
     'Апскейлер FSR 3.1': 'O upscaler FSR 3.1',
@@ -1976,7 +1990,11 @@ PT_BR = {
     'Вылет «Transaction failed» на Seamless Hunt': 'O travamento "Transaction failed" no Seamless Hunt',
     'Вылет «Transaction failed» на Seamless Hunt, журналы, по которым гость BBSC перестал следовать за чужим хозяином, и проверки BBSC 0.0.2 с игроком на Windows': 'O crash "Transaction failed" no Seamless Hunt, os logs que fizeram o convidado do BBSC parar de seguir o mundo de um estranho e os testes do BBSC 0.0.2 com um jogador no Windows',
     'Страница трофеев, не находившая файлы дампа': 'A página de troféus que não encontrava os arquivos do dump',
-    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры и вылеты в менеджере памяти игры': "Logs e testes: um congelamento da GPU numa luta contra chefe na NVIDIA, um crash em Yahar'gul, modelos esticados, um crash no Steam Deck, efeitos ficando pretos, texturas arco-íris e crashes no gerenciador de memória do jogo",
+    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры, вылеты в менеджере памяти игры, падения частоты кадров на NVIDIA и выход на рабочий стол при игре по сети': "Logs e testes: um congelamento da GPU numa luta contra chefe na NVIDIA, um crash em Yahar'gul, modelos esticados, um crash no Steam Deck, efeitos ficando pretos, texturas arco-íris, crashes no gerenciador de memória do jogo, quedas de FPS na NVIDIA e Sair para a área de trabalho jogando online",
+    'Запуск игры на встроенных видеокартах Intel Arc/Xe': 'O jogo iniciando em GPUs integradas Intel Arc/Xe',
+    'Журналы и проверки: процессоры AMD FX, полноэкранный режим в Wayland с несколькими мониторами и версия AppImage в Gear Lever': 'Logs e testes: processadores AMD FX, tela cheia no Wayland com vários monitores e a versão da AppImage no Gear Lever',
+    'Хранилище с клавиатурой и мышью': 'O baú de armazenamento com teclado e mouse',
+    'Журналы падения частоты кадров на NVIDIA': 'Logs de quedas de FPS na NVIDIA',
     'Отметка трофеев, уже полученных на PS4': 'Marcar troféus já conquistados no PS4',
     'Предметы BBSC, которые не выдавались новому персонажу': 'Itens do BBSC que não eram dados a um novo personagem',
     'Пустое окно лаунчера при запуске': 'A janela em branco do launcher ao iniciar',
@@ -2620,6 +2638,8 @@ ES = {
     "Бег примерно с 70% наклона стика вместо 90%": "Correr a partir de un 70 % de inclinación del stick en lugar del 90 %",
     "Физика тел как в Dark Souls": "Física ragdoll de Dark Souls",
     "Тела и предметы разлетаются от ударов": "Los cadáveres y los objetos salen volando al recibir golpes",
+    'L3: прыжок на бегу': 'L3 salta al correr',
+    'На бегу с зажатым кругом L3 прыгает, как повторное нажатие круга. Патч Kyo (из bbhost)': 'Corriendo con el círculo pulsado, L3 salta como volver a pulsar el círculo. Parche de Kyo (de bbhost)',
     # Add to Steam
     "Добавить в Steam": "Añadir a Steam",
     "Игра в библиотеке Steam запускается сразу, с настройками этого лаунчера": "Desde la biblioteca de Steam el juego arranca directamente, con los ajustes de este launcher",
@@ -2950,8 +2970,11 @@ ES = {
     'Вылеты при загрузке областей': 'Cierres al cargar zonas',
     'Интерфейс, пропадавший не в 1080p, векторы движения больших чудовищ и ошибка памяти': 'La interfaz que desaparecía fuera de 1080p, los vectores de movimiento de las bestias grandes y un fallo de memoria',
     'Вылеты при загрузке некоторых карт, меню жестов с клавиатуры и изменения изображения для апскейлера': 'Cierres al cargar algunos mapas, el menú de gestos desde el teclado y cambios de imagen para el escalador',
-    'Экранная клавиатура для имени персонажа и уведомление о компиляции шейдеров': 'El teclado en pantalla para el nombre del personaje y el aviso de compilación de shaders',
-    "Быстрая загрузка после смерти и перемещения (bbhost) и сервер The Hunter's Dream": "Cargas rápidas tras morir o viajar (bbhost) y el servidor The Hunter's Dream",
+    'Экранная клавиатура для имени персонажа, уведомление о компиляции шейдеров и уплотнение копий памяти в видеопамяти': 'El teclado en pantalla para el nombre del personaje, el aviso de compilación de shaders y la compactación de las copias de memoria en la VRAM',
+    "Быстрая загрузка после смерти и перемещения, прыжок L3 на бегу (bbhost) и сервер The Hunter's Dream": "Cargas rápidas tras morir o viajar, salto con L3 al correr (bbhost) y el servidor The Hunter's Dream",
+    'Два исправления GPU: счётчики отправленной работы и сэмплеры, освобождаемые после их кадра': 'Dos arreglos de la GPU: el recuento del trabajo enviado y los samplers liberados tras su fotograma',
+    'BBSC: гость больше не остаётся зрителем после гибели группы у босса': 'BBSC: el invitado ya no se queda de espectador tras caer todos ante un jefe',
+    'Неизвестный системный параметр (sysctl) больше не останавливает игру': 'Un valor del sistema desconocido (sysctl) ya no detiene el juego',
     'Сетевые библиотеки игры по сети и сервер для своего кооператива': 'Las librerías del juego online y el servidor para el cooperativo propio',
     'Основа поддержки DLSS и модель FSR 4 без шлейфов за персонажами': 'La base del soporte de DLSS y el modelo de FSR 4 sin estelas tras los personajes',
     'Апскейлер FSR 3.1': 'El escalado FSR 3.1',
@@ -2977,7 +3000,11 @@ ES = {
     'Вылет «Transaction failed» на Seamless Hunt': 'El cierre «Transaction failed» en Seamless Hunt',
     'Вылет «Transaction failed» на Seamless Hunt, журналы, по которым гость BBSC перестал следовать за чужим хозяином, и проверки BBSC 0.0.2 с игроком на Windows': 'El cierre «Transaction failed» en Seamless Hunt, los registros que hicieron que el invitado de BBSC dejara de seguir el mundo de un desconocido y las pruebas de BBSC 0.0.2 con un jugador en Windows',
     'Страница трофеев, не находившая файлы дампа': 'La página de trofeos que no encontraba los archivos del volcado',
-    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры и вылеты в менеджере памяти игры': "Registros y pruebas: un cuelgue de la GPU en un jefe con NVIDIA, un cierre en Yahar'gul, modelos estirados, un cierre en Steam Deck, efectos que se vuelven negros, texturas arcoíris y cierres en el gestor de memoria del juego",
+    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры, вылеты в менеджере памяти игры, падения частоты кадров на NVIDIA и выход на рабочий стол при игре по сети': "Registros y pruebas: un cuelgue de la GPU en un jefe con NVIDIA, un cierre en Yahar'gul, modelos estirados, un cierre en Steam Deck, efectos que se vuelven negros, texturas arcoíris, cierres en el gestor de memoria del juego, bajadas de FPS con NVIDIA y Salir al escritorio jugando online",
+    'Запуск игры на встроенных видеокартах Intel Arc/Xe': 'El juego arrancando en gráficas integradas Intel Arc/Xe',
+    'Журналы и проверки: процессоры AMD FX, полноэкранный режим в Wayland с несколькими мониторами и версия AppImage в Gear Lever': 'Registros y pruebas: procesadores AMD FX, pantalla completa en Wayland con varios monitores y la versión de la AppImage en Gear Lever',
+    'Хранилище с клавиатурой и мышью': 'El almacén con teclado y ratón',
+    'Журналы падения частоты кадров на NVIDIA': 'Registros de bajadas de FPS con NVIDIA',
     'Отметка трофеев, уже полученных на PS4': 'Marcar trofeos ya conseguidos en PS4',
     'Предметы BBSC, которые не выдавались новому персонажу': 'Los objetos de BBSC que no recibía un personaje nuevo',
     'Пустое окно лаунчера при запуске': 'La ventana en blanco del launcher al abrirlo',
@@ -3621,6 +3648,8 @@ IT = {
     "Бег примерно с 70% наклона стика вместо 90%": "Corri inclinando lo stick di circa il 70% invece del 90%",
     "Физика тел как в Dark Souls": "Fisica ragdoll di Dark Souls",
     "Тела и предметы разлетаются от ударов": "Cadaveri e oggetti volano via quando vengono colpiti",
+    'L3: прыжок на бегу': 'L3 salta durante la corsa',
+    'На бегу с зажатым кругом L3 прыгает, как повторное нажатие круга. Патч Kyo (из bbhost)': 'Correndo con il cerchio premuto, L3 salta come premere di nuovo il cerchio. Patch di Kyo (da bbhost)',
     # Add to Steam
     "Добавить в Steam": "Aggiungi a Steam",
     "Игра в библиотеке Steam запускается сразу, с настройками этого лаунчера": "Dalla libreria di Steam il gioco si avvia subito, con le impostazioni di questo launcher",
@@ -3951,8 +3980,11 @@ IT = {
     'Вылеты при загрузке областей': 'Crash durante il caricamento delle aree',
     'Интерфейс, пропадавший не в 1080p, векторы движения больших чудовищ и ошибка памяти': 'L’interfaccia che spariva fuori da 1080p, i vettori di movimento delle grandi bestie e un errore di memoria',
     'Вылеты при загрузке некоторых карт, меню жестов с клавиатуры и изменения изображения для апскейлера': "Crash al caricamento di alcune mappe, il menu dei gesti da tastiera e modifiche all'immagine per l'upscaler",
-    'Экранная клавиатура для имени персонажа и уведомление о компиляции шейдеров': 'La tastiera su schermo per il nome del personaggio e l’avviso di compilazione degli shader',
-    "Быстрая загрузка после смерти и перемещения (bbhost) и сервер The Hunter's Dream": "Caricamenti rapidi dopo una morte o un viaggio (bbhost) e il server The Hunter's Dream",
+    'Экранная клавиатура для имени персонажа, уведомление о компиляции шейдеров и уплотнение копий памяти в видеопамяти': 'La tastiera su schermo per il nome del personaggio, l’avviso di compilazione degli shader e la compattazione delle copie di memoria nella VRAM',
+    "Быстрая загрузка после смерти и перемещения, прыжок L3 на бегу (bbhost) и сервер The Hunter's Dream": "Caricamenti rapidi dopo una morte o un viaggio, salto con L3 in corsa (bbhost) e il server The Hunter's Dream",
+    'Два исправления GPU: счётчики отправленной работы и сэмплеры, освобождаемые после их кадра': 'Due correzioni della GPU: il conteggio del lavoro inviato e i sampler liberati dopo il loro fotogramma',
+    'BBSC: гость больше не остаётся зрителем после гибели группы у босса': "BBSC: l'ospite non resta più spettatore dopo una sconfitta contro un boss",
+    'Неизвестный системный параметр (sysctl) больше не останавливает игру': 'Un valore di sistema sconosciuto (sysctl) non ferma più il gioco',
     'Сетевые библиотеки игры по сети и сервер для своего кооператива': 'Le librerie del gioco online e il server per la propria cooperativa',
     'Основа поддержки DLSS и модель FSR 4 без шлейфов за персонажами': 'La base del supporto DLSS e il modello FSR 4 senza scie dietro i personaggi',
     'Апскейлер FSR 3.1': 'L’upscaler FSR 3.1',
@@ -3978,7 +4010,11 @@ IT = {
     'Вылет «Transaction failed» на Seamless Hunt': 'La chiusura "Transaction failed" su Seamless Hunt',
     'Вылет «Transaction failed» на Seamless Hunt, журналы, по которым гость BBSC перестал следовать за чужим хозяином, и проверки BBSC 0.0.2 с игроком на Windows': "Il crash «Transaction failed» su Seamless Hunt, i log che hanno fatto smettere all'ospite di BBSC di seguire il mondo di uno sconosciuto e i test di BBSC 0.0.2 con un giocatore su Windows",
     'Страница трофеев, не находившая файлы дампа': 'La pagina dei trofei che non trovava i file del dump',
-    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры и вылеты в менеджере памяти игры': "Log e test: un blocco della GPU in una battaglia contro un boss su NVIDIA, un crash a Yahar'gul, modelli stirati, un crash su Steam Deck, effetti che diventano neri, texture arcobaleno e crash nel gestore della memoria del gioco",
+    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры, вылеты в менеджере памяти игры, падения частоты кадров на NVIDIA и выход на рабочий стол при игре по сети': "Log e test: un blocco della GPU in una battaglia contro un boss su NVIDIA, un crash a Yahar'gul, modelli stirati, un crash su Steam Deck, effetti che diventano neri, texture arcobaleno, crash nel gestore della memoria del gioco, cali di FPS su NVIDIA ed Esci al desktop giocando online",
+    'Запуск игры на встроенных видеокартах Intel Arc/Xe': 'Il gioco che si avvia sulle GPU integrate Intel Arc/Xe',
+    'Журналы и проверки: процессоры AMD FX, полноэкранный режим в Wayland с несколькими мониторами и версия AppImage в Gear Lever': "Log e test: processori AMD FX, schermo intero su Wayland con più monitor e la versione dell'AppImage in Gear Lever",
+    'Хранилище с клавиатурой и мышью': 'Il deposito con tastiera e mouse',
+    'Журналы падения частоты кадров на NVIDIA': 'Log dei cali di FPS su NVIDIA',
     'Отметка трофеев, уже полученных на PS4': 'Segnare i trofei già ottenuti su PS4',
     'Предметы BBSC, которые не выдавались новому персонажу': 'Gli oggetti di BBSC non dati a un nuovo personaggio',
     'Пустое окно лаунчера при запуске': "La finestra vuota del launcher all'avvio",
@@ -4622,6 +4658,8 @@ FR = {
     "Бег примерно с 70% наклона стика вместо 90%": "Courir à partir d'environ 70 % d'inclinaison du stick au lieu de 90 %",
     "Физика тел как в Dark Souls": "Physique ragdoll de Dark Souls",
     "Тела и предметы разлетаются от ударов": "Les cadavres et les objets sont projetés quand on les frappe",
+    'L3: прыжок на бегу': 'L3 saute en courant',
+    'На бегу с зажатым кругом L3 прыгает, как повторное нажатие круга. Патч Kyo (из bbhost)': 'En courant avec rond maintenu, L3 saute comme un nouvel appui sur rond. Patch de Kyo (de bbhost)',
     # Add to Steam
     "Добавить в Steam": "Ajouter à Steam",
     "Игра в библиотеке Steam запускается сразу, с настройками этого лаунчера": "Depuis la bibliothèque Steam, le jeu démarre directement avec les réglages de ce launcher",
@@ -4952,8 +4990,11 @@ FR = {
     'Вылеты при загрузке областей': 'Plantages au chargement des zones',
     'Интерфейс, пропадавший не в 1080p, векторы движения больших чудовищ и ошибка памяти': 'L’interface qui disparaissait hors 1080p, les vecteurs de mouvement des grandes bêtes et une erreur mémoire',
     'Вылеты при загрузке некоторых карт, меню жестов с клавиатуры и изменения изображения для апскейлера': "Plantages au chargement de certaines cartes, le menu des gestes au clavier et des changements d'image pour l'upscaler",
-    'Экранная клавиатура для имени персонажа и уведомление о компиляции шейдеров': 'Le clavier à l’écran pour le nom du personnage et l’avis de compilation des shaders',
-    "Быстрая загрузка после смерти и перемещения (bbhost) и сервер The Hunter's Dream": "Chargements rapides après une mort ou un voyage (bbhost) et le serveur The Hunter's Dream",
+    'Экранная клавиатура для имени персонажа, уведомление о компиляции шейдеров и уплотнение копий памяти в видеопамяти': 'Le clavier à l’écran pour le nom du personnage, l’avis de compilation des shaders et le compactage des copies de mémoire en VRAM',
+    "Быстрая загрузка после смерти и перемещения, прыжок L3 на бегу (bbhost) и сервер The Hunter's Dream": "Chargements rapides après une mort ou un voyage, saut avec L3 en courant (bbhost) et le serveur The Hunter's Dream",
+    'Два исправления GPU: счётчики отправленной работы и сэмплеры, освобождаемые после их кадра': 'Deux correctifs GPU : le décompte du travail soumis et les samplers libérés après leur image',
+    'BBSC: гость больше не остаётся зрителем после гибели группы у босса': "BBSC : l'invité ne reste plus spectateur après une défaite face à un boss",
+    'Неизвестный системный параметр (sysctl) больше не останавливает игру': 'Une valeur système inconnue (sysctl) n’arrête plus le jeu',
     'Сетевые библиотеки игры по сети и сервер для своего кооператива': 'Les bibliothèques du jeu en ligne et le serveur pour votre propre coopération',
     'Основа поддержки DLSS и модель FSR 4 без шлейфов за персонажами': 'La base de la prise en charge de DLSS et le modèle FSR 4 sans traînées derrière les personnages',
     'Апскейлер FSR 3.1': 'L’upscaler FSR 3.1',
@@ -4979,7 +5020,11 @@ FR = {
     'Вылет «Transaction failed» на Seamless Hunt': 'Le plantage « Transaction failed » sur Seamless Hunt',
     'Вылет «Transaction failed» на Seamless Hunt, журналы, по которым гость BBSC перестал следовать за чужим хозяином, и проверки BBSC 0.0.2 с игроком на Windows': "Le plantage « Transaction failed » sur Seamless Hunt, les journaux qui ont empêché l'invité de BBSC de suivre le monde d'un inconnu, et les tests de BBSC 0.0.2 avec un joueur sous Windows",
     'Страница трофеев, не находившая файлы дампа': 'La page des trophées qui ne trouvait pas les fichiers du dump',
-    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры и вылеты в менеджере памяти игры': "Journaux et tests : un gel du GPU pendant un combat de boss sur NVIDIA, un plantage à Yahar'gul, des modèles étirés, un plantage sur Steam Deck, des effets devenus noirs, des textures arc-en-ciel et des plantages dans le gestionnaire de mémoire du jeu",
+    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры, вылеты в менеджере памяти игры, падения частоты кадров на NVIDIA и выход на рабочий стол при игре по сети': "Journaux et tests : un gel du GPU pendant un combat de boss sur NVIDIA, un plantage à Yahar'gul, des modèles étirés, un plantage sur Steam Deck, des effets devenus noirs, des textures arc-en-ciel, des plantages dans le gestionnaire de mémoire du jeu, des chutes de FPS sur NVIDIA et Quitter vers le bureau en jouant en ligne",
+    'Запуск игры на встроенных видеокартах Intel Arc/Xe': 'Le jeu qui démarre sur les GPU intégrés Intel Arc/Xe',
+    'Журналы и проверки: процессоры AMD FX, полноэкранный режим в Wayland с несколькими мониторами и версия AppImage в Gear Lever': "Journaux et tests : processeurs AMD FX, plein écran sous Wayland avec plusieurs écrans et la version de l'AppImage dans Gear Lever",
+    'Хранилище с клавиатурой и мышью': 'Le coffre de stockage au clavier et à la souris',
+    'Журналы падения частоты кадров на NVIDIA': 'Journaux de chutes de FPS sur NVIDIA',
     'Отметка трофеев, уже полученных на PS4': 'Marquer les trophées déjà obtenus sur PS4',
     'Предметы BBSC, которые не выдавались новому персонажу': 'Les objets de BBSC non donnés à un nouveau personnage',
     'Пустое окно лаунчера при запуске': 'La fenêtre vide du launcher au démarrage',
@@ -5623,6 +5668,8 @@ DE = {
     "Бег примерно с 70% наклона стика вместо 90%": "Rennen ab etwa 70 % Stick-Neigung statt 90 %",
     "Физика тел как в Dark Souls": "Ragdoll-Physik wie in Dark Souls",
     "Тела и предметы разлетаются от ударов": "Leichen und Objekte fliegen bei Treffern umher",
+    'L3: прыжок на бегу': 'L3 springt beim Rennen',
+    'На бегу с зажатым кругом L3 прыгает, как повторное нажатие круга. Патч Kyo (из bbhost)': 'Beim Rennen mit gehaltenem Kreis springt L3 wie ein erneuter Druck auf Kreis. Patch von Kyo (aus bbhost)',
     # Add to Steam
     "Добавить в Steam": "Zu Steam hinzufügen",
     "Игра в библиотеке Steam запускается сразу, с настройками этого лаунчера": "Aus der Steam-Bibliothek startet das Spiel direkt, mit den Einstellungen dieses Launchers",
@@ -5953,8 +6000,11 @@ DE = {
     'Вылеты при загрузке областей': 'Abstürze beim Laden von Gebieten',
     'Интерфейс, пропадавший не в 1080p, векторы движения больших чудовищ и ошибка памяти': 'Die Oberfläche, die außerhalb von 1080p verschwand, Bewegungsvektoren der großen Bestien und ein Speicherfehler',
     'Вылеты при загрузке некоторых карт, меню жестов с клавиатуры и изменения изображения для апскейлера': 'Abstürze beim Laden einiger Karten, das Gestenmenü per Tastatur und Bildänderungen für den Upscaler',
-    'Экранная клавиатура для имени персонажа и уведомление о компиляции шейдеров': 'Die Bildschirmtastatur für den Charakternamen und der Hinweis zum Kompilieren der Shader',
-    "Быстрая загрузка после смерти и перемещения (bbhost) и сервер The Hunter's Dream": "Schnelles Laden nach Tod oder Reise (bbhost) und der Server The Hunter's Dream",
+    'Экранная клавиатура для имени персонажа, уведомление о компиляции шейдеров и уплотнение копий памяти в видеопамяти': 'Die Bildschirmtastatur für den Charakternamen, der Hinweis zum Kompilieren der Shader und das Verdichten der Speicherkopien im VRAM',
+    "Быстрая загрузка после смерти и перемещения, прыжок L3 на бегу (bbhost) и сервер The Hunter's Dream": "Schnelles Laden nach Tod oder Reise, Sprung mit L3 beim Rennen (bbhost) und der Server The Hunter's Dream",
+    'Два исправления GPU: счётчики отправленной работы и сэмплеры, освобождаемые после их кадра': 'Zwei GPU-Fehlerbehebungen: die Zählung der übermittelten Arbeit und Sampler, die nach ihrem Frame freigegeben werden',
+    'BBSC: гость больше не остаётся зрителем после гибели группы у босса': 'BBSC: der Gast bleibt nach einer Niederlage gegen einen Boss nicht mehr Zuschauer',
+    'Неизвестный системный параметр (sysctl) больше не останавливает игру': 'Ein unbekannter Systemwert (sysctl) hält das Spiel nicht mehr an',
     'Сетевые библиотеки игры по сети и сервер для своего кооператива': 'Die Bibliotheken für das Online-Spiel und der Server für den eigenen Koop',
     'Основа поддержки DLSS и модель FSR 4 без шлейфов за персонажами': 'Die Grundlage für DLSS und das FSR-4-Modell ohne Schlieren hinter Figuren',
     'Апскейлер FSR 3.1': 'Der FSR-3.1-Upscaler',
@@ -5980,7 +6030,11 @@ DE = {
     'Вылет «Transaction failed» на Seamless Hunt': 'Der Absturz „Transaction failed“ auf Seamless Hunt',
     'Вылет «Transaction failed» на Seamless Hunt, журналы, по которым гость BBSC перестал следовать за чужим хозяином, и проверки BBSC 0.0.2 с игроком на Windows': 'Der Absturz „Transaction failed“ auf Seamless Hunt, die Logs, durch die ein BBSC-Gast nicht mehr der Welt eines Fremden folgt, und Tests von BBSC 0.0.2 mit einem Windows-Spieler',
     'Страница трофеев, не находившая файлы дампа': 'Die Trophäenseite, die die Dateien des Dumps nicht fand',
-    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры и вылеты в менеджере памяти игры': "Logs und Tests: ein GPU-Hänger in einem Bosskampf auf NVIDIA, ein Absturz in Yahar'gul, verzerrte Modelle, ein Absturz auf dem Steam Deck, schwarz werdende Effekte, Regenbogentexturen und Abstürze in der Speicherverwaltung des Spiels",
+    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры, вылеты в менеджере памяти игры, падения частоты кадров на NVIDIA и выход на рабочий стол при игре по сети': "Logs und Tests: ein GPU-Hänger in einem Bosskampf auf NVIDIA, ein Absturz in Yahar'gul, verzerrte Modelle, ein Absturz auf dem Steam Deck, schwarz werdende Effekte, Regenbogentexturen, Abstürze in der Speicherverwaltung des Spiels, FPS-Einbrüche auf NVIDIA und Zum Desktop beenden im Online-Spiel",
+    'Запуск игры на встроенных видеокартах Intel Arc/Xe': 'Der Spielstart auf integrierten Intel-Arc/Xe-GPUs',
+    'Журналы и проверки: процессоры AMD FX, полноэкранный режим в Wayland с несколькими мониторами и версия AppImage в Gear Lever': 'Logs und Tests: AMD-FX-Prozessoren, Vollbild unter Wayland mit mehreren Monitoren und die Version des AppImage in Gear Lever',
+    'Хранилище с клавиатурой и мышью': 'Die Lagerkiste mit Tastatur und Maus',
+    'Журналы падения частоты кадров на NVIDIA': 'Logs von FPS-Einbrüchen auf NVIDIA',
     'Отметка трофеев, уже полученных на PS4': 'Auf der PS4 bereits erhaltene Trophäen markieren',
     'Предметы BBSC, которые не выдавались новому персонажу': 'BBSC-Gegenstände, die ein neuer Charakter nicht bekam',
     'Пустое окно лаунчера при запуске': 'Das leere Launcher-Fenster beim Start',
@@ -6215,6 +6269,8 @@ ZH_CN = {
     'Бег примерно с 70% наклона стика вместо 90%': '摇杆推到约 70% 即可奔跑，而不是 90%',
     'Физика тел как в Dark Souls': '黑暗之魂式布娃娃物理',
     'Тела и предметы разлетаются от ударов': '尸体和物品被击中时会飞散',
+    'L3: прыжок на бегу': '奔跑时按 L3 跳跃',
+    'На бегу с зажатым кругом L3 прыгает, как повторное нажатие круга. Патч Kyo (из bbhost)': '按住圆圈奔跑时，L3 会像再次按下圆圈一样跳跃。Kyo 的补丁（来自 bbhost）',
     'shadnet-p2p: на вашем ПК или VPS': 'shadnet-p2p：在你的电脑或 VPS 上',
     'Платиновый': '白金',
     'Золотой': '金',
@@ -6923,8 +6979,11 @@ ZH_CN = {
     'Вылеты при загрузке областей': '加载区域时的崩溃',
     'Интерфейс, пропадавший не в 1080p, векторы движения больших чудовищ и ошибка памяти': '非 1080p 下消失的界面、大型野兽的运动矢量与一处内存错误',
     'Вылеты при загрузке некоторых карт, меню жестов с клавиатуры и изменения изображения для апскейлера': '加载部分地图时的崩溃、用键盘打开的手势菜单，以及超分辨率的画面改动',
-    'Экранная клавиатура для имени персонажа и уведомление о компиляции шейдеров': '角色名的屏幕键盘与着色器编译提示',
-    "Быстрая загрузка после смерти и перемещения (bbhost) и сервер The Hunter's Dream": "死亡或传送后的快速加载（bbhost）与 The Hunter's Dream 服务器",
+    'Экранная клавиатура для имени персонажа, уведомление о компиляции шейдеров и уплотнение копий памяти в видеопамяти': '角色名的屏幕键盘、着色器编译提示，以及显存中内存副本的压缩',
+    "Быстрая загрузка после смерти и перемещения, прыжок L3 на бегу (bbhost) и сервер The Hunter's Dream": "死亡或传送后的快速加载、奔跑时 L3 跳跃（bbhost）与 The Hunter's Dream 服务器",
+    'Два исправления GPU: счётчики отправленной работы и сэмплеры, освобождаемые после их кадра': '两项 GPU 修复：已提交工作的计数，以及在其帧结束后才释放的采样器',
+    'BBSC: гость больше не остаётся зрителем после гибели группы у босса': 'BBSC：首领战全灭后，客人不再一直处于观战状态',
+    'Неизвестный системный параметр (sysctl) больше не останавливает игру': '未知的系统值（sysctl）不再导致游戏停止',
     'Сетевые библиотеки игры по сети и сервер для своего кооператива': '联机库与自建合作服务器',
     'Основа поддержки DLSS и модель FSR 4 без шлейфов за персонажами': 'DLSS 支持的基础，以及角色身后无拖影的 FSR 4 模型',
     'Апскейлер FSR 3.1': 'FSR 3.1 超分辨率',
@@ -6950,7 +7009,11 @@ ZH_CN = {
     'Вылет «Transaction failed» на Seamless Hunt': 'Seamless Hunt 上的“Transaction failed”崩溃',
     'Вылет «Transaction failed» на Seamless Hunt, журналы, по которым гость BBSC перестал следовать за чужим хозяином, и проверки BBSC 0.0.2 с игроком на Windows': 'Seamless Hunt 上的“Transaction failed”崩溃、让 BBSC 访客不再跟随陌生人世界的日志，以及与 Windows 玩家一起测试 BBSC 0.0.2',
     'Страница трофеев, не находившая файлы дампа': '找不到转储文件的奖杯页面',
-    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры и вылеты в менеджере памяти игры': "日志与测试：NVIDIA 上首领战中的 GPU 卡死、Yahar'gul 的崩溃、被拉伸的模型、Steam Deck 上的崩溃、变黑的特效、彩虹色纹理，以及游戏内存管理器中的崩溃",
+    'Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, радужные текстуры, вылеты в менеджере памяти игры, падения частоты кадров на NVIDIA и выход на рабочий стол при игре по сети': "日志与测试：NVIDIA 上首领战中的 GPU 卡死、Yahar'gul 的崩溃、被拉伸的模型、Steam Deck 上的崩溃、变黑的特效、彩虹色纹理、游戏内存管理器中的崩溃、NVIDIA 上的帧率下降，以及联机时的退出到桌面",
+    'Запуск игры на встроенных видеокартах Intel Arc/Xe': '游戏在 Intel Arc/Xe 集成显卡上启动',
+    'Журналы и проверки: процессоры AMD FX, полноэкранный режим в Wayland с несколькими мониторами и версия AppImage в Gear Lever': '日志与测试：AMD FX 处理器、Wayland 多显示器下的全屏，以及 Gear Lever 中显示的 AppImage 版本',
+    'Хранилище с клавиатурой и мышью': '使用键盘和鼠标操作储物箱',
+    'Журналы падения частоты кадров на NVIDIA': 'NVIDIA 上帧率下降的日志',
     'Отметка трофеев, уже полученных на PS4': '标记已在 PS4 上获得的奖杯',
     'Предметы BBSC, которые не выдавались новому персонажу': '新角色拿不到 BBSC 物品的问题',
     'Пустое окно лаунчера при запуске': '启动时启动器窗口空白的问题',

launcher/bbport_launcher.py

@@ -160,6 +160,8 @@ TWEAKS = [
      "Камера не поворачивается сама при движении; ручное управление и захват цели работают"),
     ("tweak_easy_run", "Бег с меньшим наклоном стика", "Бег примерно с 70% наклона стика вместо 90%"),
     ("tweak_ragdoll", "Физика тел как в Dark Souls", "Тела и предметы разлетаются от ударов"),
+    ("tweak_l3_run_jump", "L3: прыжок на бегу",
+     "На бегу с зажатым кругом L3 прыгает, как повторное нажатие круга. Патч Kyo (из bbhost)"),
 ]
 # Loading and smoothness (patches from bbhost, applied at start): bbport.ini key, title, subtitle,
 # default.
@@ -1031,10 +1033,15 @@ THANKS = (
         _github("GoncaloLobo0", "Вылеты при загрузке областей"),
         _github("bmy", "Векторы движения больших чудовищ и ошибка памяти"),
         _github("Mrsuss60", "Меню жестов с клавиатуры, слот удалённого изображения и журнал неудачных резервирований памяти"),
-        _github("SrShadowy", "Экранная клавиатура для имени персонажа и уведомление о компиляции "
-                             "шейдеров"),
-        _github("droogie", "Быстрая загрузка после смерти и перемещения (bbhost) и сервер "
-                           "The Hunter's Dream"),
+        _github("SrShadowy", "Экранная клавиатура для имени персонажа, уведомление о компиляции "
+                             "шейдеров и уплотнение копий памяти в видеопамяти"),
+        _github("Wooloomooloo2", "Запуск игры на встроенных видеокартах Intel Arc/Xe"),
+        _github("droogie", "Быстрая загрузка после смерти и перемещения, прыжок L3 на бегу "
+                           "(bbhost) и сервер The Hunter's Dream"),
+        _github("Asanilo", "Два исправления GPU: счётчики отправленной работы и сэмплеры, "
+                           "освобождаемые после их кадра"),
+        _github("AlexanderDzhoganov", "BBSC: гость больше не остаётся зрителем после гибели группы у босса"),
+        _github("nullsumlabs", "Неизвестный системный параметр (sysctl) больше не останавливает игру"),
         _github("Wozzardman", "Сервер для своего кооператива и бесшовный призыв BBSC"),
         _github("IFreemz", "Модель FSR 4 без шлейфов за персонажами"),
         _github("FireBurn", "Апскейлер FSR 3.1"),
@@ -1079,7 +1086,8 @@ THANKS = (
         _github("simo1730", "Страница трофеев, не находившая файлы дампа"),
         _github("Nahnahchi", "Журналы и проверки: зависание GPU в битве с боссом на NVIDIA, вылет "
                               "в Яхар’гуле, растянутые модели, вылет на Steam Deck, чёрные эффекты, "
-                              "радужные текстуры и вылеты в менеджере памяти игры"),
+                              "радужные текстуры, вылеты в менеджере памяти игры, падения частоты "
+                              "кадров на NVIDIA и выход на рабочий стол при игре по сети"),
         _github("thomasgarafano1", "Hunter's Atlas, не готовивший карту с дампом GOTY, и проверка исправления"),
         _github("TacticalBill", "Отметка трофеев, уже полученных на PS4"),
         _github("holydingus", "Предметы BBSC, которые не выдавались новому персонажу"),
@@ -1088,6 +1096,10 @@ THANKS = (
         _github("BlazinKarp", "Оверлей Steam в игре"),
         _github("molnar-a", "Вылет на Steam Deck после путешествия через фонарь и проверка исправления"),
         _github("Aman9das", "Просьба о раскладке клавиатуры из bbport 0.6"),
+        _github("eberhardweber", "Журналы и проверки: процессоры AMD FX, полноэкранный режим в "
+                                 "Wayland с несколькими мониторами и версия AppImage в Gear Lever"),
+        _github("GitBire", "Хранилище с клавиатурой и мышью"),
+        _github("npc-xc", "Журналы падения частоты кадров на NVIDIA"),
     )),
     ("Другие благодарности", (
         ("Dommo, goomab", "Иконки кнопок Xbox и Switch (Nexus Mods)",

launcher/bbport_update.py

@@ -14,7 +14,7 @@ import re
 import tempfile
 import urllib.request
 
-VERSION = "0.70-linux.3"
+VERSION = "0.70-linux.5"
 
 
 def _build():

patches/Bloodborne.xml

@@ -3492,4 +3492,16 @@
             <Line Type="bytes" Address="0x018281A8" Value="C783500E000002000000"/>
         </PatchList>
     </Metadata>
+    <Metadata Title="Bloodborne" Name="L3 Run-Jump" Note="While running with Circle held, L3 jumps as letting go of Circle and pressing it again does; Circle is unchanged. Works with any c0000.hks that keeps the game's run-jump (vanilla, Hyperborne); not with the Nightreign Movement scripts. Uses one byte at 0x05AD3D00 in the zeroed tail of .bss as a 3-frame window." Author="Kyo (from droogie/bbhost)" PatchVer="1.0" AppVer="01.09" AppElf="eboot.bin" isEnabled="false">
+        <PatchList>
+            <!-- PadManipulator::Update: the call of ActionRequest::Update goes through the new code; was E8 BA 71 4E 00 -->
+            <Line Type="bytes" Address="0x01928751" Value="E8AA68B903"/>
+            <!-- the script's SpEffect query (env 56) goes through the new code; was 48 8B 8B C8 01 00 00 -->
+            <Line Type="bytes" Address="0x01E142F1" Value="E98AAD6A039090"/>
+            <!-- new code in the zero tail of the code segment: L3 pressed while running adds the Rolling request; was zeros -->
+            <Line Type="bytes" Address="0x054BF000" Value="803DF94C6100007406FE0DF14C6100F64711207444F6471920753EF64710207438488B47084885C0742F488B80C80100004885C07423488B40084885C0741A817840870100007406488B4058EBEC804F1202C605A74C610003E9B20895FC"/>
+            <!-- new code: SpEffect 390 counts as on for 3 frames after it; was zeros -->
+            <Line Type="bytes" Address="0x054BF080" Value="3D86010000752C803D724C6100007423488B0DE1F747004885C97417483B59607511488B3D374B3200BE01000000E9976695FC488B8BC8010000E9395295FC"/>
+        </PatchList>
+    </Metadata>
 </Patch>

scripts/patches.py

@@ -62,6 +62,7 @@ EFFECTS={
     'tweak_no_camera_rotation':(None,'Disable Camera Auto Rotation via Movement'),
     'tweak_easy_run':(None,'Sensitive Analog Input (easier to run)'),
     'tweak_ragdoll':(None,'DS1-like physics'),
+    'tweak_l3_run_jump':(None,'L3 Run-Jump'),
     # Loading and smoothness (from droogie/bbhost); the first two are on unless turned off.
     'tweak_quick_reentry':(None,'Quick Re-entry'),
     'tweak_fast_deflate':(None,'Fast Run-time Deflate'),

src/runtime_atlas_build.h

@@ -1,3 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-#pragma once
-#define BB_ATLAS_BUILD_JSON "{\"adapter_protocol\":1,\"upstream_release\":\"windows-v1.8.1\",\"upstream_commit\":\"bee7ec16213022f15bf34084b5587f1ff09e0e65\",\"feature_schema\":1}"

src/runtime_kernel.c

@@ -254,10 +254,17 @@ static ABI int32_t guest_sysctl(const int32_t *name,uint32_t namelen,void *old,u
         if (old) { if (*oldlen<4) return fail_posix(ENOMEM); memcpy(old,&value,4); }
         *oldlen=4; return 0;
     }
-    fprintf(stderr,"STOP: unsupported sysctl mib");
-    for (uint32_t i=0;i<namelen && i<8;++i) fprintf(stderr," %d",name[i]);
-    fputc('\n',stderr);
-    exit(21);
+    /* Any other name: ENOENT, as FreeBSD answers a name it does not know, instead of stopping the
+     * game (exit 21). The first few are logged with their mib. From the nullsumlabs fork
+     * (bloodborne_pc-deck-optimized), after Awakenchan's Windows port. */
+    static int logged;
+    if (logged<8) {
+        ++logged;
+        fprintf(stderr,"Runtime: sysctl mib");
+        for (uint32_t i=0;i<namelen && i<8;++i) fprintf(stderr," %d",name[i]);
+        fprintf(stderr," is not known: ENOENT\n");
+    }
+    return fail_posix(ENOENT);
 }
 
 /* ---- pthread_once and thread-specific data ---- */

src/runtime_services.c

@@ -135,8 +135,10 @@ static ABI int32_t hide_splash(void) { note("SystemService: splash screen hidden
 static ABI int32_t launch_browser(void) { note("SystemService: web browser request ignored (offline)"); return 0; }
 /* Exit to desktop in the world (gpu/shim/bbport_game_menu.cpp): the System menu's entry runs the
  * game's Exit Game, which saves and leaves the world, and arms the quit here. The game closes
- * once it is back at the title: when the intro logos start loading (a menu/logo_ file opens) or
- * the title menu is built (its texts: runtime_quit_at_title), with no save data mounted, or after
+ * once it is back at the title: when the intro logos start loading (a menu/logo_ file opens), the
+ * title menu is built (its texts) or the game's menu flow says its title menu is up (online play
+ * comes back without either: gpu/games/bloodborne_menu_pointer.cpp, #46; all three call
+ * runtime_quit_at_title), with no save data mounted, or after
  * the last save unmounts. The game's own Exit Game disarms it, and so do two minutes without
  * getting there (the question answered No). Closing is the window's own close (SDL_EVENT_QUIT:
  * the window thread ends the process with exit code 0). */

tests/test_layer_mirror_policy.cpp

@@ -0,0 +1,200 @@
+// SPDX-FileCopyrightText: Copyright 2026 bbport contributors
+// SPDX-License-Identifier: GPL-2.0-or-later
+// When a mirror is made again over its valid blocks only (gpu/layer/layer_mirror_policy.h).
+//
+// The default run of 0.7 without any BB_MIRROR_* variable compacted nothing for its whole length:
+// 223-225 mirrors of 1,750 MiB, 7.8 MiB each, with 612 MiB of waste between them (2.7 MiB each).
+// The fixed 8 MiB a mirror had to waste was more than a whole mirror of that run, so no mirror was
+// ever eligible. These tests pin the per-mirror share that replaced it, and the segments a mirror
+// comes back as.
+#include "layer/layer_mirror_policy.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdio>
+#include <vector>
+
+namespace {
+
+using VideoCore::LayerPolicy::CompactBudget;
+using VideoCore::LayerPolicy::kMaxSegmentsPerMirror;
+using VideoCore::LayerPolicy::kRetrySeconds;
+using VideoCore::LayerPolicy::kSegmentPays;
+using VideoCore::LayerPolicy::MirrorMinHole;
+using VideoCore::LayerPolicy::MirrorMinWaste;
+using VideoCore::LayerPolicy::MirrorSegments;
+using VideoCore::LayerPolicy::Segment;
+using VideoCore::LayerPolicy::SegmentsBytes;
+
+constexpr u64 kShift = 16;         // the layer's block: 64 KiB
+constexpr u64 kBlocksPerMiB = 16;  // 64 KiB blocks in a MiB
+
+void TestMinWasteFollowsSize() {
+    // Never below 1 MiB: a copy costs what it frees otherwise.
+    assert(MirrorMinWaste(0) == 1_MB);
+    assert(MirrorMinWaste(1_MB) == 1_MB);
+    assert(MirrorMinWaste(4_MB) == 1_MB);
+    // A quarter of the mirror while that is small enough.
+    assert(MirrorMinWaste(8_MB) == 2_MB);
+    assert(MirrorMinWaste(16_MB) == 4_MB);
+    // 31 MiB / 4 is 7.75 MiB, still under the 8 MiB cap.
+    assert(MirrorMinWaste(31_MB) == 31_MB / 4);
+    // And at most 8 MiB, the whole per-mirror threshold of 0.7.
+    assert(MirrorMinWaste(32_MB) == 8_MB);
+    assert(MirrorMinWaste(1_GB) == 8_MB);
+
+    // The run that exposed it: 223 mirrors of 1,750 MiB hold 612 MiB of waste, 7.85 MiB and
+    // 2.74 MiB a mirror. Under the fixed 8 MiB none qualified; under the share all of them do.
+    const u64 mirror = 7'850'000; // 7.85 MiB
+    const u64 waste = 2'870'000;  // 2.74 MiB
+    assert(MirrorMinWaste(mirror) < waste);
+    assert(waste < 8_MB); // what the old fixed threshold asked for
+}
+
+void TestMinHoleFollowsSize() {
+    assert(MirrorMinHole(1_MB) == 256_KB);
+    assert(MirrorMinHole(8_MB) == 256_KB);
+    assert(MirrorMinHole(64_MB) == 2_MB);
+    assert(MirrorMinHole(1_GB) == 4_MB);
+}
+
+void TestNoRuns() {
+    assert(MirrorSegments({}, kShift, 1_MB, kMaxSegmentsPerMirror).empty());
+}
+
+void TestOneRunStaysOneSegment() {
+    const std::vector<Segment> runs{{0, 100}};
+    const auto segments = MirrorSegments(runs, kShift, 1_MB, kMaxSegmentsPerMirror);
+    assert(segments.size() == 1);
+    assert(segments[0].first == 0 && segments[0].end == 100);
+}
+
+void TestHeadAndTailComeOffForFree() {
+    // Valid [16, 64) in a mirror of 128 blocks (8 MiB): a head of 1 MiB and a tail of 4 MiB. Both
+    // come off without an extra mirror, so all 5 MiB come back whatever the per-hole minimum says.
+    const std::vector<Segment> runs{{16, 64}};
+    for (const u64 min_hole : {u64{256_KB}, u64{2_MB}, u64{4_MB}}) {
+        const auto segments = MirrorSegments(runs, kShift, min_hole, kMaxSegmentsPerMirror);
+        assert(segments.size() == 1);
+        assert(segments[0].first == 16 && segments[0].end == 64);
+        assert((128 << kShift) - SegmentsBytes(segments, kShift) == 5_MB);
+    }
+}
+
+void TestHoleIsSplitOnlyWhenItPays() {
+    // An 8 MiB mirror with two 64-block runs and a hole between them.
+    const std::vector<Segment> two{{0, 64}, {72, 128}}; // the hole is 8 blocks = 512 KiB
+    // The hole is under the extra mirror's worth (kSegmentPays): kept, so one segment and the
+    // caller frees nothing beyond the ends.
+    const auto kept = MirrorSegments(two, kShift, 256_KB, kMaxSegmentsPerMirror);
+    assert(kept.size() == 1);
+    assert(kept[0].first == 0 && kept[0].end == 128);
+    assert(SegmentsBytes(kept, kShift) == 128 << kShift);
+
+    // A 2 MiB hole does pay for the mirror it costs: split in two.
+    const std::vector<Segment> wide{{0, 64}, {96, 160}}; // the hole is 32 blocks = 2 MiB
+    const auto split = MirrorSegments(wide, kShift, 256_KB, kMaxSegmentsPerMirror);
+    assert(split.size() == 2);
+    assert(split[0].first == 0 && split[0].end == 64);
+    assert(split[1].first == 96 && split[1].end == 160);
+    assert(SegmentsBytes(split, kShift) == (128 << kShift));
+    assert((160 << kShift) - SegmentsBytes(split, kShift) == 2_MB);
+}
+
+void TestWasteBetweenValidBlocksFreesNothing() {
+    // Many small holes: the mirror comes back whole, so the caller skips it. This is the case the
+    // old `continue` decided for every mirror.
+    std::vector<Segment> runs;
+    u64 at = 0;
+    for (u32 i = 0; i < 40; ++i) {
+        runs.push_back({at, at + 16});
+        at += 16 + 1; // a 64 KiB hole after each 1 MiB run
+    }
+    const u64 size = runs.back().end << kShift;
+    const auto segments = MirrorSegments(runs, kShift, MirrorMinHole(size), kMaxSegmentsPerMirror);
+    assert(SegmentsBytes(segments, kShift) == size);
+}
+
+void TestSegmentCapKeepsTheSmallestHoles() {
+    // Twenty runs of 64 blocks with holes of 1..19 MiB between them.
+    std::vector<Segment> runs;
+    std::vector<u64> holes;
+    u64 at = 0;
+    for (u32 i = 1; i <= 20; ++i) {
+        runs.push_back({at, at + 64});
+        holes.push_back(u64(i) * kBlocksPerMiB);
+        at += 64 + u64(i) * kBlocksPerMiB;
+    }
+    holes.pop_back(); // 19 holes between 20 runs
+
+    const auto segments = MirrorSegments(runs, kShift, 256_KB, kMaxSegmentsPerMirror);
+    assert(segments.size() == kMaxSegmentsPerMirror);
+    // Nothing is lost: every valid block is inside one of the new mirrors, and they do not
+    // overlap.
+    std::size_t next = 0;
+    for (const auto& segment : segments) {
+        assert(segment.first < segment.end);
+        while (next < runs.size() && runs[next].first >= segment.first &&
+               runs[next].end <= segment.end) {
+            ++next;
+        }
+    }
+    assert(next == runs.size());
+    for (std::size_t i = 0; i + 1 < segments.size(); ++i) {
+        assert(segments[i].end <= segments[i + 1].first);
+    }
+    assert(segments.front().first == runs.front().first);
+    assert(segments.back().end == runs.back().end);
+
+    // Each split is a hole, and the holes split are the biggest ones: with 8 pieces at most, 7
+    // splits remain and they go to the 7 biggest holes (13..19 MiB).
+    std::vector<u64> split_holes;
+    for (std::size_t i = 0; i + 1 < segments.size(); ++i) {
+        split_holes.push_back(segments[i + 1].first - segments[i].end);
+    }
+    const std::vector<u64> expected(holes.end() - 7, holes.end());
+    assert(split_holes == expected);
+}
+
+void TestRunsAreNotSplitForNothing() {
+    // The guard against the opposite failure (0.7 made 411 mirrors in 8 minutes for 0.4 GB of data
+    // on the 2 GB laptop): holes of a handful of blocks never pay for the mirrors they would add,
+    // so the runs stay in one segment.
+    const std::vector<Segment> runs{{0, 1}, {2, 3}, {4, 6}};
+    for (const u32 limit : {kMaxSegmentsPerMirror, 1u, 0u}) {
+        const auto segments = MirrorSegments(runs, kShift, 0, limit);
+        assert(segments.size() == 1);
+        assert(segments[0].first == 0 && segments[0].end == 6);
+        // Nothing freed between the valid blocks: only the (absent) head and tail come off.
+        assert(SegmentsBytes(segments, kShift) == (6 << kShift));
+    }
+}
+
+void TestRetryAndBudget() {
+    assert(kRetrySeconds == 30);
+    // The per-split minimum the two tests above rely on.
+    assert(kSegmentPays == 1_MB);
+    // A small waste is taken whole; a large one is capped so the copies spread over the seconds
+    // that follow instead of landing in one long frame.
+    assert(CompactBudget(1_MB) == 1_MB);
+    assert(CompactBudget(32_MB) == 32_MB);
+    assert(CompactBudget(612_MB) == 32_MB);
+    assert(CompactBudget(0) == 0);
+}
+
+} // namespace
+
+int main() {
+    TestMinWasteFollowsSize();
+    TestMinHoleFollowsSize();
+    TestNoRuns();
+    TestOneRunStaysOneSegment();
+    TestHeadAndTailComeOffForFree();
+    TestHoleIsSplitOnlyWhenItPays();
+    TestWasteBetweenValidBlocksFreesNothing();
+    TestSegmentCapKeepsTheSmallestHoles();
+    TestRunsAreNotSplitForNothing();
+    TestRetryAndBudget();
+    std::printf("layer-mirror-policy-test: all checks passed\n");
+    return 0;
+}

tests/test_sampler_gc.py

@@ -0,0 +1,287 @@
+# SPDX-FileCopyrightText: Copyright 2026 bbport contributors
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""CPU sampler-GC regression with production lookup, Touch and natural age advancement.
+
+Compile the Sampler declaration, lookup/GC bodies, LRU, defer/pop and timeline
+accessors. Only Vulkan allocation, image GC and completion progress are adapters.
+The 4000-object allocation limit is modeled; no device or game is used.
+"""
+import os
+from pathlib import Path
+import shlex
+import shutil
+import subprocess
+import tempfile
+import unittest
+
+from paths import ROOT
+
+
+def body(text, anchor):
+    start = text.index('{', text.index(anchor))
+    depth = 0
+    for at in range(start, len(text)):
+        if text[at] == '{':
+            depth += 1
+        elif text[at] == '}':
+            depth -= 1
+            if depth == 0:
+                return text[start + 1:at]
+    raise ValueError('unbalanced source: ' + anchor)
+
+
+VK_STUB = r'''#pragma once
+#include <cstdint>
+#include <memory>
+#include <vector>
+namespace vk {
+using Sampler=std::uint64_t;
+inline unsigned destroyed=0;
+inline Sampler next_id=0;
+inline std::vector<Sampler> destroyed_ids;
+struct UniqueSampler {
+    std::unique_ptr<Sampler> value;
+    UniqueSampler()=default;
+    explicit UniqueSampler(Sampler id):value(std::make_unique<Sampler>(id)){}
+    UniqueSampler(UniqueSampler&&) noexcept=default;
+    UniqueSampler& operator=(UniqueSampler&&) noexcept=default;
+    ~UniqueSampler(){if(value){++destroyed;destroyed_ids.push_back(*value);}}
+    Sampler operator*() const{return *value;}
+};
+}
+'''
+
+
+HARNESS = r'''#include "common/hash.h"
+#include "common/lru_cache.h"
+#include "common/scope_exit.h"
+#include "common/unique_function.h"
+#include "textures/sampler.h"
+#include <algorithm>
+#include <atomic>
+#include <bit>
+#include <cstdio>
+#include <deque>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <tsl/robin_map.h>
+#include <xxhash.h>
+void check(bool condition, const char *message) {
+    if (!condition)
+        throw std::runtime_error(message);
+}
+namespace Vulkan {
+class Instance {};
+} // namespace Vulkan
+namespace BbToggle {
+constexpr int PendingPollLimit = 0;
+bool Disabled(int) { return true; }
+} // namespace BbToggle
+VideoCore::Sampler::Sampler(const Vulkan::Instance &, const Gcn::Sampler &, Gcn::BorderColorBuffer,
+                            bool, float) {
+    auto created = vk::UniqueSampler(++vk::next_id);
+    <<OWNER>>
+}
+VideoCore::Sampler::~Sampler() = default;
+struct Timeline {
+    std::atomic<u64> current_tick{1}, gpu_tick{0};
+    u64 CurrentTick() const noexcept { <<CURRENT>> }
+    u64 KnownGpuTick() const noexcept { <<KNOWN>> }
+    bool IsFree(u64 tick) const noexcept { <<FREE>> }
+    u64 NextTick() noexcept { <<NEXT>> }
+    void Refresh() {}
+};
+struct Scheduler {
+    Timeline work_semaphore;
+    struct PendingOp {
+        Common::UniqueFunction<void> callback;
+        u64 gpu_tick;
+    };
+    std::deque<PendingOp> pending_ops;
+    std::recursive_mutex pending_ops_mutex;
+    std::atomic<u32> num_pending_ops{0};
+    u32 pending_polls = 0;
+    u64 CurrentTick() const { return work_semaphore.CurrentTick(); }
+    void DeferOperation(Common::UniqueFunction<void> &&func) { <<DEFER>> }
+    void PopPendingOperations() { <<POP>> }
+    void Complete(u64 tick) {
+        work_semaphore.gpu_tick = tick;
+        PopPendingOperations();
+    }
+};
+struct Cache {
+    Vulkan::Instance instance;
+    Scheduler scheduler;
+    std::mutex samplers_mutex;
+    tsl::robin_map<u64, VideoCore::Sampler> samplers;
+    Common::LeastRecentlyUsedCache<u64, u64> sampler_lru;
+    <<INITIAL_AGE>>
+    u64 trigger_gc_samplers, pressure_gc_samplers, critical_gc_samplers;
+    explicit Cache(u32 max_samplers) { <<THRESHOLDS>> }
+    vk::Sampler GetSampler(const Gcn::Sampler &sampler, Gcn::BorderColorBuffer border_color_base,
+                           bool is_depth, float extra_lod_bias) {
+        <<GET>>
+    }
+    void GarbageCollectImages() {} // no images in this sampler-only fixture
+    void RunGarbageCollector() { <<RUN_GC>> }
+    void GarbageCollectSamplers() { <<GC>> }
+    // Only progress/completion is modeled. Age advances exclusively inside production RunGC.
+    void CompletedFrame() {
+        RunGarbageCollector();
+        scheduler.Complete(scheduler.work_semaphore.NextTick());
+    }
+    vk::Sampler Lookup(u64 key) {
+        Gcn::Sampler sampler{};
+        sampler.min_lod = u32(key);
+        sampler.max_lod = 4095;
+        return GetSampler(sampler, Gcn::BorderColorBuffer{}, false, 0.f);
+    }
+    void Fill() {
+        for (u64 key = 0; key < trigger_gc_samplers; ++key)
+            Lookup(key);
+    }
+};
+int main(int argc, char **argv) {
+    try {
+        check(argc == 3, "scenario max-samplers");
+        const std::string scenario = argv[1];
+        const auto limit = u32(std::stoul(argv[2]));
+        check(limit >= 32, "limit too small");
+        Cache cache(limit);
+        if (scenario != "startup")
+            for (int i = 0; i < 20; ++i)
+                cache.CompletedFrame();
+        const u64 inserted_age = cache.gc_tick;
+        cache.Fill();
+        const auto target = cache.Lookup(0); // calls production Touch even on repeat lookup
+        const auto initial_count = cache.samplers.size();
+        if (scenario == "startup" || scenario == "warm-fresh") {
+            cache.RunGarbageCollector();
+            const auto early = vk::destroyed;
+            const bool target_destroyed =
+                std::find(vk::destroyed_ids.begin(), vk::destroyed_ids.end(), target) !=
+                vk::destroyed_ids.end();
+            std::printf("scenario=%s limit=%u trigger=%llu inserted_age=%llu age_after=%llu "
+                        "current_tick=%llu completed_tick=%llu early=%u target_destroyed=%d "
+                        "remaining=%zu pending=%u\n",
+                        argv[1], limit, (unsigned long long)cache.trigger_gc_samplers,
+                        (unsigned long long)inserted_age, (unsigned long long)cache.gc_tick,
+                        (unsigned long long)cache.scheduler.CurrentTick(),
+                        (unsigned long long)cache.scheduler.work_semaphore.KnownGpuTick(), early,
+                        target_destroyed, cache.samplers.size(),
+                        cache.scheduler.num_pending_ops.load());
+            if (scenario == "startup") {
+                check(early == 0 && !target_destroyed &&
+                          cache.samplers.size() == initial_count - 10 &&
+                          cache.scheduler.num_pending_ops == 10,
+                      "premature first-GC destruction");
+                cache.scheduler.Complete(cache.scheduler.work_semaphore.NextTick());
+                check(vk::destroyed == 10 && cache.scheduler.num_pending_ops == 0,
+                      "startup final release");
+            } else
+                check(early == 0 && cache.samplers.size() == initial_count,
+                      "fresh Touch did not protect");
+        } else {
+            // The first reference completes before later frames: the default pacing case.
+            cache.scheduler.Complete(cache.scheduler.work_semaphore.NextTick());
+            for (int frame = 0; frame < 18; ++frame) {
+                if (scenario == "touch-hot")
+                    check(cache.Lookup(0) == target, "hot object replaced");
+                cache.CompletedFrame();
+            }
+            bool target_destroyed = std::find(vk::destroyed_ids.begin(), vk::destroyed_ids.end(),
+                                              target) != vk::destroyed_ids.end();
+            check(vk::destroyed == 10, "cold entries did not age out");
+            check(target_destroyed == (scenario == "paced-cold"), "Touch/expiry result wrong");
+            std::printf("scenario=%s inserted_age=%llu final_age=%llu destroyed=%u "
+                        "target_destroyed=%d completed_before_expiry=1 pending=%u\n",
+                        argv[1], (unsigned long long)inserted_age,
+                        (unsigned long long)cache.gc_tick, vk::destroyed, target_destroyed,
+                        cache.scheduler.num_pending_ops.load());
+        }
+        return 0;
+    } catch (const std::exception &e) {
+        std::fprintf(stderr, "FAIL %s\n", e.what());
+        return 1;
+    }
+}
+'''
+
+class SamplerGcTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        compiler = shlex.split(os.environ.get('CXX', 'c++'))
+        if not compiler or not shutil.which(compiler[0]):
+            raise unittest.SkipTest('a C++20 compiler is required')
+        flags = shlex.split(os.environ.get('CXXFLAGS', ''))
+        cls.tmp = tempfile.TemporaryDirectory()
+        cls.addClassCleanup(cls.tmp.cleanup)
+        folder = Path(cls.tmp.name)
+        probe = folder / 'dependencies.cpp'
+        probe.write_text('#include <tsl/robin_map.h>\n#include <xxhash.h>\n'
+                         '#include <fmt/format.h>\n'
+                         'int main() { return int(XXH3_64bits("", 0) == 0); }\n')
+        result = subprocess.run(compiler + flags + ['-std=c++20', str(probe),
+                                '-lxxhash', '-o', str(folder / 'dependencies')],
+                                capture_output=True, text=True, timeout=60)
+        if result.returncode:
+            raise unittest.SkipTest('C++20, robin-map/fmt headers and libxxhash are required')
+        vk_header = folder / 'vulkan/vk_common.h'
+        vk_header.parent.mkdir()
+        vk_header.write_text(VK_STUB)
+        read = lambda name: (ROOT / 'gpu' / name).read_text(encoding='utf-8')
+        texture = read('textures/texture_cache.cpp')
+        memory = read('textures/texture_cache_memory.cpp')
+        timeline = read('vulkan/timeline.h')
+        replacements = {
+            'OWNER': next(line for line in read('textures/sampler.cpp').splitlines()
+                          if 'handle =' in line),
+            'CURRENT': body(timeline, 'u64 CurrentTick()'),
+            'KNOWN': body(timeline, 'u64 KnownGpuTick()'),
+            'FREE': body(timeline, 'bool IsFree('),
+            'NEXT': body(timeline, 'u64 NextTick()'),
+            'DEFER': body(read('render/scheduler.h'), 'void DeferOperation('),
+            'POP': body(read('render/scheduler.cpp'), 'void Scheduler::PopPendingOperations('),
+            'INITIAL_AGE': next(line.strip() for line in read('textures/texture_cache.h').splitlines()
+                                if 'u64 gc_tick =' in line),
+            'THRESHOLDS': '\n'.join(line for line in texture.splitlines()
+                                    if '_gc_samplers = max_samplers' in line),
+            'GET': body(texture, 'vk::Sampler TextureCache::GetSampler('),
+            'RUN_GC': body(memory, 'void TextureCache::RunGarbageCollector('),
+            'GC': body(memory, 'void TextureCache::GarbageCollectSamplers('),
+        }
+        code = HARNESS
+        for key, value in replacements.items():
+            code = code.replace('<<' + key + '>>', value)
+        source = folder / 'sampler-gc.cpp'
+        source.write_text(code)
+        cls.exe = folder / 'sampler-gc'
+        result = subprocess.run(compiler + flags + ['-std=c++20', '-Wall', '-Wextra', '-Werror',
+                                '-I', str(folder), '-I', str(ROOT / 'gpu'), str(source),
+                                '-lxxhash', '-pthread', '-o', str(cls.exe)],
+                                capture_output=True, text=True, timeout=60)
+        if result.returncode:
+            raise RuntimeError(result.stdout + result.stderr)
+
+    def run_case(self, mode):
+        result = subprocess.run([str(self.exe), mode, '4000'], capture_output=True,
+                                text=True, timeout=10)
+        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+        print(result.stdout, end='')
+
+    def test_first_gc_retains_fresh_samplers_until_render_completion(self):
+        self.run_case('startup')
+
+    def test_fresh_lookup_after_warmup_does_not_evict(self):
+        self.run_case('warm-fresh')
+
+    def test_completed_cold_samplers_age_out(self):
+        self.run_case('paced-cold')
+
+    def test_repeated_lookup_refreshes_the_hot_sampler(self):
+        self.run_case('touch-hot')
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_submission_publish.py

@@ -0,0 +1,408 @@
+# SPDX-FileCopyrightText: Copyright 2026 bbport contributors
+# SPDX-License-Identifier: GPL-2.0-or-later
+"""A queued submission must not be visible to the decoder before its count is published.
+
+Compiles the actual SubmitGfx/SubmitAsc publication blocks and the consumer's pop
+block from gpu/cp/command_processor.cpp. The producer is paused at its publication
+point (after the queue push, before the counter); the queue is then inspected the
+way the decoder does it, under the queue mutex. If the task is visible there, the
+count must already cover it.
+
+Why the pause is injected instead of taking submit_mutex: the decoder takes the
+same mutex inside its pop block, so parking the producer on it would park the
+consumer too -- which is exactly why the window is short in production. The pause
+sits on the boundary under test; the queue, both mutexes and the counter are real.
+
+No Vulkan device and no command decoding: only the queue, the mutexes and the
+counter take part, which is where the ordering lives.
+
+Also executes the production SignalGpuIdle and WaitGpuIdle bodies. Rasterizer
+and GPU execution are omitted: idle callbacks are explicitly invoked by the test.
+"""
+import os
+from pathlib import Path
+import re
+import shlex
+import shutil
+import subprocess
+import tempfile
+import unittest
+
+from paths import ROOT
+
+SOURCE = ROOT / 'gpu/cp/command_processor.cpp'
+PUSH = 'queue.works.push_back(std::move(work));'
+
+
+def _block_start(text, pos):
+    """Index of the line holding the lone '{' that opens the block around `pos`."""
+    opener = None
+    for match in re.finditer(r'\n([ \t]*)\{\n', text[:pos]):
+        opener = match
+    if opener is None:
+        raise ValueError('no block opener before offset %d' % pos)
+    return opener.start() + 1
+
+
+def _match_brace(text, start):
+    depth = 0
+    for index in range(start, len(text)):
+        if text[index] == '{':
+            depth += 1
+        elif text[index] == '}':
+            depth -= 1
+            if depth == 0:
+                return index + 1
+    raise ValueError('unbalanced block at offset %d' % start)
+
+
+def _producer_block(text, function):
+    """One producer: the queue push under the queue mutex, then the count publication."""
+    entry = text.index('void CommandProcessor::%s' % function)
+    push = text.index(PUSH, entry)
+    start = _block_start(text, push)
+    end = text.index('submit_cv.notify_one();', push) + len('submit_cv.notify_one();')
+    block = text[start:end]
+    block = block.replace(PUSH, PUSH + '\n        NotePushed();')
+    # Pause on the boundary under test: before the count's lock, wherever it is.
+    return re.sub(r'([ \t]*)(std::scoped_lock \w+\{submit_mutex\};)',
+                  r'\1HoldPublication();\n\1\2', block)
+
+
+def _pop_block(text):
+    entry = text.index('void CommandProcessor::Run(')
+    pop = text.index('queue.works.pop_front();', entry)
+    start = _block_start(text, pop)
+    return text[start:_match_brace(text, start)]
+
+
+def _statement(text, start_anchor, statement):
+    entry = text.index(start_anchor)
+    at = text.index(statement, entry)
+    return text[at:at + len(statement)]
+
+
+def _body(text, anchor):
+    entry = text.index(anchor)
+    start = text.index('{', entry)
+    return text[start + 1:_match_brace(text, start) - 1]
+
+
+def _idle_snapshot(text):
+    entry = text.index('void CommandProcessor::AfterBatch(')
+    at = text.index('decoded = num_submits == 0;', entry)
+    start = _block_start(text, at)
+    return text[start:_match_brace(text, start)]
+
+
+HARNESS = r'''#include <algorithm>
+#include <atomic>
+#include <condition_variable>
+#include <cstdint>
+#include <cstdio>
+#include <deque>
+#include <latch>
+#include <functional>
+#include <string>
+#include <memory>
+#include <mutex>
+#include <span>
+#include <thread>
+#include <utility>
+
+using u32 = std::uint32_t;
+using u64 = std::uint64_t;
+constexpr u64 NoSeq = ~u64{0};
+
+namespace BbStats {
+std::atomic<u64> guest_submit_stamp{0};
+}
+namespace BbTimeline {
+inline constexpr int GuestSubmit = 0;
+inline void Note(int, u64 = 0, u64 = 0) {}
+}
+namespace BbFreeCheck {
+inline void NoteSubmit(u64, const u32*, size_t) {}
+}
+struct SubmittedCopy {
+    const u32* guest_dcb = nullptr;
+};
+struct Prep {
+    void Enqueue(u64, void*) {}
+    void* Build(std::span<const u32>) { return nullptr; }
+};
+struct Work {
+    std::span<const u32> dcb, ccb;
+    u64 seq = NoSeq;
+    u64 stamp = 0;
+    std::shared_ptr<SubmittedCopy> copy;
+};
+
+namespace BbIrq {
+enum class Line { GpuIdle };
+std::atomic<unsigned> raises{0};
+void Raise(Line) { ++raises; }
+}
+// A diagnostic wrapper around a real mutex. While the producer is paused, the
+// flag lets the observer distinguish a held queue lock without try_lock's
+// permitted spurious failure. Lock acquisition/release order is unchanged.
+struct TrackedMutex {
+    std::mutex mutex;
+    std::atomic<bool> held{false};
+    void lock() { mutex.lock(); held.store(true); }
+    void unlock() { held.store(false); mutex.unlock(); }
+};
+struct State {
+    struct Queue {
+        TrackedMutex mutex;
+        std::deque<std::unique_ptr<Work>> works;
+    } queue;
+    std::mutex submit_mutex;
+    std::condition_variable submit_cv;
+    std::atomic<u32> num_submits{0};
+    std::atomic<u32> num_commands{0};
+    u64 submissions_total = 0;
+    u64 decoded_total = 0;
+    u32 num_mapped_queues = 1;
+    u32 gnm_vqid = 1;
+    u64 gfx_submit_seq = 0;
+    std::atomic<bool> work_retired{true};
+    Prep* draw_prep = nullptr;
+    std::span<const u32> dcb, ccb;
+    Work* last_decoded = nullptr;
+    std::deque<std::pair<u64, u64>> frame_ends;
+    bool frame_end = false;
+    std::atomic<bool> armed{false};
+    std::latch pushed{1};
+    std::latch pub{1};
+    std::latch pub_release{1};
+
+    void NotePushed() {
+        if (armed.load(std::memory_order_acquire)) {
+            pushed.count_down();
+        }
+    }
+
+    void HoldPublication() {
+        if (!armed.load(std::memory_order_acquire)) {
+            return;
+        }
+        pub.count_down();
+        pub_release.wait();
+    }
+
+    void Submit(bool gfx) {
+        auto work = std::make_unique<Work>();
+        auto* draw_prep = this->draw_prep;
+        [[maybe_unused]] void* prepared = nullptr;
+        if (gfx) {
+<<GFX>>
+        } else {
+<<ASC>>
+        }
+    }
+
+    void SignalGpuIdle(u64 generation) {
+<<SIGNAL>>
+    }
+
+    std::function<void()> IdleCallback() {
+        u64 generation;
+        bool decoded;
+<<SNAPSHOT>>
+        (void)decoded;
+        return <<CALLBACK>>;
+    }
+
+    std::latch waiting{1};
+    std::atomic<bool> wait_noted{false};
+    void NoteWaitPredicate() {
+        if (num_submits != 0 && !wait_noted.exchange(true)) waiting.count_down();
+    }
+    void WaitGpuIdle() {
+<<WAIT>>
+    }
+
+    void PopOne() {
+<<POP>>
+    }
+
+    bool Empty() {
+        std::scoped_lock lock{queue.mutex};
+        return queue.works.empty();
+    }
+
+    /// AfterBatch's own decision, on the same counter.
+    bool WouldBeIdle() {
+        bool decoded = false;
+        <<IDLE>>
+        return decoded;
+    }
+
+    /// Run()'s loop condition, on the same counters.
+    bool LoopContinues() {
+        return (<<LOOP>>);
+    }
+};
+
+struct Result {
+    bool visible = false;
+    u32 counted = 0;
+    u32 queued = 0;
+    bool premature = false;
+    u32 left = 0;
+    u64 total = 0;
+    unsigned early_idle = 0;
+    unsigned stale_idle = 0;
+    unsigned fresh_idle = 0;
+};
+
+Result Run(bool gfx) {
+    State s;
+    s.Submit(gfx); // the counted one
+    s.armed.store(true, std::memory_order_release);
+    std::thread producer([&] { s.Submit(gfx); }); // pushed, not yet counted
+    s.pushed.wait();
+    s.pub.wait();
+
+    Result r;
+    {
+        r.visible = !s.queue.mutex.held.load();
+        if (r.visible) {
+            std::scoped_lock q{s.queue.mutex};
+            r.counted = s.num_submits.load();
+            r.queued = u32(s.queue.works.size());
+        }
+    }
+    if (r.visible) {
+        s.PopOne();
+        r.premature = s.WouldBeIdle() && !s.LoopContinues();
+    }
+    auto idle = s.IdleCallback();
+    BbIrq::raises = 0;
+    idle();
+    r.early_idle = BbIrq::raises.exchange(0);
+    s.pub_release.count_down();
+    producer.join();
+    while (!s.Empty()) {
+        s.PopOne();
+    }
+    // The callback captured before the new publication must now be stale even
+    // after all work is drained: the generation guard must reject it.
+    idle();
+    r.stale_idle = BbIrq::raises.exchange(0);
+    s.IdleCallback()();
+    r.fresh_idle = BbIrq::raises.exchange(0);
+    r.left = s.num_submits.load();
+    r.total = s.submissions_total;
+    return r;
+}
+
+int main(int argc, char** argv) {
+    const std::string mode = argc > 1 ? argv[1] : "publication";
+    if (mode == "wait") {
+        State s;
+        s.Submit(true);
+        std::atomic<bool> returned{false};
+        std::thread waiter([&] { s.WaitGpuIdle(); returned = true; });
+        s.waiting.wait(); // actual wait predicate observed outstanding work
+        const bool early = returned.load();
+        s.PopOne();      // production queue -> submit pop, then notify_all
+        waiter.join();
+        std::printf("wait: early=%d returned=%d count=%u\n", int(early),
+                    int(returned.load()), s.num_submits.load());
+        return early || !returned || s.num_submits != 0 ? 1 : 0;
+    }
+    int bad = 0;
+    for (int i = 0; i < 2; ++i) {
+        const bool gfx = i == 0;
+        const Result r = Run(gfx);
+        if (r.visible) {
+            std::printf("%s: snapshot=available counted=%u queued=%u premature_idle=%d left=%u total=%llu\n",
+                        gfx ? "SubmitGfx" : "SubmitAsc", r.counted, r.queued,
+                        int(r.premature), r.left, static_cast<unsigned long long>(r.total));
+        } else {
+            std::printf("%s: queue_locked snapshot=not_taken left=%u total=%llu\n",
+                        gfx ? "SubmitGfx" : "SubmitAsc", r.left,
+                        static_cast<unsigned long long>(r.total));
+        }
+        if (mode == "publication" && r.visible) {
+            std::printf("  a queued submission was visible before its count was published\n");
+            ++bad;
+        }
+        if (r.premature) {
+            std::printf("  the decoder leaves the loop with a submission still queued\n");
+        }
+        std::printf("  idle callbacks: before_publication=%u stale=%u fresh=%u\n",
+                    r.early_idle, r.stale_idle, r.fresh_idle);
+        if (mode == "early-idle" && r.early_idle != 0) ++bad;
+        if (mode == "generation" && (r.stale_idle != 0 || r.fresh_idle != 1)) ++bad;
+        if (r.left != 0 || r.total != 2) {
+            std::printf("  the count and the queue do not agree after the drain\n");
+            ++bad;
+        }
+    }
+    return bad == 0 ? 0 : 1;
+}
+'''
+
+
+class SubmissionPublishTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        compiler = shlex.split(os.environ.get('CXX', 'c++'))
+        if not compiler or not shutil.which(compiler[0]):
+            raise unittest.SkipTest('a C++20 compiler is required')
+        text = SOURCE.read_text(encoding='utf-8')
+        callback = re.search(r'rasterizer->SignalAfterGpu\((\[this, generation\] \{ SignalGpuIdle\(generation\); \})\);', text)
+        if callback is None:
+            raise ValueError('idle callback anchor changed')
+        wait = _body(text, 'void CommandProcessor::WaitGpuIdle(')
+        wait = wait.replace('return num_submits == 0;',
+                            'NoteWaitPredicate(); return num_submits == 0;')
+        code = (HARNESS
+                .replace('<<SIGNAL>>', _body(text, 'void CommandProcessor::SignalGpuIdle('))
+                .replace('<<SNAPSHOT>>', _idle_snapshot(text))
+                .replace('<<CALLBACK>>', callback.group(1))
+                .replace('<<WAIT>>', wait)
+                .replace('<<GFX>>', _producer_block(text, 'SubmitGfx'))
+                .replace('<<ASC>>', _producer_block(text, 'SubmitAsc'))
+                .replace('<<POP>>', _pop_block(text))
+                .replace('<<IDLE>>', _statement(text, 'void CommandProcessor::AfterBatch(',
+                                                'decoded = num_submits == 0;'))
+                .replace('<<LOOP>>', _statement(text, 'void CommandProcessor::Run(',
+                                                'while (num_submits || num_commands) {')
+                         [len('while ('):]
+                         [:-len(') {')]))
+        cls.tmp = tempfile.TemporaryDirectory()
+        cls.addClassCleanup(cls.tmp.cleanup)
+        folder = Path(cls.tmp.name)
+        source = folder / 'publish.cpp'
+        source.write_text(code, encoding='utf-8')
+        cls.exe = folder / 'publish-test'
+        result = subprocess.run(compiler + ['-std=c++20', '-Wall', '-Wextra', '-Werror',
+                                            '-pthread', str(source), '-o', str(cls.exe)],
+                                capture_output=True, text=True, timeout=120)
+        if result.returncode:
+            raise RuntimeError(result.stdout + result.stderr)
+
+    def run_case(self, mode):
+        result = subprocess.run([str(self.exe), mode], capture_output=True, text=True, timeout=15)
+        self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+        print(result.stdout, end='')
+
+    def test_count_is_published_before_the_task_is_visible(self):
+        self.run_case('publication')
+
+    def test_idle_callback_cannot_accept_unpublished_queued_work(self):
+        self.run_case('early-idle')
+
+    def test_generation_rejects_stale_callback_and_accepts_fresh_idle(self):
+        self.run_case('generation')
+
+    def test_wait_gpu_idle_blocks_then_wakes_after_the_real_pop(self):
+        self.run_case('wait')
+
+
+if __name__ == '__main__':
+    unittest.main()