[JuliusBairaktaris]

Draft, opened early to track progress in the open. The branch is the consolidated build (nx2 + every finished item, 240 commits; native work in progress sits behind runtime switches that default off). The checklist below is the whole plan; ticked items are committed. Commits titled EXPERIMENT (do not merge) hold A/B switches and are dropped before this leaves draft.

Goal

Ocarina of Time (0400486024DEC000) on an RX 9070 XT (RDNA 4, Adrenalin 26.10.2) and a Ryzen 7 9800X3D (Zen 5), on a 3440x1440 240 Hz OLED HDR display with VRR:

• unlocked, capped at floor(R − R²/3600) = 224 fps so presents stay inside the VRR window, with the emulator able to render 240 fps natively uncapped (4.17 ms per frame for every critical thread) so the cap has headroom for flat pacing; frame generation optional on top
• AMD FSR 4 upscaling / Native AA, AMD frame generation through AMD's frame-generation swapchain (driver frame pacing), Anti-Lag 2, lowest input latency
• everything that can run natively runs natively: GPU work as native GPU work (bindless textures, GPU page table, GPU-driven commands), guest code translated once into optimised native code
• full use of the hardware: GPU ≥ 95% busy when uncapped, the emulator's front/back GPU threads and guest cores not waiting on each other
• native 21:9 with correct field of view, HUD and cutscenes; 16:9 movies and 2D screens pillarboxed, never stretched
• no VRR flicker on the OLED: the refresh interval stays steady through gameplay, loads, menus and movies
• correct HDR and SDR colours, no rendering artefacts, flat frame times, no shader or traversal stutter, short loads, movies at their own speed
• one-hour sessions without crash, device loss or memory growth; saves load back

Every change is benched on Windows with the game; the before/after table below is updated as items land.

Numbers so far

Updated 2026-11-08 23:00. Field (balcony above Kokiri village, camera pan) and walk (ladder, cutscene, village route) scenes at 16:9, one run per column. base = this branch's nx2 rebase before the native work (allr); native (cons2) = the consolidated build at 994ba77 (GPU page table not yet active, bindless off); native (cons7) = the consolidated build at 6ce1332a03 with the GPU page table, the front-thread wait cuts (QMD view, GPU-kept compute list words, no drain behind narrowed semaphore reads), shader objects and the dynamic rasterization state, indirect-branch cache off. The base and cons2 columns were measured while the machine compiled (load 67–100%); cons7 ran with every compile paused, and the base build gets the same paused run in the final sweep.

metric	base	native (cons2)	native (cons7)
field real fps	45.5	44.6	62.4
walk real fps	42.4	43.5	61.7
GPU busy %, field	69	69	80
HostTiming busy %, field	56	69	67
GPUBack busy %, field	54	58	62
boot s	9.6	12.6	–
save load s	13.5	14.9	–

With the steady VRR presenter on, PresentMon sees the re-presented frames at the 224 Hz cap, so its lows and spikes describe the presentation, not the game frames; those cells are left out.

Where the frame goes now (cons7, field 62 fps = 16 ms/frame): the GPU is 80% busy (~13 ms/frame), and the guest CPU core 0, HostTiming and the GPU back thread each take ~10–11 ms/frame. Every one of them has to come down to 4.17 ms for 240 fps; the GPU per-pass profile and the shared translation cache are the next items.

Plan and progress

Native architecture (the main work now)

Everything that can run natively runs natively; items the new designs supersede are dropped instead of finished.

