Since it was released, the Raspberry Pi has been hailed as the perfect all-in-one retro game console. Now, it’s easier to do than ever, and it doesn’t take any advanced Linux knowledge to do. Here’s how to make your own retro game console in about 30 minutes.
We’ve walked you through all sorts of DIY projects for the Raspberry Pi, but this one might be the simplest. You’ll have your retro game console — complete with old-school controllers — up and running within 30 minutes. All you need to do is install the operating system on an SD card and do some simple file sharing from your PC.
Before we get started, let’s go over some basics. Emulating old-school video games requires two things: game ROMs and an emulator to play them. A ROM is a copy of a game that exists on your device. An emulator is an application that can play that ROM. The rule of ethics is that you should have a physical copy of a game if you have a ROM (or you can create your own from your old cartridges). We’ll leave it to you to come up with the ROMs on your own. With that, let’s get the Raspberry Pi set up.
What You’ll Get
Your Raspberry Pi will boot automatically into EmulationStation. This is a program running off a custom SD card called RetroPie that allows you to use a controller to select an emulator and a game without ever touching a keyboard or mouse. After everything’s set up, you’ll be able to navigate and do everything you need to do on the Raspberry Pi from a controller.
What systems can you emulate? A lot of them:
- Amiga (UAE4All)
- Atari 2600 (RetroArch)
- Doom (RetroArch)
- Final Burn Alpha (RetroArch)
- Game Boy Advance (RetroArch)
- Game Boy colour (RetroArch)
- Game Gear (Osmose)
- Intellivision (RetroArch)
- MAME (RetroArch)
- MAME (AdvMAME)
- NeoGeo (GnGeo)
- NeoGeo (Genesis-GX, RetroArch)
- Sega Master System (Osmose)
- Sega Megadrive (DGEN)
- Nintendo Entertainment System (RetroArch)
- PC Engine / Turbo Grafx 16 (RetroArch)
- Playstation 1 (RetroArch)
- Super Nintendo Entertainment System (RetroArch)
- Sinclair ZX Spectrum (Fuse)
- Z Machine emulator (Frotz)
Some of the more advanced emulators like the Playstation 1 and Neo Geo don’t work as well, but for the most part the older systems work great.
What You Need
You don’t need much to get started here:
- A Raspberry Pi (the 256MB or 512MB model will work).
- At least a 4GB SD card.
- USB Controllers (optional, but makes the whole thing a lot more fun. I used these cheap USB SNES controllers from Amazon).
- A USB keyboard and mouse (just for the initial setup, you won’t need it afterwards).
- A router (to transfer your ROMs).
- TV/monitor, AV/HDMI cables, power supply (you can find a full list of compatible SD cards, power bricks, and everything else on the Raspberry Pi Wiki).
- A Windows/Mac/Linux computer to transfer your ROMs.
- A copy of the free software Cyberduck (or any FTP, SFTP client).
Step 1: Download and Install RetroPie on a SD Card
Because of the work of PetRockBlock, the process of installing all of these emulators on your Raspberry Pi is incredibly easy:
- Download the RetroPie Project SD card image.
- Once it’s downloaded, extract the image to the SD card the same way you would a normal Raspbian image. Windows users can do this really easily with the Win32DiskImager, and Mac users can use the RPI-sd card builder. Linux users have to a pretty simple command line trick. Either way, check out our beginner’s guide to DIYing with the Raspberry Pi and follow the same instructions you would with Raspbian.
- When it’s done, remove the SD card and put it in your Raspberry Pi.
As far as the initial setup, that’s all you need to do. In fact, if you plan on using a keyboard and mouse instead of a controller you’re basically done and can skip to step four to transfer over your ROM files.
If you’d prefer to manually install the emulators, you can do that as well. SuperNintendoPi has a great setup guide for doing it, but be warned: the manual process takes around six to nine hours to download and install everything. The benefit is that you get the newest versions of emulators and you can select what gets installed. For our purposes though, the above method works great and is incredibly simple.
Step 2: Boot Your Raspberry Pi and Set Up EmulationStation
Next up we’ll boot up your Raspberry Pi. Plug in one of your controllers and your keyboard to the Raspberry Pi. Insert the SD card you just burned, and turn the Raspberry Pi on. It should boot directly into EmulationStation. On the first boot, you’re prompted to set up the controls for EmulationStation.
Follow the onscreen prompts with your controller to set it up (up, down, left, right, etc). When you’re finished, you can navigate through EmulationStation with just your controller. These controls will not work with the emulators — that takes an extra step we’ll get to in the next section. After you confirm your controller works, pull up the menu (you picked the button for this during the prompts, mine is the Start button), and exit EmulationStation to go to the command line.
Step 3: Configure Your Controllers for the Emulators
This looks a little daunting at a glance, but it’s actually very easy and only takes a few minutes to do. Once you’re in the command line, it’s time to calibrate your controller. This takes a few steps. With your controller and keyboard still plugged in, type this into command line:
cd RetroPie/emulators/RetroArch/tools ./retroarch-joyconfig >> ~/RetroPie/configs/all/retroarch.cfg
Next, grab your controller and follow the onscreen prompts to set up your button configuration. Your controller may lack some of the buttons the prompts want you to set up (for example, my SNES controller doesn’t have a joystick or R2/L2, R3/L3 buttons), so just press any button during those prompts, we’ll clean those up next.
If you’re using an Xbox 360, PS3 or similar controller, you can skip this next part entirely. If you’re using a retro-style SNES controller like I am, you’ll need to go through a couple more steps.
We need to delete those extra buttons that the Super Nintendo controller doesn’t have from the configuration file you just created. You have two options for editing the controller configuration file you just created. You can do so on the Raspberry Pi itself by going into Raspbian (type “startx” into the command line), or you can use FTP software like Cyberduck on your desktop computer. Since we’re going to be transferring ROMs with Cyberduck in the next section anyway, we’ll just use that to edit the controller configuration.
Now we need to edit the button layout file:
From the command line on the Raspberry Pi, type
and look for the line “inet addr.” This is your IP address (it will read something like 192.168.1.8). Write that down.
- Open up Cyberduck on your computer, and select “Quick Connection”.
- Select SFTP (SSH File Transfer Protocol).
- For the server number, enter the number you wrote down down in step one. Your username is “pi” and the password is “raspberry”. Click OK to go to the Raspberry Pi’s SD card.
- Navigate to RetroPie > Configs > all.
- Here you’ll find the retroarch.cfg file. Select it and open it up in the text editor.
If you’re using a Super Nintendo controller like I am, you need to delete a few lines. Find and delete these lines if so:
input_player1_l2_btn = "4" input_player1_r2_btn = "4" input_player1_l3_btn = "4" input_player1_r3_btn = "4"
- Also highlight and delete: ““input_player1_l_x_plus_btn = “x”” and all the lines under it if you don’t have an analogue stick on your controller (for example, my SNES controller).
(Optional) While you’re here, you can also set up a trigger to exit the emulator and kick you back to EmulationStation. This is handy because otherwise you have to reboot the Pi every time you quit a game. So, at the end of the retroarch.cfg file, add these lines:
input_enable_hotkey_btn = "X" input_enable_hotkey_btn = "Y"
- Replace “X” and “Y” with numbers that correspond to two buttons on your controller that you want to trigger an exit from the game. I used Start and Select (8 and 9).
- If you just have one controller, you can now save the file and exit.
Optional: Now you’re all set up to use your controller in the emulators, but if want to have two controllers connected, you need to take one more step. For this, we’re assuming both controllers are identical:
- in the retroarch.cfg file, find and highlight the line “input_player1_joypad_index = “0” and select all the lines after it.
- Copy the text and paste it right below. You should have two blocks of identical text.
- In the second block that you just pasted, change everything that says “player1” to “player2”. For example, the first line should read: “input_player2_joypad_index=”0”. The second line, “input_player1_a_btn = “1”, etc.
- Save the file and exit.
That’s it, your controllers are all set up and ready to go.
Step 4 (Optional): Transfer Your Roms from Your Primary Computer
For this step, we’re going to assume you already have a bunch of ROMs on your primary computer. However, if you have them on your Raspberry Pi you can just move them over to the correct folders and you’re all set.
- Make sure your Raspberry Pi is on, and connected to your router.
- Now head over to your primary computer and connect to your Raspberry Pi with Cyberduck again.
- Navigate to RetroPie > roms.
- Copy over any ROMs on your computer to the corresponding system folder and you’re done.
From here on out, you’ll be able to easily copy ROMs to the Raspberry Pi remotely through this method, so don’t worry if you want to add more down the line. Once the file transfer is done, go ahead and reboot the Raspberry Pi with your controllers connected and everything should be good to go.
Once you finish the above, your Raspberry Pi should boot directly into the EmulationStation every time you start it, and you’ll able to control the whole thing with your attached controllers — no keyboard or mouse required. That said, if you’re having problems, resources are available to you. Here are a few places to seek out help:
- PetRockBlock: The official page for the RetroPie Project. Includes lots of guides, tips and a forum for troubleshooting.
- Super Nintendo Pi: This is a full guide for a manual install, and includes lots of tips on setting up controllers, as well as skinning EmulationStation to make it look a little better.
- The Raspberry Pi forums: Lots of people are sharing their tips for getting emulators working better, as well as different controller setups and more in the official Raspberry Pi forums.
Music in video: Subway Sonicbeat