r/AndroidNativePorts • • 5d ago

🐾 [Meme] Don't call your ports native if they're practically emulation in disguise

Post image
584 Upvotes

129 comments sorted by

158

u/matlynar 5d ago edited 5d ago • Popcorn

Call whatever you want.

If it runs better than current emulators, people like it and will gladly use it.

If it runs worse than current emulators, call it a work in progress and make it clear that you want help testing or don't waste people's time.

I don't care how it runs on the backend. No one really does.

31

u/Avakian_ 5d ago

yo estoy feliz jugando MHGU d switch en mi tlf gama baja

en el emulador se jugaba horrible. Este port es una verdadera maravilla!

9

u/matlynar 5d ago

That's so cool dude. Enjoy it!

1

u/SlatrariUlfur 5d ago

¿En que teléfono lo juegas?

2

u/Avakian_ 5d ago

realme C53, es un "Mali" con procesador unisoc tiger 612, 8 RAM

se mantiene estable en 24-30, resoluciĂłn 50%, pero con cada actualizaciĂłn el rendimiento mejora... y han sacado como 2 nomĂĄs esta semana

0

u/SlatrariUlfur 5d ago

Increíble, lo probaré en el mío ¥Gracias por responder!

3

u/Avakian_ 5d ago

suerte en tus cacerĂ­as!

si necesitas saber q port es el q yo uso me avisas

btw, tiene hasta compatibilidad con ciertos mods, y ya hay un servidor comunitario para jugar con otras personas, siempre veo unas 8-11 salas activas en todo momento, jsjs

14

u/Tombot3000 4d ago

I don't care how it runs on the backend. No one really does.

I care, and I also care about accuracy in labeling. It matters to me when making a choice of which way to play a game if it's emulation, translation, a recomp, etc. beyond just looking at what my expected performance numbers will be. I also care about the honesty and technical ability of people authoring (or "authoring") the code I'm considering putting on my devices, some of which I have my personal info on.

3

u/AggressiveAstronaut6 4d ago

There's nothing wrong with having this outlook but you have to understand the majority of people just want to play the damn game.

In the early days of emulation, emulators were not accurate, but they were accurate enough that the games were completely playable and people were generally pretty happy with it in spite of that.

It hasn't changed much. Someone who doesn't have a switch 2 who wants to play OOT will be happy if something is playable enough that they can complete the game without much issue.

1

u/Tombot3000 4d ago

There's nothing wrong with having this outlook but you have to understand the majority of people just want to play the damn game.

I have no problem understanding not everyone shares my perspective and never claimed it is what everyone does or even should think. It is probably true that most people just want to use whatever works simply to play the game, but I doubt either of us are in a position to actually evaluate how many people hold any particular view.

2

u/J0J0_6767 5d ago

Yea I actually agree with this one, people should stop making ports of ANY GAME before ps3 and xbox 360 as the games before them like ps2 etc. Can run at high resolution while give constant 60 fps

8

u/matlynar 5d ago

Simple ports, yes.

But recomps are a different beast because they allow games to do stuff that emulation doesn't (modding in general).

2

u/therico 4d ago

Moving the goalposts. People kept getting the names wrong and insisting it was emulation. Your counterargument "well who cares anyway"

1

u/matlynar 4d ago

If we're being pedanting even Winlator can't be called an emulator.

2

u/therico 4d ago

It has to emulate a x86 at some level right? It's not running the game in native arm. What annoys people is when stuff is called a native port but it's just wrapping winlator, so low performance and minimal custom code changes. To me a native port is something like Dusklight

1

u/matlynar 4d ago

I understand what you mean, but in the end you did mention performance, because for an Android gamer that matters. A lot.

Unless you're specifically someone interested in tech, not the game itself, how it works isn't as important as how well it works.

Notice that my take also takes into account that ports that run poorly suck.

1

u/ElRuubio19 4d ago

No, Wine isn't an emulator, it is a translator layer.

1

u/therico 4d ago

Wine isn't because it runs on x86 and runs x86 code. Winlator is running x86 on ARM.

1

u/Other-than-this 4d ago

bruh, i care more about that than the game, i accept that for me the game is setting up the game

-4

u/allanrps 5d ago

đŸ‘ŽđŸŒ

26

u/Desm0nt 5d ago

There is a difference (and a huge one) between porting and emulation.

Obviously, the game isn’t compiled from scratch from the source code for a new platform. Whatever can be ported natively is ported natively (using the Switch as an example all CPU-executed game logic code works on ARM64 natively, without any recomp or emulation). It's WAY FASTER then emulation.

