How to Build the Best PC for Emulation and Retro Gaming

Emulation PC Build

Last updated: July 2018

Emulation is the practice of using a program (called an emulator) on a PC to mimic the behavior of a video game console, in order to play (usually retro) console games on a computer. If you want to put together a PC that will give you the best performance for playing games on emulators at the lowest price, then you’ve come to the right article!

By building a PC for yourself, you can ensure that it is tailor-made for your exact needs with as little waste as possible. Below you’ll find five sections to take you through everything you need to know.

We’ll explain which components are the most important for emulation, and how to get the most out of your new gaming rig.

Let's get to it!

In Section 1, we provide example PC builds that combine components to be well-suited for running emulators.

In Section 2, we’ve got a part-by-part explanation of how to select components for your emulation build.

In Section 3, we’ve got some guidance on different emulation PC gamepad/controller options.

In Section 4, you'll find answers to the most frequently asked questions regarding emulation and PC hardware.

Finally, in Section 5, we have an overview of the most prominent software for emulation.

DISCLAIMER: While emulation itself is a completely legal way to play games, and emulators are a vital (often open-source and volunteer-produced) aspect of the ongoing conservation of aging games—piracy is illegal in the US, and some other countries. Therefore, we here at Logical Increments DO NOT condone piracy in any way.

Section 1: Example Emulation PC Builds

These builds are designed to provide sufficient computing power for playing games on most well-developed emulators. The compatibility and performance of any given title will vary from emulator to emulator and from build to build. General info on how these parts were selected and prioritized is available in section two below.

Note: When building a new PC, you’ll need to install an operating system. For maximum compatibility with available emulation software, we recommend using Windows (unless you’re going with a Raspberry Pi, in which case we recommend RetroPie). You can purchase Windows here. Some people are eligible to get Windows free through school or work, so you may also look into that.

The Raspberry Pi Emulation Build ($100)

For the serious DIY-ers with a seriously tight build budget, there is the Raspberry Pi. This teeny tiny computer-on-a-chip has become a very popular low-end (and highly-portable) retro emulation solution. Don’t be misled by its size: the newest generation of this little thing can handle home consoles up to the early 1990s (up to the SNES and the Playstation), and handheld consoles up to the early 2000s (up to the Game Boy Advance).

So if you just want to play some native-resolution Game Gear or SNES games, for instance, then this might be a great choice for you. But be forewarned: even in the already-finicky world of emulators, the set-up for a Raspberry Pi emulation machine can be quite complicated (but as usual, there are some great walkthroughs for this).

Of course, the most obvious trade-off here is that this is not going to be suitable for use as a desktop PC—not even as a basic browsing-and-emailing PC. The most likely OS choice for a Raspberry Pi emulation machine, RetroPie, gives you a very clean and elegant console-like interface, at the expense of most typical PC functionality. The official OS of the Raspberry Pi, Raspbian, does boast some barebones ordinary PC capabilities, but lacks the emulation-friendliness of RetroPie (and would likely lack a lot of software compatibility/performance that most users would desire for everyday use).

PC: CanaKit Raspberry Pi 3 B+ Starter Kit
Storage: Stock (32GB Samsung MicroSD) or 64GB Sandisk Ultra MicroSD
Power Supply: Stock (2.5A Adapter)
CPU Cooler: Stock (Passive Heat Sinks)
Case: Stock (Glossy Black Enclosure) or SB Components Transparent Case
Operating System: RetroPie

The Cost-Effective Emulation Build ($400)

Now that the Raspberry Pi is out of the way, we move into the realm of the full-size, multipurpose computers. This is a low-tier build for those of you with a somewhat restricted build budget, but who still want something that can handle a wide variety of emulators while also serving as a solid general-use desktop PC.

At this level, we’re taking advantage of great integrated graphics performance on a new Ryzen CPU to skip a graphics card entirely (though you’ll notice that we don’t go particularly heavy with the graphics cards in the builds below either, as the CPU is much more important for emulation). In addition to being a capable general-use desktop PC, this computer would be suitable for emulation of home consoles up to the mid-1990s, and handheld consoles up to the mid-2000s.

