Two Ancestors:
yuzu, Ryujinx & Their Lineages
Two open-source projects defined modern Nintendo Switch emulation over the past decade. Each chose a different language, license, and architectural philosophy: C++ focused on speed, and C# focused on accuracy. Both original projects concluded their development in 2024, but their codebases live on through vibrant community continuations. This survey explores their designs, performance optimizations, and lasting engineering legacies.
The Two Lineages
How two different programming languages and philosophies shaped a decade of console emulation.
yuzu Lineage
C++ • GPLv3Started in 2018 by the team behind Citra, yuzu was written in modern C++ under the GPLv3 license. Its engineering emphasized peak execution speed and pragmatic graphics pipeline simplifications, such as the major "Hades" shader compiler rewrite. Community branches like Sudachi and Citron carried the code forward, leading into Eden.
Ryujinx Lineage
C# (.NET) • MITStarted in September 2017 by gdkchan, Ryujinx was crafted in C# (.NET) under the permissive MIT license. Its core mission focused on meticulous emulation accuracy, clean architectural separation, and maintainability across platforms. When the original project ended in 2024, multiple community branches emerged, including Ryubing and other continuations.
Translating Guest CPU Instructions
Console hardware runs 64-bit ARM instructions, while PCs use x86-64. Here is how three major paradigms tackle instruction translation.
Just-In-Time (JIT) Translation
Both dynarmic (in yuzu and Eden) and ARMeilleure (in Ryujinx) compile guest ARM instructions into x86 machine code in RAM as the game runs. A shared intermediate representation converts complex instructions into optimized machine code blocks for fast execution. Direct host memory mapping allows near-native memory access speeds without manual address translation.
PPTC Disk Cache
Introduced in June 2020 by developer Ricken, Ryujinx's PPTC saves translated code blocks to your local storage. On future game launches, the emulator loads pre-translated code straight from disk, eliminating repetitive translation stutter. Because PPTC only stores existing JIT translations, it shortens boot times but does not increase steady-state peak framerates.
Static Recompilation (AOT)
The modern recompilation wave translates guest AArch64 code entirely into C ahead of time, compiling it once into a native PC binary. This eliminates the runtime JIT compiler entirely and runs the game logic directly on the operating system. It requires no on-the-fly instruction translation, but demands dedicated recompilation engineering for each specific title.
Profile-Guided Optimization (PGO)
Why C++ emulators use static PGO builds, and why .NET emulators don't need one.
What PGO Is: Paving Desire Paths
Profile-Guided Optimization (PGO) works just like paving footpaths across a grassy campus after watching where students actually walk. The compiler observes exactly which code branches execute most frequently during real gameplay, then restructures the binary. Functions that run constantly are grouped together for instant CPU cache access, while rare error branches are moved out of the way.
What PGO Touches in an Emulator
In an emulator, PGO optimizes the host C++ binary: the dynarmic dispatcher, texture management, buffer handling, and Vulkan command queues. It does not optimize the translated game code, because guest instructions are generated dynamically at runtime by the JIT compiler. The performance gain comes entirely from making the emulator's own coordinating engine faster and leaner.
C++ vs .NET: Static PGO vs Dynamic PGO
C++ emulators like Eden require a two-pass build workflow to collect execution profiles and generate optimized binaries. In contrast, emulators built on modern .NET leverage built-in Dynamic PGO and Tiered Compilation active by default. The .NET runtime monitors hot code paths in memory and automatically re-optimizes methods during execution, making a separate static profile download unnecessary.
Ryujinx Code in the 2026 Recompilation Wave
How permissive MIT licensing allowed Ryujinx's subsystems to power the next generation of native ports.
Permissive MIT License
Ryujinx was released under the permissive MIT license, permitting developers to reuse its code without strict copyleft obligations. When static recompilation projects emerged, they could freely incorporate Ryujinx's battle-tested subsystems into new native PC engines. This open licensing model ensured that years of community reverse-engineering work remained permanently accessible.
Ryujinx Shader Translator
Translating proprietary console GPU shaders to standard desktop APIs is one of emulation's most complex challenges. Ryujinx's robust Shader Translator (MIT) was directly integrated by multiple 2026 recompilation projects to convert console shaders to Vulkan SPIR-V. Its modular design allowed other teams to benefit from years of meticulous GPU decoding without starting from scratch.
Audio Renderer Subsystem
Producing accurate interactive audio requires faithful reproduction of voice mixing, resampling, and DSP effects. Modern recompilation tools have ported Ryujinx's audio rendering engine directly into their native runtimes. This demonstrates how a clean, well-architected subsystem can thrive long after the original host application has ceased updates.
Recompilation vs PPTC
Both PPTC and static recompilation avoid re-translating the same instructions on every run, but they operate through different mechanics. PPTC is a dynamic runtime cache that still runs within an emulator's virtual machine framework. Recompilation transforms game instructions ahead of time into standalone C code that compiles natively for the target operating system.
Fun Facts & How It Ended
Key milestones, funding models, and the resolution of both original projects.
DMCA Lawsuit and $2.4M Settlement
In February 2024, Nintendo sued Tropic Haze in federal court in Rhode Island alleging DMCA anti-circumvention violations. The lawsuit stated yuzu sold early-access builds through Patreon (over 7,000 patrons, ~$30,000/month, as reported), and that memberships doubled when a major first-party game leaked ahead of launch. In March 2024, the parties settled for $2.4 million and yuzu ceased development. (Note: These were allegations in the complaint and were not adjudicated in court due to the settlement.)
Contact and Mutual Discontinuation
On October 1, 2024, Ryujinx halted development after Nintendo contacted lead developer gdkchan offering an agreement to discontinue the project and remove its repositories. No lawsuit was filed in court, and whether financial compensation was involved remains unconfirmed. The announcement was shared on Discord by contributor riperiperi. Ryujinx's Patreon historically had ~800 patrons ($1,500–$1,700/month).
Early Access vs Public Releases
The two projects approached distribution differently: yuzu maintained a paywalled Patreon tier granting subscribers early-access development builds with daily updates, whereas Ryujinx released all emulator builds freely to the public while accepting voluntary community donations.
Hades, NiCE, PPTC & Recompilation
Both codebases contributed enduring milestones: yuzu introduced Project Hades (2021 shader overhaul) and Project NiCE (NCE on ARM64), while Ryujinx introduced PPTC disk caching (2020). Ryujinx's modular MIT-licensed subsystems, including its Shader Translator and Audio Renderer, continue to power the 2026 static recompilation wave.
Research Monograph & Source Transparency
All technical claims are verified against primary documentation and public codebases.
Read the Full Technical Monograph on GitHub
Examine our source-checked survey with line-by-line verification against upstream public repositories.
| Domain / Subject | Primary Citation & Source | Verification Method |
|---|---|---|
| .NET Dynamic PGO & Tiered Compilation | Microsoft Learn: ".NET 8 runtime — what's new" | Audited upstream runtime documentation; verified against Ryujinx.csproj |
| MSVC & Clang PGO Architecture | Microsoft Learn (/GENPROFILE, /USEPROFILE) & Eden build scripts | Verified compiler mechanisms and public distribution scripts |
| CPU Translation Engines (dynarmic & ARMeilleure) | dynarmic & Ryujinx open-source repositories | Source audits of SSA IR and MemoryManagerMode implementations in open trees |
| PPTC Architecture & Release History | Ryujinx 1.0.4709 Release Notes (Ricken, 2020-06-16); Ptc.cs | Audited Deflate compression streams in ARMeilleure/Translation/PTC/Ptc.cs |
| 2026 Recompilation Adoption | Public open-source Switch recompilation repositories | Audited MIT Shader Translator and Audio Renderer dependencies in upstream projects |
| Legal Proceedings & Project Resolutions | U.S. District Court (Case 1:24-cv-00082, D.R.I.), GameSpot, GamesRadar, AP News, GamingOnLinux | Cross-referenced public court complaints, settlement filings, and contributor statements |
Every technical claim on this page is verified in Monograph 09. No commercial game files, keys, or firmware are hosted or distributed.