How Game Emulation Works: Running Classic Hardware on Modern Systems

The Magic of Emulation

Press a button on an emulator, and decades-old hardware springs to life on your modern device. A Super Nintendo game runs on your phone. A Sega Genesis title plays in your browser. Arcade cabinets live again on your PC.

This isn't magic—it's emulation, one of computing's most fascinating technical challenges. Let's explore how it works.

What Is Emulation?

Emulation is software that replicates hardware functionality. An emulator creates a virtual environment mimicking original gaming systems, allowing programs designed for that hardware to run on completely different systems.

The Challenge

Original game systems used custom processors, unique graphics chips, specialized audio hardware, and proprietary memory architectures. Games were written in machine code targeting specific hardware.

To run these games on modern systems requires recreating every component's behavior in software—down to CPU cycle timing, graphics rendering quirks, and audio synthesis characteristics.

The Core Components

1. CPU Emulation

The Central Processing Unit is the system's brain. Classic consoles used various CPUs:

• NES: Ricoh 2A03 (6502-based, 1.79 MHz)
• SNES: Ricoh 5A22 (65C816, 3.58 MHz)
• Sega Genesis: Motorola 68000 (7.6 MHz)
• Game Boy: Custom Sharp SM83 (4.19 MHz)

The Emulation Challenge:
Modern CPUs use completely different architectures. Intel x86, ARM, and other modern processors don't natively understand these old instruction sets.

The Solution:
Emulators implement virtual CPUs that:

1. Fetch instructions from game ROM
2. Decode what operation is requested
3. Execute that operation on virtual hardware
4. Update system state accordingly

For each vintage CPU instruction, the emulator runs equivalent modern CPU code producing the same result.

Example:
When an NES game executes "LDA #$05" (Load Accumulator with value 5):

Original Hardware: One CPU instruction (3 cycles)
Emulator: Fetch instruction → Decode → Set register → Update cycle count (dozens of modern CPU instructions)

2. Memory Management

Classic systems had distinct memory regions:

NES Example:

• 2KB internal RAM
• Cartridge ROM (program code)
• PPU VRAM (graphics)
• OAM (sprite data)
• Mapper registers (advanced cartridges)

Emulation Approach:
Create virtual memory spaces with distinct behaviors:

class NESMemory {
  ram = new Uint8Array(2048);
  rom = null; // Loaded from game file
  ppu = new PPUMemory();
  
  read(address) {
    if (address < 0x2000) {
      return this.ram[address % 0x800]; // RAM mirrors
    } else if (address >= 0x8000) {
      return this.rom[address - 0x8000]; // Cartridge ROM
    }
    // Handle other regions...
  }
}

Each memory access checks the address and routes to appropriate virtual component.

3. Graphics Emulation

This is often the most complex part.

Original Hardware:
Classic systems used dedicated graphics chips (PPUs, VDPs) with unique capabilities:

• Tile-based rendering
• Sprite systems with size/priority limits
• Hardware scrolling
• Color palettes
• Scanline rendering

Example: NES PPU
The NES Picture Processing Unit (PPU) renders 240 scanlines of 256 pixels each, 60 times per second. It supports:

• Two background layers (nametables)
• 64 sprites (8x8 or 8x16 pixels)
• 52 colors (but only 25 on-screen simultaneously)

Emulation Approach:
Recreate graphics chip behavior, then output to modern graphics APIs:

1. Emulate original rendering - Simulate scanline-by-scanline rendering, sprite limitations, palette restrictions
2. Generate framebuffer - Create a virtual screen matching original resolution
3. Scale and display - Use modern APIs (OpenGL, WebGL) to scale and display on modern screens

Performance Trick:
Instead of emulating every single clock cycle of graphics rendering (extremely slow), emulators often use "fast rendering" that produces identical visual output more efficiently.

4. Audio Emulation

Classic game audio used specialized chips synthesizing sound:

NES Audio (2A03 APU):

