Two Zelda recompilation projects are turning Switch games into native builds

Static recompilation spent years as a party trick. Now two repositories do it for Tears of the Kingdom, one on x86-64, one on Apple silicon, and both have star counts in the thousands. The demo trick has become a genre with two entries.
The console leaves the pipeline
A Switch game is machine code for an ARM64 chip, plus calls into Nintendo's system services and into NVN, the console's graphics API. An emulator loads that code and translates it while the game runs: fetch a block, convert it, cache it, execute, repeat, on a thread that is always slightly behind.
A static recompiler does that conversion once, before the user presses play. The output is ordinary code that a normal compiler turns into a Windows or Linux executable. At runtime there is no fetch step, no block cache, no translation thread stealing cycles. The CPU side was paid for in one lump, on a build machine.
That is where the headroom comes from, and it explains why the interesting features here are all graphics features. Once you own the render loop as ordinary code, you can insert things into it. An emulator has to intercept a console's idea of a frame and hope the game does not notice.
What the build actually contains
[valentderah/totk-pc-recomp](https://github.com/valentderah/totk-pc-recomp) sits at 7,328 stars as of 15 November 2026. It is a static recompilation of Tears of the Kingdom, the 2023 Switch release, into a native x86-64 application for Windows and Linux. The README's first claim is blunt: native code, not emulation.
It ships no game files. You need your own copy dumped from your own console, meaning the base game and one of the 1.1.0, 1.2.1 or 1.4.3 updates. The README refuses to explain how to obtain those files, says the game is built from your files on your machine so the result contains the game, and says it must not be shared.
Status is early development: playable on both platforms, with visual bugs and crashes still expected. That belongs before any feature list, and a feature list is what the rest of this piece is.
The setup takes NSP and XCI files, plus compressed NSZ and XCZ, and extracts them itself. Then it builds the game once. Shaders are prepared at install instead of during play, which is the difference between a first hour of stutter and a first hour that looks like the rest of the game.
The display stack and the mod shelf
| Feature | What the port offers |
|---|---|
| Frame rate | 60 fps by default, up to 144 fps or the monitor refresh rate, marked experimental |
| Resolution | Custom resolutions (1080p, 2K and up), supersampling, AMD FSR 1 upscaling |
| Upscaling on RTX | DLSS and DLAA, with `nvngx_dlss.dll` downloaded from NVIDIA's DLSS SDK repository during setup |
| HDR | HDR10 output with separate peak, game and HUD brightness |
| Aspect ratios | 16:10, 3:2, 21:9 and 32:9 game resolutions, with camera and interface reshaped to match |
The ultrawide row is the one to sit with. Stretching a 16:9 image to 32:9 is a shader trick any emulator can do. Rendering a wider field of view and reflowing the HUD means touching the game's camera code and interface layout. That is per-game work, done by someone who has read enough of the game to move its furniture.
HDR works the same way. Peak, game and HUD brightness as separate values only make sense if you have taken over tone mapping. DLSS fits because the render loop is yours to hand a lower internal resolution to. Emulation can reach these too, though it is harder to land when the frame is assembled by something that does not know what the game intends.
The frame-rate numbers deserve a caveat. 144 fps is a ceiling the port allows, not a measurement anyone published. The README lists no benchmarks, and a scene can hold 60 and then hitch when the camera crosses a cell boundary.
The other half of the bargain is the mod shelf. Mods built for emulators load here, dropped into a mods folder next to totk.exe and ordered in the menu. RomFS mods work, TKMM's merged output works, and so do ExeFS code patches as .ips or .pchtxt files, with the game rebuilding itself to apply them. HD texture packs work because the port grows the texture heap to whatever a pack asks for; the README names the HDPacks.com 4K Texture Pack v1.0 as tested on 1.4.3 and 1.2.1.
The rebuild is the interesting part. A code patch that would need a runtime hook in an emulator gets folded into the binary before it runs.
The same goal on Apple silicon, different bottleneck
[ly05010419/MacNativeGames](https://github.com/ly05010419/MacNativeGames) has 7,857 stars as of the same date and is written in C. It plays your own Tears of the Kingdom and Breath of the Wild natively on Apple silicon Macs, with apps for iPhone and iPad. Its README describes the same shape: no emulator, the game's own ARM64 code running directly on Apple chips, NVN graphics rebuilt on Metal, system services answered by a small host.
Here the labour lands somewhere else. Both sides are ARM64, so instruction translation is a much smaller share of the job than on x86-64. The work goes into the graphics layer and the system services. Same destination, different bottleneck, which is a reminder that static recompilation names a family of techniques rather than one recipe.
The project also shows the cost curve of shader precompilation. Its shared shader list holds 18,244 shader variants across 14,725 shaders, gathered from players' builds and sent as identifiers only. Even with that list, the README warns that stutter on entering a new scene is expected. A 20 to 40 minute build, plus a community list to shave off the worst hitches: that is what building natively costs.
Every game is a project
Look at what has to exist for one title. NSP and XCI parsing. Per-version pins, since MacNativeGames dropped 1.1.2 outright. Shader precompilation, at install or through a shared list. Patches for the parts of the game that assume a handheld or a dock. And a toolchain on the user's machine.
None of that carries over between titles. Engines get reused; the fight does not. The genre grows one game at a time, clustering around the most documented titles and the people willing to spend weeks on them. Tears of the Kingdom is close to the best case: enormous, well studied, popular enough that someone will answer a question about a memory address at 2am. A second target, Apple silicon, doubles the number of contributors rather than the number of games.
The MacNativeGames README shows the same fragility. It recommends handing the repository to an AI assistant that follows an install skill, because every Mac, game version and dump differs slightly. When the instructions are written for a machine to read, the setup is not something a normal person is expected to do.
The legal shape, described plainly
Both projects distribute a translator and a patching pipeline. Neither distributes the game. What the repositories hold is code, addresses, hashes used to check that your files are the expected ones, and in the Mac project's case shader identifiers with no shader code. TotK-Recomp's MIT license says the same in one line: it grants nothing for Nintendo's game.
This is the argument emulators have made for years, and it has held up unevenly: in some jurisdictions, in some cases, against some plaintiffs. Dumping is a separate question that depends on where you live, and the Mac project says so instead of pretending otherwise. The argument is cleaner here than for an emulator, since the tool never contains a console's firmware, and weaker in one respect, since the output is a permanent artifact rather than a runtime.
Watch where the technique gets passed along. TotK-Recomp credits LAS Recomp, MacNativeGames, d2r-mobile, nxnative, SavageWindRecomp, Ryujinx's shader translator and hactool. MacNativeGames credits d2r-mobile for the rewriter that started its NVN-on-Metal layer. The roadmap for this genre is a credits file: one person solves NSP parsing, another solves NVN on Metal, a third solves the camera, and the next game starts from all three. That is why the last month looks like a wave and the next one may look like a plateau.
Related articles
Six Amateurs, 1,113 Episodes, a Thousand Yuan of Compute an Episode: How an AI Drama Got Hand-Built
The first ten seasons of Armed Into Song run to roughly a thousand episodes and have passed ten billion cumulative views, with six core creators and not one of them film-school trained. Compute runs 1,000–2,000 yuan an episode; a normal shot takes three rolls, a battle twenty-plus, and anything that looks flat is graded a sixty and thrown out.
One server, one AI streamer: inside the code that runs a nightly livestream
open-yoki is the production code behind an AI host who streams nightly on Binance Square, with the persona, voice and money features stripped out. Headless Chrome draws the frame, ffmpeg pushes RTMP, a folder of Markdown decides what she feels and what she posts.
Pinky lets an agent drive your phone, and holds the Send button until you click Allow
Pinky connects any MCP agent to a real iPhone or Android phone and enforces approval in its own gateway rather than in a prompt. Banking apps are invisible, password fields are off limits, and on Android 13 the agent gets a hidden second screen.
ByteDance's SeedRealtime takes two frames a second and decides when to speak
Doubao-Seed-Realtime-1.0 folds camera frames, screen frames and speech into one full-duplex session, at no more than two frames per second. The interesting decisions are the frame rate, the proactive speaking, and the audit reply that ships switched on.