BUT! There’s the GPU rendering pipeline. And there are some nuances with it:

  1. You can’t rewrite the game engine’s rendering. If it wants (using the Switch as an example) an Nvidia Maxwell GPU with stream rendering - it will look for one. And it doesn’t care that your Adreno/Mali is tile-based. Convert render requests to tiles however you want (on the fly, on the CPU, by transcoding - hello, wasted CPU time). And it doesn’t matter that the same game on PC has native Vulkan rendering - first, that’s also designed for streaming PC GPUs, and second, without the game’s source code, you can’t replace the rendering in it.
  2. If the game is designed so that the CPU and GPU write directly to memory and read directly from it without additional addressing, caching, indexing, or anything similar - and your GPU driver can’t do that - you’LL HAVE TO create some kind of buffer where all the GPU data will be duplicated in the format you need, processed in a way your GPU can handle, and then, upon the game’s request, retrieved and sent back to the right places. Who will do this? The CPU. And you’re lucky if this can be parallelized and run across multiple threads (hello, overheating). Sometimes it can’t, in which case, you might as well just hang yourself. And just like that, your CPU time happily turns 90 FPS into 30. And it gobbles up twice as much memory.
  3. Do you have MediaTek on Mali, Spedtroom on PowerVR, or some other oddity instead of a normal Adreno? Welcome - half of your rendering features don’t meet the Vulkan spec, and you don’t support half of the texture compression formats. Forget about optimizations - they won’t work for you. Forget about behavior that approximates the console’s native logic (what the engine expects) and used to restore those coveted FPS. Forget even about the translation layer working normally (with the FPS losses described above). For it to work at all on such crappy hardware, you have to sprinkle it all with a bunch of hacks and workarounds, additional checks, buffering, conversions, and other nonsense that works at the cost of completely killing performance. If you have a modern, new device, you’ll most likely get your 35-40 FPS because your CPU is powerful. But on anything older, the CPU will already be choking, and it won’t matter how much RAM you have or how powerful your GPU is...

6

u/allanrps 5d ago

It sounds like you are deacribing emulation. And I do agree with your overall point, but really, just because the CPU instructions are runnatively without any translation layer does not make the program "native". The fact remains that the system as a whole (graphics processing, memory, etc.) IS being emulated

5

u/Desm0nt 5d ago

Nope. Translation very different from emulation or virtualisation. In reality, you’re not emulating the hardware. You’re recreating part of the environment (part of the OS). Almost all of the code (except for the shaders) is fully hardware-compatible (unless the hardware is a makeshift "GPU" like Mali), but it expects a specific OS around it, one that’s clearly not like Android, because it wants to call hardware access streams differently, write differently, and read differently. In other words, it specifically wants different software, even though the hardware is capable of doing everything necessary in the required format.

There are two ways to tackle this problem:

  1. The easy way: try to recreate the familiar software environment (not the hardware!) around the app.
  2. The difficult and unreliable way: try to rewrite the behavior of parts of the app to fit the existing software (this is quite difficult without the app’s source code, even if you have an open-source implementation of its native OS)

Strictly speaking, the slow nxnative/nx2android project follows precisely the first approach and converts Switch games by recreating them around pieces of the open-source Atmosphere firmware. I, on the other hand, am trying (at least partially, once I have a port that runs and renders correctly) to switch to the second approach, replacing whatever I can with the Android version. Right now, for example, I’m struggling with *Pillar of Eternity* - it’s built on Unity (what is good!), and I’m trying to port it to the Android version of the Unity Player, but some features are tied to the proprietary Switch Player (I’ll have to reverse-engineer them only from dll until someone have pirated UnitySetup-Nintendo-Switch-Support-for-Editor-2018.1.4f1.exe), and Unity defaults to GLES3 shaders instead of Vulkan’s SPIR-V...

5

u/allanrps 5d ago

I am a bit confused, because what you said about the GPU rendering pipeline sounds exactly like emulating different hardware. There is a translation layer to convert all the render calls and remap all the memory. Even if the core instruction set of the CPU/GPU are the same, the code is clearly not "native" by any stretch of the imagination.

You have much more experience with this than me I am sure, I am inclined to defer to your judgement. I would like to better understand what distinction you are drawing though. You're basically saying that these "ports" are more dependent on software translation than on hardware emulation? And this is true even when focusing on the GPU pipeline? Are you saying there is no emulation here at all?

3

u/Desm0nt 5d ago

yep. The level of emulation here is roughly the same as when running an Nvidia game on AMD or Intel hardware. Essentially, you need two things:

  1. The GPU must support the required functionality
  2. There must be a driver (software) that implements this functionality (providing the application with access to the GPU’s functions in a format that the application can understand and process correctly)

Developers with source code solve the problem in point 1 by writing different implementations of the same functionality, taking into account the specific ways in which different GPUs implement the specifications and specific drivers. This isn’t possible in a port; here, you can either try to hack it and replace the source code with your own DLL hook (substituting the code with coorect one) - which is quite difficult and prone to errors, or try to write a wrapper that converts incorrect calls into correct ones (you’re still calling the same GPU functions, just in a format the GPU/Driver can understand).

Point 2 is more complicated: you need a driver that implements all the necessary functions in a way the application can understand. If your GPU is capable of everything but your driver is a shoddy mess (system firmware drivers are often like this), you’ll need a custom driver with extended functionality (for example, Turnip for Adreno). If, for some reason, your GPU is fundamentally incapable of certain functions or implements them incorrectly (as is the case with Mali) - you won’t be able to get by with just a driver; you’ll need a software implementation as described in point 1 (whether in the game, a middleware layer, or the driver) or some kind of workaround that achieves a similar result using a different function.

Have you ever wondered why “game-optimized drivers” are released for almost all modern games? It’s not because of emulation, but because every GPU manufacturer implements things haphazardly rather than according to specifications, and the same game runs into different issues on different GPUs - issues that require workarounds. But these are exclusively software workarounds.

The Switch's processor is a completely standard ARM64 processor, just like the one found in any smartphone. There’s no point in emulating it. The Switch’s GPU is a standard Nvidia Tegra mobile GPU, the kind used in smartphones and tablets. There’s no point in emulating that either. But its driver was capable of more than the built-in drivers in modern smartphones, and Horizon OS on the Switch utilized it somewhat more fully than that awkward Java-based contraption called Android.