CPU: AMD R5 2400G
Motherboard: ASRock AB320M
RAM: 4GB DDR4 2400
Storage: 1TB Seagate BarraCuda HDD
Power Supply: EVGA 500 B1
CPU Cooler: Stock
Case: Corsair 88R
Operating System: Windows 10

The Midrange Emulation Build ($800)

As usual, building at the mid-range yields an incredible machine for the price. This build features an i5 CPU, a discrete graphics card, twice the RAM of the previous tier, and room to upgrade in the future.

At this level, you get an SSD that can fit not only your OS and your important programs (and thus have them running noticeably faster), but also your emulators and your emulation frontend—although you may still have to stow your games on the HDD, if your collection is large.

You may also notice that, relative to our general PC gaming builds in our primary build chart, this build features a somewhat more powerful CPU than GPU; this is because, as explained at more length below, emulation takes much better advantage of the CPU than the graphics card. Still, this computer would fare well in a wide variety of conventional PC games at 1080p; but on-topic, this build would be suitable for emulation of home consoles up to the early 2000s, and handheld consoles up to the late 2000s.

CPU: Intel i5-8500
Graphics Card: EVGA GTX 1050 Ti
Motherboard: MSI B360 Gaming
RAM: 8GB DDR4 2666
Storage 1: 128GB Adata SU800 SSD
Storage 2: 1TB Seagate BarraCuda HDD
Power Supply: EVGA 500 B1
CPU Cooler: CryoRig H7
Case: Corsair SPEC-04
Operating System: Windows 10

The High-Performance Emulation Build ($1500)

Very high performance build, although not twice as high as the higher-value ‘Balanced Price-to-Performance’ build.

The CPU in this build features some of the best single-threaded performance on the market today, which is easily one of the most important metrics for the performance of emulation software. The RAM amount has also been doubled yet again, to ensure sufficient capacity for large graphics caches when emulating consoles like the Wii U and the PS3.

This build also features a large enough SSD to accommodate the entire emulation set-up of most users, with enough HDD storage to handle even a collection featuring a fair number of large game files from recent console libraries.

Once again, this build differs from the builds on our homepage by placing more budgetary stress on the CPU and RAM than on the graphics card (prioritizing what emulators use the most over what general PC games use the most). Regardless, this computer would be capable of providing great performance in the vast majority of conventional PC games at 1080p; and as for the task at hand, this build would be suitable for emulation of home consoles up to the late 2000s, and handheld consoles up to the early 2010s (emulators permitting).

CPU: Intel i7-8700K
Graphics Card: Zotac GTX 1060 6GB
Motherboard: Asus Prime Z370-A
RAM: 16GB (2 X 8GB) DDR4 3200
Storage 1: 500GB Crucial MX500 SSD
Storage 2: 2TB HGST Ultrastar HDD
Power Supply: EVGA 750 SuperNOVA G3
CPU Cooler: CryoRig R1 Ultimate
Case: Cooler Master Stryker SE
Operating System: Windows 10

The Absurd, Beastly Emulation Build ($2500)

If you want to be beyond certain that you’re receiving the best performance that any given emulator is capable of giving, then this is the build for you.

This build still features an i7-8700K, because the vast majority of emulators rely entirely (or almost entirely) on the first and second core of the CPU; all of the very-high-tier workstation CPUs (and comparable AMD CPUs) feature lower per-core speeds in exchange for higher core counts, which makes them slightly worse choices for an emulation-centric build. But unlike the build above, this time the i7 is bolstered by one of the best GPUs on the market, a further doubling of the RAM, and an extremely high-speed M.2 SSD.

This machine would not only be capable of doing all of the emulation mentioned in each of the above builds (and maybe more, pending future emulator development . . .) but would also be suitable for high-performance gaming in any modern conventional PC game (including at resolutions above 1080p).

