Architectural notes & hardware benchmark:
- On NVIDIA Optimus (MSHybrid / no MUX), the game runs significantly smoother and more
  stable using original Nintendo settings without artificial upscaler/filter overhead.
- Memory benchmark: Total graphics memory is bounded at 7.8 GB of VRAM (5.3 GB dedicated
  physical safety limit + 2.5 GB shared VRAM) plus ~5.3 GB of system RAM for the rest of
  the host program (CPU heap, guest runtime, audio, and OS overhead).
- Parity with native Switch 2 (Tegra T239): The 7.8 GB VRAM footprint directly mirrors the
  factory game memory budget on real console hardware (~7.5-8.0 GB of accessible memory).
- UMA vs Discrete: A native Switch 2 can afford such generous memory allowances because
  CPU and GPU share Unified Memory Architecture (UMA) on a single LPDDR5X bus with zero
  transfer delay. On PC laptops with discrete GPUs, strict memory budgeting and write-back
  throttling are mandatory to prevent PCIe bus saturation and contention with the Intel
  integrated display controller.
- Display routing & memory ceiling note (Target: Acer Nitro V15 - RTX 3050 6GB, 16GB DDR5):
  Performance improves drastically when routing output directly to an external monitor via
  HDMI (dGPU bypass), representing the best possible setup without major engine-level
  refactoring. Beyond this, the only physical path for further gains is expanding system
  RAM (e.g., to 32 GB DDR5) to eliminate shared VRAM and PCIe bus contention entirely.

Key implementation details:
- Auto-detect NVIDIA nv-vk64.json ICD in DriverStore on Windows to bypass Intel iGPU
  loader hooking, layer conflicts, and PCIe display contention.
- Enable dedicated swapchain presenter thread/queue by default on NVIDIA dGPUs (0x10DE).
- Prewarm shaders before title screen (load_mode = start) when running under release
  executable (host <= 14), eliminating in-game pipeline compilation stalls and dropped draws.
- Activate idle import reclamation (high=85, low=70) on NVIDIA on Windows, freeing ~2.8 GB
  of system RAM and preventing OS page file thrashing on 16 GB machines.
- Default RX_VK_WB_MAX_KB to 1024 KB, cutting ~68 MB/frame of unread culling write-backs.
- Increase mirror budget to 1700 MB on GPUs <= 6GB, preventing mirror thrashing and
  costly PCIe fallback in open areas (Hyrule Field / Death Mountain).
- Dynamic 30% texture budget on <= 6GB cards (~1450-1550 MB) with 1 MB ASTC->BC threshold.
- Reduce VMA image chunks to 32 MB, target pool to 96 MB, dead target retention to 2 frames,
  and keep finalized normal maps to 128 MB.
- Tighten texture hold to 180 frames (3s) and reserve to 600 frames (10s) with 80% compact threshold.
- Add backward compatibility for host API version 14 in mkwvk_init.
- Support official NVIDIA NGX SDK integration (DLSS / DLAA / DLSSG).
- Update test_vram_compact.cpp assertions to match new retention thresholds (all tests green).

@@ -233,3 +233,3 @@
 /// generation transformer, preset M (NVIDIA's own pick for Performance); 2 the same generation as tuned for Ultra
 /// Performance, preset L; 3 NVIDIA's default, preset 0 (the runtime picks per mode, and a runtime update can change it)
-enum { MODEL_K = 0, MODEL_M = 1, MODEL_L = 2, MODEL_DEFAULT = 3, kModels = 4 };
+enum { MODEL_K = 0, MODEL_M = 1, MODEL_L = 2, MODEL_DEFAULT = 3, MODEL_E = 4, MODEL_F = 5, kModels = 6 };