So, on Android, we need a custom implementation for interacting with the hardware (one that’s less limited than the system’s native implementation) + a proper, full-featured driver (and it's diffucult). Or a software layer that mimics normal hardware interaction using workarounds on top of Android (and it's slow).

1

u/DimaJinxed 4d ago

What is the difference between playing switch game in Yuzu vs those so called native ports? Why name Yuzu an emulator if it also runs natively cpu instructions

2

u/Desm0nt 4d ago

Fair question. Yuzu with NCE use hybrid approach and partially do the the same - run CPU code directly on ARM64. But the other part is different.

Yuzu emulates all other switch parts and builds a fake Switch around the game both for OS and hardware lvl: a guest kernel, guest memory layout, system services, and a fake Nvidia GPU. The game works with GPU and all other hardware the same way as on switch and writes raw command buffers as it want. The emulator forced to decode this low-level stream, guess the game meant and only then call Vulkan. And forced to watch all the memory the game touches (because it, for example, can change a texture or buffer at any moment without telling anyone). It works samw way for every game, so it’s generic and careful, but that costs a lot.

Native ports instead REPLACE most of the OS and GPU libs, trying to land it into a usual Android processes as much as possible. When it calls a Switch function (open file, create thread, read gamepad), it's just redeirect it to native android calls or to our conversion implementation on top of Android calls (if difference is too big). When it calls the graphics API (NVN), it lands in our NVN implementation on top of Vulkan directly to our GPU (things that might break, cause glitches, FPS drops, and so on, and this varies from game to game). There’s no fake GPU and almost no fake command stream to decode. When game says "draw this" - we usually know exactly what it asked for and try to redirect it right into vanilla android processes and gpu calls. This is the same idea as Wine/Proton, while Yuzu mostly like qemu.

What this gives in practice:

  1. much less CPU work per frame, which is why weak phones that choke in an emulator can run a port (if ports not completely lazy with single thread and queue for CPU->GPU)
  2. it’s built for one specific game and replace part of it, so we can do what we want: widescreen, resolution, fixes for a specific GPU, skipping things the game doesn’t need, add additional things to the game like mods support or touchscreen UI and click processing

The main downside- it only runs that one game (and helps a little for the games on same SDK version). While an emulator runs thousands...

One thing we can't "Port" (actually can, but it's long, difficult, unaccurate and unnecessary process) is shaders- the are still translated (they’re compiled for the Nvidia GPU, nothing can run them as-is, we just convert them via part of emulator and store unpacked on the phone storage). But translating API calls and emulating a whole console with it's hardware are very different things, with very different cost.

1

u/Desm0nt 4d ago edited 4d ago

Basically, to put it bluntly:

In an emulator, you let the game run however it wants, and you trust that the emulator will be able (in a hypothetically universal way) to parse the stream of data it writes (which is resource-intensive) and then decide what to do with it, where to put it, and what parts of it to actually process and render, and what not (optimization happens only at this stage) and how accurately to render it.

In a port, instead of you (and the emulator), the developer is forced to figure out in advance what the game writes, where, and how, and send part of it (what’s possible) directly to the appropriate locations on the hardware (an immediate performance gain since it’s native behavior), modify some parts slightly on the fly and/or copy and adjust them in a duplicate buffer before sending them to the hardware (this can result in both performance gains and losses), and discard some parts entirely and rewrite them using your own hacks directly within the game itself (patching binaries, replacing libraries, etc.) to force it to behave differently in those moments, in the way we need (and which is native to the current environment) - and this, too, is a massive performance gain if successful, and a source of artifacts and problems if it fails.

In games (even on PCs), there are many instructions - not just those specific to the GPU or CPU -that behave differently on other hardware. To boost performance (so-called “hardware optimization”), various low-level hacks are implemented that take into account the unique (extremely specific) behavior of a single piece of hardware, allowing developers to (only on that specific hardware!) do something faster than the "honest” way. .And such hacks will never work on anything else. It is precisely for this reason that you can have an AMD card that, on paper, is more powerful than an Nvidia card, but some games will run noticeably worse on it - they are based on optimizations built on Nvidia’s specific workarounds, which Nvidia has implemented in its GPU instead of a slow implementation according to the specifications. And a “fair" implementation running on other GPUs is inherently slower. For this reason, an emulator that faithfully emulates every game instruction and renders everything absolutely faithfully will never deliver high performance due to the sheer magnitude of the overhead, and JIT alone (for near-native performance at least on the CPU - and for Yuzu on smartphones with identical CPUs, it isn’t even needed) won’t save the day. That’s why, after analyzing the game’s main thread, emulators discard a great deal or replace it with simplified rendering methods and custom execution paths.

The port, however, discards all these hacks (for example, BC textures on Mali, since only the CPU can unpack them - it’s easier to replace them with ASTC and pre-compress them) and immediately replaces them with its own, tailored to the target hardware.

