There are two ways to make an old console run on modern hardware, and they couldn’t be more different. Software emulation translates the original machine’s behavior into code, one processor instruction at a time, running on a general-purpose CPU. FPGA replication rebuilds the machine itself, cycle by cycle, inside reconfigurable logic that behaves the way physical chips behaved. One approach simulates what the computer does; the other attempts to be the computer.
By 2026, this debate has outgrown its enthusiast forum origins. Software emulation on a modern PC is nearly free, visually excellent, and covers more systems than any hardware solution ever could. MiSTer FPGA, meanwhile, has matured into a complete ecosystem with hundreds of cores, add-on boards, and a user base that extends well beyond its original retro-gaming niche. The honest question is no longer which side is “right” — it’s which definition of “closest to the original” you care about, because the two approaches win on different measurements.
What each approach actually is
The comparison only makes sense when both sides are understood on their own terms. Software emulation reads the game’s instructions and executes them through a program that imitates the console’s processors. Modern emulators achieve remarkable accuracy through cycles where each CPU instruction’s timing is matched to reference hardware — some console emulators now reproduce behavior down to the clock cycle. The flexibility is enormous: any PC can run dozens of systems, save states let you rewind mistakes, shaders add CRT effects on any display, and netplay connects players across continents.
MiSTer FPGA takes the opposite route. Its DE10-Nano board houses a field-programmable gate array, and each console is recreated as a hardware description that gets compiled onto the chip. The processor, memory, video output, and audio generation all exist as logic circuits replicating the original silicon’s behavior in real time. When an FPGA core claims cycle accuracy, the claim is structurally different from an emulator’s: the chip isn’t interpreting the machine, it’s reconstructing the machine’s own components in digital logic.
The distinction matters for two measurements that fuel most debates. Latency — the delay between your input and the action appearing on screen — is genuinely lower on FPGA hardware, typically by one to three frames in practice. And compatibility with peripherals, unlicensed games, and edge cases tends to be higher on FPGA, because hardware doesn’t take shortcuts the way software sometimes does. But both advantages come with costs that software emulation avoids entirely.
Where the gap actually shows
Twenty years of emulator development has narrowed the practical gap dramatically. For most games, on most systems, on a decent modern PC, software emulation and FPGA are indistinguishable in blind testing — the differences live in the remaining five percent of situations where timing edge cases, uninitialized memory states, or per-console hardware quirks produce visible or audible discrepancies. The systems where FPGA still clearly leads are well understood:
- Systems with complex custom co-processors. Titles relying on enhancement chips — the Super FX in certain Super Nintendo releases, the Sega 32X’s dual-CPU architecture, cartridge-level audio synthesis — run correctly on FPGA cores and occasionally misbehave in emulators that approximate rather than replicate the coprocessing.
- Arcade boards with interleaved logic. Arcade cores on MiSTer replicate mid-frame processor interleaving that produces subtle synchronization effects; a handful of games depend on this timing, and their emulator equivalents remain approximations.
- Peripherals and edge-case titles. Unlicensed games, development tools, and accessories that probe hardware directly — testing uninitialized memory, exploiting bus timing — behave identically on FPGA and unpredictably on software.
- Original signal chain reproduction. FPGA cores output video through analog stages that mirror what a CRT would receive, which matters for light-gun compatibility and for those who capture signals for archival purposes.
For everything outside these categories — the vast majority of popular titles across every major system — software emulation in 2026 delivers what most players will perceive as the same experience. The accuracy argument, once a genuine dividing line, has narrowed to specific technical niches.
The full comparison
Deciding between the approaches requires weighing factors beyond accuracy alone. Cost, upgrade path, game library breadth, input latency, and long-term maintenance all differ substantially between FPGA hardware and PC-based emulation. The practical picture looks like this:
| Factor | MiSTer FPGA | Software emulation (PC) |
|---|---|---|
| Startup cost | Significant; base board plus I/O boards and storage | Near zero; any existing PC qualifies |
| System coverage | Dozens of cores; strongest in 8/16-bit and arcade | Hundreds of systems, including newer consoles |
| Input latency | Lowest practical; deterministic hardware timing | One to three frames higher on average; tunable |
| Accuracy edge cases | Cycle-level reproduction of original logic | Excellent, occasionally approximate on complex systems |
| Save states | Limited on some cores; growing support | Universal, with rewind and frame-advance |
| Display flexibility | CRT output via analog add-ons; HDMI with scaling | Full modern display support with shader correction |
| Maintenance | Community-driven; cores update irregularly | Active projects with frequent releases |
| Learning curve | Hardware setup and core configuration | Familiar PC interface; per-core settings |
The table’s most consequential row is the first: cost. MiSTer’s entry price — the base board, a suitable power supply, I/O boards for controllers and analog output — buys a dedicated machine with a fixed ceiling on what it can become. The same money invested in a mid-range PC provides emulation for far more systems, better visual customization, and continuous improvement through emulator updates. These are not just different products; they represent different philosophies about what preservation means.
Latency: the measurement that actually divides
Of all the technical claims surrounding FPGA, input latency attracts the most scrutiny because it’s measurable and it affects play directly. The best software emulators with run-ahead features — techniques that skip ahead in emulation to eliminate the delay of processing one frame — approach FPGA latency within a fraction of a frame. Run-ahead works by emulating several frames ahead and discarding the intermediate state, effectively removing one to two frames of lag on systems where the technique is stable.
FPGA latency is structurally lower because there’s no software layer between the input and the response. The chip receives the button press, the logic evaluates it on the next clock cycle, and the result appears in the same frame as the press would have on original hardware. In competitive contexts — speedrunning precision platforms, fighting games with tight cancel windows — this one-to-three frame difference is genuine and perceptible. In single-player adventure games or turn-based titles, it’s invisible.
The nuance worth internalizing: latency advantage isn’t universal across FPGA. Core quality varies; some cores add their own frame of buffering in audio or video processing. The most latency-sensitive players already know this, and it’s part of why core selection on MiSTer tends to be more deliberate than emulator selection on PC.
The peripheral and authenticity question
Software emulation has largely solved the visible side of retro gaming — the picture, the sound, the save state convenience — but the invisible side remains stubborn: how a console interacts with its accessories. FPGA cores handle most original controllers, light guns, memory cards, and link cables without configuration, because the hardware reproduces the bus that those accessories plug into. Some peripherals — specific multitaps, obscure third-party adapters, regional cartridge variants — work identically on FPGA and struggle in emulation.
This matters differently depending on the player. For someone playing through a library of classic titles with a modern controller, none of this is relevant. For someone running a commercial collection, a museum exhibit, or a speedrunning event with strict verification rules, the difference between emulated and hardware-replicated input can determine whether the setup is accepted as legitimate.
There’s also the question of what happens to the original machine. FPGA replication, done thoroughly, preserves the original’s behavior even if the original hardware fails — the chip becomes a functional archive. Software emulation preserves the behavior too, but through a different kind of record: a written description that depends on ongoing development to interpret correctly. Both are legitimate preservation; neither is complete on its own.
Cost, complexity, and the hidden trade-offs
Neither approach is free of friction. The real considerations each brings:
- FPGA hardware investment. Beyond the entry price, MiSTer’s ecosystem involves add-on boards for specific consoles, cooling solutions, storage, and occasional updates that require technical patience. Total cost of a fully configured system approaches that of a mid-tier gaming PC — with a fraction of its flexibility.
- Emulator configuration burden. Modern emulation frontends have simplified setup dramatically, but per-game tweaks, shader selection, and controller calibration still require occasional tinkering; the reward is near-total control over the experience.
- Game library differences. FPGA cores excel in earlier consoles and arcade systems; software emulation covers everything from the 1970s through current-generation consoles. Anyone whose interests extend into 3D and modern-era titles has no FPGA equivalent for those systems at all.
- Community support structures. Emulator projects ship documentation, wikis, and active forums with predictable update cadences. FPGA cores depend on a smaller community of developers, and some cores have gone dormant — a risk to consider when investing in specific hardware add-ons.
These trade-offs explain why the communities rarely convert each other. The players who value flexibility, breadth, and customization stay on PC; those who value determinism, authenticity, and physical hardware stay on FPGA. Both positions are internally consistent; the disagreement is over what the word “original” means.
What changed by 2026
Both ecosystems have evolved in ways that make direct comparison harder than it was five years ago. On the software side, run-ahead, per-frame audio synchronization, and cycle-accurate cores for systems once considered impossible — certain earlier handhelds, specific arcade boards — have closed the gap on the remaining technical advantages FPGA held. The accuracy ceiling of software emulation has risen to the point where the two approaches overlap for most practical purposes.
On the hardware side, MiSTer’s ecosystem has expanded well beyond its original scope: more systems, better audio fidelity in later cores, improved video output options, and a distribution process that makes core installation as simple as copying files. The project’s longevity is itself a signal — nearly a decade of continuous community development has produced a library of cores that covers the systems where hardware replication delivers the clearest benefit.
The result is a landscape where the honest answer to “which is closer to the original” is “both, in different ways.” Software emulation reproduces the machine’s behavior in software, with extraordinary precision and total flexibility. FPGA reproduction rebuilds the machine’s logic in hardware, with deterministic timing and genuine peripheral compatibility. Neither fully replaces the other, and neither fully represents the original experience — which is why the question is ultimately personal rather than technical.
Making the decision
The practical framework for choosing between the two is less about which is objectively better and more about which measurement you prioritize. The considerations that typically decide it:
- If breadth and flexibility matter most, software emulation wins decisively: one PC covers hundreds of systems, supports every modern controller and display, and improves continuously through active development.
- If timing precision and hardware authenticity matter most, MiSTer FPGA delivers measurable advantages: lower latency, cycle-accurate behavior, and peripheral compatibility that software cannot fully replicate.
- If cost is the primary constraint, emulation requires only hardware you likely already own, while a functional FPGA setup represents a meaningful investment dedicated to a single purpose.
- If the goal is archival or verification-grade play, FPGA’s deterministic behavior and signal reproduction make it the preferred choice in contexts where “this behaves exactly like the original” is a requirement rather than a preference.
Most enthusiasts eventually own both, and that’s not indecision — it’s recognition that each tool excels where the other doesn’t. The PC is the universal translator of retro gaming; the FPGA is the archive that preserves the original’s logic in silicon. Keeping both, for anyone deeply invested in the hobby, is less a duplication of effort than a recognition that preservation and practicality occasionally pull in different directions.
The verdict: different definitions of “closest”
The FPGA-versus-emulation debate persists because both sides are correct about what they measure. Software emulation in 2026 delivers accuracy that satisfies the overwhelming majority of players, at a cost that approaches nothing, across a library that no hardware solution can match. MiSTer FPGA delivers timing, compatibility, and authenticity in a form that software cannot structurally reproduce — for the specific systems where those advantages matter.
“Closest to the original” is the wrong question in the abstract and the right question in the particular. For a casual player revisiting their childhood library on a laptop, software emulation is the original experience, reconstructed invisibly. For a speedrunner chasing hundredths of a second, for an archivist documenting peripheral behavior, for a purist running a CRT from an analog output — FPGA is the only option that truly behaves like the hardware it replaces.
The healthiest way to think about the two approaches isn’t as competitors but as complementary answers to the same preservation problem. Software keeps the machines alive in code; FPGA keeps them alive in logic. Together, they ensure that a forty-year-old console’s behavior remains reproducible long after the last working original has failed — and for a hobby built entirely around those machines, that’s the outcome both camps were ultimately working toward.