The more accurately an old machine comes back, the fewer people can play what it was running.
The emulator boots. The logo appears. The timing holds. The firmware makes the calls it once made.
The original game arrives intact.
Intact enough to disappoint precisely the people the original interface excluded.
Keep the inputs. Keep the display assumptions. Keep the old arrangement between hand, screen and machine.
That can be an achievement.
It can also be a gate.
An emulation setup is less singular than it looks.
There’s the emulator, which reimplements a console.
There’s the BIOS or firmware, the platform holder’s own small binary that handles booting, memory-card formatting and low-level system calls.
There’s the ROM or disc image.
Then there’s configuration, which decides how this reconstructed machine will actually behave.
Four objects.
Not one old game returning from the dead.
The distinction matters because fidelity can live in any of them.
Emulator code can reimplement a console without containing a line of its copyrighted material.
A firmware dump can preserve original boot behavior.
A disc image can preserve the game data.
A configuration can insist on the old timing, the old display, the old input path.
Calling all of it “the game” is convenient in the way a moving box is convenient.
Everything fits, and none of the fragile parts stay visible.
Fidelity has a serious case.
A game isn’t only its dialogue and its rules.
It’s also the circumstances through which those rules become action.
Change the timing carelessly and a rhythm changes.
Change a firmware call and a boot path changes.
Change an input assumption and an action may stop arriving when the software expects it.
The demanding end of that case reaches all the way down to the clock.
Classic 8-bit and 16-bit systems can require emulation accurate to individual cycles, and to undocumented hardware bugs, before some commercial software will run at all.
That isn’t nostalgia for beige plastic.
It’s a claim that an old machine had behavior beyond its published intentions, and that the behavior was load-bearing.
The engineering vocabulary makes the bargain unusually plain.
High-level emulation approximates a subsystem’s output algorithmically.
Low-level emulation executes original or near-equivalent microcode.
One emulator can take either path for the same audio hardware.
The high-level route is faster.
The low-level route is slower, and reproduces behavior that depends on quirks the fast route never models.
An interpreter and a dynamic recompiler stage the same argument elsewhere.
The interpreter walks each instruction in sequence. Slower, more exact.
Recompilation translates blocks into native code ahead of execution. Dramatically faster, and self-modifying code makes bit-exactness much harder to guarantee.
The original machine asks for obedience.
The host machine sends an invoice.
But the faithful setup has a second cost, and it starts before any instruction executes.
An interface is not only a description of a game. It is the route into it.
An old control scheme can be historically exact and physically unavailable.
An original display assumption can be technically correct and perceptually unusable.
A printed manual once carried a controller diagram at a scale and permanence no contextual prompt matches.
Losing the manual meant losing the map of the machine.
When manuals thinned out, that instructional burden moved inside the game.
An emulator faithfully preserves however little of it the game bothered to carry.
Accessibility work has spent two decades naming those barriers.
In voluntary guidelines, rather than a certification line with a guard at the door.
Voluntary is both merciful and insufficient.
It leaves room for a game whose form makes unusual demands.
It also leaves a person unable to meet those demands with nobody to appeal to.
The barrier gets a name.
It does not automatically get a door.
This is where emulation stops resembling an archive and starts resembling an argument.
An emulator already routes controller input through a mapping layer.
It can write a virtual memory card to the host filesystem.
It can take save states, snapshots of the whole machine at an instant, which the original console never offered anyone.
So the emulated machine can be exact in its internal behavior while the interface around it becomes deliberately unlike the original.
Internal-resolution upscaling makes the point without ceremony.
A console’s output was one thing.
An emulator can render internally at several multiples of it, producing an image sharper than the hardware or the television ever produced.
Nobody mistakes that for literal hardware behavior once it has been named out loud.
The image is improved by becoming less original, and almost nobody objects.
Input changes get a harder moral accounting, because they reach the game’s verbs.
A remapped control, an alternate device, or a slower route through a command can look like a revision of the work.
Yet the original mapping was also a revision.
It was one machine’s decision about which hands, which movements and which devices would count as a command.
The vocabulary gives the whole dispute away.
Nobody calls an upscaled image a cheat.
Everybody has, at some point, called a remapped button one.
The difference isn’t technical.
Both are the host machine declining to reproduce a limit the original imposed.
One limit was in the picture.
The other was in the hands, and the hands are where the accusation lives.
Access has its own cost, and it should be stated as plainly as fidelity’s.
A feature can preserve a decision while altering the pressure that made the decision mean anything.
An input change can be a translation, a repair, or a new performance of the same score.
The software can’t tell you which.
Save states are useful precisely because they are not original hardware behavior.
That usefulness can quietly demote a failure state the design had put at its centre.
Neither setup is the honest one and the other the indulgence.
A faithful reconstruction preserves timing, quirks and conditions that would otherwise vanish with the last working unit.
An accommodating one preserves the game’s decisions for people the original conditions kept out.
One is loyal to the machine’s claim.
One is loyal to the encounter with it.
Both are called emulation, and the word has been doing that work quietly for years.
Which layer of the game is it being faithful to?