Repository navigation
Releases
Kaichii b47 (750bf47)
Changes since build 45
Performance
- Fewer duplicate mesh pipeline builds with static vertex input. A mesh draw could inherit vertex attributes left by an earlier draw and compile another Vulkan pipeline for the same shaders. An isolated Ocarina of Time save built 31 mesh pipeline keys instead of 72 for the same 26 shader sets with static vertex input. With the usual dynamic input setting, both builds produced 31 keys. This measures pipeline builds in one scene, not an FPS gain (#85).
Switch Sports Resort
- The Power Cruising shader can read an output attribute it wrote. Kaichii previously rejected the reported
ISBERD.ATTR.32.Oinstruction. It now supports that exact 32-bit, unskewed read in task and mesh programs while continuing to reject unmodelled modes. Synthetic translation tests and four SPIR-V validation cases pass. The affected game was not available for a visual check, so the water is not yet confirmed fixed (#86).
Everything merged
- video_core: reuse mesh pipelines across static vertex inputs (#85) (
fbcdcf34bc) - shader_recompiler: read task and mesh output stage attributes (#86) (
8129503e50)
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 kaichii.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 |
Not in this build: macos-arm64. Their builds failed or GitHub couldn't run them; the next build tries again.
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.
Coming from a build named Lichii? It won't update itself to Kaichii: download Kaichii once by hand. Saves, settings and shader caches stay where they are and carry over.
Kaichii b45 (1a8f45d)
Changes since build 42
Performance
- Frame pacing targets game frames when frame generation is on. Target 30/60/90/120 now count each game's frame once and space its generated presents within that interval. Generation also leaves a free presentation frame for the next game frame, avoiding a wait when the queue fills. Unit tests cover target rates and queue capacity. Donkey Kong Bananza ran with FSR3 2x and Target 60 and produced generated frames (#83).
Crashes and stability
- Texture cleanup uses the image's own GPU address space. Unregistering an image after a channel switch no longer looks in the newly bound channel's page table. A synthetic two-address-space test passes; the reported multi-channel game case has not been replayed (#83).
- VP9 header encoding no longer reads past its stream while propagating a carry. The regression test reproduced the old stream exception and passes with the fix. (#83).
- Windows sparse-vector pages stay writable after another thread commits them. This avoids a protection change that could race with a GPU cache update. Both Windows binary variants compile (#83).
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 kaichii.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 |
Not in this build: macos-arm64. Their builds failed or GitHub couldn't run them; the next build tries again.
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.
Coming from a build named Lichii? It won't update itself to Kaichii: download Kaichii once by hand. Saves, settings and shader caches stay where they are and carry over.
Kaichii b42 (ec5c54b)
Changes since build 41
Built from nx2 at ec5c54bb45. Build 41 was c9d4273. That's 1 merged change.
Performance
- Revisiting Switch 2 textures can cause fewer memory stalls. Kaichii now keeps uploaded game-memory pages in RAM while the PC has enough free memory. When RAM is low, it still gives the OS a cold-page hint; Linux uses a gentler hint instead of requesting immediate pageout. This avoids paging out data that the game may soon need again. Synthetic policy and range tests pass. A user played Ocarina of Time on Linux and reported noticeably smoother gameplay, but no controlled FPS gain has been measured (#82).
The Linux Qt build opened the user's existing game library and launched Ocarina of Time. Windows and macOS game runs have not been verified for this change.
Everything merged
- Keep uploaded guest memory warm until host RAM is low (#82)
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 kaichii.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 |
Not in this build: macos-arm64. Their builds failed or GitHub couldn't run them; the next build tries again.
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.
Coming from a build named Lichii? It won't update itself to Kaichii: download Kaichii once by hand. Saves, settings and shader caches stay where they are and carry over.
Kaichii b41 (c9d4273)
Changes since build 40
Built from nx2 at c9d427387f. Build 40 was d581eb7. That's 1 merged change.
Graphics and performance
- Switch 2 DMA copies and clears keep texture-list pages current. Some destination pages were missed when the source had no GPU-modified range, which could leave later GPU reads with stale data. Synthetic copy and clear tests pass; no game image has been compared for this change (#81).
- Vulkan avoids a mid-draw wait when descriptor memory fills. Descriptor storage can grow within a bounded frame budget and submits a pending command buffer before reusing its memory. This addresses a potential stall and reuse hazard; no frame-rate gain has been measured (#81).
- Large ASTC arrays use smaller temporary decode images on integrated GPUs. GPU ASTC-to-BC transcoding now works in layer batches when needed and keeps its output buffer reserved through upload recording. Batch and lifetime tests pass; no integrated-GPU game run has measured the visual result or speed (#81).
- Mario Kart World receives its expected GPU timestamp path. Its Switch 2 program ID selects the legacy timestamp calculation while other games keep the Ampere calculation. A program-ID test passes; Mario Kart World was not run for this change (#81).
Crashes and stability
- Short or unmapped data is handled more carefully. Guest memory spans check every page and their exclusive end, short hexadecimal keys no longer read beyond their value, CMIF short reads preserve the untouched guest buffer, and unsigned bitfield folding handles word-boundary cases. Synthetic regression tests pass; no particular game crash was reproduced for this batch (#81).
- Missing render targets and staging-buffer wraps stay distinguishable and safe. A failed render-target lookup no longer looks like a valid null texture descriptor, and a busy first streaming region does not lose the current staging position. Both cases have regression tests; no game-specific visual comparison was made (#81).
Controls, audio and networking
- A game no longer overwrites your saved volume and mute choices. Its audio-target commands still change its own state and may affect the current sound, but they do not rewrite the user's audio settings. The service was tested through IPC, without a game-specific audio comparison (#81).
- Motion timing resets when a controller reconnects. SDL restarts the sensor clock and its error backoff, avoiding a stale timestamp after reconnect. The clock test passes; a physical controller reconnect has not been tested for this release (#81).
- HTTPS requests use a usable CA bundle. Kaichii and its updater select a system certificate file when available, honor explicit OpenSSL overrides and retain the bundled fallback. Certificate selection tests pass; this is not a claim that every network endpoint was exercised (#81).
Everything merged
- Port selected Lichii correctness and stability fixes into Kaichii (#81)
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 kaichii.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 kaichii.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.
Coming from a build named Lichii? It won't update itself to Kaichii: download Kaichii once by hand. Saves, settings and shader caches stay where they are and carry over.
Kaichii b40 (d581eb7)
Changes since build 39
Built from nx2 at d581eb7bd9. Build 39 was 0107a8d. That's 3 merged changes.
New features
- A cover view for the game list. View → Game List Mode → Cover View shows your games as their covers alone, large and without names, like a shelf. The covers fill the window's width in whole columns and resize with it; each is the game's own artwork at full resolution, with rounded corners and a soft shadow. Point at a cover to see the game's name, double-click to play, right-click for the usual menu; searching and controllers work as in the other views. Seen on Windows (#79).
- Compatibility reports say how smoothly a game ran. The report now asks two separate things: Compatibility, whether the game works (graphics, sound, crashes, progress), and the new Smoothness, how fluid it felt on your computer with your settings: Perfect, Smooth, Occasional stutters, Choppy or Very poor. You can also give the usual frame rate, which the performance overlay shows. A game that only loads or doesn't start has no smoothness to give, so the choice turns off. The compatibility descriptions now speak only of whether the game works (#77).
Compatibility list
- See at a glance how a game plays, not only whether it works. The compatibility list shows each report's smoothness and frame rate under its compatibility, in the comparison by operating system and in a Smoothness column of each system's table. The first such report: Ocarina of Time on Windows 11, Perfect, with occasional stutters at 25-33 fps. Reports sent before this release show a dash (#77).
Everything merged
- compatibility: report how smoothly a game ran, apart from whether it works (#77)
- qt: a cover view for the game list, a shelf of large covers (#79)
- docs: release notes for the next build (#80)
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 kaichii.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 kaichii.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.
Coming from a build named Lichii? It won't update itself to Kaichii: download Kaichii once by hand. Saves, settings and shader caches stay where they are and carry over.
Kaichii b39 (0107a8d)
Changes since build 38
Built from nx2 at 0107a8d9c8. Build 38 was 0592b5d. That's 4 merged changes.
New features
- A redesigned performance overlay. View → Show Performance Overlay now shows the frame rate in large type, the frame time, and how busy the CPU and the GPU are: the CPU figure is the busiest emulated core or GPU emulation thread, the GPU figure is the host GPU's busy time per frame, and the higher one is highlighted because it is what limits the frame rate. Below it, a 5-second graph of frame times marks the min, median and max and draws slow frames in red, and a footer shows the upscaler, the resolution scale and how many frames frame generation adds. For Switch 2 games the numbers come from the game's real frames and the footer shows the 1% low and the stutters. The overlay still stays where you drag it and remembers the spot. Its background is solid rather than see-through, so it keeps working on COSMIC and Wayland. Ported from Zortos's redesign in Lichii (zortos293#1345), and used on Windows with Ocarina of Time (#74).
- Icons in the menus. The File, Emulation, View, Tools, Multiplayer and Help menus show line icons, as Lichii's do. In Lichii they come only with its own dark theme; here they work in every theme, darker on light themes and lighter on dark ones, and they follow a theme change. Options with a check box have none, so their check mark stays visible. The icons are Lichii's, from zortos293#1365 (#75).
Compatibility list
- Reports are compared by operating system. The same game can run better on Linux than on Windows on the same PC, and every report already records its operating system. The compatibility list now opens with a table of games against Windows, Linux and macOS, showing the newest report on each and how many there are, then lists every report in a section for its system with the system's full name. Reports of the same game under different titles count as one game. Existing reports are included as they are (#73).
For developers
- Qt Charts is no longer needed. The performance overlay was its only user (#74).
- The GPU busy time is measured without
EDEN_DKB_FRAME_TRACEwhen the overlay asks for it, one frame at a time; nothing is recorded while the overlay is hidden (#74). tools/ci/test_menu_icons.pychecks that every menu icon the frontend asks for exists and is in its resource file (#75).
Everything merged
- site: compare each game's compatibility by operating system (#73)
- qt: frame stats overlay redesign, ported from Lichii (big fps, CPU/GPU %, 5 s graph) (#74)
- qt: icons in the menus, in every theme (#75)
- docs: release notes for the next build (#76)
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 kaichii.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 kaichii.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.
Coming from a build named Lichii? It won't update itself to Kaichii: download Kaichii once by hand. Saves, settings and shader caches stay where they are and carry over.
Kaichii b38 (0592b5d)
Changes since build 36
Built from nx2 at 0592b5db52. Build 36 was 2417332. That's 3 merged changes.
Big fixes
- Windows: games start again. On Windows, build 36 stopped every game about a second after it started: the loading screen stayed on "Iniciando..."/"Starting...", the log showed
Break 0xE401, and closing Kaichii hung on "Emulation thread failed to stop". Linux was not affected. The cause was in the emulated kernel: a game thread that waits inside a system call can wake up on another emulated core, and the Windows build (clang-cl with ThinLTO) kept using the core it had left, so the call's results went to another thread's registers. That thread then made calls the game never asked for and the game aborted. The kernel now reads which core and thread it runs on afresh each time, on every compiler. Played on Windows (i7-12700H, RTX 3050 Laptop) with Super Mario Bros. Wonder and Ocarina of Time, which both failed before; a build without the fix still failed on the same PC (#70).
Crashes and stability
- Tip if a game closes by itself on Windows: programs that draw overlays (FPS counters, recorders) install Vulkan layers that load into Kaichii too. While investigating the fix above, Ocarina of Time closed at its first movie because of FPS Monitor's layer (
fpsmonvk64.dll), which crashed inside its own code; uninstalling FPS Monitor fixed it. If a game closes without an error, try closing or uninstalling overlay programs first.
For developers
- The C++ tests run to the end on Windows. A page table test wrote to memory that Windows had only reserved, which crashed the tests binary there; CI runs the tests only on Linux, so it was never seen (#71).
- Release notes like these. Each release now starts with what changed since the previous one: these written notes when there are new ones, and always the full list of what was merged (#72).
Everything merged
- kernel: never inline the reads of the kernel's thread locals (Windows boot abort) (#70)
- tests: reserve the page table range before the move test writes to it (#71)
- ci: detailed release notes, with the changes since the previous build (#72)
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 kaichii.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 kaichii.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.
Coming from a build named Lichii? It won't update itself to Kaichii: download Kaichii once by hand. Saves, settings and shader caches stay where they are and carry over.
Kaichii b36 (2417332)
Automatic build of nx2 at 2417332.
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 kaichii.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 kaichii.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.
Coming from a build named Lichii? It won't update itself to Kaichii: download Kaichii once by hand. Saves, settings and shader caches stay where they are and carry over.