CPU: Intel i7-8700K
Graphics Card: EVGA GTX 1080 Ti
Motherboard: MSI Z370 Gaming Pro Carbon
RAM: 32GB (2 X 16GB) DDR4 3200
Storage 1: 500GB Samsung 970 EVO M.2 SSD
Storage 2: 4TB HGST Deskstar HDD
Power Supply: Corsair HX850
CPU Cooler: Fractal Design Celsius S24
Case: Cooler Master Cosmos C700P
Operating System: Windows 10

Emulation PC Build

Section 2: Choosing PC Hardware for an Emulation PC


The CPU is the single most important part of a computer whose primary job is playing games on emulators. This is because it does all or most of the simulation of the console during emulation.

For many emulators of older systems, it may be the case that only the speed and power of the first core of your CPU will matter for the quality of emulation. For emulators of newer systems, two or more cores may come into play, and it’s usually two: one that simulates the console’s central processor and one that simulates the console’s graphics processor.

As a result, the CPU should be the first part selected for an emulation build, and should be the highest-tier component. This is true of all of the example builds above except for the final one, which goes for a more conventionally balanced GPU choice.

Some of the emulators for consoles from the past decade have dabbled with implementing more cores for improved performance, but for an emulation build, overall, single-core speed should definitely still be prioritized over core count.

Graphics Card (GPU)

It may be natural to assume that the graphics card is the most important part of an emulation computer—due to the fact that the graphics card is the most important part of a general PC gaming rig—but this is typically incorrect.

As explained above, most of the simulation of console hardware that happens during emulation, in the majority of cases, is the duty of the CPU. In fact, unlike in conventional PC gaming, it is often possible to upscale the resolution of an emulated console quite considerably without significantly degrading performance.

Still, the GPU can not be entirely neglected, for the following reasons: some emulators, especially of more recent consoles, have been taking better advantage of the power of graphics cards; many emulators do make use of the graphics card in some limited fashion; there is always the chance that future emulator development will lead to GPU-boosted emulation of a console that matters to you; and most people who want to play emulated games would also like to have the capability to play general PC games, even if that is not their top priority.

So a balance has been struck in the example builds above: the graphics card has a lower priority and a lower-tier choice than some other parts in each build, but is still a capable, modern, not-too-unbalanced card for each situation.


Unlike in the majority of other build situations, RAM is something that should be prioritized to some extent for an emulation build. Everything from shaders and other graphics assets to save-relevant processes to some pre-loading functions can make use of RAM capacity.

In fact, in my own personal PC, emulation of the Wii U is one of only two tasks to ever take advantage of my PC’s 16GB of installed RAM by using more than 8GB at one time (the other was 3D rendering, a topic covered by another of our big guide articles). But for users who are not intent on using the most recent of emulators (like those for the Wii U and PS3), 8GB or even 4GB of RAM is still likely to be enough.

Storage (HDD, SSD)

What amount of storage you need for emulation depends heavily upon which consoles you want to emulate.

If your primary interest in emulation is mostly retro, you don’t need much. In particular, if you mostly want to play cartridge-based home consoles from the 1980s and early 1990s (including the Atari consoles, Master System, Genesis, Neo Geo, NES, SNES, and N64), and handhelds up to the early 2000s (including the Game Gear, Neo Geo Pocket, Neo Geo Pocket Color, Game Boy, Game Boy Color, and Game Boy Advance), then you could theoretically get away with less than 100GB of storage for your entire machine—including the OS, emulators, and games.

This is because the files for such classic games are miniscule when compared to the capacities of modern storage devices, which makes it possible to store hundreds or even thousands of them in a relatively small amount of space. Still, even in this situation, we would recommend getting at least 500GB for a desktop computer (or at least 32GB for a Raspberry Pi), just to be sure.