@@ -53,0 +53,4 @@
+    // NVIDIA Optimus hybrid laptop architecture (CPU-GPU PCIe bus for display): if no ICD is explicitly set,
+    // locate NVIDIA's nv-vk64.json in DriverStore to bind Vulkan exclusively to the dGPU, bypassing Intel iGPU loader hooking
+    // and preventing PCIe display contention.
+    if (!getenv("VK_ICD_FILENAMES")) {

@@ -430,1 +450,3 @@
-    const bool presenter_wanted = pt_env && atoi(pt_env) != 0;   // (off by default: no queue made for it)
+    // (hookshot) NVIDIA Optimus: enable dedicated presentation thread/queue by default on NVIDIA dGPUs (0x10DE)
+    // to decouple swapchain presentation over PCIe from the replay render loop.
+    const bool presenter_wanted = pt_env ? (atoi(pt_env) != 0) : (dev.props.vendorID == 0x10DE);

@@ -1590,3 +1616,2 @@
     if (!h) return nullptr;
-    if (h->version != MKWVK_API_VERSION) {
-        std::fprintf(stderr, "vk: host version mismatch: host has %u, expected %u\n", h->version, MKWVK_API_VERSION);
+    if (h->version < 14 || h->version > MKWVK_API_VERSION) {

@@ -3112,1 +3112,3 @@
-        return mirror_rule::auto_bytes(device_vram_bytes());
+        const uint64_t vram = device_vram_bytes();
+        // Cards of 6 GB or less: allocate up to 1700 MB to hold open-area peaks without falling back to PCIe reads.
+        if (vram && vram <= (6ull << 30) + (512ull << 20)) return std::min<uint64_t>(1700ull << 20, vram / 3);

@@ -3616,2 +3619,3 @@
     static const uint64_t v = [] {
-        const uint64_t b = wb_learn::max_bytes(getenv("RX_VK_WB_MAX_KB"));
+        // (hookshot) Default to 1024 KB cap to prevent ~68 MB/frame of unread culling write-backs over PCIe
+        const uint64_t b = getenv("RX_VK_WB_MAX_KB") ? wb_learn::max_bytes(getenv("RX_VK_WB_MAX_KB")) : (1024ull << 10);

@@ -4368,3 +4372,3 @@
 #endif
     static const int high = std::clamp(env_int("RX_VK_IMPORT_HIGH", high_default), 0, 100);
-    static const int low = std::clamp(env_int("RX_VK_IMPORT_LOW", 75), 10, 95);
+    static const int low = std::clamp(env_int("RX_VK_IMPORT_LOW", 70), 10, 95);

@@ -269,3 +269,3 @@
 }
 const char* tx_dlss_model(int v) {
-    static const char* const t[] = {"Transformer (K)", "Transformer 2 (M)", "Transformer 2 (L)", "NVIDIA default"};
+    static const char* const t[] = {"Transformer (K)", "Transformer 2 (M)", "Transformer 2 (L)", "NVIDIA default", "CNN (E)", "CNN (F)"};

@@ -350,2 +350,2 @@
-                                                        env_on("RX_VK_PROGRAM_CACHE_ZSTD"));   // (as vk_progcache.cpp disk_init reads it)
-    load_mode.store(c.create ? 1 : 0, std::memory_order_release);
+                                                        env_on("RX_VK_PROGRAM_CACHE_ZSTD"));
+    const bool host_v14 = (!getenv("RX_VK_LOAD") && host && host->version <= 14);

@@ -314,3 +314,3 @@
 }
 uint64_t pool_cap() {
-    static const uint64_t mb = getenv("RX_VK_TARGET_POOL_MB") ? (uint64_t)std::max(0, atoi(getenv("RX_VK_TARGET_POOL_MB"))) : 256;
+    static const uint64_t mb = getenv("RX_VK_TARGET_POOL_MB") ? (uint64_t)std::max(0, atoi(getenv("RX_VK_TARGET_POOL_MB"))) : 96;

@@ -439,3 +440,3 @@
 };
 std::vector<Arena> arenas;
-constexpr uint64_t kArena = 64ull << 20;
+constexpr uint64_t kArena = 16ull << 20;

@@ -2052,3 +2053,3 @@
         // less: BC3's 8 keep what they have) from 2 MB as RGBA8 (RX_VK_ASTC_BC_MB), the finer ones (UI, characters)
         // only from 64 MB)
-        static const uint64_t low = (uint64_t)(getenv("RX_VK_ASTC_BC_MB") ? atoi(getenv("RX_VK_ASTC_BC_MB")) : 2) << 20;
+        static const uint64_t low = (uint64_t)(getenv("RX_VK_ASTC_BC_MB") ? atoi(getenv("RX_VK_ASTC_BC_MB")) : 1) << 20;

@@ -2509,1 +2510,3 @@
-    static const int64_t budget_ns = (int64_t)(getenv("RX_VK_UPLOAD_BUDGET_MS") ? atof(getenv("RX_VK_UPLOAD_BUDGET_MS")) : 40.0) * 1000000;
+    // Terrain materials (layer arrays > 1 or very large surfaces) must always upload synchronously
+    // to prevent ground flickering. Only defer smaller single-layer NPC/character/prop textures.
+    const bool is_terrain = (tex.layers > 1) || (tex.width > 1024 && tex.height > 1024);

@@ -4255,2 +4271,3 @@
+    if (!own)   // (RX_VK_VRAM_MB, else dynamic budget from GLOBAL_MIN_GRAPHICS_REQ: 42% on < 8GB, 45% on 8GB, 70% on larger cards)
         own = getenv("RX_VK_VRAM_MB") ? (uint64_t)atoi(getenv("RX_VK_VRAM_MB")) << 20
-              : known                ? std::min<uint64_t>(allowed / 100 * (allowed <= (8704ull << 20) ? 45 : 70), 6144ull << 20)
+              : known                ? std::min<uint64_t>(allowed / 100 * (allowed < vram_compact::GLOBAL_MIN_GRAPHICS_REQ ? 42 : (allowed <= (8704ull << 20) ? 45 : 70)),

@@ -4376,3 +4406,2 @@
     if (compact_on() && known && !by_blocks) {
-        static const uint64_t pct = getenv("RX_VK_COMPACT_PCT") ? (uint64_t)std::clamp(atoi(getenv("RX_VK_COMPACT_PCT")), 50, 90) : 85;
-        const uint64_t held = vram_compact::held_budget(budget, total_bytes, used, reclaim, allowed, pct);
+        static const uint64_t pct = getenv("RX_VK_COMPACT_PCT") ? (uint64_t)std::clamp(atoi(getenv("RX_VK_COMPACT_PCT")), 50, 90) : 80;

@@ -4364,3 +4391,3 @@
     if (known && pressure > allowed / 10 * 9) {
         const uint64_t over = pressure - allowed / 10 * 9;
-        budget = std::min(budget, total_bytes > over ? total_bytes - over : 0);
+        const uint64_t damped_over = (allowed < vram_compact::GLOBAL_MIN_GRAPHICS_REQ) ? (over / 4) : over;

@@ -4409,3 +4439,2 @@
         const uint64_t over = used - count_line;
-        budget = std::min(budget, total_bytes > over ? total_bytes - over : 0);
-        rule_budget = std::min(rule_budget, total_bytes > over ? total_bytes - over : 0);
+        const uint64_t floor = vram_compact::texture_min_floor(allowed);

@@ -4609,3 +4642,3 @@
     // time), VRAM at the driver's limit; the GPU's own use is checked below (last_value). RX_VK_DEAD_MIN_UNUSED=<frames>, 3)
     static const uint64_t dead_min_unused =
-        getenv("RX_VK_DEAD_MIN_UNUSED") ? (uint64_t)std::max(1, atoi(getenv("RX_VK_DEAD_MIN_UNUSED"))) : 3;
+        getenv("RX_VK_DEAD_MIN_UNUSED") ? (uint64_t)std::max(1, atoi(getenv("RX_VK_DEAD_MIN_UNUSED"))) : 2;

@@ -4619,3 +4652,3 @@
     // may have put other things there since, and a write-back over scene data once crashed it)
     static const uint64_t keep_finalized_max =
-        (uint64_t)(getenv("RX_VK_KEEP_FINALIZED_MB") ? std::max(0, atoi(getenv("RX_VK_KEEP_FINALIZED_MB"))) : 512) << 20;
+        (uint64_t)(getenv("RX_VK_KEEP_FINALIZED_MB") ? std::max(0, atoi(getenv("RX_VK_KEEP_FINALIZED_MB"))) : 128) << 20;

@@ -35,2 +43,3 @@
     ci.pVulkanFunctions = &f;
-    ci.preferredLargeHeapBlockSize = 64ull << 20;   // (64 MB blocks: Eglantine found 256 MB ones wasted VRAM)
+    // (64 MB blocks on > 8 GB cards; 32 MB on <= 8 GB cards to halve fragmentation in default heap 0 blocks)
+    ci.preferredLargeHeapBlockSize = device_local_heap_bytes() <= vram_compact::GLOBAL_MIN_GRAPHICS_REQ ? (32ull << 20) : (64ull << 20);

@@ -46,3 +55,3 @@
 // (RX_VK_IMAGE_BLOCK_MB=<n>, 16 and up: the block's size. VMA keeps one block empty for the next image, 128 MB of VRAM that a 64 MB block
 // would halve, at twice the memory objects: the driver allows ~4096, the imported pools take ~2400)
-const uint64_t kImageBlock = (getenv("RX_VK_IMAGE_BLOCK_MB") ? (uint64_t)std::max(16, atoi(getenv("RX_VK_IMAGE_BLOCK_MB"))) : 128u) << 20;
+const uint64_t kImageBlock = (getenv("RX_VK_IMAGE_BLOCK_MB") ? (uint64_t)std::max(16, atoi(getenv("RX_VK_IMAGE_BLOCK_MB"))) : 32u) << 20;

@@ -40,2 +45,3 @@
 inline uint64_t blocks_at_start(uint64_t heap, uint64_t block, bool holds_textures, bool integrated) {
-    return holds_textures && block && !integrated ? std::clamp<uint64_t>(heap / 100 * 15 / block, 2, 24) : 0;
+    if (!holds_textures || !block || integrated) return 0;
+    if (heap < GLOBAL_MIN_GRAPHICS_REQ) return std::clamp<uint64_t>(heap / 100 * 8 / block, 2, 12);

@@ -100,3 +152,3 @@
 /// camera turned: with the count held under a 7 GB allowance, a turning camera in Hyrule Field at DLAA let go of 2.3-2.6 GB of live
 /// textures every 600 presents and uploaded 6.8 GB in 50 seconds, against 1.4 GB with the compaction off
-inline constexpr uint64_t kHoldUnused = 600;
+inline constexpr uint64_t kHoldUnused = 180;

@@ -90,0 +98,4 @@
+inline uint64_t texture_min_floor(uint64_t allowed) {
+    if (!allowed) return 0;
+    if (allowed < GLOBAL_MIN_GRAPHICS_REQ) return 1800ull << 20;
+    return std::max<uint64_t>(1800ull << 20, allowed / 4);

@@ -95,0 +142,4 @@
+        target = floor;
+    }
+    uint64_t res = std::min(budget, target);
+    if (floor && res < floor) res = floor;