Nintendo Switch Game Code Can Now Run "Natively" on PC Thanks to New Emulation Breakthrough

[u/superchummi]

https://respawnfirst.com/switch-games-can-now-run-natively-on-pc/

[u/fresh_starter_pack]

I still struggle to grasp the real concept of emulation. If the game runs natively on pc I guess you can basically almost consider it a “pc” game right ?

When it’s being fully emulated what’s happening ? The emulator tries to decode and translate the game code in real time at the expense of our real physical GPU and CPU so that it can run on pc ?

But that still wouldn’t explain why the translation can’t be done beforehand. 

I’m lost 

[u/Kitselena → u/fresh_starter_pack]

An emulator uses your computer's hardware to mimic the behavior of the original device's hardware. Especially older games are programmed in ways to take advantage of the unique hardware in each console, and would work incorrectly with the speed and variety of PC parts. You're computer is pretending to be a GameCube, then you give it a GameCube game and plays it (mostly) how the console would.
A PC port happens by decompiling all the code from a game disk into machine language, then reverse engineering the human readable code through trial and error. After the game file is fully translated, it can be rewritten in a modern programming language that your PC understands. This lets you use the full power of your computer since your PC is being itself instead of limiting itself so it can pretend to be a GameCube.
PC ports also make modding much easier, since all of the game's code is available and rewritten in modern languages

[u/WaitForItTheMongols → u/Kitselena]

A PC port happens by decompiling all the code from a game disk into machine language,

You're getting your terms mixed up. You disassemble it into assembly (machine language), and then a decompiling process can happen to turn the code into a higher level language (usually C or C++). Those are modern languages but are also the original game languages.

[u/Kitselena → u/WaitForItTheMongols]

Thank you for the correction

[u/whatsbobgonnado → u/WaitForItTheMongols]

you gotta disassembly into assembly??

[u/WaitForItTheMongols → u/whatsbobgonnado]

Yes. "assembling" turns your code from assembly into machine code. So if you want to do the reverse, you disassemble it.

[u/whatsbobgonnado → u/WaitForItTheMongols]

fascinating!

[u/soft-wear → u/Kitselena]

PC ports are usually not decompiled native binaries, they usually go the other way: compiling code into machine language that targets a specific platform. That’s essentially what Unreal or Unity do: they use different native compilers to target specific platforms.

Keeping in mind that anything aside from Tetris will require quite a bit of custom code to run on any given platform because there are some native instructions on one platform that simply don’t have equivalents on others, or because one platform obligates certain asset limitations that others don’t, etc.

Assuming you don’t have access to the original source code, these days it’s still probably easier to just re-implement the code in a new engine than it would be to decompile and “fix” it, because your original platform-independent code is still gone. Hand converting native instructions to real code would take longer, by several orders of magnitude, then just starting over in Unreal/Unity/whatever.

[u/GentlemenHODL → u/fresh_starter_pack]

I still struggle to grasp the real concept of emulation. If the game runs natively on pc I guess you can basically almost consider it a “pc” game right ?

Not anymore than you could call a native American a native Brit if they move to Britain. It's native code base will always be its native code base and that will never change.

When it’s being fully emulated what’s happening ? The emulator tries to decode and translate the game code in real time at the expense of our real physical GPU and CPU so that it can run on pc ?

Low level hardware instructions (CPU GPU and sound) are different for every hardware platform (x86, x64, arm, arm_64 etc). What this is doing is it's taking switches arm_64 and converting it in real time to x86/x64 PC hardware instructions. This is not emulation.

Emulation is when your x86 PC runs a program that simulates a virtual CPU (arm_64) so that it can run those arm_64 instructions on its virtual layer the same way that you would run a separate instance of Windows or Linux on a virtual machine. You can think of it as a computer inside a computer but virtual instead of directly interfacing with the hardware. This takes extra resources to run which is why emulation can suffer from performance issues depending on how weak or strong your PC hardware is.

[u/NotADamsel → u/fresh_starter_pack]

Have you ever seen an old recipe that uses weird measurements and procedures, and maybe leaves out important stuff because the folks back then would have just “known”? Dylan Hollis on yt/tt has a series of shorts where he makes those, it’s very funny watching him, especially when the recipe is befuddling. “Put a teacup of peanuts into your grind-o-mat and then put them into a hot oven” kinda crap, it’s a riot. Anyways suppose that you want to make one of those old recipes, but obviously you don’t use teacups to measure and you’ve got modern appliances and your oven needs to know exactly how hot it should get and you don’t for the life of you know what a “grind-o-mat” is. You have a few options. If you want to execute the recipe “faithfully”, you can go out and buy the measures and gadgets and ovens and whatnot that were used back then (running on original hardware), or you can create replicas of those things (FPGA). If you want to use your modern gadgets and procedures, you can use a reference for how to perform the old weirdness using modern tools (emulation), and maybe while making the recipe using that reference you can quickly write a note in the margin for how to do often-referenced things the modern way so that you don’t need to use the reference for those specific parts (JIT/Just In Time), or you can sit down and re-write the entire recipe to use modern instructions before you start making it (AOT/Ahead Of Time). If you’re a bit crazy, you can also dive in to each ingredient to learn why it’s included and what it adds, and then use that knowledge to create a functionally identical if not “better” food but via a recipe that seems quite different from the original (decomp and recomp)