• 2 pulse wave channels
• 1 triangle wave channel
• 1 noise channel
• 1 DMC sample channel

SNES Audio (SPC700):

• 8-channel ADPCM sample playback
• Hardware effects (echo, filtering)

Emulation Approach:
Simulate each audio channel's waveform generation, mix channels, and output to modern audio APIs (Web Audio, DirectSound, etc.).

Timing Challenge:
Audio must stay synchronized with gameplay. If emulation runs too fast or slow, audio pitch changes or crackling occurs. Careful timing management is crucial.

5. Input Handling

Original controllers connected to specific input ports with defined protocols.

Emulation Approach:
Map modern inputs (keyboard, gamepad, touch) to virtual controller states:

class Controller {
  buttonStates = {
    up: false, down: false, left: false, right: false,
    a: false, b: false, start: false, select: false
  };
  
  handleInput(modernInput) {
    // Map modern input to virtual controller
    this.buttonStates.a = modernInput.isPressed('Space');
    // etc...
  }
  
  readState() {
    // Game reads controller state
    // Return virtual button states
  }
}

Timing: The Hardest Problem

Getting timing right is emulation's greatest challenge.

Why Timing Matters

Original hardware ran at precise speeds:

• NES CPU: 1.789773 MHz (exactly)
• Frame rate: 60.0988 FPS (NTSC)
• Scanline timing: 341 PPU cycles

Games were programmed expecting this exact timing. Off by even a fraction, and:

• Games run too fast or slow
• Animations stutter
• Music pitch shifts
• Physics breaks
• Bugs appear that didn't exist on real hardware

Cycle-Accurate Emulation

The Gold Standard:
Emulate every single hardware cycle. If the original CPU took 7 cycles to execute an instruction, the emulator takes 7 virtual cycles.

Advantages:

• Maximum accuracy
• Handles edge cases and obscure behavior
• Games work exactly as on real hardware

Disadvantages:

• Computationally expensive
• May be overkill for most games

High-Level Emulation (HLE)

The Pragmatic Approach:
Instead of emulating every cycle, identify what the hardware accomplished and reproduce results more efficiently.

Example:
Rather than emulating every audio DSP cycle, detect when game uploads audio data and use modern audio APIs to play it directly.

Advantages:

• Much faster
• Works well for most games

Disadvantages:

• May miss edge cases
• Doesn't work for games using hardware unusually

Hybrid Approaches

Modern emulators often blend techniques:

• Cycle-accurate CPU emulation
• HLE for audio/video where possible
• Cycle-accurate fallback when HLE fails

Mapper Emulation

What Are Mappers?

Original game cartridges weren't just ROM chips. Many included additional hardware:

• Memory bank switching (accessing more ROM than addressable)
• Save RAM with battery backup
• Extra audio chips
• Real-time clock chips

These chips (called "mappers") need emulation too.

Example: MMC3 (Most common advanced NES mapper):

• Bank switching for large games
• IRQ generation for split-screen effects
• Powered hundreds of NES games

Emulator must understand each mapper's behavior to run games using it.

Save State Technology

One of emulation's killer features: save states.

How It Works:
Capture complete system state:

• All RAM contents
• All CPU registers
• All PPU/GPU registers
• Controller states
• Audio system state
• Cycle counters

Serialize this data to a file. To restore, deserialize and load everything back.

Why Original Hardware Couldn't Do This:
Too much state data to store quickly. Modern systems have fast storage and abundant RAM, making save states practical.

Performance Optimization

Why Emulation Is Resource-Intensive

For each original CPU cycle, modern CPUs execute dozens or hundreds of instructions. A simple NES instruction might require:

1. Check program counter
2. Fetch instruction from virtual memory
3. Decode opcode
4. Update virtual registers
5. Check for interrupts
6. Update cycle counters
7. Synchronize with PPU
8. Update audio buffers

Multiply this by millions of cycles per second, and emulation becomes demanding.

