Emulation Accuracy

From Emulation General
(Redirected from Accuracy)
Jump to navigation Jump to search

Accuracy is how accurate the emulator is to the original hardware. Accuracy is most often achieved by tighter syncing. More accuracy means less graphics and audio glitches, at the cost of additional CPU power required to run the game at full speed.


Low accuracy[edit]

Low accuracy emulators will have a large amount of visual and audio glitches. They will typically use various game-specific hacks to skip over problems, such as speed or compatibility issues with specific games. Many times, these emulator authors will only prioritize popular games, and the less popular games will be incompatible. An example of this is Speedy Gonzales: Los Gatos Bandidos with emulators such as ZSNES and Snes9x, where the game will soft-lock towards the end. This can also become very problematic when ROM hacks use these hacks to run by abusing the errors to create otherwise impossible behavior. This means that the ROM hack can only be used in that one specific emulator and is incompatible with real hardware (either through flash cart or reproduction). Such an issue has occurred with ZSNES and still occurs today with new N64 ROM hacks.

Many times, newer emulators use High Level Emulation (HLE) as opposed to Low Level Emulation (LLE), which results in lower accuracy. There are some exceptions to HLE causing low accuracy, such as the Dolphin emulator, but these exceptions are uncommon. More information about this can be found at the High/Low level emulation page.

Medium accuracy[edit]

Medium accuracy emulators will have fewer glitches, but will still have many problems. Most emulators fall into this category.

High accuracy[edit]

High accuracy emulators try to replicate the original system as closely as possible, and for that reason take more CPU power to do so. They will have fewer audio and visual glitches. High accuracy emulators may or may not be cycle accurate. Some high accuracy emulators can achieve 100% compatibility with commercially released games.

Cycle accuracy[edit]

Cycle accurate emulation is trying to perfectly emulate timings right down to per-cycle accesses. So each individual component is emulated at exactly the right time, in perfect sync, and so on, which has a high CPU cost. The speed of the emulation depends on the way cycle accuracy is implemented. Cycle accuracy doesn't necessarily mean 100% accuracy. Only if the emulator is implemented perfectly is it perfect. An example of a cycle accurate emulator not being perfect is Higan with the ROM Hack "Mario and Luigi: Kola Kingdom Quest," where on real hardware, the level title text has graphical glitches whereas those glitches do not exist in Higan.

Chip accuracy[edit]

Chip accurate emulation works by simulating each logic chip on the board individually. Not only does this take a tremendous amount of processing power or specialized hardware to run (as in, even emulating something from the 1970s on a chip accurate level would need Dolphin-level system requirements to run at a good speed), but they also require a incredible amount of effort to make. This accuracy method is almost useless. Although it is the only way to achieve true 100% hardware simulation, cycle accurate emulation can already achieve accuracy which is virtually indistinguishable from the real hardware, aside from a very limited amount of edge cases. In addition, cycle-accurate emulators have much lower system requirements and programming difficulty. Currently, the only chip accurate emulators that are usable run on Field Programmable Gate Arrays, or FPGAs, which are essentially custom programmable chips. Machines dedicated to this type of emulation exist, such as the WIP Zimba 3000 by kevtris. Other examples of chip accurate emulation can be found in flash carts such as the SD2SNES, where various add-on chips are emulated on the included FPGA.


This emulator needs its own section on accuracy, because its accuracy method is unique. DICE emulates arcade machines from the early 1970s. The architecture of these systems is different from a modern architecture, mostly because they don't have a CPU. DICE emulates the discrete logic components of the machines at a circuit level. Although the results are accurate the you need a fast 64-bit PC to run these arcade games at full speed.


There are two sides when it comes to the issue of accuracy. One side argues that as long as an emulator plays the majority of games at full speed on most computers and devices without too many obvious glitches, it does not matter how accurately it actually replicates the original hardware and its many quirks and functions. The faithfulness of the emulator to the console it is emulating comes second to its overall ability to play games. The other side argues that an emulator should ultimately strive to simulate the hardware as much as possible, as that is the only way to achieve as much compatibility as possible, as well as the only way to preserve the hardware. Thus, speed and scalability to most devices is a lower priority to accuracy to the real console, both for purposes of compatibility and preservation.

Even within the second side, however, there is some disagreement as to just how much accuracy is actually needed. On most platforms, after obtaining a certain amount of accuracy, going further requires an exponential growth in system requirements, the results of which may not be noticeable to the vast majority of users. Cycle accuracy in particular has been hotly debated in regards to its usefulness, due to how such an extreme level of accuracy requires a lot of extra processing power for relatively few gains in compatibility.

Simply put, it's a disagreement between wanting 'good enough' or perfection no matter the cost.

Console revisions[edit]

Many consoles have different internal hardware revisions which degrade accuracy or change the consoles' behavior in another way, such as the SNES 1CHIP (various games have minor issues, such as a small mess of pixels at the top of the screen in games such as Super Ghouls 'n Ghosts or Demon's Crest), Genesis Model 3 (fixed a bug that some games such as Gargoyles used), various Commodore 64 revisions (fixed a useful bug that allowed for smooth horizontal scrolling), or PS2 SCPH-750XX (less compatibility with some PS2 games and PS1 games). These specific consoles are not generally emulated in their respective emulators, and those emulator developers tend to focus only on one revision. An exception to this is VICE, which tries to emulate as many different revisions of the Commodore 64 as possible and as accurately as possible.

Further reading[edit]


NES Accuracy Tests

Game Boy Accuracy Tests

SNES Accuracy Tests