• Front-thread waits on the GPU (measured limiter): guest semaphore waits resolved on the GPU timeline, GPU-written command lists without front waits (video_core: decouple the split GPU threads — Ocarina of Time holds 60 fps on AMD, plus fixes for three older races #805's design, draw/dispatch indirect), fewer submits per frame
• Native GPU backend — done: texture/sampler pool mirror; GPU page table for storage, global memory and constant buffers (it never ran before: IsBufferDeviceAddressSupported() stayed false on Vulkan 1.2+, fixed); draw-input watch; exact barriers; per-draw state as dynamic-state deltas, with a shader-object path to A/B against pipelines. Open: the descriptor heap (bindless) fails device setup on 26.10.2 (VK_ERROR_INITIALIZATION_FAILED, being root-caused), then removing the binding memo. Dropped on measurement: GPU-generated draw runs (draw recording is 3% of the frame budget). Design: notes/native-gpu-backend.md
• Native guest code — done: guest calls/returns as host call/ret (−13.5% on a 544-site call mix), per-call-site indirect-branch cache (−30% on virtual calls; a boot crash it caused is fixed and Xbyak errors now report the guest PC), core-independent code, three FP-state correctness fixes from a new instruction-level compare mode; a whole-game compile test and Lichii-config fuzzing gate every JIT change. In progress: one translation cache shared by the six cores, then persisted per game build (removes ~9–11 s of compile per save load)
• Native OS layer: idle cores, the address arbiter and HLE service threads wait natively (no spin loops; a service round trip is ~0.1 µs awake, ~8 µs from sleep). Dropped with evidence: direct service-call dispatch (host-core services can block and would deadlock the calling core) and guest threads as host threads (guest-visible scheduling rules; fiber switches are 0.5% of a guest core)
• Load-time work measured: game file read through a memory mapping; a texture transcode cache and pipeline warm-up are not needed (loads wait 0 ms on ASTC transcodes; the disk pipeline cache with driver binaries is already loaded at boot before the save is picked)
• Superseded and dropped: draw replay memo, binding memo, uniform reuse/compare, buffer_cache: upload each byte of native uniform banks once a frame #802 per-frame uniform banks, storage binding memos, back-side DrawRun folding, a second recording thread, video_core: decouple the split GPU threads — Ocarina of Time holds 60 fps on AMD, plus fixes for three older races #805's QMD view/list-indirect port, block extension / RSB / indirect-branch cache micro-work in the JIT

Bench and tooling (outside the repo)

• Windows bench harness: debug-server driven scenes, PresentMon frame times (avg, 1%, 0.1%), GPU busy, per-thread CPU busy, real fps, live log watch and hang watchdog, movie-speed check, flicker / shadow-flicker / tile-artefact metrics
• Bench saves: Kokiri balcony, plus other locations
• Symbolized profiling builds (PDB + sampled thread stacks)
• Walk + camera route with per-spike stutter attribution; several scenes in one game session; presentation-side checks (white/black frames from the real desktop output); runs refused when a GPU profiler layer is attached
• In-game performance overlay (real fps, displayed fps, 1% low, front/back/GPU ms) for the bench builds
• Idle-machine A/B campaign (≥ 3 runs per side) replacing the loaded-machine numbers above
• ThinLTO bench builds matching release codegen

Loading, stutter

• Draw waiting on an unbuilt pipeline builds it itself (port of vk_graphics_pipeline: build a held draw's pipeline inline again for worker-only builds #321)
• Pipeline builder raised while a draw waits for its build
• Pipeline eviction by memory budget (port of vk_pipeline_cache: keep Switch 2 pipelines up to a memory budget instead of evicting them after 9000 frames #313), rebuild-stutter fixes (from Ocarina of Time: fix stutter from pipeline rebuilds and slow compute builds #408), shader precache on the loading screen (Precache shaders before game start (compute, from #579/#741) #781, now in nx2)
• Pipeline libraries with optimized links only where needed on AMD (port of vulkan: pipeline libraries + shader warm-up from the game files (first-visit shader stutter) #579's core), workaround for AMD-Gfx-Drivers#126
• VK_KHR_pipeline_binary: driver binaries kept by the emulator
• Boot-phase and per-load timing log lines
• NSO modules sized from their headers; disk pipeline cache loads while the guest boots; merged RomFS built from the container TOC; container parsed once
• fsp: reads larger than the guest's buffer refused (host buffer overflow)
• Host zstd for the game's .zs files (in the nx2: Ocarina of Time performance work (split GPU thread, caches, JIT, kernel), squashed on build 116 #717 split, in the consolidated build)
• Save-load phases measured: guest code compilation is ~9–11 s of the load (580k–710k blocks); the AOT translation cache removes it; game file read through a memory mapping
• Walking stutter: pipelines built on the GPU thread (worst 862 ms) and pipeline-library builds over 50 ms — fix in the build (every cached pipeline prebuilt in the background within a budget, both pipeline libraries built at once), to measure on the walk route

CPU / real fps

• video_core, vulkan: AMD and split GPU thread fixes for Ocarina of Time #573 AMD fixes (query copies, unoptimized stalling shader, 512-draw submits, threaded unswizzle)
• Stage-4 sync points: video_core: macro DMA reads on the split front without draining the back #243, query_cache: keep fence-flagged reports pending until their fence runs (Ocarina white flashes) #337, video_core: wait only for a macro DMA read's own query reports #559; video_core: let a channel wait for a GPU-written command list without blocking the others #752 and texture_cache: don't upload stale guest memory into new images (Ocarina of Time +20% in Castle Town) #463 now in nx2
• textures: swizzle and unswizzle block linear in 16-byte units from a per-GOB offset table #784 GOB-table swizzle + AVX-512 unswizzle; gpu_thread: reset pending-channel poll timer on channel progress and use 1-tick sleeps on Windows #621 now in nx2
• Timer thread sleeps in the OS for relaxed events; wakes only when an event would be late; latent hang on destroyed event types fixed
• HostTiming CPU use: the Switch 1 compositor ticked at 6 kHz for Switch 2 titles with the speed limit off (82% of the timer thread); kept at the display rate now
• MMCSS "Games" for present and audio threads; per-draw debug hooks behind one gate; flat TIC/TSC maps
• Fastmem backing reserved and committed on use (cannot fail at boot)
• Syncpoint page updated on each guest increment
• zen5 build preset
• eden-cli input pumped at 1000 Hz (was 240 Hz)
• nx2: Ocarina of Time performance work (split GPU thread, caches, JIT, kernel), squashed on build 116 #717 split into 50 commits (kernel, JIT, front/back split, OoT patches), rebased on nx2
• Guest panic at boot with nx2: Ocarina of Time performance work (split GPU thread, caches, JIT, kernel), squashed on build 116 #717 root-caused: a guest compare-and-swap on a write-protected page could report success without writing; fixed with unit tests (in the consolidated build, 10-boot check pending)
• video_core: decouple the split GPU threads — Ocarina of Time holds 60 fps on AMD, plus fixes for three older races #805 parts kept as A/B candidates for the consolidated build: split threads park with MWAITX, fence-release drain skipped when nothing to release, buffer-use race fixes, upload join skip (texture_cache: skip uploads a join copy overwrites whole #817), DMB as lock or, FCMP flags without RCL, page-indexed block ranges
• Front thread: per-word dispatch bypass for 3D words, header decode, FindPage early-out (A/B candidates)
• Back thread outside the draw path (method handling, uploads, ring decode): profiling on the fast path, then cuts
• AMD logic-op workaround writes a guest register and defeats the dynamic-state early-out: fix
• zen5 codegen (-march=znver5) is the default for every Windows bench build; A/B against generic in the sweep
• Not done on purpose: GPU-thread pinning by default (common: pin the split GPU threads to their own cores by default #769) — starves the pinned threads when other processes use those cores (12 fps pinned vs 216 fps unpinned on the title scene); stays opt-in. Large pages for guest memory (20 GB locked up front with 4 KiB guest mappings). PGO for the llvm-mingw build (release PGO is the MSVC-ABI build).

GPU / RDNA 4

• Render-pass-end barrier only where a hazard exists; transform-feedback barrier only after passes that ran transform feedback (~140 fewer barriers per frame)
• Query sync: one fill, one barrier and one resolve per sync on AMD
• Task/mesh pipelines no longer treated as tessellation
• The stalling AMD compute shader is rebuilt optimized in the background and swapped in
• EDEN_NX2_GPU_MARKERS: named passes/draws for RGP captures
• Memory priority + pageable device-local memory
• ASTC re-compressed to BC7 on the GPU (DirectXTex encoder port) instead of BC3
• float16 on AMD's driver from 26.10.2 (bit-exact check on the 9070 XT); HMUL2/HFMA2 .FMZ with half operands translate
• Uniform banks bound only as far as their mapping reaches (reads past the mapping)
• Barrier before a guest compute dispatch only on a real hazard (was a full GPU drain ~300×/frame); render-pass hazard check by image-set generation
• Hierarchical depth (HiZ/HiS) back on: depth attachments out of GENERAL + TRANSFER_DST (A/B switch in the build)
• Static vertex input on AMD (dynamic vertex input forces the driver's generic vertex fetch); AMD's fast-linked pipelines relinked optimized in the background
• "Patch topology not used with tessellation" warning at boot: fix its cause
• GPU time per frame: AA network fully replaced, RGP-guided pass cuts, async compute where it pays
• Not done on purpose: host image copy (moves tiling onto the CPU, which is the limit).

Present, pacing, latency

• Qt fullscreen window exactly screen-sized (independent flip)
• VRR present policy: IMMEDIATE + 224 cap with VRR, FIFO_LATEST_READY without; present_wait2 pacing; "Variable Refresh Rate Display" setting
• Built-in FPS unlock and Switch 2 frame-rate limit up to 240 Hz (port of Ocarina: FPS Unlock built-in and Switch 2 frame rate limit slider #655)
• Guest frames started from the host display; Anti-Lag 2 (VK_AMD_anti_lag) at that point
• AMD FSR frame generation through AMD's frame-generation swapchain; driver-assisted frame pacing (HW flip) prerequisites checked and logged
• Input published as soon as it changes; keys read on SDL's raw input thread; input-to-present latency measured
• Gamepads through Microsoft GameInput's reading callbacks when its runtime is installed, SDL otherwise
• VRR flicker: panel VRR range read from EDID, refresh-interval steadiness metrics, steady-cadence presenter (re-presents the last image while the guest has no new frame); measured in the sweep
• Input-to-present latency A/B and frame-generation pacing check on the PC
• AMD's hardware-flip FSR 4 frame-generation swapchain on RDNA 4 (driver 26.10.1 or newer, enabled automatically): the FG context reports Mode 2 (HW flip) and PresentMon frame times stay flat (a thick frame-time band means the software pacing path); Lichii logs the FG mode and the Windows hardware-accelerated GPU scheduling (HAGS) state at startup, since HW flip needs HAGS on; no driver VSync (Lichii presents IMMEDIATE under the 224 VRR cap)

Image quality

• AMD FSR 4 Native AA and upscaling for the game's AA network slot (ports of Ocarina of Time: NVIDIA DLSS and DLAA in place of the game's anti-aliasing network #678 and Ocarina of Time: AMD FSR 3.1 in place of the game's anti-aliasing network #695), host jitter on scene draws
• Native HDR presentation (port of feat: add native HDR presentation #180), HDR only while Windows HDR is on, HDR10 metadata, HDR Off/On/Auto; follows Windows HDR and calibration changes during play
• Green tint on AMD (port of Fix Ocarina of Time's green tint on AMD: bind light-table shadow maps through descriptor arrays #354); white flashes (query_cache: keep fence-flagged reports pending until their fence runs (Ocarina white flashes) #337)
• Whole-image analysis tools (PSNR, SSIM, FLIP, shimmer, ghosting, banding against a 3× supersampled reference); runs in the sweep to set the default AA mode and FSR sharpness
• HDR screenshots were the raw HDR code values in an 8-bit image (grey); now tone-mapped at the user's reference white
• The upscaler's negative LOD bias no longer applies to the game's own render targets (blur, fog, reflections were read a mip too sharp)
• Debug server answers requests in parallel (a long input no longer blocks screenshots and the hang watchdog)
• Rendering gate for every build: golden images (16:9 SDR, 21:9 HDR) with FLIP/SSIM thresholds from run-to-run noise, a tile detector validated on real captures, every native verify layer at 0 differences, presentation and flicker checks
• Link's shadow shimmers and shows as blocks (on every build, base included): root cause in progress
• Fairy glow: with a fairy near the camera the image washes out and two dark vertical seams appear (possibly the open fairy-cave report fix corrupt fairy cave #740); tomb red line (shader: interpolate noperspective varyings perspective-correct (Ocarina of Time tomb red line, #441) #722)

Ultrawide 21:9

• The game really renders 3440x1440 (it stayed 2560x1440 and was stretched before): picture/scene size sites from Hookshot
• Camera, HUD, menus, movies and speech bubbles at 21:9 inside the game, ported from Ivan0xFF's oot-mod (MIT)
• Checked in game: native 3440x1440 render with Hor+ field of view, HUD and menus 16:9 in the centre, pause menu opens without a crash
• HUD at the real screen edges (hearts and magic left, item buttons right, menus centred) by rewriting the HUD layout's edge anchors; Z-target reticle and markers corrected at all three projection sites; texture heap grown for the wider picture. The game has no cutscene letterbox
• 21:9 checked in game on the consolidated build (HUD edges, Z-targeting, minimap/area name/save icon still centred)

Movies

• AV1 on the GPU (Vulkan Video, D3D12VA, D3D11VA, then libdav1d) with an FFmpeg package carrying four FFmpeg master fixes (the Vulkan out-of-memory was FFmpeg 9.0.2 requesting host-copyable video images); any decoder error moves on to the next path
• Movies play at their own speed at high frame rates (nx2's nx2: keep refused decoder packets and stop the movie clock running ahead (#659 follow-up) #809 clock plus hold-before-write); presents paced at a multiple of the movie rate; speed logged every 10 s
• RGBA movie output interpolates chroma
• Movie frames self-checked (decoded vs written vs guest memory) and the submitted stream can be dumped
• Stale 128×128 tiles over the title movie and the load menu: still present on the native build (51 tiles found by the new detector); root cause in progress (lead: uploads skipped for images whose pages are all marked stale)
• Banding in the intro movie: root cause (the movie path stays a plain copy, no filter)
• FFmpeg from a pinned public master build (BtbN) that already carries the four fixes, instead of an own package

Correctness and stability

• nx2:gsv 903 and prepo 10500 handled; texture headers with format 0 treated as no texture; no false unmapped-read reports for sparse regions
• robustness2 / external_memory_host detection; CPU Boost no longer speeds the game up (port of core_timing: don't scale the guest counter for CPU Boost/Overclock in Switch 2 titles (fixes #317) #785); docked by default for Switch 2 titles
• CPMUtil: CI packages honour <package>_CUSTOM_DIR; sirit builds with libc++ 23
• White frames and device losses traced to a GPU profiler layer left attached to every Vulkan process (not a code bug); the bench now refuses such runs
• One-hour session without crash, device loss or memory growth; saves load back

Merge readiness

• Linux GCC 13 -DENABLE_WERROR=ON build + ctest (first full run: two build fixes in, 4 of 1149 tests failing and being fixed), tools/clang-format.sh clean
• EXPERIMENT commits dropped, winners kept unconditionally
• Final before/after table from idle-machine runs

AMD driver bug found on the way

• AMD-Gfx-Drivers#126: fast-linked graphics pipeline libraries write the colour of demoted invocations when derivatives follow the demote (standalone repro, validation clean). The workaround links only the affected pipelines optimized.

Credits

Ultrawide techniques from Ivan0xFF's oot-mod (MIT), Hookshot and NX2navi. Ported with their authors kept: #180, #243, #313, #321, #337, #354, #408, #559, #573, #579, #655, #678, #695, #717, #769 (opt-in part), #784, #785.

🤖 Generated with Claude Code

[coderabbitai]

Important

Draft PR not reviewed

Draft PRs are not automatically reviewed by default.

• Trigger a manual review

To automatically review draft PRs, update your CodeRabbit configuration:

reviews:
  auto_review:
    drafts: true

• Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

Share

• X
• Mastodon
• Reddit
• LinkedIn

[MorpheusCode117]

Must be merged quick

[JuliusBairaktaris]

@zortos293 is it OK if Lichii reads gamepads through Microsoft's GameInput API? It delivers each new controller reading through a callback, so input no longer waits for SDL's 1 ms pump.

Microsoft's GameInput header (API v3) is MIT-licensed, so it can go in-tree with its notice. The runtime is Microsoft's separately installed redistributable: Lichii wouldn't ship it, only load it when it's present, and keep SDL everywhere else. It's one commit in this PR, easy to drop if you'd rather stay with SDL only.