How do emulators work and how are they written? [closed]

Emulation is a multi-faceted area. Here are the basic ideas and functional components. I’m going to break it into pieces and then fill in the details via edits. Many of the things I’m going to describe will require knowledge of the inner workings of processors — assembly knowledge is necessary. If I’m a bit too vague on certain things, please ask questions so I can continue to improve this answer.

Basic idea:

Emulation works by handling the behavior of the processor and the individual components. You build each individual piece of the system and then connect the pieces much like wires do in hardware.

Processor emulation:

There are three ways of handling processor emulation:

  • Interpretation
  • Dynamic recompilation
  • Static recompilation

With all of these paths, you have the same overall goal: execute a piece of code to modify processor state and interact with ‘hardware’. Processor state is a conglomeration of the processor registers, interrupt handlers, etc for a given processor target. For the 6502, you’d have a number of 8-bit integers representing registers: A, X, Y, P, and S; you’d also have a 16-bit PC register.

With interpretation, you start at the IP (instruction pointer — also called PC, program counter) and read the instruction from memory. Your code parses this instruction and uses this information to alter processor state as specified by your processor. The core problem with interpretation is that it’s very slow; each time you handle a given instruction, you have to decode it and perform the requisite operation.

With dynamic recompilation, you iterate over the code much like interpretation, but instead of just executing opcodes, you build up a list of operations. Once you reach a branch instruction, you compile this list of operations to machine code for your host platform, then you cache this compiled code and execute it. Then when you hit a given instruction group again, you only have to execute the code from the cache. (BTW, most people don’t actually make a list of instructions but compile them to machine code on the fly — this makes it more difficult to optimize, but that’s out of the scope of this answer, unless enough people are interested)

With static recompilation, you do the same as in dynamic recompilation, but you follow branches. You end up building a chunk of code that represents all of the code in the program, which can then be executed with no further interference. This would be a great mechanism if it weren’t for the following problems:

  • Code that isn’t in the program to begin with (e.g. compressed, encrypted, generated/modified at runtime, etc) won’t be recompiled, so it won’t run
  • It’s been proven that finding all the code in a given binary is equivalent to the Halting problem

These combine to make static recompilation completely infeasible in 99% of cases. For more information, Michael Steil has done some great research into static recompilation — the best I’ve seen.

The other side to processor emulation is the way in which you interact with hardware. This really has two sides:

  • Processor timing
  • Interrupt handling

Processor timing:

Certain platforms — especially older consoles like the NES, SNES, etc — require your emulator to have strict timing to be completely compatible. With the NES, you have the PPU (pixel processing unit) which requires that the CPU put pixels into its memory at precise moments. If you use interpretation, you can easily count cycles and emulate proper timing; with dynamic/static recompilation, things are a /lot/ more complex.

Interrupt handling:

Interrupts are the primary mechanism that the CPU communicates with hardware. Generally, your hardware components will tell the CPU what interrupts it cares about. This is pretty straightforward — when your code throws a given interrupt, you look at the interrupt handler table and call the proper callback.

Hardware emulation:

There are two sides to emulating a given hardware device:

  • Emulating the functionality of the device
  • Emulating the actual device interfaces

Take the case of a hard-drive. The functionality is emulated by creating the backing storage, read/write/format routines, etc. This part is generally very straightforward.

The actual interface of the device is a bit more complex. This is generally some combination of memory mapped registers (e.g. parts of memory that the device watches for changes to do signaling) and interrupts. For a hard-drive, you may have a memory mapped area where you place read commands, writes, etc, then read this data back.

I’d go into more detail, but there are a million ways you can go with it. If you have any specific questions here, feel free to ask and I’ll add the info.


I think I’ve given a pretty good intro here, but there are a ton of additional areas. I’m more than happy to help with any questions; I’ve been very vague in most of this simply due to the immense complexity.

Obligatory Wikipedia links:

  • Emulator
  • Dynamic recompilation

General emulation resources:

  • Zophar — This is where I got my start with emulation, first downloading emulators and eventually plundering their immense archives of documentation. This is the absolute best resource you can possibly have.
  • NGEmu — Not many direct resources, but their forums are unbeatable.
  • — The documents section contains resources regarding machine architecture for popular consoles

Emulator projects to reference:

  • IronBabel — This is an emulation platform for .NET, written in Nemerle and recompiles code to C# on the fly. Disclaimer: This is my project, so pardon the shameless plug.
  • BSnes — An awesome SNES emulator with the goal of cycle-perfect accuracy.
  • MAME — The arcade emulator. Great reference.
  • — This is a JavaScript 6502 emulator with a cool little forum.
  • dynarec’d 6502asm — This is a little hack I did over a day or two. I took the existing emulator from and changed it to dynamically recompile the code to JavaScript for massive speed increases.

Processor recompilation references:

  • The research into static recompilation done by Michael Steil (referenced above) culminated in this paper and you can find source and such here.


It’s been well over a year since this answer was submitted and with all the attention it’s been getting, I figured it’s time to update some things.

Perhaps the most exciting thing in emulation right now is libcpu, started by the aforementioned Michael Steil. It’s a library intended to support a large number of CPU cores, which use LLVM for recompilation (static and dynamic!). It’s got huge potential, and I think it’ll do great things for emulation.

emu-docs has also been brought to my attention, which houses a great repository of system documentation, which is very useful for emulation purposes. I haven’t spent much time there, but it looks like they have a lot of great resources.

I’m glad this post has been helpful, and I’m hoping I can get off my arse and finish up my book on the subject by the end of the year/early next year.

Leave a Comment