Anka Native runs Switch 2 games' own code natively on Android, with their graphics rebuilt on Vulkan. Released as Anka Native by EddizEge; this release is Anka Native 0.3.0.
It is not an emulator: the game's own ARM64 code runs directly on the phone's CPU. A small host answers the system calls the game makes, and the game's NVN graphics (including the Switch 2's task and mesh shaders) are replayed on Vulkan, with the game's shaders translated once, ahead of time, from your own dump.
Not affiliated with Nintendo, any game publisher, or the projects credited in NOTICE.md; please report problems in this repository's Issues, not to them. https://github.com/EddizEge/AnkaNative/issues
Caution
Nothing from any game is in this repository or in the app: no game code, no game data, no keys, no firmware, no shader libraries. Use only your own, legally owned game dumps. Do not ask for games, keys or dumps, and do not share them in Issues.
Anka is the Zumruduanka (Zümrüdüanka) of Turkish myth, the phoenix that rises from its ashes. Anka Native shares its name and its mark with the Anka emulator by the same author: here the games rise again on a phone, from their own code.
| Game | Title ID | Version | Status |
|---|---|---|---|
| The Legend of Zelda: Ocarina of Time (Switch 2) | 0400486024DEC000 |
update v131072 (.nup dump) |
Experimental, playable with problems. Measured on one phone (below) |
| Donkey Kong Bananza | 040074A01BF12000 |
update 458752 | Played on Android before Anka Native's changes; not tested again since |
| Mario Kart World | 0400C3F00006E000 |
1.8.0 (base game) | Experimental before Anka Native's changes (in game and driving, with graphics problems); not tested again since |
Other versions are refused with a message that says which version the app needs. Each game is built into its own app
(for example Anka Native with the id dev.ankanative.android.oot for Ocarina of Time).
Measured in Ocarina of Time, on one phone. Every number here comes from a POCO F8 Pro (Snapdragon, Adreno 830, 12 GB of RAM) with a
Turnip driver, playing the game from a .nup dump. No other phone was tried, and Donkey Kong Bananza and Mario Kart World were not run
with these changes.
- From the save it loads into Kokiri Forest and Link's house; it stayed in the forest for 18 minutes without being closed, and saving from the pause menu (System > Save) worked.
- Frame rate in Kokiri Forest: about 14 fps (it was 4.8-5.4 before the shader page index), with the trees, plants and the arch that are drawn with mesh shaders. 20 fps is not reached.
- At a low frame rate the game now runs at about 0.8-1.0 of its normal speed (it was about a quarter at 15 fps).
- Memory is the limit on 12 GB: about 10 of the phone's 10.9 GiB were in use while it played, and Android closed background apps. With the RAM saver on, total RAM use was 9.6 GB.
What changed, with more numbers: CHANGELOG_ANKA_NATIVE.md. The game's notes: dm/games/0400486024DEC000/README.md.
- Android 13 or newer (Android 12 and 12L: the app installs, but is untested there and needs a custom driver with Vulkan 1.3 and placed memory maps, such as the Anka Turnip driver; Android versions), a 64-bit phone with a Snapdragon (Adreno) GPU and 12-16 GB of RAM. Only a 12 GB POCO F8 Pro (Adreno 830) was tried with this release; with 12 GB, memory is tight.
- Less than 16 GB of RAM: turn the RAM saver on (the game's ⋯ › Game settings › RAM saver). Without it Android may close the game in heavy areas; with it, total RAM use in Ocarina of Time dropped to 9.6 GB on the 12 GB test phone. It costs storage writes (about 2 GB per area load) and needs that much free space.
- A Vulkan driver with
VK_EXT_map_memory_placed. Phone drivers often lack it (the POCO F8 Pro's own Qualcomm driver does): install a Turnip driver, such as the Anka Turnip driver. The app's readiness check (Settings > Readiness check) says whether yours has it. - Your own game dump, of a game you legally own: a
.nupfile or a dump folder (base/withexefs/andromfs/, andupdates/<version>/if any). NSP and XCI files do not work for Switch 2 games. No keys or firmware are needed. - Time to prepare the game once (see "Install"): on the phone itself (new in 0.2.0, experimental), or on a computer (Windows, Linux or Mac).
- Free storage on the phone: the prepared game (the pack, with its shader library) is a few hundred MB to a few GB; the RAM saver writes about 2 GB per area load.
- Optional: your own
Lossless.dllfrom Lossless Scaling for Windows, for frame generation (never included).
The release has the APK (anka-native-<version>.apk, app id dev.ankanative.android) and SHA256SUMS.txt. To check a download on a computer:
sha256sum -c SHA256SUMS.txt --ignore-missing (on a Mac: shasum -a 256 -c SHA256SUMS.txt). Only download the app from this
repository's Releases: a copy from anywhere else may be modified.
This is an experimental build with no warranty (LICENSE).
On the phone (new in 0.2.0, experimental): copy the dump (or the .nup) to the phone, install the APK, open Anka Native, allow
All files access, tap Add game, pick the dump and tap Prepare. The app rewrites the game's code and translates its shaders in
the background, with a notification (keep the phone charging: it takes a long time, about an hour for Ocarina of Time). When it is done,
the game's card says Ready; tap Play. If anything fails, the card says why and keeps its log; preparing on a computer still works.
On a computer (Windows, Linux or Mac):
- Prepare the game on a computer, once: make the environment as android/README.md describes,
then run
scripts/prepare.pywith its Python: a terminal interface that checks what is needed, lets you pick the dump or the.nup, and shows the progress and the time left (Pack a game;scripts/pack_android.pyis the packer it runs). It rewrites the game's code for Android and translates its shaders for Vulkan into a pack (<title ID>-work/android-pack, next to the dump). Ocarina of Time has about 42,000 shaders: this takes a long time and needs .NET, a C compiler (for its compressed code) and several GB of free disk. - Copy the dump (or the
.nup) to the phone, for example toSwitch2/, and the pack next to it asSwitch2/<title ID>-work/android-pack. The pack is made from your dump for your phone: never share it. - Install the APK, open Anka Native and allow All files access.
- Install a GPU driver if the readiness check asks for one (below).
- Tap Add game and pick the dump folder or the
.nup. The app finds the pack next to it; tap Play.
Saves are kept in the app's own storage (Android/data/<app id>/files/saves). When you uninstall, Android asks whether to keep that
data. A game's ⋯ menu backs saves up to Switch2/save-backups/<title ID>/ (kept when the app is uninstalled) and restores them.
Anka Native has its own app id, so it installs beside other builds and does not see their saves; move a save with the game's
⋯ menu (back up in one app, restore in the other).
The games run on Turnip, Mesa's open Vulkan driver for Adreno GPUs. The Anka Turnip driver is a Turnip build prepared for Anka Native: https://github.com/EddizEge/AnkaTurnip (download its release zip). In the app: Settings > GPU driver > Install... > Pick a zip..., then start the game again. Settings > GPU driver also offers to download community Turnip builds. A driver is never part of this repository or of the APK.
The gear on the main screen holds the app's settings; a game's ⋯ menu > Game settings holds that game's own.
| Setting | What it does |
|---|---|
| RAM saver (uses storage) (Game settings) | Off by default; turn it on if your phone has less than 16 GB of RAM. The game's large textures live in a file in the app's cache folder instead of in RAM, so Android can drop and reload them instead of closing the game. For phones short of RAM with free storage; it writes about 2 GB to storage per area load in Ocarina of Time |
| Frame-rate cap | the game's own, 60, 30, 20 or 15 fps |
| Game resolution | the phone's 1080p or the game's own |
| 3D resolution (Game settings) | the size the game renders its 3D scene at: the game's own choice (Dynamic, the default), a fixed level, or Dynamic with a top level |
| GPU driver | the Vulkan driver the game runs on (the system's, or an installed Turnip zip) |
| Frame generation | Lossless Scaling's frame generation (2x, 3x, 4x or a target frame rate); needs your own Lossless.dll |
| Performance overlay | fps, GPU time, 3D render resolution, throttling and battery over the game |
| Readiness check | what the phone is missing for a game, with a button to fix most items |
| Language | the app's language: the phone's, English, Türkçe, Português (Brasil) or Español (Latinoamérica) |
On-screen controls have a layout editor; gamepads work. Every switch the host reads is listed in docs/env_switches.tsv; a game's tested settings are in its profile.
- Ocarina of Time is slow: about 14 fps in Kokiri Forest, lower in open areas.
- Memory on 12 GB phones: Android may close the game after a long session or in a heavy area; it closes background apps while the game runs. Turn the RAM saver on (recommended below 16 GB of RAM). Back up your saves often.
- Textures may pop in while walking (textures released under memory pressure are made again) and shimmer.
- The first start of 0.3.0, and the first with another GPU driver, shows a white glow for about 10 s, and the trees and plants drawn with mesh shaders come after about 45 s, while their shaders compile.
- Adreno 840 with Anka Turnip: the game may still lose the GPU device when gameplay starts (#5). 0.3.0 has a change for it, but it is untested: we have no Adreno 840.
- With Qualcomm's own driver on the Adreno 840, the world is black or wrong-coloured.
- Short stalls while walking come from pipelines built late and from memory pressure.
- Anti-aliasing is not visible yet: the game's SMAA pass runs, but its blend weights are all zero.
- Donkey Kong Bananza and Mario Kart World were not tested with Anka Native's changes. Only one phone was tried.
- The phone gets hot, and the frame rate drops when it throttles.
Tell us how it runs on your phone in Discussions: the device reports thread has a short template (phone, RAM, driver, game, frame rate, what works and what does not). Bugs you can reproduce go to Issues. Settings › Share log sends the app's newest log. Never post game files, keys or packs.
How to set up the environment, prepare a game and build the APK: android/README.md (and android/TESTING.md for testing on a phone). A test APK without the on-phone packer is built with:
cd android/app
./gradlew --no-daemon -q -PnxGames=0400486024DEC000 -PnxApp=oot -PnxPackEngine=fake apk # -> out/anka-native-oot.apk-PnxApp=<suffix> sets the app id dev.ankanative.android.<suffix> and -PnxLabel its name; -PnxPackEngine=fake leaves out the
on-phone packer. Signed releases are built with android/tools/release.sh (docs/RELEASING.md). The icons are made by android/tools/anka_icons.py. The Mac and iPhone builds this repository also holds are
described in docs/mac-and-iphone.md.
Most of Anka Native's code, its commit messages and these documents were written by an AI coding assistant (Claude Opus 5.5, by Anthropic) working under the direction of the human maintainer, who decided what to try, played and tested the builds on his phone, and is responsible for the release. Many of the measurements were taken by automated runs on that phone. It is experimental and has bugs.
Most of the code is MIT (LICENSE); the frame generation port (dm/gfx/vk_android/lsfg), mesh draws through compute
(dm/gfx/vk_android/vka_memu* and the passes in memu/), one shader translator file (InstEmitAmpereMesh.cs) and the Anka mark's script (android/tools/anka_logo.py) are
GPL-3.0-or-later. The Android app is GPL-3.0-or-later as a whole, because it links GPL-3.0-or-later parts (mesh draws through compute in every build, frame
generation, and the shader translator in an APK that carries the on-phone packer); its source is this repository at the commit in the
app's build tag. Credits, third-party code and their licenses: NOTICE.md. The Anka mark and its icons are EddizEge's own
design, GPL-3.0-or-later. The app's About section names the license and points to NOTICE.md.
Use only games you own. Do not ask for games, keys or dumps.