If, on the other hand, you are interested in emulating more modern stuff, you’ll need more room. In particular, if you mostly want to play disc-based home consoles (including the Saturn, Dreamcast, PS1, PS2, PS3, GameCube, Wii, and Wii U), and handheld consoles from the mid-2000s onward (including the PSP, DS, and 3DS), then you’ll need considerably more space for your entire library, and should invest in at least 1TB.

Power Supply (PSU)

Getting a PSU that doesn’t support a sufficient wattage for your build, or (even worse) getting a budget PSU that may not have been well-made, increases the risk of catastrophic failure for your build. The specifications or numbers on the packaging don't tell the whole story, so unless you're an electrical engineer, the best way to find a good power supply is to ask an expert.

Don’t risk damaging your components. Get a high-quality PSU. Unlike many other components, the quality of power supplies does not increase as much over time. A high-quality power supply bought today, will still be a high-quality power supply in 5 or 10 years.

Emulation PC Build

Section 3: Controllers for Emulation

You can stick with keyboard in some cases if you really want or need to, but most people prefer to play with a controller when they’re playing console games that were designed for controllers. And choosing a controller is a fairly big decision, as it will affect your experience of every game you decide to play.

USB Classic Controller Clone

Buffalo Classic USB Gamepad

There are many of these on the market, and which you choose would really come down to which console’s controller you think is the best (or are most used to . . . or are most nostalgic for).

Personally, I picked up some inexpensive SNES-style USB controllers for a Raspberry Pi set-up I made last year—while I use an Xbox 360 controller for my desktop. But there are also options that resemble NES, Sony DualShock, Genesis or Master System, and N64 controllers.

Xbox 360 Controller

Xbox 360 Gamepad

It’s hard to go wrong here. It’s familiar and it will work with almost any emulator (via RetroArch, Dolphin, PCSX2, etc).

The wired version has great compatibility with existing emulators and frontends, but you’ll also need the wireless adapter if you go for the wireless version.

Xbox One Controller

Xbox One Gamepad

Similarly (but somewhat newer), the Xbox One controller feels familiar and works great on Windows PCs.

Playstation 4 Controller

Playstation 4 Gamepad

The PlayStation 4 controller is compatible with any ordinary PC. The controller itself is $45 for the standard black model, and if your chosen motherboard doesn't come with bluetooth, cheap USB Bluetooth adapters can be obtained for less than $10 each.

Emulation PC Build

Section 4: Frequently Asked Questions About Emulation

FAQ 1: Is emulation morally wrong?

No! Emulation just refers to using a piece of software to mimic the behavior of a console. As long as the code for each emulator is entirely original, and does not steal any code or devices that belong to another company or individual, then an emulator is a legal creation.

Moreover, emulation is an absolutely crucial means of preserving access to aging consoles and games; the people who work on emulators are very often just one or more passionate volunteers, and the vast majority of emulators that exist have been made available to everyone by their creators, free and open-source. Not only is emulation most assuredly not morally wrong, it is to be celebrated and appreciated!

However, duplicating copyrighted code or games is absolutely illegal in the US (and some other countries, depending on circumstances). This is why you will find a disclaimer in the introduction of this article which states unequivocally that “we here at Logical Increments DO NOT condone piracy in any way.” Taking a copyrighted console BIOS or piece of software that does not belong to you qualifies as piracy.

FAQ 2: Does an emulation PC require a powerful CPU?

Yes, but not always. The CPU is definitely the biggest factor in the ability of your PC to play games on emulators, as it does all or most of the simulation of the console hardware. You can find more information on this in the CPU portion of the second section above.

But on emulators for consoles from the 1970s, 1980s, and even early 1990s, a low-end CPU should be more than capable of providing agreeable performance.

And it is also true that some developers of the emulators for recent systems like the PS3 and the 3DS are figuring out how to better leverage GPU power to boost performance.

But none of that changes the fact that your CPU will be the primary determinant of your PC’s emulation capabilities, and that emulating the last 20 years of consoles reliably requires some reasonably high computing power.

FAQ 3: Why don’t emulators always require (or benefit from) a powerful graphics card?

