An emulator is software (or hardware) that mimics another system, letting you run programs designed for one device on a completely different one. It works by translating instructions meant for the original system into instructions your current hardware can understand, essentially pretending to be something it’s not. The most common examples include running old video game console titles on a modern PC, testing mobile apps without a physical phone, and keeping decades-old business software alive on new computers.
How an Emulator Translates Instructions
Every processor speaks its own language, a set of basic instructions it knows how to execute. A Super Nintendo processor doesn’t speak the same language as your laptop’s processor. An emulator sits between the two and acts as a real-time translator.
The simplest approach is called interpretation. The emulator reads one instruction at a time from the original program, figures out what it means, then runs the equivalent operation on your hardware. It follows a straightforward loop: fetch an instruction, decode it, execute it, move to the next one. This works reliably but is slow because every single instruction goes through that decode step in software rather than running directly on the chip.
A faster method is binary translation. Instead of handling instructions one by one, the emulator converts entire blocks of the original program into new code your processor can run natively. Some emulators do this ahead of time, translating the whole program before it launches. Others use dynamic binary translation, converting chunks of code on the fly and caching the results so the same section doesn’t need translating twice. Apple’s Rosetta 2, which lets newer Mac chips run software built for older Intel Macs, uses ahead-of-time compilation like this. It translates the program once, stores the result, and runs it at near-native speed afterward.
Common Types of Emulators
Game Console Emulators
This is what most people picture when they hear the word “emulator.” Software like Dolphin (for GameCube and Wii) or PCSX2 (for PlayStation 2) recreates an entire console’s hardware on your PC. The emulator handles not just the CPU instructions but also the graphics chip, sound hardware, and memory management, converting each layer into something your computer can process. The goal is to let you play console games on hardware that has nothing in common with the original system.
Mobile Development Emulators
Android Studio includes a built-in emulator that simulates Android devices on your computer. Developers use it to test apps across a variety of screen sizes, hardware profiles, and Android versions without needing a closet full of physical phones. You can spin up virtual versions of phones, tablets, Wear OS watches, Android TV, and even Android Automotive systems. Each virtual device specifies the exact Android version and hardware characteristics to mimic, so developers can catch bugs that only appear on specific configurations.
Full System Emulators
Tools like QEMU emulate an entire computer, including the processor, memory, storage controllers, and network hardware. Every time you start it, you’re booting a complete virtual machine that thinks it’s running on real hardware. This lets you run an entirely different operating system, or even an OS built for a different processor architecture, inside a window on your desktop.
Enterprise and Legacy Emulators
Businesses and government agencies use emulators to keep old software running long after the original hardware has been retired. Maryland’s Department of Information Technology, for example, uses a mainframe emulator called TN3270 to connect modern PCs to legacy mainframe systems. Many organizations built critical databases and applications on hardware from the 1970s and 1980s that no longer exists. Rather than rewrite millions of lines of code, they emulate the old environment on current machines.
Emulation vs. Virtualization vs. Simulation
These three terms get mixed up constantly, but they describe different things. An emulator recreates foreign hardware in software, translating instructions from one architecture to another. If you’re running a Super Nintendo game on a PC, every instruction the original console would have processed is being converted into something your processor understands. The original software has no idea it’s not running on real hardware.
Virtualization is different because the guest and host share the same processor architecture. A virtual machine running Windows on a Windows server doesn’t need to translate CPU instructions at all. The processor runs the guest code directly, and a thin software layer just manages resource sharing. This makes virtualization significantly faster than emulation for compatible systems.
Simulation models behavior without trying to run real software. A network simulator, for instance, mimics how data packets move through a network using code that replicates the physics and protocols involved. It’s not executing actual router firmware. It’s purely mathematical modeling. No instruction translation happens.
Software Emulation vs. FPGA Hardware Emulation
Most emulators are software running on general-purpose processors, but there’s a hardware alternative: FPGA (field-programmable gate array) devices. An FPGA is a chip that can be rewired to physically replicate the circuits of another processor. Instead of translating instructions through software, the FPGA becomes the original hardware at an electrical level.
The practical difference comes down to timing accuracy and input lag. Software emulators often rely on USB for controller connections, which introduces polling delays that don’t exist on original hardware. They also use shortcuts to maintain performance on less powerful systems, which can cause subtle timing differences. FPGA implementations run at the bare metal level with zero software overhead, making them cycle-accurate: every operation happens in exactly the same number of clock ticks as the original hardware.
For most casual users, the difference is imperceptible. But for rhythm games, fast-paced arcade titles, and anything where frame-perfect input matters, FPGA emulation is noticeably more responsive. Hardware enthusiasts often describe FPGA devices like the Analogue Pocket or MiSTer as indistinguishable from playing on the original console. The tradeoff is cost and complexity. Achieving the same cycle-accurate results through software emulation is possible but requires significantly more processing power.
The Legal Side of Emulation
Emulator software itself is legal. The code must be developed independently, without copying proprietary components from the original manufacturer. Courts have consistently upheld this. In a notable case involving Sony and the developers of the PS2 emulator PCSX2, the court ruled that reverse-engineering a system for compatibility purposes falls under fair use, as long as no copyrighted firmware or BIOS files are distributed with the emulator.
Where legality gets complicated is with the game files (ROMs) and system firmware (BIOS files) that emulators need to actually run anything. Downloading commercial game ROMs without owning the original cartridge or disc typically violates copyright law. Nintendo, Microsoft, and other console manufacturers have aggressively enforced this position. In 2023, Nintendo won a $12 million judgment against a major ROM distribution site for facilitating mass copyright infringement.
U.S. copyright law does allow making a backup copy of software you own for archival purposes under Section 117 of the Copyright Act. But this provision doesn’t explicitly cover ripping a game cartridge to a digital file, and the legal boundaries vary by country. The safe rule of thumb: the emulator is legal, but the games and system files you load into it carry their own copyright restrictions.
Why Emulators Matter
Emulators solve a fundamental problem in computing: hardware doesn’t last forever, but the software people depend on often needs to. Game preservation communities use emulators to keep thousands of titles playable long after the original consoles stop working. Developers use them to test software across dozens of device configurations without buying physical hardware. Businesses use them to avoid rewriting critical systems every time they upgrade their infrastructure. At every level, emulators bridge the gap between the system software was built for and the hardware that’s actually available today.