Lichii OoT AMD Stable

The first stable build of this branch — and maybe the last one.

The biggest bug left in Ocarina of Time — white bloom and fog washing over the screen after a long play session — is finally fixed. With it gone, this build is what I consider stable.

The long-session white bloom/fog is fixed

After some playtime (especially after moving between areas), huge white blurry blobs could spread over the horizon or wash out whole rooms, depending on the camera angle, and only a restart cleared them.

• Cause: when the game freed memory and reused the same addresses for new data, the emulator kept a cached GPU mapping that still pointed at the old pages. A few meshes then read unrelated data as vertices, produced invalid values, and the bloom and fog spread them into white. Now a reused mapping is checked and pointed at the current pages again (PantACRO4life, zortos293#1221; traced independently by 99ivs on zortos293#849).
• Every GPU range into memory the game destroys is unmapped too (Zortos, zortos293#1199).
• New textures no longer skip their upload where the texture collector dropped a GPU-written image, which also showed as white fog blobs (from CheezerWheezer's AMD build; Frizti's Fritchii made the same call). EDEN_NX2_TC_SKIP_STALE=1 restores the old behaviour.

Tested on an RX 9070 XT over a long session: no white bloom, and no change in frame rate.

Downloads

Platform	Standard	PGO
Windows x86_64	zip	zip
Linux x86_64	AppImage · tar.gz	AppImage · tar.gz
Linux aarch64	AppImage · tar.gz	AppImage · tar.gz

Built from oot-amd-perf at fcd9b06. No macOS build this time: GitHub had no macOS runner available.

Everything from build 13 is included: FSR 4 (off by default; Configure → Graphics → "Use AMD FSR 4 in place of a game's DLSS"), pipeline binaries, the Song of Time and Castle Town guard house fixes, the AMD ASTC corruption fixes, and the rest.

Tip

Ocarina of Time above 60 fps: press Ctrl+U (Toggle Framerate Limit) or set Frame rate limit (Switch 2) under the game's Properties > Graphics. Leave the FPS Unlock (built-in) add-on enabled; it keeps animations and physics at normal speed.

Thank you

To everyone involved in the development: Zortos and all contributors to zortos293/Lichii, Djihads80 and Eglantine, Frizti (Fritchii), CheezerWheezer, PantACRO4life, 99ivs, Celmax, chuppatricky and mja00, jpkto, kraibse, RsMan-Dev, every PR author whose work is in here, and the Eden and yuzu developers this all stands on. Thanks as well to everyone who reported the white bloom and sent logs and captures on zortos293#849 and zortos293#867.

And thank you to everyone who used my builds, tested them and reported back. This was for you.

Standard or PGO: try both

Important

Every platform has a standard and a PGO build, and neither is always faster. Try both and keep the one that runs best for you. The long-session lighting problems reported with earlier PGO builds were most likely this bug; if you still see them on PGO, use the standard build.

Linux

Linux packages come as an AppImage (self-contained, needs glibc 2.39 or newer: Ubuntu 24.04, Fedora 40, Debian 13, Arch) and a tar.gz (uses your system libraries, so Qt 6 and the usual libraries must be installed).

Lichii oot-amd-perf build 13 (0080d0d)

Automatic build of oot-amd-perf at 0080d0d.

What's new since build 10

AMD FSR 4 (off by default)

• AMD FSR 4 can replace Ocarina of Time's own upscaler and a Switch 2 game's DLSS (ported from CheezerWheezer's AMD build). It is off by default in this release.
• To turn it on: Configure → Graphics → "Use AMD FSR 4 in place of a game's DLSS", with Resolution 1X, then start the game. Needs Windows and a GPU AMD's runtime supports: Radeon RX 9000, or RX 7000 / RX 6000 with a recent driver. AMD's FidelityFX DLLs are in the Windows zip.

Performance and smoothness

• Pipeline binaries (VK_KHR_pipeline_binary): compiled pipelines are saved and reused. On an RX 9070 XT, Ocarina's warm-boot pipeline builds dropped from about 76 s to under 1 s. Shader caches from other drivers are accepted (CheezerWheezer).
• The texture collector evicts GPU-written images without waiting on the GPU unless memory is critical: fewer texture hitches (CheezerWheezer).
• Periodic texture stalls on cards with 10 GB or more of VRAM: the collector's ceiling now scales with the card's budget (zortos293#1129).
• Texture joins skip an upload that layer copies overwrite entirely (zortos293#1079).
• Host shaders keep float16 under the AMD float16 workaround.

Fixes

• Ocarina of Time: Song of Time crackle fixed (the ADPCM decoder had the sign of its nibble steps inverted; zortos293#1073).
• NUP games: a .zs member without a zstd header is served from its sibling instead of failing or reading corrupt data (RsMan-Dev).
• Ocarina of Time: Castle Town guard house freeze and its video memory blowup fixed; adds a built-in "Texture Pool x2" add-on for the game, which you can turn off under Add-Ons (zortos293#976).
• Corruption that built up over long sessions (until a restart): an evicted pipeline no longer loses its storage buffer pointers when it is rebuilt (zortos293#1143).
• AMD corruption and device loss: every ASTC decode and texture unswizzle store is bounds-checked; edge blocks wrote into other images' memory on AMD (Frizti, from CheezerWheezer's build).
• Threads waiting on GPU sync operations are released when the GPU threads stop, so closing a game no longer hangs (zortos293#1058, jpkto).
• Switch 2 semaphore mirror restored, with every semaphore region kept (zortos293#979, zortos293#1014).
• Each device memory manager has its own translation generations (zortos293#984); the last page table level is reserved from the range's last byte (zortos293#957); PFS0, RomFS, NCA and XCI parsers are hardened against malformed files (zortos293#947).

Warning

PGO builds and long sessions: PGO builds have shown lighting and texture problems after long play time. If you see them, use the standard build.

Tip

Ocarina of Time above 60 fps: press Ctrl+U (the Toggle Framerate Limit hotkey) to unlock the frame rate, or set Frame rate limit (Switch 2) under the game's Properties > Graphics (e.g. 120; applies when the game starts) to cap it there. The FPS Unlock (built-in) add-on, on by default, keeps animations and physics at normal speed at any frame rate; leave it enabled.

Standard or PGO: try both

Important

Every platform has a standard and a PGO build, and neither is always faster: some users report the standard build runs better on their PC. Try both and keep the one that runs best for you.

Linux

Linux packages come as an AppImage (self-contained, needs glibc 2.39 or newer: Ubuntu 24.04, Fedora 40, Debian 13, Arch) and a tar.gz (uses your system libraries, so Qt 6 and the usual libraries must be installed).

Build Type	Standard	PGO	Notes
amd64	AppImage · tar.gz	AppImage · tar.gz	Make the AppImage executable (chmod +x) and run it
ARM (aarch64)	AppImage · tar.gz	AppImage · tar.gz

Windows

Windows packages are in-place zip files: extract and run lichii.exe, or eden-cli.exe from a terminal.

Build Type	Standard	PGO	Notes
amd64 / x86_64	zip	PGO zip	Both built with clang-cl and ThinLTO; the PGO zip adds a profile trained on Ocarina of Time

macOS

Build Type	Standard	PGO	Notes
arm64 (Apple Silicon)	zip		macOS 15 or newer. Not notarized: right-click and choose Open the first time, or run xattr -dr com.apple.quarantine lichii.app. eden-cli is inside the app, in Contents/MacOS

The PGO builds are the same programs compiled with profile-guided optimization. Linux uses clang with Eglantine's profile; Windows uses clang-cl and ThinLTO with a profile trained in Lichii on Ocarina of Time, so other games gain less.

Lichii perf/oot-amd-120 build 10 (e32d474)

Automatic build of perf/oot-amd-120 at e32d474.

Tip

Ocarina of Time above 60 fps: (Experimental: Many bugs have been fixed, but some issues may still occur.) press Ctrl+U (the Toggle Framerate Limit hotkey) to unlock the frame rate, or set Frame rate limit (Switch 2) under the game's Properties > Graphics (e.g. 120; applies when the game starts) to cap it there. The FPS Unlock (built-in) add-on, on by default, keeps animations and physics at normal speed at any frame rate; leave it enabled.

Standard or PGO: try both

Important

Every platform has a standard and a PGO build, and neither is always faster: some users report the standard build runs better on their PC. Try both and keep the one that runs best for you.

Linux

Linux packages come as an AppImage (self-contained, needs glibc 2.39 or newer: Ubuntu 24.04, Fedora 40, Debian 13, Arch) and a tar.gz (uses your system libraries, so Qt 6 and the usual libraries must be installed).

Build Type	Standard	PGO	Notes
amd64	AppImage · tar.gz	AppImage · tar.gz	Make the AppImage executable (chmod +x) and run it
ARM (aarch64)	AppImage · tar.gz	AppImage · tar.gz

Windows

Windows packages are in-place zip files: extract and run lichii.exe, or eden-cli.exe from a terminal.

Build Type	Standard	PGO	Notes
amd64 / x86_64	zip	PGO zip	Both built with clang-cl and ThinLTO; the PGO zip adds a profile trained on Ocarina of Time

macOS

Build Type	Standard	PGO	Notes
arm64 (Apple Silicon)	zip		macOS 15 or newer. Not notarized: right-click and choose Open the first time, or run xattr -dr com.apple.quarantine lichii.app. eden-cli is inside the app, in Contents/MacOS

The PGO builds are the same programs compiled with profile-guided optimization. Linux uses clang with Eglantine's profile; Windows uses clang-cl and ThinLTO with a profile trained in Lichii on Ocarina of Time, so other games gain less.

Lichii perf/oot-amd-120 build 8 (4afcc79)

Automatic build of perf/oot-amd-120 at 4afcc79.

Tip

Ocarina of Time above 60 fps (Experimental; may softlock some quests): press Ctrl+U (the Toggle Framerate Limit hotkey) to unlock the frame rate, or set Frame rate limit (Switch 2) under the game's Properties > Graphics (e.g. 120; applies when the game starts) to cap it there. The FPS Unlock (built-in) add-on, on by default, keeps animations and physics at normal speed at any frame rate; leave it enabled.

Linux

Linux packages come as an AppImage (self-contained, needs glibc 2.39 or newer: Ubuntu 24.04, Fedora 40, Debian 13, Arch) and a tar.gz (uses your system libraries, so Qt 6 and the usual libraries must be installed).

Build Type	Standard	PGO (Recommended)	Notes
amd64	AppImage · tar.gz	AppImage · tar.gz	Make the AppImage executable (chmod +x) and run it
ARM (aarch64)	AppImage · tar.gz	AppImage · tar.gz

Windows

Windows packages are in-place zip files: extract and run lichii.exe, or eden-cli.exe from a terminal.

Build Type	Standard	PGO (Recommended)	Notes
amd64 / x86_64	zip	PGO zip	Both built with clang-cl and ThinLTO; the PGO zip adds a profile trained on Ocarina of Time

macOS

Build Type	Standard	PGO (Recommended)	Notes
arm64 (Apple Silicon)	zip		macOS 15 or newer. Not notarized: right-click and choose Open the first time, or run xattr -dr com.apple.quarantine lichii.app. eden-cli is inside the app, in Contents/MacOS

The PGO builds are the same programs compiled with profile-guided optimization. Linux uses clang with Eglantine's profile; Windows uses clang-cl and ThinLTO with a profile trained in Lichii on Ocarina of Time, so other games gain less. Prefer them when your CPU supports it.

Lichii perf/oot-amd-120 build 7 (63ed0c0)

Automatic build of perf/oot-amd-120 at 63ed0c0.

Linux

Linux packages come as an AppImage (self-contained, needs glibc 2.39 or newer: Ubuntu 24.04, Fedora 40, Debian 13, Arch) and a tar.gz (uses your system libraries, so Qt 6 and the usual libraries must be installed).

Build Type	Standard	PGO (Recommended)	Notes
amd64	AppImage · tar.gz	AppImage · tar.gz	Make the AppImage executable (chmod +x) and run it
ARM (aarch64)	AppImage · tar.gz	AppImage · tar.gz

Windows

Windows packages are in-place zip files: extract and run lichii.exe, or eden-cli.exe from a terminal.

Build Type	Standard	PGO (Recommended)	Notes
amd64 / x86_64	zip	PGO zip	Both built with clang-cl and ThinLTO; the PGO zip adds a profile trained on Ocarina of Time

macOS

Build Type	Standard	PGO (Recommended)	Notes
arm64 (Apple Silicon)	zip		macOS 15 or newer. Not notarized: right-click and choose Open the first time, or run xattr -dr com.apple.quarantine lichii.app. eden-cli is inside the app, in Contents/MacOS

The PGO builds are the same programs compiled with profile-guided optimization. Linux uses clang with Eglantine's profile; Windows uses clang-cl and ThinLTO with a profile trained in Lichii on Ocarina of Time, so other games gain less. Prefer them when your CPU supports it.

Lichii perf/oot-amd-120 build 6 (e2340a0)

Automatic build of perf/oot-amd-120 at e2340a0.

Linux

Linux packages come as an AppImage (self-contained, needs glibc 2.39 or newer: Ubuntu 24.04, Fedora 40, Debian 13, Arch) and a tar.gz (uses your system libraries, so Qt 6 and the usual libraries must be installed).

Build Type	Standard	PGO (Recommended)	Notes
amd64	AppImage · tar.gz	AppImage · tar.gz	Make the AppImage executable (chmod +x) and run it
ARM (aarch64)	AppImage · tar.gz	AppImage · tar.gz

Windows

Windows packages are in-place zip files: extract and run lichii.exe, or eden-cli.exe from a terminal.

Build Type	Standard	PGO (Recommended)	Notes
amd64 / x86_64	zip	PGO zip	Both built with clang-cl and ThinLTO; the PGO zip adds a profile trained on Ocarina of Time

macOS

Build Type	Standard	PGO (Recommended)	Notes
arm64 (Apple Silicon)	zip		macOS 15 or newer. Not notarized: right-click and choose Open the first time, or run xattr -dr com.apple.quarantine lichii.app. eden-cli is inside the app, in Contents/MacOS

The PGO builds are the same programs compiled with profile-guided optimization. Linux uses clang with Eglantine's profile; Windows uses clang-cl and ThinLTO with a profile trained in Lichii on Ocarina of Time, so other games gain less. Prefer them when your CPU supports it.

Lichii perf/oot-amd-120 build 5 (c17402b)

Ignores the update popup, next build will remove the upstream update notice.

Automatic build of perf/oot-amd-120 at c17402b.

Linux

Linux packages come as an AppImage (self-contained, needs glibc 2.39 or newer: Ubuntu 24.04, Fedora 40, Debian 13, Arch) and a tar.gz (uses your system libraries, so Qt 6 and the usual libraries must be installed).

Build Type	Standard	PGO (Recommended)	Notes
amd64	AppImage · tar.gz	AppImage · tar.gz	Make the AppImage executable (chmod +x) and run it
ARM (aarch64)	AppImage · tar.gz	AppImage · tar.gz

Windows

Windows packages are in-place zip files: extract and run lichii.exe, or eden-cli.exe from a terminal.

Build Type	Standard	PGO (Recommended)	Notes
amd64 / x86_64	zip	PGO zip	Both built with clang-cl and ThinLTO; the PGO zip adds a profile trained on Ocarina of Time

macOS

Build Type	Standard	PGO (Recommended)	Notes
arm64 (Apple Silicon)	zip		macOS 15 or newer. Not notarized: right-click and choose Open the first time, or run xattr -dr com.apple.quarantine lichii.app. eden-cli is inside the app, in Contents/MacOS

The PGO builds are the same programs compiled with profile-guided optimization. Linux uses clang with Eglantine's profile; Windows uses clang-cl and ThinLTO with a profile trained in Lichii on Ocarina of Time, so other games gain less. Prefer them when your CPU supports it.

Lichii oot-amd-perf build 3 (c938891) - Ocarina of Time: no cold-cache freezes, CI builds for every platform

Built by CI from c938891 (branch perf/oot-amd-120): Windows, Linux x86_64 / aarch64 (AppImage and tar.gz) and macOS arm64, each with and without PGO where available.

What changed since build 2

• Far fewer freezes on a cold shader cache (Ocarina of Time). Native draws whose pipeline is still being built are now skipped instead of holding the whole frame (native_async_draws defaults to Skip). Cold-cache walk through Hyrule Field on an RX 9070 XT: hitches over 50 ms went from 23 to about 9, total hitch time from 11-12 s to under 1 s, worst frame from 1.2 s to about 0.18 s. The HUD stayed intact in the check; if something is missing, set native_async_draws to Transient.
• New pipelines are translated on a worker thread instead of the GPU thread (detached shader environments, checked again before use).
• Merged zortos293/Lichii nx2 (47 commits), including the bounded wait for unbuilt Switch 2 pipelines (zortos293#465), never-used disk-cache pipelines no longer evicted (zortos293#550), HMMA on cooperative matrices (zortos293#582, zortos293#583, zortos293#657), and the DLSS and sharpening options for Ocarina (zortos293#606, zortos293#616).
• CI release builds are fixed on every platform. To get there, the native float atomic add on storage buffers is gone (it needed a patched sirit that CI's prebuilt package lacks); float atomic adds use the compare-exchange loop.
• Keep Limit speed on for Ocarina (above 60 fps its game clock and HUD run fast).

Thanks to everyone whose work is in here; each port names its PR and author in the commit.

Lichii oot-amd-perf build 2 (568b103) - Ocarina of Time on AMD: solid 60 fps

Windows build of oot-amd-perf at 568b103, built locally with MinGW clang and profile-guided optimization (Eglantine's profile), packaged like the CI's MinGW PGO zip.

Platform	Download	Notes
Windows x86_64 (MinGW, PGO)	lichii-windows-x86_64-pgo.zip	Extract and run lichii.exe; bundles its own DLLs

Only Windows again: the CI build of this branch fails because CI uses a prebuilt sirit without the atomic float add patch this branch needs. Keep Limit speed on for Ocarina (above 60 fps its game clock and HUD run fast).

The Legend of Zelda: Ocarina of Time on AMD: solid 60 fps

Castle Town market, the heaviest spot tested, now holds the 60 fps cap (60.05 mean, 59.9 minimum over 30 s) on a Ryzen 9 9950X3D + RX 9070 XT, docked. Build 1 ran the same spot at about 54-55 fps.

What changed since build 1

• Hyrule Field's white sky is fixed (zortos293#422). The fog reads its light probes through a pointer table about 130 MiB past the pool pointer; read-only table bindings stopped at 64 MiB, so the far probes read as garbage and the fog went white. Port of zortos293#351 by jpkto. Out-of-bounds storage reads on AMD now also return zeros (robustBufferAccess2 kept on, by Matt Artist / mja00).
• Everything worth taking from upstream merged: zortos293/Lichii nx2 and about 30 open Lichii PRs, including zortos293#415 (native compute store ranges, daniel-lynch), zortos293#434 (foliage pointer rebuilds, jpkto), zortos293#463 (stale texture uploads, madebyjordan), zortos293#376 (texture collector batching, Moraeszz2), zortos293#446 (semaphore polling, ne1i), zortos293#481 / zortos293#478 / zortos293#488 (buffer cache and split front, mstampfli), zortos293#448 (AMD terrain lines, persluffy-cl), zortos293#250 / zortos293#264 / zortos293#288 (tibzejoker, Kajcsi), zortos293#296 (SmileyTatsu's ASTC uploads), zortos293#300, zortos293#245, zortos293#333, zortos293#427, zortos293#436, zortos293#440, zortos293#495, zortos293#437 and smaller fixes.
• From Eglantine: the Switch 2 font service (Alleexxi), puller fence release under Balanced/Accurate fences and macro query flushes (kraibse), buffer cache and memory layout speedups (zortos293), guest RAM release on stop (SmileyTatsu), the transform feedback offset fix (CloudP4bbs, Eglantine#673), and hand ports of PreTenD's TLD4 register limit and Jonas's partial-Preflushable flush guard.
• AMD fixes from mja00's and chuppatricky's branches: sampler comparison only for depth samples and blend state rebuilds (sharkiix), a null texture for handles past the pool (chuppatricky), and a fresh start when the driver rejects the on-disk pipeline cache (Erick).
• Left out on purpose: Lichii zortos293#337 (fence-flagged query reports) cost about 9 fps in Castle Town with no flash difference measured, so it is reverted on this branch.

Optional: pin the GPU threads

Graphics > Extras > Hacks > Pin GPU threads (Lichii zortos293#418, after Frizti) gave about +9% uncapped here (60.5 -> 65.9 fps). It is off by default and skips itself below 6 physical performance cores.

Thanks to everyone whose work is in here; each port names its PR and author in the commit.

Lichii oot-amd-perf build 1 (745eeb0) - Ocarina of Time on AMD: ~17 to ~58 fps

Windows build of oot-amd-perf at 745eeb0, built locally with MinGW clang and profile-guided optimization (Eglantine's profile), packaged like the CI's MinGW PGO zip.

Platform	Download	Notes
Windows x86_64 (MinGW, PGO)	lichii-windows-x86_64-pgo.zip	Extract and run lichii.exe; bundles its own DLLs

Only Windows this time: the CI build of this branch fails because CI uses a prebuilt sirit without the atomic float add patch this branch needs. Keep Limit speed on for Ocarina (above 60 fps its game clock and HUD run fast); the built-in Dynamic FPS add-on handles frames below 60.

The Legend of Zelda: Ocarina of Time on AMD: ~17 → ~58 fps

Kokiri Forest gameplay on Windows with an AMD Radeon GPU went from about 17 fps to about 58 fps
(Ryzen 9 9950X3D + RX 9070 XT, docked, built-in Max Resolution add-on on). Host GPU time per frame
dropped from ~55 ms to ~10.5 ms. Not a locked 60 yet; the remaining limit is the emulator's two
GPU threads waiting on each other.

What changed

• AMD: one waited occlusion-query read per resolve. AMD drivers wait on every query of a
  WAIT_BIT copy; that was an 11 ms GPU stall per frame. Port of chuppatricky's AMD testbuild fix
  (601d3712d2, by Matt Artist / mja00).
• Native uniform banks no longer break render passes. The 64 KiB bank is re-checked per page
  once per guest submission/acquire/inline upload and only changed pages are uploaded (was a full
  upload on every bind: ~22,000 render passes a second).
• Precise split-front macro DMA reads and cheaper acquires (Lichii zortos293#345 by Celmax), plus
  skipping the query-flush round trip when no report is pending in the read range.
• Ocarina's CPU reads of GPU-written pages are preflushed instead of stalling the CPU and the GPU
  thread on the host GPU each time (EDEN_NX2_PREFLUSH=0 restores on-demand flushing).
• Faster software HMMA for the upscaling network (Lichii zortos293#174 by Matt Artist / mja00).
• Native compute semaphore releases are noted for split-front acquires (after Frizti's
  9932d05c4a).
• Merged the latest Lichii nx2.

Diagnostics (off unless their variable is set)

• EDEN_NX2_FLASH_WATCH (ported from Frizti's Lichii branch) finds single-frame flashes.
• EDEN_DKB_FRAME_TRACE now also reports the GPU time between timed draws and the commands
  recorded there (DKB gpu_gaps, DKB gpu_gap_ops); EDEN_NX2_GPU_PROFILE reports queue submits
  per call site.
• MinGW builds name their threads; the sampler writes module offsets that
  tools/nx2/symbolize.py names with llvm-symbolizer.
• tools/nx2/oot-amd/perf.py: launch, load a save and measure fps through the debug server.

Credits

Built on the work of the Lichii and Eglantine contributors, Eden and yuzu. Specifically:
Celmax (Lichii zortos293#345), Matt Artist / mja00 (Lichii zortos293#174, the AMD occlusion-query fix and the OoT
performance research in chuppatricky's AMD testbuild), chuppatricky (AMD testbuild),
Frizti (flash watch, compute-release tracking, Dynamic FPS integration), Dark (Dynamic FPS patch),
Zortos and everyone whose pull requests are merged into Lichii nx2.

---