Changes

An emulator is ;It'''accurate''' when an instruction given s important to both the program know that emulation accuracy and compatibility are two different things; while how closely an emulator mimics the original hardware results in both outputting the same resultis important, don't mistake that for compatibility. That means accurate emulators produce much fewer audio and video glitchesWhether games run properly is a separate concern, usually at the cost of more processing power neededaccuracy can sometimes influence it. See [[#Perfection. It's often achieved by using tighter synchronization3F|"perfection"]] and [[#Controversy|"controversy"]] sections.

Notable accuracy-centric emulators include ;In the world of computing, terms like "[[Nintendo_Entertainment_System_emulators#EmulatorsHypervisors|Mesen2hypervisors]] (NES)", "[[aresSimulators|simulators]] (SNES", N64"[[Compatibility_layer|compatibility layers]]", NGP, WonderSwan)"[[Wrappers|wrappers]]", "[[FPGA|FPGA-based hardware cloning]]" and "[[BlastEm:Category:Emulators|software emulators]] (Sega Mega Drive) among others" are often used interchangeably, leading to confusion. While they share some similarities, each technology serves a distinct purpose and operates at different levels.

The more accurate Within the realm of computer science, emulation occupies a niche distinct from virtualization or other techniques. Whereas hypervisors usually used for partitioning physical hardware resources among multiple guest operating systems, and simulators where developers build virtual replicas of specific environments or processes, emulation endeavors to recreate an emulator isentire historical architecture. This digital reconstruction seeks to faithfully capture the instruction set, timing behaviors, the lesser deviations there is from real hardware behavior but features and even peripheral nuances of a bygone hardware platform. Unlike compatibility layers, which translate software instructions to a native format, emulation builds a virtual stage upon which the software itself can perform authentically. Emulation's intricate tapestry sometimes intertwines with threads of other technologies though. Notably, certain emulators leverage hypervisors for a more demanding it isefficient handling of resource allocation and isolation. IronicallyAdditionally, some emulators employ compatibility layers as subcomponents, acting as translators for specific libraries or APIs that aspect might at times otherwise be at odds incompatible with the host environment. Think of these layers as linguistic bridges, allowing the emulated software to converse fluently with how authentic the experience ismodern system hardware. By strategically merging these techniques and the help of skilled use of [[High/Low_level_emulation|HLE and LLE or Hybrid]], when it introduces [[Input lagDynamic_recompilation|compiler techniques]]and using specific features such as Fast Memory Access[https://github. A similar debate surrounds CRT shaders com/PCSX2/pcsx2/pull/5821][https://github.com/PCSX2/pcsx2/pull/7295][https://yuzu-emu.org/entry/yuzu-fastmem/#what-is-fastmem][https://dolphin-emu.org/blog/2016/09/06/booting-the-final-gc-game/] and instruction set support (such as well[https://whatcookie.github. Not to mention the hardware intensive nature of very accurate emulators io/posts/why-is-avx-512-useful-for-rpcs3/ AVX-512 for later consoles may be at odds RPCS3]) and other various optimizations[https://yuzu-emu.org/entry/yuzu-progress-report-dec-2023/#android-adventures-and-kernels-with the emulator's usability-benefits], especially with the recent collapse certain emulators achieve impressive levels of Moore's Law (in layman's termsperformance and compatibility, you can't just "buy a better PC" if semiconductor technology does not catch up fast enough with what it takes for accurate emulation that makes zero compromises for optimizing speed)further unlocking the doors to historical software [[Preservation_projects|preservation]].[https://youtu.be/cCXri4yDHmU]

So in summary, an accurate emulator is when an instruction given to both the program and the hardware results in both outputting the same result. That means accurate emulators produce much fewer audio and video glitches, usually at the cost of more processing power needed. It's often achieved by using tighter synchronization. The more accurate an emulator is, the lesser deviations there is from real hardware behavior but the more demanding it is. Ironically, that aspect might at times be at odds with how authentic the experience is, when it introduces [[Input lag]]. A similar debate surrounds CRT shaders as well. Not to mention the hardware intensive nature of very accurate emulators for later consoles may be at odds with the emulator's usability, especially with the recent collapse of Moore's Law (in layman's terms, you can't just "buy a better PC" if semiconductor technology does not catch up fast enough with what it takes for accurate emulation that makes zero compromises for optimizing speed). As a result, accuracy and emulator authenticity continue to be controversial subjects and highly a matter of opinion depending on what aspect of the experience the user values more.