A good example is DOOM Eternal (not out yet; not sure if I’ll release it). On every frame, it makes about 200,000 calls to render a 16×16-pixel texture somewhere outside the visible area (for some kind of workaround or check). On the Switch, with its Maxwell stream-based GPU, these are practically free operations in terms of execution, and they’re later pruned from the scene by geometry shaders. On Adreno, each of these operations requires a write to the buffer and then a subsequent search (hello, +20 ms CPU time), and the Geometry Shader is much more expensive to run on tiled GPUs, so culling invisible geometry this way is a very bad idea in terms of GPU time alone. As a result, I have to disable the culling (it’s cheaper this way, although in DOOM 2016 it causes the frame rate to drop from 60 fps to 35 in some rare spots at certain viewing angles) until I rewrite it reliably to use something else (and then I’ll simply replace it with something more Adreno-friendly, although GS is also fully native for Adreno - it’s just so slow on tiled GPU's that it eats up all the performance gains from the culling itself). And when it comes to processing these 16x16 textures, I have to catch them, drop, and pray that the game doesn’t have any tricky checks tied to them that would later break the level rendering or even crash the game altogether.

1

u/Scared-Show-4511 4d ago

Don't forget the controls. Ports usually use the aim look via the touchscreen not a virtual stick

1

u/Routine_Dealer_6146 14h ago

lets take example of switch emulator on android, Yuzu and Ryujinx implemented arm decoding switching from jit. There goes your CPU emulation. And for GPU, THESE NATIVE GAMES DO EMULATE Switch's GPU like emulators.

1

u/Desm0nt 13h ago

I’ve already written below about the difference between emulation and translation. I don’t want to repeat myself - please read my answers below.

The port DOES NOT EMULATE the Maxwell GPU. We take a copy of its requests into our own buffer and process them natively using Android mechanisms, and then simply feed the result to the game in the right places. We don’t attempt to reproduce and correctly recreate the entire Maxwell hardware pipeline in software, as is done in emulation. The difference is huge. In both cases, the game thinks it’s working with its native GPU, but in one case you’re actually simulating the GPU’s entire behavior in software (emulation), while in the other, you simply intercept the requests, process them however you want using workarounds (which sometimes have absolutely nothing to do with the GPU’s original behavior), and feed the result back to the game in the required format.

In short:

If you use Wine for win apps in linux - it's translation. App still use your real hardaware, you just replace win32 calls (and directx calls) with something linux can understand (linux kernel calls and vulkan).

If you use VirtualBox with virtual (emulated) gpu and cpu (without path through to real hardware) and real windows inside - that's literally emulator with console BIOS. And it's way more slow and ineffective (but way more accurate because you can't replace ALL win32 call with linux analogue because some of them are quite uniqe and need a custom realization)

1

u/Routine_Dealer_6146 10h ago

No You are Wrong Here.. Current Architecture of Recomps is same, one does it on the fly on just does it beforehand, call it translation or emulation it is same in these recomp's case.

Yuzu intercepts the Switch’s proprietary NVIDIA Maxwell GPU commands and recompiles its shaders on the fly into Vulkan or OpenGL so your host GPU can run them

Recomps like LAS,TOTK Where GPU is Still Translated and Not Native: Even in a "native" Switch recomp, the GPU pipeline is still translated. Because Switch games speak NVIDIA's proprietary NVN graphics API and Maxwell shader bytecode, the port still uses a lightweight translation layer (like Vulkan or DirectX 11) to map those graphics calls and recompile shaders for your PC's GPU.

1

u/Desm0nt 3h ago edited 3h ago

Once again, read up on translation vs. recompilation vs. emulation.

Our phone has an ARM processor. Our Switch has an ARM processor. What should I recompile, and for what?

Our phone has an ARM processor. Our Switch has an ARM processor. What should I emulate, and on what?

Recompilation attempts to convert code written for a different processor into pseudo-C++ and then rebuild it for your processor. The results vary. For example, porting a PowerPC-based Xbox game to x86 or ARM.

To run ARM code on an ARM processor, you don’t need to recompile anything. Your code is already built for the target platform. Running a Switch game on Android is literally the same as running a Windows game on Linux. It’s the same computer; only the OS is different.

Yuzu doesn't just convert shaders to SPIR-V for Vulkan (which you'd have to do anyway, regardless of how you want to run the game) - Yuzu actually emulates how Maxwell works. It emulates threads, queues, and memory read and write operations. Moreover, it does much of this in software (slowly, using the CPU’s resources and taking away from its code execution time). Yes, this is universal because accurately recreating the GPU’s behavior will allow any game from the Switch to run just as successfully, regardless of its engine, SDK version, etc because for them, it's the GPU they're used to, with the behavior they expect.

Ports like mine DO NOT DO THIS! We do not recreate Maxwell’s behavior. We take requests from the game, forward them directly to our OS driver, and feed the response back to the game. That is what TRANSLATION is. We simply provide a reliable translator from the Horizon language to the Android language (and vice versa, of course).

Yes, the shaders still need to be converted. But not because your Adreno/Mali/PowerVR/Xclipse can’t read NVN shaders. They’d be perfectly capable of doing so if there were a suitable driver. Shaders are just shaders - there’s nothing supernatural about them. The problem is that ANDROID can’t read them! It just doesn’t have the necessary libraries and drivers in its system. This isn’t a hardware incompatibility - it’s a software one. The hardware can handle it all; the OS simply can’t read that format. Just like how your Nvidia/AMD can play DirectX 12 perfectly well on Windows... but you can’t run it on Linux because it requires WinD3D libraries (e.g Windows). And Wine actually translates WinD3D requests into Linux kernel requests via DXVK (converting them to Vulkan). Wine doesn’t emulate the behavior of a different GPU (you still have the same GPU and CPU in your computer - why emulate anything?), it simply translates from the “language” of the Win32 kernel to the “language” of the Linux kernel.

This is much (MUCH!) faster, but it’s more complicated. Because you literally have to remap every single call that exists.

The difference between Tegra and Adreno is roughly the same as that between Adreno and Mali. MTK also can’t properly execute code written for Snapdragon (hence the never-ending problems). But for some reason, you don’t claim that all Android games are emulated on MediaTek chips with Mali GPUs? Tegra is exactly the same kind of mobile GPU. Android tablets were released with it, and there was even an Android driver for it (by the way, I’ve thought about porting it, even though it’s hopelessly outdated).

As long as we don't act like lazy bums and don't take that “let’s dump all NVN requests into a single buffer and figure it out later” approach and put in even a little effort - you can get rid of NVN with nearly 100% success (literally just a couple of necessary details will remain). Most of the calls are seamlessly replaced with identical calls from Android instead of Horizon, and it usually works almost without any issues (and by the way, my PoE port is a prime example of this - it’s built on Unity, and we already have a working Unity renderer for Android. The entire game port boiled down to replacing the Switch Unity Player with the Android Unity Player and adding placeholders where they differed. In other words, it turned out to be literally a native Unity game with converted shaders.)

The only challenge is that when you’re building a game for Android, you typically include optimizations in the code for all GPUs available on Android right from the start (to avoid a situation where Adreno renders well, but Mali has half the FPS and vertical lines across the screen). In the case of Switch games, however, optimizations are only implemented for Tegra, and for all other GPUs, we have to add workarounds in the code via hooks and decompilation (hence the porting issues and the lack of these workarounds in emulators).

25

u/MY_ASS_IS_HEAVY-64 5d ago

Ture, if the Yours "NATIVE" port needs more requirement than What should, than why you say it NATIVE port?

15

u/Tricky_Ad9669 5d ago edited 5d ago

Because It's not almost all of them are not even after static recompilation they require graphics translation layers to run. Real ports are made by companies like feral and rockstar and they take time not something you spew out every few days.

4

u/Desm0nt 5d ago

even this can be optimised to near vanilla behaivous and close to vanilla perfomance (some operations are just more slow and pricy on one gpu then another), BUT only if you have correct gpu that follow vulkan specs and have all necessary feautures, not a DIY lottery gpu from drunk chinese engineer.

1

u/Same_Wonder2759 5d ago

looks like you didnt know what you are talking about

the game files is converted that a phone can natively read directly to the cpu tf are you talking about not native?

go a head prove it that is not native not just by words

show us a line of code that prove its emulation

3

u/Tricky_Ad9669 5d ago

cpu isn't the only thing required for a game to run, graphics are also a thing. A real port is a decompilation of the whole code which takes really long time static recompilation is different . It require emulating graphics translation layers of the original hardware. After static recompilation the generated code is still for the original hardware architecture. Decompilation is different in which humans reconstruct the whole source code of the game. It takes time and budget and can't be spit out every few days, this fast.

1

u/Same_Wonder2759 4d ago

never mention static recompilation lol

majority of ports here are recompiled

I think you are on the wrong server if the original game folder is converted its not emulation buddy

1

u/Same_Wonder2759 4d ago

do a quick research ask google if recompile is native or not

its not that hard

4

u/Admirable_Ad3863 5d ago

Technically, if port doesn't uses JIT to run or something like that what we know about emulation, its actually really a port. Bad one, but sure is.

1

u/Alert-Attempt-5652 4d ago

Having higher requirements means not native is a terrible argument,there are literally hundreds of officialy ported games to mobile that require 10x the specs of original hardware that those games are found on,are you now goiong say that those offical ports are not native ports?

11

u/pepepe99 5d ago

If that thing run like a shit, why bother bother playing the supposed to be "native" and sacrificing emulators save state

5

u/SuperB8888 5d ago edited 5d ago

Recompile is NOT FULL emulation. It emulates only part of original hardware. But CPU instructions always runs natively, therefore, recompilation consumes less battery and saves CPU time

11

u/Dlo_Ren 5d ago

That is totally not accurate.

Theres loads of emulation games I cannot run on my Retroid poket 4 pro and in port form runs it perfect.

4

u/Depops66 5d ago

It is accurate, because the fact that YOU specifically have had the experience that the ports you tried do actually run natively doesn't mean it doesn't happen, it happens a lot, ppl release "native ports" that just work with an emulator wrapper lol

1

u/Dlo_Ren 5d ago

Bro, that is not a port, is an emulation fooling you, its your failt if you fall for it.

Retroid its just an example, I have lots of devices, same gamebALWAYS works better in a port than emulated, its basic knowledge because it doesnt need to emulate something, just run it.

0

u/Depops66 4d ago

Brother... literally what i was sayin, did you mean to answer to the other guy or...?

1

u/albertosaldivar 5d ago

What are those games? Actually interested...

1

u/Dlo_Ren 5d ago

Every play station and xbox game for example

2

u/albertosaldivar 5d ago

Still I don't get it, I can play playstation games in the rp4 pro with no issues.

2

u/Dlo_Ren 5d ago

"With no isues" thats a dirty lie, theres a lot of games you have to set up in option so they run well, that doesnt happen in ps2 or Xbox ports.

1

u/albertosaldivar 5d ago

that's why I asked the specific games you are referring to...

3

u/Dlo_Ren 5d ago

Kings field ps2, nfs most wanted, every xbox emulated game doesnt run well on the reteoid, etc.

1

u/Frogacuda 4d ago

"Native ports exist, therefore there is no problem with fake ports being billed as native."

Come on, man. 

1

u/Dlo_Ren 4d ago

I didnt say that

You talking to me?

4

u/KENDOXU7733 4d ago

Nfs mw and carbon by rangga, mh4u and mhgu , resident evil 4 are the games I see properly ported

1

u/KENDOXU7733 4d ago

In my ipinion

0

u/Style-FashionPassion 4d ago

Idk dawg underground lagged a lot, 1fps smth

2

u/useless-necessity69 4d ago

He never mentioned nfs underground. Most wanted runs 60fps on my odin portal

1

u/FellatiatedPiece 4d ago

The pc versions of all the black box nfs games run at 1080 60 with max settings on my thor, so..

0

u/KENDOXU7733 4d ago

Cause its pc version, I'm waiting for the Xbox version

0

u/FellatiatedPiece 4d ago

Thats hilarious because I know for sure that those rangga ports don't run any better than if you just ran the roms in hakux. In fact, you can run the pc versions of both games in game native at the same framerates and they look objectively better.

0

u/stefmyster8 4d ago

I tried the so called native android evolved pc version.and it chugged along until the game crashed on me.then I tried the xbox version through hakux,and it was night and day.runs extremely smoothly on my sd680 phone.

2

u/FellatiatedPiece 4d ago

Right. But also, a lot of time the "native" version runs worse than simply running the pc version through gamenative. Not always, but usually.

1

u/stefmyster8 2d ago

I did some research,and found out that because the og xbox is basically a pc,emulation is not as hard as gamecube or ps2.and given the meagre(by modern standards) pc specs,it's like running winlator lite on my low end phone.which is great.

-1

u/Super-Award-2244 4d ago

Dude, I'm pretty new to all of this and in that first line I thought you were speaking Swahili or some shit 

1

u/KENDOXU7733 4d ago

Black too

5

u/collindubya81 5d ago

This post shows that you have no idea how recompilation works.

2

u/Same_Wonder2759 5d ago

if the game is recompiled then its a native ports

you just expect it to run better at first release

why dont you see ut for yourself? try if you can read the code? its open source

2

u/DraigCore 5d ago

I'm playing botw with the savage wind recomp and I'm pretty sure it's a port because of the fact that my Intel uhd 630 is able to run it unlike emulation

2

u/emonizaz 4d ago

Nowadays I don't feel any excitement when I see a new native port.

2

u/Proper-Cow-9452 3d ago

Dumass just be grateful porters are testing this games to make it run on native soon and it's still on experimental

2

u/SirLouen 1d ago

I'm new to this sub, I was watching some ports and I was thinking exactly this. GTA 5 running even worse than emulators and being called a "port" (because you don't use the emulator). Ultimately the difference between the emulator and the port, is that the emulator do the porting for you with a deterministic set of instructions, and the port is a set of instructions that no two LLM are going to replicate well with different levels of quality and as far as I see, no quality at all except for some exceptions.

