Note: this is the old guide. If you want the newer version, head over here.
Yes, believe it or not this is an actual thing. Emulating a modern console such as the Nintendo Switch is possible thanks to Yuzu and the lesser-known emulator Ryujinx. The best part is, both emulators are open-source and available for Linux.
(This is probably driving Nintendo nuts.)
Unfortunately, emulating the Nintendo Switch isn’t as simple as downloading the emulator and opening a game file to play it. The process involves dumping several files from your Switch system and transfering those files to your PC in order to decrypt the games.
Before doing any of the following, put your Switch in airplane mode. There’s no telling if Nintendo can actually identify what you’re about to do with your Switch from here on out and whether they will ban your Nintendo account for it, so it’s best to keep the device offline.
In terms of hardware, you will need:
- Your Switch, obviously, along with your physical game cartridges if you wish to dump those
- Some way of getting your Switch into recovery mode (RCM). An easy way to do this is by buying this $8 RCM jig from Amazon. There are other ways, but they are more tricky
- A capable PC with a decent amount of RAM; requirements are listed in the Yuzu and Ryujinx sections
- MicroSD card that’s >= 32 GB in size with an adapter so you can transfer files via your PC
- USB-C cable for connecting your Switch to your PC’s USB 3.0 port (I say 3.0 because, apparently, payloads can’t be sent via USB 2.0 on Linux)
Check if your Switch is vulnerable to payloads (we need to send payloads to our Switch in order to dump the necessary files) by entering its serial number on Damota’s website. You can find the serial number on the bottom of the unit towards the left:
Likely, if you bought your Switch sometime in 2019 or earlier, it’s hackable, even on the latest firmware. Nintendo later updated the Switch models to increase the battery life, but very likely they also implemented something on the hardware side to prevent it from becoming exploited.
If the light is green after checking your serial number, you’re good to go:
If it’s yellow, you may have varied results. If it’s red… well, you understand traffic lights, right?
Now we’ll determine what emulator to use. Yuzu, while it has more maturity than Ryujinx, requires a morning and possibly an afternoon of your time, as you will need to dump several files from your Switch and transfer them to the PC you’re emulating with. Ryujinx, while not as fast at emulating games, will need a lot less files and therefore demands less of your time. I will be covering both emulators here. Both emulators are experimental, meaning that you are going to experience random crashes and strange graphical issues in certain areas, but they are capable of emulating most commercial games at a reasonable speed.
Normally, Windows users could follow the Quickstart Guide found at Yuzu’s website to get started (although, it shouldn’t really be called “quick” start). The problem with that guide, however, is some of the tools the guide mentions do not work on Linux. And believe me, I’ve tried running the apps with WINE, but they didn’t fully accomplish what they were supposed to do. Since they’re aren’t any guides out there — as far as I know — that cover how to get started on Linux, I decided to write a guide myself.
So first, we need to make sure that your hardware on your Linux machine at least meets the minimum requirements. According to the Quickstart Guide, the minimum requirements are as follows:
- Intel Core i5-4430 / AMD Ryzen 3 1200
- Intel HD Graphics 520 / NVIDIA GeForce GT 1030 / AMD Radeon R7 240
- 8 GB RAM
The recommended requirements are:
- Intel Core i7-8700 / AMD Ryzen 5 3600
- NVIDIA GeForce GTX 1060 / AMD Radeon RX 470
- 16 GB RAM
Naturally, as the Switch is using NVIDIA hardware, you’re going to get closer-to-the-metal performance using a NVIDIA graphics card. As far as RAM is concerned, 8 GB is barely enough based on my experience so far. I definitely would recommend having 12 GB or more, especially if you’re using AMD hardware — I’ve noticed Super Smash Bros. Ultimate eating as much as 16 GB with my RX 570; on the other hand, general RAM consumption with my GTX 1660 was around 8.5 GB.
It would be of great benefit also if your processor has at least 4 cores; that way, you can enable multicore performance in Yuzu for a massive boost in performance (since the Switch has 4 CPU cores).
1. Download Yuzu
We need to download and run Yuzu to get our folder structure set up. After downloading and extracting, simply type and enter
./yuzu in the terminal to open Yuzu. If you can’t run it for some reason, download and install the build dependencies.
You’re going to get a couple of errors when the emulator launches, saying that several files are missing; this is intentional.
Close the emulator. You should now have folders set up for Yuzu in
From here on out,
~/.local/share/yuzu/ will be referred to as
2. Prepping SD Card
We’re going to need to download several files and put them onto our MicroSD card; these will be the files necessary to allow us to load homebrew on our Switch. You can either use your existing SD card that’s in your Switch, or use a new one that’s formatted as FAT. Just remember, make sure it’s at least 32 GB in size; one of the files we’ll be dumping to it later on is almost 32 GB itself.
Download the following:
- Hekate – an all-in-one utility and launcher for the Switch. Download both the zip files for hekate and the joiner scripts. The joiner scripts will allow us to combine multiple file parts into one, which we will need to do later on. Extract the contents of the hekate zip into the root of your SD card
- Atmosphere – custom firmware for our Switch. Download the zip file and
fusee-primary.bin. Extract the zip into the root of the SD card, and place the
- Lockpick_RCM – this will dump the key files necessary for the decryption of our games. Download the
.binfile, place in
bootloader/payloads/of your SD card, just like with
- (Optional) NXDumpTool – this will allow us to dump our game cartridges as files to our SD card. This tool is optional if you already have your games installed on your SD card or your system’s internal storage from the Nintendo eShop and don’t need to dump physical games. Download the
.nrofile. Create a folder inside the
switchfolder of your SD card called
nxdumptooland put the
Eject the SD card from your PC after copying all the files over and put it into your Switch.
3. Putting Our Switch into RCM
In this guide, I’m assuming you’re using the RCM jig to get into recovery mode. If not, you can still follow along; you’ll just have to do whatever you’re doing to get the Switch into RCM.
Turn your Switch off if it isn’t already. Remove the right joycon. Insert the RCM jig all the way to the bottom to ensure the PIN on the bottom of the unit gets grounded. Insert the USB-C cable from your Switch to a USB 3.0 port on your PC. Now hold the Power and Vol+ buttons. If you get a blank screen, congratulations, your Switch is in RCM. If the Switch turns on normally, don’t fret; the USB cable likely caused the Switch to turn on by itself. Just turn the Switch back off, then try again. My setup looks like this:
Now, we need a way to send payloads to our Switch. We’ll be using fusee-launcher for this guide.
4. Dumping Keys
The Yuzu Quickstart Guide wants us to use TegraRcmGUI to send payloads — unfortunately, this only works on Windows. Fortunately, we have a Linux alternative called fusee-launcher. This tool is purely command-line-based, but fret not, it’s very easy to use.
Clone the source with:
git clone https://github.com/Qyriad/fusee-launcher.git
Now install python3-usb. On Debian-based distros this is as simple as:
sudo apt install python3-usb
We want to get biskeydump to dump our built-in-storage (BIS) keys. Download the appropriate zip file from Rajkosto’s website. Extract the
.bin file into the same folder where you cloned
fusee-launcher. With your Switch still connected to your PC in RCM, open a terminal in the same folder as
fusee-launcher.py then run (sudo privilege is required):
sudo python3 ./fusee-launcher.py biskeydump.bin
See a QR code on your Switch now along with a bunch of keys? You’ve successfully managed to send a payload to your Switch!
Grab a QR scanner app on your smartphone or other device and scan the QR code — saving the keys to the SD card doesn’t actually save the appropriate keys, so we need to use the QR code. On your phone, save the keys somewhere and transfer the file to your PC as
console.keys. Create a
keys folder in
%YUZU_DIR% if there isn’t one in there already, then put
console.keys inside that folder, like so:
We need two more key files:
title.keys. To get these, we’re going to need to send another payload to our Switch. Turn the Switch off, then put it back into RCM by holding Power/Vol+. If you still have the zipped download of hekate, extract the
.bin file into the same folder that
fusee-launcher is in. Now let’s launch Hekate on the Switch with (if the version number of hekate is different in your case, just change the name of the
.bin file to the appropriate name):
sudo python3 ./fusee-launcher.py hekate_ctcaer_5.3.0.bin
Payloads button in Hekate. Select
Lockpick_RCM.bin from the list of payloads. Lockpick_RCM will now launch. To dump our keys, just press the Power button once. Once it’s finished, turn your Switch off.
Remove the SD card from the Switch and put it into your PC. Copy
sd:switch/title.keys and paste them into
With me so far? I hope so. We now need to dump our Switch’s system files.
5. Dumping System Files
Put the SD card back into your Switch and launch the hekate payload once more. Tap
Backup eMMC. Select
eMMC BOOT0 & BOOT1. Wait a few moments.
BOOT0 & BOOT1 have now been dumped onto your SD card.
Close and now select
eMMC RAW GPP. This dumps the system’s NAND and will take about half-an-hour or maybe more, as the NAND is about 30 GB in size. If you don’t have enough space on your SD card, hekate will prompt you to take the SD card out, put the part of the file on your PC, insert it back into your Switch, and keep looping until the whole NAND is dumped. Otherwise, just sit back and relax until the dump is finished.
When the dump is complete, shut the Switch off, take the SD card out, and put it into the PC. Your system files should be in
sd:backup/(some series of characters)/. Your NAND was likely dumped in several parts, either in 1 GB parts or 2 GB parts.
Remember that joiner script I mentioned earlier? This is the time we’re going to need that. Copy the parts of the NAND into the same folder as the scripts. Run the appropriate script depending on the size of your NAND parts. So if your parts were about 2 GB each, you would run:
This will take a while. If everything went well you should have a single NAND file named
rawnand.bin that’s around 31 or 32 GB in size:
6. Extracting the Necessary Content from rawnand.bin
Again, the program the Quickstart Guide mentions here (
hacdiskmount) is Windows-only. In our case, we’ll use ninfs.
ninfs is available in the AUR. On other distros, you can install
python3 -m pip install --upgrade --user https://github.com/ihaveamac/ninfs/archive/2.0.zip
You may need to restart your Linux machine. Type and enter
mount_nandhac. If you get something like this:
ninfs successfully installed.
Navigate, via the terminal, to wherever you saved
rawnand.bin. We’re going to make a virtual mount here, so create a folder to whatever name you want. In my case, I called it
prod.keys file you dumped earlier and paste it in the same folder as
rawnand.bin. Now run:
mount_nandhac --keys prod.keys rawnand.bin mnt
The last argument there is whatever you named the folder you just made. Now you should have a virtual mount in your system. Navigate to it, and copy the following files into the same folder as
It’ll take a while. When done, rename the file extension for
.bin and copy these files over to
sysdata doesn’t exist, create it.
Now we need to mount the SYSTEM.img file with
sudo mount -o ro SYSTEM.img mnt
Copy all the contents from the virtual drive (
Contents, PRF2SAFE.RCV, save, saveMeta) to
%YUZU_DIR%/nand/system. Merge any existing files.
We’re almost done here. Unmount the virtual drive with:
sudo umount mnt
And mount USER.img:
sudo mount -o ro USER.img mnt
Copy just the
save folders to
%YUZU_DIR/nand/user. When finished, unmount the drive again with the same
umount command above.
7. Launch Yuzu!
Yup, do as the subheading says. You shouldn’t be getting any errors now, and whatever games were installed to your system’s internal storage should now show up in the games list:
If you have games saved on your SD card, simply insert it into the PC and copy the
Nintendo folder to
%YUZU_DIR/sdmc. Overwrite the existing files if necessary. Close Yuzu, then launch it again to see your SD titles:
If you want to play your game cartridges, you’ll first need to dump them with
nxdumptool. With the SD card inserted into the Switch, connect the Switch to your PC and start in recovery mode. Send the
hekate payload with
Payloads, then tap
fusee-primary.bin. The Switch will now reboot with custom firmware. Everything will appear normal. When you arrive at the main menu, tap
Album. This is the homebrew menu with a few of the applications you copied to your SD card.
Dump gamecard content, then
Cartridge Image (XCI) dump. Dump the certificate with the cartridge. Once the games you want to dump are dumped, turn the Switch off and remove the SD card. Put the SD card into the computer. Find where the game files were dumped. They may have been dumped into multiple parts; if so combine them with:
cat Super\ Mario\ Odyssey.xc0 Super\ Mario\ Odyssey.xc1 > Super\ Mario\ Odyssey.xci
Obviously, Super Mario Odyssey is just an example here; replace it with the name of the game you’re combining.
Place the combined XCI file anywhere on your PC. To launch the game on Yuzu, go to File -> Load File…. Select the XCI file, and you’re good to go.
8. (Optional) Importing Save Files
Importing your save files from your Switch system to Yuzu is relatively easy. Download the
Checkpoint.nro file from GitHub, and create a folder named
sd:switch. Put the
.nro file in the
Checkpoint folder. Remove the SD card from your PC and insert it into your Switch.
Boot the Switch into RCM. Launch
fusee-primary.bin, similar to what you were doing with dumping your game cartridges. Tap
Album and launch
To dump your game save files, select a game with the
Y button and keep selecting until you got all the save files you want to dump, then press
L. Wait for the process to complete, then turn off the Switch. Take the SD card out and put it into the PC. Save files are dumped in
You could right-click a game in Yuzu and select “Open Save Data Location”, but the problem with that is it actually opens the wrong directory. The proper save directory for Yuzu is:
So I’ll be using the example of Smash Bros. Ultimate. Navigate to where your saves are located — it’ll be the title ID followed by the name of the game. So Smash Ultimate would be:
0x01006A800016E000 Super Smash Bros Ultimate
Go into the save directory for Yuzu and if there isn’t a folder of the title ID already there, make one. Smash Ultimate‘s title ID is
01006A800016E000. Now copy
save_data from the save on your SD card to this folder. If you’re with me so far your save structure should look something like this:
Done. Just launch the game in Yuzu and it should automatically pick up the save file.
Phew. The hardest part is over. Now we can actually get into the fun of emulating your Switch games.
As of writing this I’m using Yuzu version 315. By the time you read this chances are likely there’s a newer version, as new builds are uploaded just about daily. I don’t expect your setup to be a whole lot different from mine; but the interface may look a little different. Either way, it’s nothing to fret over; you should be able to find the right options just fine.
There’s a bunch of settings that we can mess around with, but for now we’re going to want the best performance we can get. So to start things off, enable multicore CPU emulation in the Configuration menu to make good use of the multiple threads you have in your processor — but just a heads-up, the reason why this isn’t enabled by default is because it is a huge memory leaker. That’s why I recommend having at least 16 GB RAM in your system.
Another checkbox you may want to tick is
Hide mouse on inactivity. Does as it says; the mouse cursor won’t be in your way while you’re playing.
You may need to tinker around a bit with the Graphics settings. In most cases you’re going to want to use Vulkan as the API, especially if you’re using an AMD graphics card. Speaking of AMD, AMD users are going to have to make use of a special graphics driver called AMDVLK. The reason for this, is because quite often Yuzu will crash with the native Mesa drivers. The terminal output will be something like this, even if you have plenty of RAM:
terminate called after throwing an instance of 'Vulkan::vk::Exception' what(): VK_ERROR_OUT_OF_DEVICE_MEMORY Aborted (core dumped)
So you’re going to need to download and install AMDVLK. Don’t worry; this isn’t going to mess up your system at all. Just close Yuzu, open it back up, and now you should have a new device listed under the API settings. Select the one that doesn’t say
RADV; it should just be the name of your graphics card. Yuzu should now crash far less often.
There may be instances where you’ll want to use OpenGL as the API. For example, you may not be able to play Mario Tennis Aces with Vulkan. The downside with OpenGL is that you will most likely have to wait a while for the shaders to compile when launching a game, as well as a slight performance decrease. So this will be something you’ll need to experiment with to get the best results.
While you’re in the Graphics submenu, enable asynchronous GPU emulation. You can also optionally enable vsync and assembly shaders if you’re using NVIDIA hardware with OpenGL in the
Finally, let’s configure our controls. In most cases, you should be fine emulating dual joycons in docked mode. Click
Configure and set up your controls with your desired gamepad.
Now start playing! Enjoy! Check the compatibility list to see how well your games play and what workarounds may need to be made.
You can add mods to games to enhance the overall experience. Mods are placed in:
%YUZU_DIR%/load/[title ID of your game]
Mods are automatically enabled when they are added. To disable them, right-click the game in Yuzu -> Properties -> Uncheck the box for the mod.
My hardware is as follows:
- GTX 1660
- 24 GB RAM
Most of the games that I’ve tried so far run very well. There will be slowdowns in some areas, because Yuzu is trying to process shaders, but after that the games run just as good as on the console itself. I haven’t really encountered any graphical issues. Audio for the most part works great. General RAM consumption is around 12-13 GB, with a 50% load on the CPU and around 40% on the GPU. Occasionally the emulator will randomly crash, and there are certain areas or menus of a game that will cause a black screen. The recent Paper Mario: The Origami King works great, but as I’m using the mainline build (not the early access version) there’s no music for some reason.
I recorded some gameplay footage — just keep in mind that recording sapped the framerate a bit, so some games will look bad; Zelda: BoTW especially.
The thing that I frankly dislike about Yuzu, is that obtaining a copy of their early access builds requires a $5 monthly subscription to their Patreon, effectively creating this sort of paywall for better features. Ryujinx, on the other hand, has all of their builds publicly available.
Ryujinx uses less memory than Yuzu does, so you should be able to get away with 8 GB of RAM. And unlike Yuzu, it just recently became capable of playing in-game videos. The downside here, is that it’s not quite as optimized as Yuzu, so you’re going to need a pretty beefy graphics card to get games running smoothly. How beefy? Maybe a GTX 1060 or a RX 580/590; there isn’t a detailed system requirements page anywhere. There’s also no Vulkan renderer here; you can only use OpenGL for now.
Ryujinx doesn’t require anywhere near as much dumping as Yuzu. You will, however, still need the key files you dumped earlier in the Yuzu section. If you haven’t done so, follow Step 4 from said section. From the tutorials I’ve seen, it seems you just need
prod.keys but I would copy all three key files just to be safe. Copy them to
~/config/ryujinx/system. If these folders don’t exist, just run Ryujinx for the first time and the folders will be made for you. Now you’ll need to install the system firmware.
You can dump your firmware. Open Ryujinx, go to Tools -> Install Firmware -> Install a firmware from XCI or ZIP, then select the firmware zip/XCI file you downloaded. If you dumped it, just select Install a firmware from a directory as likely the dump was a collection of files put in a folder on your SD card.
You’re good to go. Configure your settings and your controls to your liking, then play your dumped cartridge games. Just give it a good two or three minutes to load. You can enable “Profiled Persistent Translation Cache” in the Settings menu to speed up boot times, but you’ll have to run the game a few times to get this to work.
I haven’t found a way to get Ryujinx to scan internally installed/SD card titles, so you’re going to have to use
nxdumptool to dump your games, whether they’re a cartridge or installed on the system itself, then copy these files to your PC. Your dump settings should be as follows:
- Dump as a NSP file
- Remove console specific data: Yes
- Generate ticket-less dump: Yes
- Change NPDM RSA key/sig in Program NCA: Yes
The other settings can be modified to your liking.
Save files should be located in
~/.config/Ryujinx/bis/user/save (you can also right-click the game after setting your games path, then select “Open User Save Directory”).
One thing I’d like to note regarding the configuration of controls, is that you may have to manually edit the
Config.json file located in
~/.config/Ryujinx to set them up. I have had an issue trying to assign buttons via the GUI; after assigning one button, it will assign the same to the other buttons after clicking them. Use jstest-gtk to find what values are assigned to each button.
In my experience there was a strange T-pose bug in Smash, where the characters are stuck in a T-pose. Supposedly this had gotten fixed recently, but I’ve had no luck here. As far as performance, it’s not quite there in comparison to Yuzu, and there’s a few graphical glitches here and there. Paper Mario: The Origami King works, but it’s been pretty sluggish on my end.
For the sake of comparing emulation performance, I found a few videos on YouTube that highlight the differences between Ryujinx and Yuzu:
Chances are more than likely someone is going to get confused at some point following this guide; if you’re comfortable using Discord you can join the Yuzu Discord group and ask for help in
#yuzu-support-linux. Ryujinx also has a Discord group. You can also ask questions here in the comments or contact me on Twitter, but I may not be the best person to ask for help.
Other than that, happy emulation!