It is natural to assume that the graphics card would play a big role in gaming via emulators, as it plays a huge role in ordinary PC gaming. But in the majority of situations, that natural assumption is incorrect.

This is because, as explained at some additional length in the CPU and GPU subsections of section two of this article, any given emulator is likely to lean heavily on the first one or two cores of the CPU (which usually simulate the behavior of parts of the console, including the graphics processing parts), and almost not at all on the graphics card.

This is also why the example builds in section one prioritize single-core speed over multi-core speed in their CPU selections.

FAQ 4: What CPU and GPU should I get for emulation?

Refer to the recommendations in section one and section two above.

FAQ 5: Emulation is hard to set up. Are there any places online I can find help setting up emulators?

Yes! There are resources and forums on numerous websites to help with setting up your emulators.

First of all, many emulators (as well as frontends) have their own associated websites with their own forums (like this one for RPCS3), and sometimes even wikis (like this simple resource page for Citra). So the official website of the emulator you’re trying to use is likely to be a great place to start.

Second of all, Reddit is home to a general emulation subreddit, an emulation troubleshooting subreddit, and a wide array of specific subreddits for popular pieces of emulation software—like /r/rpcs3, /r/cemu, /r/mame, /r/dolphin, and /r/retroarch.

Third of all, there is a massive repository of information over at the Emulation General Wiki.

For Raspberry Pi users, there is a fairly extensive wiki on GitHub to help with set-up and answer some compatibility questions.

Beyond that, most in-development emulators also have Discord, GitHub, and conventional social media channels to act as additional resources. Not to mention the existence of YouTube tutorials on everything under the sun.

So seek a community relevant to your question, ask an earnest question, and you are likely to find the answer you need.

FAQ 6: What is a frontend? What is the best frontend program for emulation? Are there free options?

A frontend is a menu system that allows you to launch all of your emulators from one single interface, similar to a modern console home menu—and/or provides a UI for command line emulators which lack native user interfaces. All of the images in this article are images of an emulation frontend (EmulationStation, specifically). The best frontend comes down to personal preference, but yes, there are free options.

Some examples of popular frontends are HyperSpin, EmulationStation, and LaunchBox. All three are available for free, but LaunchBox also offers a premium paid version called ‘Big Box’ with some additional features. (Note: All desktop versions of EmulationStation are no longer being developed/supported.)

For more information about frontend options, see section five of this article, directly below.

Emulation PC Build

Section 5: Emulation Software

Alright, so you’ve got a PC now, or at least you have one in mind. Next, you’ll want to consider which programs to use in conjunction with your emulators. Here’s an overview of the most prominent pieces of software for emulation machines, including a few prominent or recent standalone emulators that it is currently advisable to acquire separately from RetroArch:



HyperSpin is a free (but closed-source), heavily customizable emulation frontend program. Its menus are flashy and may be overly garish for some users, but that flashiness makes it perfect for looking like an arcade cabinet interface (a tacit invitation for heavy DIY users to make custom arcade builds), and it features numerous aesthetic benefits by default—like game info and in-game footage in the menus. It activates a separate launching program in order to start different emulators and run games directly from its main menu.

HyperSpin can be downloaded for free from the HyperSpin website. Or you can support their project by purchasing a support license subscription from another page on their site.


Developed by Unbroken Software, LaunchBox is a free-or-paid (but closed-source) all-in-one frontend for emulation and general PC gaming. It started out as a frontend for DOSBox, and slowly expanded to work with any kind of game that one may want to play on a PC (including emulated games and non-emulated games on platforms like Steam). In terms of aesthetics, LaunchBox is something of a middleground between the flashiness of HyperSpin and the clean simplicity of EmulationStation (and can look quite similar to either, depending on your settings).

The premium paid version sports additional customizability, additional visual resources, and a well-reviewed controller-friendly “Big Box” mode.

Launchbox can be downloaded for free from Unbroken’s website. Alternatively, you can purchase a $20 subscription (reduces to $10 after first year) or a $50 “forever-updates” license of the premium version from another page on their site.