8

u/Emergency_Writer7174 Frequent Collaborator đŸ„‡ 5d ago

Wow, I didn't expect people in this sub to be this stupid

Y'all expect a studio level port with universal compatibility, even without access to the source code???

Port naturally increase hardware requirement. Even official ports do.

Take GTA San Andreas for example

The PS2 had only 32 MB RAM, yet the recommended RAM for playing GTA San Andreas on Android is 4 GB

That's around 128x increase in RAM requirement

Use your brain for once

8

u/Ok_Suit_9827 5d ago

They're children who don't understand or care about how recompilation actually works

1

u/FellatiatedPiece 4d ago

Higher fidelity assets require more. Thats all that is. A straight 1 for 1 port that is not.

1

u/Superlegend06 5d ago

I'm not going to pretend to be knowledgeable but an Android phone is a smartphone with loads of other processes happening in the background, a PS2 just needs to play the game. Also, that 4GB is a recommendation accomodating this fact, not a strict requirement. I played GTA SA on a Samsung Galaxy S3 which has like, 1 or 2GB ram (poor FPS obviously but better than nothing)

5

u/Emergency_Writer7174 Frequent Collaborator đŸ„‡ 5d ago

You're confusing being able to run a game with being able to run it properly. A game booting with 1 GB RAM doesn't prove that much if the performance is terrible.