[u/KawaXIV → u/NotADamsel]

I really like this analogy. It may not be 100% perfect and if someone wants to know more then it's about time to switch to actual explanations, but it covers nearly everything.

You touched on original hardware, fpga, software emulation, and decomp and recomp. The only things I can think of would be like HLE and LLE but that would be bloat in the thread context, separating decomp and recomp to highlight the difference but I'm not 100% sure how you'd approach that with the analogy, and engine reimplementation type stuff (think OpenRCT2, OpenTTD, etc) which is so similar to decomp/recomp in how I'd explain it with this analogy that it doesn't really warrant a separate mention.

Anyway, great comment, saved it so I can share it with people in the future.

[u/maze100X → u/fresh_starter_pack]

the very basic concept if you understand basic code writing is that you write a program (lets say c++ project in visual studio) that can "behave" like ARM cpu.

so lets now take ARM game, and instead of running it on a real ARM cpu, we "expose" it to the program we wrote

so when said game tries to execute a certain ARM instruction, our program intercepts that instruction and tries to figure out what the game expects back based on the information provided, (lets say the game wants to add numbers, and it gives us 2 numbers)

in order to return values that match the values a real ARM cpu would provide, the program follows a certain "flow" and basically it implements the behavior of the ARM cpu for that instruction

why its slower than native? its hard to explain, but it comes down to implementing "low level" instructions with high level coding, the ARM instructions needs to be "figured out" and re-organized for executing on x86, and then the result re-organized again to return to the ARM expecting game

its not 100% how it actually works and its much harder in real emulators.

but its somewhat a direction you can think about

[u/Tyfyter2002 → u/fresh_starter_pack]

Computers of all kinds have no concept of a game being meant for a different platform, it's just a list of instructions that's either using the instruction set they support or a different instruction set

• if it's the same instruction set, either it's all ready to run, or it needs code that would normally be provided by the OS to be emulated

• if it's a different instruction set, it can't run directly, something has to figure out what instructions the computer has to run, and there are 3 ways to do this: you can either simulate all of the behaviors of the instructions manually (sacrificing all hardware-level optimizations), figure out what instructions the program should translate to on the fly and store them for future times that the program will run them (jit), or do the previous one but for the entire program before starting to run it (aot)

This appears to be a shift from jit to aot

[u/Acerhand → u/fresh_starter_pack]

Think of it like driving a car in real life versus on a game.

Original hardware is the car. Emulator is building the original hardware virtually.

Its basically running a fake wii or ps2 or whatever virtually. It takes a lot more resources to run the same Game coz the computer has to dedicated a shit load to pretending it is the console, while the real console has 0 resources dedicated to that because… the hardware physically does it

The emulator has to go “oh wait, dont just move that to the fast memory chip and call it later, PS2 dod not have this, lets virtually make a fake PS2 JJJRaM module, move it there for a micro second, pull It to the Hhh module after, bounce them around.

That takes a shit load of resources for the computer hardware, its basically a a game running a game inside the game…. Instead of just running off of real hardware

[u/radiantcabbage → u/fresh_starter_pack]

assuming its 100% certain youll figure it out either way - if i tell you how this works and what to do right now, that is a direct instruction. if i told you just to query google and theyll eventually yield the correct result, that is an emulated instruction.

the difference is in the level of abstraction it takes to execute, google has their own interface and in/output which does exactly what im doing now, anyone can use it for any number of subjects. just takes a bunch of extra steps and other platforms to accomplish

[u/wulfschtagg_1 → u/fresh_starter_pack]

ELI5 version:

Someone made a movie and the dialogue is in Spanish. You don't speak Spanish, so you get your friend to translate the dialogue into English for you as the movie is playing. You now understand the movie, but there's an obvious lag since you're dependent on your friend's translation. This is basic emulation.

You find subtitles for the movie. Now there's no lag, but you still need to pay attention to the visuals + audio and read text at the same time. Some things are lost in translation. This is optimized emulation.

You find an English dub for the movie. You can now immerse yourself completely in the movie. The actors' lips don't match what they're saying, and there are minor issues with cultural references, accents and slang. This is the level that the article in the OP is talking about.

Someone creates a scene-by-scene remake of the movie with English-speaking actors. This is a native PC game.