Optimization Techniques

JIT (Just-In-Time) Compilation:
Instead of interpreting each instruction, dynamically compile game code to native machine code. Dramatically faster but more complex.

Cached Translation:
Translate frequently executed code blocks once, cache results, reuse when encountered again.

Parallel Processing:
Run CPU, audio, and graphics emulation on separate threads where possible.

WebAssembly (for browser emulation):
Compile emulator to WebAssembly for near-native performance in browsers.

Accuracy vs. Performance

Emulation requires balancing accuracy with performance.

Perfect Accuracy:

• Emulate every hardware quirk
• Cycle-accurate timing
• Hardware bug reproduction
• Requires powerful hardware

Good Enough:

• Emulate what games typically use
• Close enough timing
• Skip obscure edge cases
• Runs on modest hardware

Most users prefer "good enough" emulation that runs smoothly over perfect accuracy requiring expensive hardware.

Browser-Based Emulation Challenges

Running emulators in web browsers adds unique challenges:

JavaScript Performance:
JavaScript is slower than compiled languages. WebAssembly helps but isn't always sufficient.

Audio Latency:
Web Audio API has higher latency than native audio systems. Careful buffering is required.

Input Handling:
Browser input events add latency. Polling gamepad state directly helps.

Storage Limitations:
Browser storage has quotas. Save states and saves must fit within limits.

Security Restrictions:
Browsers limit certain operations for security. Emulators must work within these constraints.

Solution:
Modern emulators use:

• WebAssembly for CPU-intensive code
• WebGL for graphics acceleration
• Careful audio buffering
• Gamepad API for responsive input
• IndexedDB for save storage

Why Emulation Matters for Preservation

Original hardware fails eventually:

• Capacitors dry out
• Solder joints crack
• Batteries in cartridges die
• Optical drives degrade

Emulation preserves games independently of deteriorating hardware. As long as ROM data survives, emulation enables playing games forever.

The Legal Landscape

Emulators Themselves: Generally legal. Creating software that mimics hardware isn't copyright infringement.

Game ROMs: Complicated. Copyright still applies. Distributing copyrighted ROMs without permission is illegal in most jurisdictions.

Personal Use: Gray area. Laws vary by country regarding backups of owned games.

Preservation Argument: Many advocate for legal exemptions for preservation purposes when original hardware is no longer available.

Different Types of Emulators

Console Emulators

Focus on specific systems (NES, SNES, etc.). Optimized for accuracy and performance on that particular hardware.

Multi-System Emulators

Handle multiple similar systems (all Game Boy variations, all Sega consoles).

Arcade Emulators (MAME)

Emulate thousands of arcade boards. Especially complex due to unique hardware per game.

High-Level Emulators

Emulate game functionality without simulating hardware precisely. Faster but less compatible.

Cycle-Accurate Emulators

Perfect hardware simulation. Slower but handles edge cases.

The Future of Emulation

Machine Learning:
AI could potentially learn to emulate hardware by observing behavior, without knowing internal implementation.

FPGA "Emulation":
Hardware recreation using FPGAs (Field-Programmable Gate Arrays). Not software emulation but similar preservation goals.

Cloud Emulation:
Run emulators on powerful servers, stream to any device. Eliminates performance concerns.

Improved Accuracy:
As understanding deepens and hardware improves, emulation accuracy continues advancing toward perfection.

Conclusion

Game emulation is a remarkable technical achievement. It allows vintage game code—written for long-obsolete hardware—to run on modern systems with near-perfect accuracy.

By recreating entire computer systems in software, emulators preserve gaming history and make classic games accessible to new generations. This technical wizardry ensures that great games aren't lost to hardware obsolescence.

Understanding how emulation works deepens appreciation for both the original hardware engineers' cleverness and modern emulator developers' skill in recreating it.

Experience the result of this technical achievement. Play emulated classics on Innovatex.one and explore gaming history preserved through software.