Although I assembled it myself, and its software all comes from an open-source DIY project, in many ways my MiSTer is the most versatile computer I own. It’s a shapeshifting wonderbox that can change its own logic to make itself run like countless other machines as accurately as possible. From old arcade boards to early PCs to vintage consoles, MiSTer developers are devoted to helping it turn into an ever-expanding range of hardware.
If you’ve ever wanted to use computer software or hardware that is no longer available for sale, you’ve probably run into emulation before. It’s a huge field that often involves a ton of people working on a technically challenging feat: how to write software that lets one computer run code that was written for another. But there’s only so much traditional emulators can do. There are always inherent compromises and complexities involved in getting your current hardware to run software it was never designed to handle. Emulated operating systems or video games often encounter slowdown, latency, and bugs you’d never have encountered with the original devices. So what if there was a way to alter the hardware itself?
Well, that’s MiSTer. It’s an open-source project built upon field-programmable gate array (FPGA) technology, which means it makes use of hardware that can be reconfigured after the fact. While traditional CPUs are fixed from the point of manufacture, FPGAs can be reprogrammed to work as if they came right off the conveyor belt with the actual silicon you want to use.
What this means is, you’re not tricking a processor into believing it’s something else, you’re setting it up to run that way from the start. A MiSTer system can theoretically run software from the NES to the Neo Geo, to the Apple II or Acorn Archimedes, and deliver responsive, near-as-dammit accurate performance next to what you’d get from the actual devices.
Of course, it’s not as easy as that makes it sound. In order to program an FPGA to act like a computer from three decades ago, you have to intimately understand the original hardware. And that’s what makes MiSTer one of the technically coolest DIY projects going today, building on the knowledge of developers around the globe.
FPGAs aren’t new technology. Two early companies in the field (sorry) were Altera, now owned by Intel, and Xilinx, now part of AMD. The two have competed since the 1980s for market share in programmable logic devices, largely serving enterprise customers. One of the biggest advantages of FPGAs on an industrial scale is that companies can iterate their software design on hardware before they need to manufacture the final silicon. FPGAs are widely used to develop embedded systems, for example, because the software and the hardware can be designed near-concurrently.
You might be familiar with FPGAs if you’ve come across Analogue’s boutique console clones, like the Mega Sg and the Super Nt. Those use FPGAs programmed in a certain way to replicate a single, specific piece of hardware, so you can use your original physical cartridges with them and get an experience that’s very close to the actual consoles.
The MiSTer project is built around more accessible FPGA hardware than you’d find in commercial or enterprise applications. The core of the system is an FPGA board called the DE10-Nano, produced by another Intel-owned company called Terasic that’s based out of Taiwan. It was originally intended for students as a way to teach themselves how to work with FPGAs.
The DE10-Nano looks somewhat similar to a Raspberry Pi — it’s a tiny motherboard that ships without a case and is designed to be expanded. The hardware includes an Altera Cyclone V with two ARM Cortex-A9 CPU cores, 1GB of DDR3 SDRAM, an HDMI out, a microSD card slot, a USB-A port, and Ethernet connectivity. It runs a Linux-based OS out of the box and sells for about $135, or $99 to students.
MiSTer is inspired by MiST, an earlier project that made use of an Altera FPGA board to recreate the Atari ST. But the DE10-Nano is cheaper, more powerful, and expandable, which is why project leader Alexey Melnikov used it as the basis for MiSTer when development started a few years back. Melnikov also designed MiSTer-specific daughterboards that enhance the DE10-Nano’s capability and make a finished machine a lot more versatile; the designs are open-source, so anyone is free to manufacture and sell them.
You can run MiSTer on a single DE10-Nano, but it’s not recommended, because the board alone will only support a few of the cores available. (A “core” is a re-creation of a specific console or computer designed to run on the MiSTer platform.) The one upgrade that should be considered essential is a 128MB stick of SDRAM, which gives MiSTer enough memory at the right speed to run anything released for the platform to date.
Beyond that, you’ll probably want a case, assuming you’d rather not run open circuitry exposed to the elements. There are various case designs available, many of which are intended for use with other MiSTer-specific add-ons that vertically attach to the DE10-Nano. An I/O board isn’t necessary for most cores, for example, but it adds a VGA port along with digital and analog audio out, which is useful for various setups. (A lot of MiSTer users prefer to hook up their systems to CRT TVs to make the most of the authentic output and low latency.) You can add a heatsink or a fan, which can be a good idea if you want to run the system for extended periods of time. And there’s a USB hub board that adds seven USB-A ports.
For my setup, I ordered the DE10-Nano, a 128MB SDRAM stick, a VGA I/O board with a fan, a USB hub board, and a case designed for that precise selection of hardware. These largely came from different sources and took varying amounts of time to show up; you can order the DE10-Nano from countless computer retailers, but other MiSTer accessories involve diving into a cottage industry of redesigns and resellers. Half of my parts arrived in a battered box from Portugal filled with shredded paper and loosely attached bubble wrap.
MiSTer accessories are based on Melnikov’s original designs, but since the project is open-source, many sellers customize their own versions. My case, for example, includes a patch cable that hooks directly into the IO board to control its lighting, while some others require you to route the LEDs yourself. The USB board, meanwhile, came with a bridge to the DE10-Nano that seemed to be a different height from most others, which meant I had to improvise a little with screw placements. Nothing I ordered came with instructions, so it did take some time to figure out what should go where, but everything worked fine in the end. The only other thing I had to do was go buy a small hex screwdriver for the final screws in the case.
That’s part of the fun with MiSTer. There’s a base specification that everything works around, but you’re still ultimately assembling your own FPGA computer, and you can adjust the build as much or as little as you want.
Once your hardware is set, you need to install the MiSTer software. There are a few ways to do this, and you’ll want to dig around forums and GitHub for a while so you know what you’re doing, but the method I went with was simple in the end — essentially, you format your microSD card with an installer package, put it into the DE10-Nano, plug in an Ethernet cable and a USB keyboard, power on the system, and it’ll download all of the available cores. Your SD card will then be set up to boot the MiSTer OS directly, and you can run another script to make sure everything’s updated with the most recent versions.
The MiSTer OS is very simple, with a default background that looks like pixelated TV static and a basic menu in a monospaced font that lets you select from lists of console and computer cores. The first thing I did was load some old Game Boy Advance ROMs I dumped well over a decade ago, because for some reason Nintendo doesn’t want to sell them for the Switch. (Please sell them for the Switch, Nintendo.) The performance felt about as authentic as I could’ve expected, except for the fact that I was looking at a 4K TV instead of a tiny screen.
My main reason for getting into MiSTer is to have a hardware-based way to access the parts of computer history that I missed, or to revisit forgotten platforms that I was around for. I knew that computer systems like the Apple II and the Amiga were big gaps in my knowledge, so it’s great to have a little box that can run like either of them on command. I’ve also been getting into the MSX platform, which was popular in Japan in the ’80s. My next rainy-day project is to work on an install of RISC OS, the Acorn operating system that was on the first computers I ever used at school in the UK. (You can actually still buy licensed ROM copies of various versions of the OS, which was a neat surprise.)
MiSTer development is a vibrant scene. Melnikov has a Patreon that’s updated several times a week with improvements he’s made to various cores, but there are lots of other people contributing to the project on a daily or weekly basis. A colleague introduced me to the work of Jose Tejada, for example, who’s based in Spain and has made a ton of progress on replicating old Capcom arcade machine boards. There’s another project aiming to get the original PlayStation running, marking the biggest step yet into 3D hardware on MiSTer.
FPGAs are often talked about as if they’re a silver bullet for perfect emulation, but that’s really not the case — at least, not without a lot of effort. Anything that runs perfectly on MiSTer, or as close to perfectly as is otherwise imperceptible, is the result of a ton of work by talented programmers who have spent time figuring out the original hardware and applying the knowledge to their cores. Just read this post from the FPGA PSX Project about what it took to get Ridge Racer running on MiSTer, as well as the assessment of how far they have to go. The cores can vary in quality, accuracy, and state of completion, but a lot of them are still under active development and huge strides have been made in the past couple of years.
Analogue lead hardware engineer Kevin Horton spoke to The Verge in 2019 about the work that went into re-creating the Sega Genesis for the Mega Sg console. The process took him nine months, including two-and-a-half months figuring out the CPU at the heart of the console. “I didn’t know Genesis very well, and knew literally nothing about the 68000 CPU at all!” he said. “This was my first foray into both things and probably slowed the process down since I had to learn it all as I went.”
Ultimately, Horton confirmed the accuracy of his work by directly connecting a 68000 to an FPGA and comparing their performance on a test that ran for a week straight. It demonstrates the lengths that FPGA enthusiasts go to in pursuit of the most accurate results possible, but what makes MiSTer special is that this is largely the work of hobbyists. No one’s paying anyone a salary to make incremental tweaks to the performance of the arcade version of Bionic Commando, but that’s where Tejada has directed his passion.
MiSTer is an important project because it speaks to the concept of preservation in a way that all too often goes underserved by the technology industry. The project makes the argument that the way we run software is as big a part of our experience as its content. Yes, you can port or emulate or re-release software to run on modern hardware, but there’s always going to be a compromise in the underlying code that moves the pixels in front of your eyes.
Of course, that might sound like a pretty niche concern for anyone who’s satisfied with, say, the emulated software you can run in a browser at Archive.org. I’m often one of those people myself — emulation can be great, and it’s hard to beat the convenience. But the MiSTer project is an incredible effort all the same. I’ll never have a shred of the technical knowledge possessed by MiSTer developers, but I’m grateful for their effort. Once you build your own system, it’s hard not to feel invested in the work that goes into it; MiSTer is a never-ending pursuit of perfection, and there’s something beautiful about that.
Photography by Sam Byford / The Verge