Emulating Nintendo Switch Games on Linux

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.)

Getting Started

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:

Serial number of the Switch

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:

Switch Serial Number Checker

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.

Yuzu

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.

Yuzu missing files

Close the emulator. You should now have folders set up for Yuzu in ~/.local/share/yuzu/:

  • dump
  • load
  • log
  • nand
  • sdmc

From here on out, ~/.local/share/yuzu/ will be referred to as %YUZU_DIR%.

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 .bin file in bootloader/payloads/
  • Lockpick_RCM – this will dump the key files necessary for the decryption of our games. Download the .bin file, place in bootloader/payloads/ of your SD card, just like with fusee-primary.bin
  • (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 .nro file. Create a folder inside the switch folder of your SD card called nxdumptool and put the .nro file inside.

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:

RCM Jig insertion

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!

biskeydump

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:

console.keys, the file you need to make yuzu work properly

We need two more key files: prod.keys and 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

Tap the 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/prod.keys and sd:switch/title.keys and paste them into %YUZU_DIR%/keys.

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 Tools, then Backup eMMC. Select eMMC BOOT0 & BOOT1. Wait a few moments. BOOT0 & BOOT1 have now been dumped onto your SD card.

Tap 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:

bash join_15_2GBparts_linux_macosx.sh

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:

rawnand is a dump of your Switch's NAND

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 ninfs with:

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:

mount_nandhac

You have 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 mnt:

mkdir mnt

Copy the 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 rawnand.bin:

  • BCPKG2-1-Normal-Main.img
  • PRODINFO.img
  • USER.img
  • SYSTEM.img

It’ll take a while. When done, rename the file extension for BCPKG2-1-Normal-Main.img and PRODINFO.img to .bin and copy these files over to %YUZU_DIR%/sysdata. If sysdata doesn’t exist, create it.

Now we need to mount the SYSTEM.img file with ninfs:

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 Contents and 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:

NAND titles should show up when you start Yuzu

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:

SD titles can also show up if you add them in the proper folder

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 fusee-launcher. Tap 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.

Start nxdumptool. Choose 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 Checkpoint inside 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 hekate.

In hekate, tap Payloads -> fusee-primary.bin, similar to what you were doing with dumping your game cartridges. Tap Album and launch Checkpoint.

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 sd:switch/Checkpoint.

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:

%YUZU_DIR%/nand/user/save/0000000000000000/FAE8C2C1BDBAC40A022B00B13827EB1E

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:

%YUZU_DIR%/nand/user/save/0000000000000000/FAE8C2C1BDBAC40A022B00B13827EB1E/01006A800016E000/save_data

Done. Just launch the game in Yuzu and it should automatically pick up the save file.

Configuring Yuzu

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.

Multicore enabled in Yuzu

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 Advanced panel.

Enabling async GPU emulation in Yuzu

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.

Setting up controls in Yuzu

Now start playing! Enjoy! Check the compatibility list to see how well your games play and what workarounds may need to be made.

SSBU screenshot in Yuzu

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.

Mods are also supported in Yuzu

My hardware is as follows:

  • i5-8400
  • 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.

Ryujinx

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 either dump your firmware or simply download it. 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.

Firmware installation in Ryujinx

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.

Game compatibility can be found on GitHub. Mods are also supported here; just right-click the game and select “Open Mods Directory”. If you need more help, follow their guide on GitHub.

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.

Paper Mario in Ryujinx

For the sake of comparing emulation performance, I found a few videos on YouTube that highlight the differences between Ryujinx and Yuzu:

Questions?

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!

4.1 7 votes
Article Rating

You might want to check out the following articles too!

cow_killer

cow_killer

Subscribe
Notify of
guest
4 Comments
Oldest
Newest Most Voted
Inline Feedbacks
View all comments

[…] Emulating Nintendo Switch Games on Linux […]

[…] Emulating Nintendo Switch Games on Linux (boilingsteam.com) […]

Vodram

An alternative to SSNC is https://ismyswitchpatched.com