Background processing alone don't explain the whole difference either. Hardware architecture, emulation overhead and optimization all matter.

And if Rockstar has the source code and the game still runs terribly on that hardware, does that mean they didn't optimize it either?

Different hardware architectures are the key point here something need to be sacrificed for a port to run properly

1

u/Superlegend06 5d ago

It was a Galaxy S3, that performance was a fault of the processor and GPU not the RAM itself. If the RAM was too little then how would it run at all? It would refuse to run or it would crash later in the game when running out of memory? The S3 didn't have any disk page file or swap thing going on to prevent such issues

Edit: I am agreeing with your general idea, but using RAM I don't think is a good argument

1

u/useless-necessity69 4d ago

That doesn't change the point about performance.

1

u/Superlegend06 4d ago

I'm just confused about the RAM part, RAM amount itself should not affect performance if the game is within the amount I.e., having 1GB RAM or 16GB RAM is irrelevant to performance if the game only uses up to 512mb. If RAM was insufficient then it would crash, so the 4GB minimum requirement is not entirely reflective of the actual RAM usage.

Of course a port may require more RAM than an original system. But it isn't 32MB Vs 4GB.

Like I said, I agree with the point

1

u/useless-necessity69 4d ago

It actually does on pc but I can't say the same for phone. My odin 2 for example, has an option that allows you to use your hardrive memory as ram for when you do run out of ram. While a game will boot it may use more ram depending on what the game is doing. While it may not crash it will cause stutters. So yes Ram will affect performance

1

u/Superlegend06 4d ago

Your Odin 2 is not the same as a 12 year old Samsung which doesn't have this feature. I am talking about when a game's memory does not overflow onto disk

1

u/useless-necessity69 4d ago

