I set up Horizon-Android on a spare phone last week, and the part that ate the evening was not the emulator itself. It was a build compiled for the wrong CPU architecture and a keys file still sitting inside a ZIP. Everything else took about twenty minutes.
So here is the order that actually works: verify the APK, install it over USB with adb, stage your own keys, firmware and dumps onto the phone with adb push, then boot a single small game and tune it before touching anything else. Budget 45 to 60 minutes, and expect most of that to be file copying rather than clicking.
One caveat up front: a lot of details are build-specific — minimum Android version, the package name, the exact menu labels, which GPU driver builds are offered. Those change between releases, so check the project's documentation instead of guessing from an older tutorial. Guessing costs you an evening.
Two things decide whether you finish
In my experience the failures cluster around two causes:
- The ABI of the APK you downloaded. A build with the wrong native libraries will simply refuse to install.
-
Whether your
prod.keyswas dumped from the same firmware as your game dumps. Mismatched keys look like a broken emulator but are a key problem.
Both are diagnosable in under a minute with the commands below, and neither is a bug in the emulator.
Requirements and a pre-flight check
You need:
- An Android device with a 64-bit ARM CPU (
arm64-v8a). Most phones and tablets from the last several years qualify; x86 tablets and 32-bit-only devices do not. - A Vulkan-capable GPU. The emulator renders through Vulkan, so an old graphics driver is the most common reason for an instant crash on launch.
- The Horizon-Android APK that matches your device ABI, taken only from the project's official release page.
- Your own
prod.keysandtitle.keys, dumped from a Switch console you own. - Your own game dumps in
.xcior.nspformat. - Android Platform Tools (
adb) on a PC, or a file manager on the phone. - Free storage equal to at least twice the size of your largest dump, so there is room for saves, shader caches and updates.
Run these checks before you download anything:
-
adb deviceslists your phone asdevice, notunauthorized. - The ABI list contains
arm64-v8a. - The APK hash matches the one published on the release page.
-
prod.keysandtitle.keysare on the phone's storage as plain files, not inside an archive. - At least one
.xcior.nspdump is already copied over.
To check the architecture:
adb shell getprop ro.product.cpu.abilist
If it prints something like arm64-v8a,armeabi-v7a,armeabi, grab the arm64-v8a APK. If it prints only armeabi-v7a, stop — this device cannot run the emulator at all.
A word on legality: this guide does not cover obtaining keys or ROMs. Distributing keys, or game dumps you did not make yourself, is illegal in most jurisdictions.
Step 1: verify the hash, then install over USB
Download the APK into an otherwise empty folder, then hash it:
cd ~/Downloads/horizon
sha256sum Horizon-Android-*.apk
Compare the output with the hash on the release page, character by character. This matters more than it sounds: repackaged emulator APKs with injected payloads are common in search results, and an emulator is a high-privilege app — it reads your storage and runs native code.
Now install it over USB rather than dragging the file across:
adb devices
adb install -r Horizon-Android-arm64-v8a.apk
I prefer adb install because it hands back a real error code instead of Android's generic 'App not installed' dialog. When something fails, you learn why.
A successful run looks roughly like this:
$ adb install -r Horizon-Android-arm64-v8a.apk
Performing Streamed Install
Success
$ adb shell pm list packages | grep -i horizon
package:org.horizon.android
The package name above is a placeholder — substitute whatever your grep actually prints, and write it down, because you will need it in Step 3.
Step 2: stage keys, firmware and games
Open the app once so it creates its data directory, then push everything to a known location instead of hunting through the UI:
adb push prod.keys /sdcard/Download/horizon/
adb push title.keys /sdcard/Download/horizon/
adb push Metroid\ Dread.xci /sdcard/Download/horizon/games/
Inside the emulator, open the keys or decryption settings screen (the label varies by build) and point it at /sdcard/Download/horizon/prod.keys. Do the same for title.keys in its own slot. Then run the firmware install step and select your dumped firmware folder, and finally set the game directory to /sdcard/Download/horizon/games.
Here is what each file is for:
| File | Where it goes | What it does |
|---|---|---|
prod.keys |
keys / decryption screen | decrypts your own dumps |
title.keys |
same screen, separate slot | per-title keys some dumps need |
| firmware files | firmware install dialog | system modules a subset of games expect at boot |
.xci / .nsp
|
game directory | shows up in the library after a rescan |
Without keys, encrypted Switch content cannot be read — that is the format, not a defect. Firmware supplies system modules that certain titles query on boot, so those games fail even with perfect keys.
To confirm, go back to the game list and pull to refresh. If it stays empty, either the path is wrong or the file is still zipped:
adb shell ls -l /sdcard/Download/horizon/games/
You want a non-zero file size in that listing. A .zip sitting in that folder will never appear in the library.
Step 3: boot one lightweight game and tune it slowly
Start with a small title, not your biggest 3D game. Open the per-game settings and work through this order, changing one item at a time:
- GPU driver. Begin with the system driver. Only switch to a custom Vulkan driver (Turnip is the Adreno-oriented open-source one) if the game crashes or renders black. Which driver build suits your GPU is documented per release — check it.
- Accuracy level. This is the speed-versus-correctness dial. Glitches after boot? Raise it. Too slow? Lower it.
- Docked mode. Makes the emulator present itself as a docked console with a higher resolution target. Leave it off on weaker hardware.
- Resolution scale. Start at 1x and only push it up once the game is stable.
Changing four settings at once tells you nothing about which one helped. A small game also proves the whole chain — install, keys, firmware, GPU — in a fast loop.
Success looks like a title screen and a steady frame rate for a couple of minutes. If your build has an on-screen performance overlay with FPS and frame time, watch it. Then save a state and reload it:
adb shell ls -l /sdcard/Android/data/org.horizon.android/files/
Remember to swap in your own package name. Files appearing there after a save confirm the app has working storage access.
When something goes wrong
The install fails instantly, even though the APK downloaded fine. You will see something like INSTALL_FAILED_NO_MATCHING_ABIS ... res=-113. That means the native libraries in the APK do not match your device — go back to the ABI list and download the arm64-v8a build.
The library is empty after a refresh. Check the directory listing from Step 2. Either the path is wrong or the dump is still compressed.
The game crashes or shows a black screen on launch. Suspect the graphics driver first; switch back to the system driver or a different custom build.
A game boots but looks wrong, or runs badly. Move the accuracy level one notch in the appropriate direction before you touch anything else.
Everything installs but games refuse to load. Compare the firmware your dumps came from with the prod.keys you pushed.
Takeaway
Verify the APK before installing it, install over adb so you get real errors, keep keys and dumps as plain files in one known folder, and tune exactly one setting at a time on a lightweight game. That sequence turns an evening of guesswork into a checklist you can repeat on any device.
This article was originally published on AI Release — https://ai-release.org. If you want more step-by-step guides like this one, the channel is at https://t.me/ai_release1.
Happy tinkering, and remember: dump your own keys and your own games.
Top comments (0)