An emulator isn't accurate when it has a large amount of visual and audio glitches and favors performance as much as possible. To work around these glitches, emulator developers typically include game-specific hacks (and prioritize popular games) to skip over problems, such as compatibility issues that can cause games to break. Many times, these emulators will be deemed incompatible with the less popular (obscure) games. As Near (then known as byuu) explains in a 2011 Ars Technica article linked below, ''Speedy Gonzales: Los Gatos Bandidos'' will soft-lock towards the end due to a specific hardware edge case that isn't emulated in [[ZSNES]] or [[https://github.com/snes9xgit/snes9x/issues/280 Snes9x]], but is properly dealt with in his own emulator [[higan]] due to his documentation of the system. This can also become very problematic when ROM hacks abuse software errors (aka. emulator oversights) to create otherwise impossible behaviors to achieve what they can. When a ROM hack can only be used in that one specific emulator, he explains, it becomes incompatible with real hardware (either through a flash cart or printed), and that such an issue has occurred with [[ZSNES]] before and continues to occur with Nintendo 64 ROM hacks.

Newer emulators tend to favor High-Level Emulation (HLE) ===Medium accuracy===Medium accuracy finds itself in between, think of it as opposed to Lowthe middle ground. Emulators with medium-Level Emulation (LLE), which results in lower level accuracyhave a decent level of compatibility with commercially released games and should be able to get the job done for the most part. While emulators like [[Dolphin]] favor Emulators with medium accuracy but still retain HLE for performance and have successfully used don't cover some of the more advanced nuances of the hardware it seeks out to an advantageimitate, these types but this shouldn't matter a whole lot for a good number of exceptions are uncommon and [[High/Low games. Most high-level emulation|it can still hinder accuracy]]emulators may fall into this category.

===Medium In summary, emulators with medium-level accuracy===Most emulators headed by multiple developers tend to have fewer glitches are passable. They aren't the worst, but stillthey aren't fantastic either, have many problemsthey sit in the middle.

High emulation accuracy is a level of precision that emulator developers strive for when achieving [[#Cycle_accuracy|cycle accuracy]] or even [[#Partial cycle-accuracy|partial-cycle accuracy ]] is not practical or necessary. In this This approach, the emulator replicates the components of focuses on replicating the original system 's components as closely as possible, aiming for a faithful reproduction to faithfully reproduce its behavior while staying mindful of the system's behaviorhardware demands. The pursuit of high accuracy often results in the need for Though it may demand more processing powercompared to lowly accurate emulators, leading to pursuing a more accurate emulation experience can pay off in the form of fewer audio and /visual glitches and improved better handling of edge cases used by niche scenarios that creative game programmersoften implement. Emulators with high accuracy may or may not be Though they don't mimic every clock cycle as precisely as cycle-accuracy, highly accurate, but they generally exhibit a notable level emulators capture the essence of fidelity to the original hardwarevery well. Achieving Also achieving 100% compatibility with commercially released games is a common goal for emulators with high accuracy. Some of these emulators represent an even more meticulous level of precision in replicating the original system compared to other highly accurate emulators, this heightened level of accuracy often involves more sophisticated techniques, demanding increased computational resources. ===Cycle accuracy===Cycle accuracy is a more stringent form of emulation accuracy that seeks to precisely replicate the timing and execution of each individual cycle of the original hardware. This type of emulation accuracy aims to match the appropriate timing and execution of each cycle. The authenticity and performance of the emulator in question depends in how cycle accuracy is implemented. Typically, emulators with this level of accuracy ensure that situations where precise timing is required are properly dealt with.

===Very high accuracy===Very high So, in summary, we can talk about three types of cycle emulation : "partial cycle-accuracy represents an even more meticulous level of precision in replicating the original system. Emulators with very high ", "cycle-based accuracy go beyond the standard high" and "full cycle-accuracy level, aiming to achieve an even closer match to the behavior of the original hardware". This heightened level These can be considered as subsets of "cycle accuracy often involves more sophisticated techniques, demanding increased computational resources. The distinction between high " Due to technical challenges and very high performance considerations, emulators often employ either "partial cycle-accuracy lies in the finer details and nuances that very high " or "cycle-based accuracy seeks to capture, resulting in an emulation experience that minimizes any discrepancies or artifacts compared to " depending on the original system. Emulators with very high accuracy may be especially appealing to users seeking an unparalleled level of authenticity and completeness in their emulation experiencespecific requirements.

===Cycle-based accuracy===By emulating the components in a cycle-per-cycle fashionMesen, BlastEm, NanoBoyAdvance, Azayaka, we get MartyPC and Stella are recognized for their cycle-based accuracy. This type of accurate emulation accuracy aims to reproduce , though for knowing the system's functional behavior within a specified specific degree of cycle without necessarily adhering to the exact timing of each -by-cycle. Since this method doesn't go out of its way to mimic the precise timing and execution of precision for each cycle, it may not be able to handle all hardware edge casesneeds further research.

An example ====Partial cycle-accuracy====This focuses on replicating the timing of instructions and key internal operations, while simplifying or skipping some less critical details. This can lower the performance requirements compared to full cycle accuracy. Remember, just because an emulator is partially cycle-accurate doesn't necessarily make it more accurate than a highly accurate emulator. For example, CEN64 only emulates the CPU pipeline cycle-based emulator accurately and that's all, on the other hand Simple64 is jgnes with its more accurate in terms of timing for specific tasks like certain DMA transfers, even though it doesn't achieve partially cycle-based accurate emulation .:Examples of the Ricoh 2A03 partially cycle-accurate emulators are [https://old.reddit.com/r/emulation/comments/vy8cg7/ares_v129_has_been_released_crossplatform/ig4da06/ bsnes] and PPU[https://discord.com/channels/976404869386747954/976463759935696977/1106700321222299762 CEN64].

====Cycle -based accuracy====Unlike cycle-based This type of emulation accuracy, cycle accuracy is aims to reproduce the system's functional behavior within a more stringent form specified number of emulation accuracy that seeks cycles without necessarily adhering to precisely replicate the exact timing and execution of each individual cycle of the original hardware. This type Since this method doesn't go out of emulation accuracy aims its way to match mimic the appropriate precise timing and execution of each cycle, it may not be able to handle all hardware edge cases. The authenticity and performance :An example of the a cycle-based emulator in question depends in how cycle accuracy is implemented. Typically, emulators jgnes with this level its cycle-based emulation of accuracy ensure that situations where precise timing is required are properly dealt withthe Ricoh 2A03 and PPU.

====Full cycle-accuracy====This aims to mimic every aspect of the CPU's timing and behavior, including internal operations and interactions with other components like memory and I/O devices. This demands the highest processing power for emulation among the cycle level accuracy subsets.:[https://old.reddit.com/r/emulation/comments/vy8cg7/ares_v129_has_been_released_crossplatform/ig4da06/ Examples of fully cycle-accurate emulators are Mesen2 with its NES and SNES emulation, Cen64, : higan and BlastEmares].

Gate-level accuracy focuses on operating at the level of logical gates within a digital circuit. In this approach, the focus is to replicate the behavior of the system by emulating the interactions and operations of logic gates. This level of abstraction allows for a more efficient imitation of digital circuits, as it does not delve into the intricacies of individual transistors. this This level of system emulation is suitable for scenarios where a higher-level understanding of circuit behavior is sufficient. This method of hardware imitation should not be recommended for general purposes (for example, casual gaming), because of its rather poor performance because it is as a result of the emulator mimicking the desired machine at a very low level, and as such, requires loads of computational power to function.

Example Examples of gate-level emulators are Breaknes and GateBoy.

Transistor-level accuracy represents a more granular emulation accuracy level that delves into the behavior of individual transistors within a digital circuit. This approach aims to replicate the electrical characteristics and interactions of transistors, offering a higher degree of accuracy at the cost of increased computational complexity, way more than that of gate-level accuracy. This method is probably the most accurate representation of the electrical characteristics and interactions within a machine's circuit, but because of due to its extremely demanding nature, it should not be recommended for most people looking to play their childhood video games not only because of its abysmal performance, but also because it requires way too much computational power to execute. This type of hardware emulation is great for hardware enthusiasts and homebrew developers who want to get a deep understanding of the functionality and behavior of the hardware in question at a very detailed level.

While it may be theoretically possible to have a 100% perfect emulator, that feat is very rare (if not nearly impossible), even for some highly regarded emulators such as [[higan]] or kevtris's work on the various FPGA-based consoles by Analogue. Just because an emulator claims to be "cycle accurate" or "100% compatible" does not mean that said emulator is flawless. This even includes situations in which all emulator accuracy tests (iei.e. [[PS1 Tests]]) are passed, as these tests cannot cover every single edge case, and some of these tests may even fail on real hardware, leading to even more confusion. Some things are nearly impossible to perfectly emulate, such as some of the illegal opcodes of the [[wikipedia:MOS_Technology_6502|6502]], where the results are completely unpredictable on hardware, and different hardware revisions have different results and different illegal opcodes. The closest one could get to writing a perfect emulator would be if someone were to exactly copy an original ASIC map or a decap onto an FPGA, and even then, that isn't always a magic bullet.

The ones that don't favor accuracy argue that emulators do not need to be as accurate as possible if it can play all the games they need. And because these games tend to be the most recognized alongside the console, there shouldn't really be an interest in making more games work since those ones do. A more compelling point is 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 doesn't matter how accurately it replicates the original hardware and its many quirks and functions. The faithfulness of the emulator to the console it's emulating comes second to its overall ability to play games.