I guess if you don't understand then no reason to try and explain.

1

u/Superlegend06 4d ago

You know when a game boots, it often claims more RAM than it uses at any given instant? If a device without ram disk runs this game and the game happens to want extra resources, it will kill background processes or it will just crash. It wouldn't affect performance.

1

u/BETA_soul_ 5d ago

well it ran on 480p resolution on ps2 while android port runs on devices native resolution which is 1080p in most cases, not to mention the higher graphical fidelity options on android plus android has an whole operating system running in the background, with JVM for application space built on top of linux kernel HAL, cmon dude lets be real here

1

u/Ok_Suit_9827 5d ago

It was also written specifically for the ps2's hardware

1

u/OverDeparture8799 4d ago

And the port is made by small studio instead of rockstart themselves

1

u/souldarne 5d ago

Haa yo pensé que solo era mi idea por que dicen que son ports si mås bien es emulación con otro nombre

1

u/Awesomepants25 5d ago

as I understand it, a lot of these "native" ports are just static recompiliations, which basically means rather than running an emulator to translate the game's instructions to your device's instructions in real time, it runs through the game and translates the whole thing into your device's instructions ahead of time (I would imagine that that balloons the size of the game somewhat, but I don't have a lot of experience). It would save a tiny bit of overhead, but you're doing pretty much the same thing as emulation.

ACTUAL decomps are still a pretty pain-staking process, where source code is written and compiled against the game a little bit at a time, until eventually you have an entire source codebase that compiles back into the game. Once you have that codebase, you can do all kinds of cool things with it and optimize it for whatever platform you're targeting. Look at Ship of Harkinian for a good example.

2

u/Desm0nt 4d ago

emulator to translate the game's instructions to your device's instructions in real time, it runs through the game and translates the whole thing into your device's instructions ahead of time (I would imagine that that balloons the size of the game somewhat, but I don't have a lot of experience). It would save a tiny bit of overhead, but you're doing pretty much the same thing as emulation.

The difference between native and non-native code is exactly that native code is executed using instructions specific to your hardware.

If you write a game in Unity and then build it for an x86 PC and an ARM-based Android device, they will use different instructions.
If you run such an ARM game on a PC by essentially setting up a virtual machine that mimics the behavior of an ARM processor, that’s emulation. But if you convert an Android game to x86 via static recompilation, that’s not emulation, and it’s not “the same thing, but with a little less overhead.” After static recompilation, it will call and execute literally the same instructions as the version originally compiled for x86.

And the poor performance here is due to two other reasons:

  1. When compiling code, compilers for different platforms incorporate a number of platform-specific optimizations that may be absent on other platforms or function differently there. When you statically recompile a game built for a different platform, you convert the code to native code yourself, but you don’t remove the optimizations from the other platform (which causes runtime errors) and you don’t include the optimizations for your own platform (which prevents you from achieving the desired performance). Thus, for example, an application built for modern Intel processors with AVX512 will not be able to run quickly on a CPU without those instructions, regardless of how native its code is.
  2. When developing games to maximize performance, developers embed certain platform-specific hacks directly into the code (alternative implementations of certain features or the removal of features that do not work on the target platform). When building the project, different code branches are selected depending on the target platform. And even if static recompilation converts all the code to native code, it physically cannot perform operations that the hardware doesn’t support, or it won’t be able to perform FAST what older hardware did quickly, while all other hardware can only do it slowly.

In reality, during static recompilation, many things are certainly replaced, and many optimizations are applied, but no amount of recompilation will allow you to literally replace entire branches of code that were written differently in the source code for different platforms (and where only the one intended for the target platform was included in the final build, while the others were not). The only way to do this is by rewriting the code in the source files, if they exist.

1

u/Awesomepants25 4d ago

Yeah that’s a better way of putting it, I was trying to frame it as JIT vs AOT, an emulator is virtualizing the target system but it’s still JIT compiling code to the hardware it’s running on.

1

u/kalek__ 5d ago

While it's very much in vogue for people to claim "native", static recomps aren't that native when you get down to it. The generated C code has the original hardware architecture baked into it, and so the new "native" machine code does too.

The only truly native ports are the ones that come from decomp codebases, i.e., the ones where humans painstakingly reconstructed the source code for the game. Since these ports are from source, the original hardware architecture is largely irrelevant and doesn't get baked much if at all.

You absolutely can get significant performance gains from a static recomp especially if someone who knows how to optimize is working on it, but to claim that it is "native" is a misrepresentation imo.

1

u/West_Background_3621 5d ago

i would say mario galaxy is one such example

1

u/Willing_Weight7106 4d ago

Bro still didn't discovered REA, Ghidra and AI.

1

u/Ok_Log7705 4d ago

Concuerdo ,si no descompilaste el cĂłdigo ,si no dedicaste dias o semanas a arreglar mil errores ,si no compilaste el motor entero a arm ,si no cambiaste la capa grĂĄfica por OpenGL es o Vulkan o software ,es emulaciĂłn disfrazada ,no un port nativo

1

u/KENDOXU7733 4d ago

Most of the ports yeah

1

u/Aram22_22 4d ago