Now developed by Alec Lofquist and Nils Bonenberger, EmulationStation is a free, clean, simple frontend program with native controller support—that works exceptionally well with RetroPie, for those of you with Raspberry Pi machines. The design of its menu is particularly suited to television displays.

An older, not-updated-since-2015 version of EmulationStation is also available for Windows and Debian desktop users (and every menu screenshot in this article was taken in the desktop version of EmulationStation, a custom installation of which is what I personally use as my frontend).

You can download EmulationStation for free from the EmulationStation website.


Developed by Andrew Mickelson, Attract-Mode is a free, open-source, lightweight frontend for command line emulators (such as MAME). It is fully controller-friendly, and is a perfect choice for an arcade cabinet set-up. And it is available on any operating system that you might want to use.

Attract-Mode can be downloaded for free from Mickelson’s website.



While not itself technically an emulator, RetroArch grants direct access to many emulators. Developed by The Libretro Organization, RetroArch is an open-source jack-of-all-trades program that is part-frontend, part-emulator, and part-media-player. Capable of running on a staggeringly huge number of platforms (if you include the various video game consoles on which it can run), RetroArch incorporates a variety of existing emulators as ‘cores’ in order to allow running a massive number of retro consoles from a single program. For the vast majority of retro consoles—including everything from Nintendo, Atari, SNK, Sega, Sony, and others between the 1970s and early 2000s—RetroArch is now the easiest and most recommended way to access emulators.

While it can be used behind a separate frontend like one of those mentioned above, RetroArch also has its own clean and elegant UI. Some of its other notable features include its consistent cross-console gamepad configuration, native save state support, and incorporation of shaders to allow the modifying of game visuals (for example: you can add a subtle CRT effect, so that retro titles look how they would have originally looked).

RetroArch can be downloaded for free from the RetroArch website. Or you can support their project by making a donation via another page on their site.


Dolphin is an open-source emulator for the Nintendo GameCube and the Nintendo Wii.

Dolphin can be downloaded for free from the Dolphin website.


PPSSPP is an open-source emulator for the Sony Playstation Portable.

PPSSPP can be downloaded for free from the PPSSPP website. Or you can show appreciation for their project by donating anywhere from $2.49 to $49 via another page on their site.

Citra (early in development)

Citra is an open-source emulator for the Nintendo 3DS.

Citra can be downloaded for free from the Citra website. They also accept support via donations through the “Patreon” menu item in the upper right of their site.

RPCS3 (early in development)

RPCS3 is an open-source emulator for the Sony Playstation 3.

RPCS3 can be downloaded for free from the RPSC3 website. They also accept support via donations or work contributions through the “Patreon” menu item in the upper right of their site.

Cemu (early in development)

Cemu is a closed-source emulator for the Nintendo Wii U.

Cemu can be downloaded for free from the Cemu website. Or you can show appreciation for their project by donating through Patreon via another page on their site.

Emulation PC Build


A great emulation PC is any PC that lets you emulate the games you want to emulate at the level of performance that you desire. But regardless of which level of emulation you want to do, put the weight of your resources toward your build’s CPU, followed (in order) by its RAM, GPU, and storage space.

Consider following one of the example builds above in section one, so that you can be sure that your build will be suited for its role and also reasonably balanced. And always check for compatibility between the programs you want to use and the hardware you want to buy. (We do our research here, but it would be almost impossible to check every possible combination of software and hardware on our own.)

Follow this guide, and in no time you’ll have a gaming PC up and running for emulation and retro gaming!

About Us

Daniel is the Content Editor for Logical Increments.

He also does all of the graphic design, writing, and web development for The Gemsbok blog website and The Gemsbok YouTube channel, where you can find articles and videos on literature, games, films, and philosophy.

Logical Increments helps more than 2 million PC builders each year with hardware recommendations for any budget.

If you want to see our build recommendations for general purpose gaming PCs, check them out!