A perfect machine can still arrive without permission to turn on.
That’s the small absurdity at the centre of PC preservation.
Emulation can reconstruct a processor, a graphics chip, a memory map.
Even the awkward timing an old game mistook for a law of nature.
Then the reconstructed game meets a modern PC and waits.
For a launcher, an account, a driver, a patch, a server somewhere else.
The machine is present.
The door is not open.
PC distribution likes to compress all of this into a word.
Purchase.
But a purchase can depend on five different systems agreeing in sequence.
Payment and license issuance. Download integrity. Activation. Driver and graphics-API compatibility. Patch delivery.
Each has a different owner.
Each has a different clock.
Each can prevent the first frame.
The storefronts are unusually candid about the first separation.
An account receives an entitlement for an application ID.
The subscriber agreement calls the purchased access right a subscription, and describes content and services as licensed rather than sold.
The files aren’t the whole transaction.
They’re the material the transaction permits an account to receive.
That distinction can fail before the game has a file worth preserving.
When Steam converted Argentine peso and Turkish lira wallet balances to dollars, it was a currency event.
Not a software event.
A regional payment restriction, a currency mismatch, or a stranded balance can still stop a purchase at the first gate.
The game hasn’t become inaccessible through rot.
It has become inaccessible through bookkeeping.
The next gate looks more physical.
A client downloads depot files, checks their checksums, and decompresses the installation locally.
A corrupted chunk or an antivirus quarantine can make a file absent or suspect.
That’s the familiar kind of failure.
The machine has lost part of the thing it needs.
Activation is stranger, because all the files can be present.
A protection layer or a publisher launcher verifies the entitlement against a server.
An offline-capable design caches a local token after that check.
An always-online design asks again at every launch, sometimes while play is already underway.
DRM-free installers make the opposite promise by containing no online check at all.
Which is a preservation decision disguised as a marketing one.
SimCity made the dependency visible by failing at scale.
Its persistent server connection was required to run.
Launch demand overwhelmed the capacity behind it, and the fix was more servers rather than more game.
The client on the buyer’s drive was intact throughout.
The game was simply on the far side of a queue.
Ownership had acquired a waiting room.
Then comes compatibility, which usually gets blamed on the game.
The game is the last thing on screen.
A rendering backend queries the installed driver for a feature level.
An old driver, a missing runtime, or a regression in one rendering path can end a launch before the game has made any claim about its own code.
That isn’t the same failure as a kernel-level anti-cheat conflict.
Both produce a crash at the door.
An anti-cheat driver can collide with security software, with virtualization tools, or with another kernel-mode driver already loaded.
One failure asks whether the graphics stack can render.
The other asks whether the host will admit a second authority into its most sensitive layer.
Patches keep the whole arrangement from settling down.
A delta patch replaces only the changed portions, keeping a local build in step with the storefront’s current assumptions.
It can also change protection, anti-cheat or compatibility requirements after the sale.
A driver that cooperated with one build is not promised to cooperate with the next.
A preserved installer can quietly become a record of a version the account is no longer invited to launch.
Emulation begins as an answer to that instability.
An emulator project distributes independent code.
A software description of what a console did, rather than a copy of the console maker’s code.
The achievement is real.
A processor can be described again.
A graphics system can be persuaded to behave like an older one.
But the emulator isn’t the machine’s whole past.
Most systems from the disc era onward need original firmware for boot procedures, memory-card formatting and low-level system calls.
That firmware belongs to the console maker.
No amount of elegant reimplementation quietly converts it into a free component.
Nor does the emulator settle the ROM.
Dumping media you own produces a personal backup.
Downloading the identical bytes from an unauthorized source produces the same file with a different chain of custody.
The file cannot tell you which one it is.
Which is why the familiar claim that emulation is legal manages to be both true and evasive.
It answers a question about the tool.
It leaves the firmware and the game standing outside the answer.
So the reconstructed machine has a provenance problem exactly where the commercial machine has a permission problem.
One can be built and not lawfully completed.
The other can be lawfully bought and not reliably run.
The case for the commercial stack isn’t frivolous.
Entitlements connect an account to patches, fraud controls, multiplayer services, and a driver environment somebody is still maintaining.
A platform can keep a large, unruly field of hardware legible enough to support.
That continuity costs independence.
The executable stays present while the permission to execute it lives somewhere else.
The case for emulation isn’t nostalgia in a trench coat.
It can make a vanished processor reproducible, preserve timing no replacement hardware supplies, and expose the boundary between a game and the service contract that later gathered around it.
That freedom costs labour, performance, firmware provenance, and an uncomfortable quantity of law left outside the emulator window.
Neither arrangement contains the other.
No amount of engineering will make one of them absorb the other’s problem.
A current compatibility stack makes a game available in practice.
A reconstructed machine makes it intelligible after its stack disappears.
Which owner gets to decide what running means, once the machine has become a service?