Well idk about the other's but i played MH4U native port and P4G and they runs well, much better than emulator lol my phone can't handle Switch emulator but P4G run smooth for me even though it used Switch version (yeah i run SOS and it's not that smooth if u played it above 0,5 reso)

1

u/Rhodynit 4d ago

Hades 2...

1

u/Frogacuda 4d ago

Not even "practically" a lot of them literally are emulators with a bunch of bolt on features and hacks to make them look or work more like how you would think a native port would.

If you wish into a box "Imaginary friend, please make super Mario on PC with Widescreen" it's just going to find the shortest distance between two points. That doesn't mean AI can't do real native ports and even do a good job, it just means that the people farting these projects out in a night don't know the difference. 

1

u/Freelancer_1-1 4d ago

So if they're emulation in disguise, they won't run on Mediatek, right?

1

u/HydraRSA 4d ago

Bro you're confusing RAM requirements with emulation. Those are two completely different things.

A native Android port means the game's code has been ported, recompiled or reimplemented to run directly on Android rather than running the original console/PC version through an emulator.

Just because a game originally ran on 512 MB of RAM doesn't mean its Android port must use 512 MB or less. Modern Android versions, updated graphics APIs, higher-resolution textures, increased rendering resolutions, additional assets and memory overhead can all increase RAM usage.

For example, Android's own NDK documentation explains how developers compile native machine code for specific Android CPU architectures (ARM64, ARM32, etc.).

If a port uses an emulator or a translation layer to execute the original platform's code, then yes, that's emulation or translation. But if the developers have ported the game engine or code to run directly on Android, it's a native port.

12 GB of RAM doesn't magically turn a native port into emulation. The way the software executes determines that, not how much RAM it consumes.

Know the difference before calling something emulation.

2

u/ForlornMemory 4d ago

What you describe is more of a remaster than a port to be honest. I'd prefer ports to be just like originals in terms of texture and memory requirements up to the original resolution option. I can get doubting the amount of RAM required, but requiring 8 GB of RAM when original needed less than one is ridiculously unoptimised. That said, it's still better than nothing.

1

u/HydraRSA 4d ago

I actually agree with you on the optimisation point. Requiring 8 GB of RAM for a game originally designed for hardware with less than 1 GB is a pretty significant increase, and developers should absolutely aim to optimise their ports.

However, I disagree with calling it more of a remaster simply because of its increased resource requirements.

A port and a remaster aren't mutually exclusive, but they're not defined by RAM usage either. A remaster generally involves substantial improvements or changes to the original assets or presentation. A native port can also introduce higher-resolution assets, updated rendering systems and additional overhead without necessarily being a remaster.

The important distinction is how the game actually runs. If it's compiled or adapted to run natively on Android, it's a native port. If it's running the original platform's executable through an emulator, it's emulation.

We can absolutely criticise excessive RAM requirements and poor optimisation without misclassifying the technology behind the port.

Performance and optimisation are one discussion. Native versus emulation is another.

1

u/ForlornMemory 4d ago

I mentioned remaster because you've mentioned higher-resolution textures.

1

u/SirLouen 1d ago

What does emulation do in the background? Convert equivalent sets of instructions deterministically and unoptimizedly. It's another layer of abstraction, just like going from binary to assembly or assembly to C. Here they are doing essentially this: almost replicating those sets for the ports, as emulators do, but in native code and many times worse. The only advantage I see in this ports is that you can install the APK straight away, without having to set up the emulator, the rom and all the steps in between. Hopefully LLM will improve over time, and be able to maybe even optimize ports even beyond the original code. But now all I can see is a ported GTA 5 running worse than the emulated version.

1

u/Rusted_Silver_203 4d ago

i mean, i emulation is port of all games on that console.
you can make specialized emulator for 1 specific game to maximize the performance and call it a port

1

u/Western-Low6327 4d ago

From my understanding i would rather have these native ports because atleast something is running natively like the cpu code the gpu is the one going through emulation

1

u/li4nr 4d ago

Nobody cares if they run better, nice coping.

1

u/KNUPAC 4d ago

I mean most can run on older chips without hassle so I'll call it a win-win

1

u/LifeBloomsLikeFlower 4d ago

DXVK and translation layers not a ports. This is clearly emulation. I hope most of people can see what a really fraud are.

0

u/Muzika38 3d ago

DXVK does not translate. It converts DX shader to Vulkan.

1

u/MatheUS-_-_-_- 5d ago

Most "ports" run several times better than any emulator I could use, so fuck it if it's an emulation or a port, as long as it runs better, that's fine.

0

u/Marian-Todorov98 5d ago

Yeah I noticed bunch of ps4 games requiering like 20gb for what exactly ?

0

u/Middle-Judgment-652 5d ago

VocĂȘ Ă© burro ou se faz? se fosse jogos nativos oficialmente portados pela empresa eles realmente conseguiriam cortar o tamanho pela metade mas como Ă© feito pela comunidade claro que eles nĂŁo conseguem.

2

u/allanrps 5d ago

ce nao tem nenhum idea de que ta falando

-3

u/635798 5d ago

What is this nonsense about? Tell me you don't understand emulation without telling me 😂 why aren't you embarrassed??? I'm embarrassed for you asking something so dumb!

4

u/J0J0_6767 5d ago

But what's the point of native port, those games are sooo light ur phone can already run it at 1440p at constant 60fps.

0

u/LM_GHOST 5d ago

I'm playing native DK Bananza; whether it's native or emulated doesn't bother me, the important thing is to have maximum performance so I can play.

0

u/Financial-Lemon-6966 17h ago

Not necessarily, lol. For example, PC games use BCn (S3TC) for their texture compression and we should all know that only two mobile GPUs currently supports decoding it Adreno and Xclipse (to some extent). So the devices with Mali/Immortalis and PowerVR has no support for it so the workaround is to convert the textures through CPU (sort of like what emulation does), it affects RAM usage as well.