Windows 'not an emulator' compatibility tool Wine 6.4 out now

Could anyone give me a one-sentence summary on the difference between emulators and translation layers? I've done some searching and I think I got the gist of it (low-level emulators are basically trying to recreate the emulated OS instead of just wrapping individual functions), but I couldn't see much distinction between high-level emulation and a translator.

Quoting: PinguinoCould anyone give me a one-sentence summary on the difference between emulators and translation layers? I've done some searching and I think I got the gist of it (low-level emulators are basically trying to recreate the emulated OS instead of just wrapping individual functions), but I couldn't see much distinction between high-level emulation and a translator.

from my limited understanding is that emulators try to emulate everything from hardware to software.
wine doesn't emulate hardware, is why its a translation layer

QuoteCould anyone give me a one-sentence summary on the difference between emulators and translation layers?

Emulators emulate, translation layers don't. :P

I'm posting it as a comment rather than a correction because I may well be completely wrong, so I'd welcome discussion, but

QuoteOnce a year or so, all the development is bundled into a stable release.

By my understanding, this is actually backwards. My understanding of the Wine development process is that they produce a major version at the beginning of the year, which may get a handful of maintenance updates. Every two weeks Wine gets a point release that's moving towards the major release at the start of the next year. So it's not that the major version bundles up the changes, but rather that that release was the target for the previous year's development work. Much like the non-LTS releases of Ubuntu are test versions for the next LTS. release. But I could be wrong.

Quoting: CatKillerMy understanding of the Wine development process is that they produce a major version at the beginning of the year, which may get a handful of maintenance updates

Pretty much correct.

Quoting: CatKillerEvery two weeks Wine gets a point release that's moving towards the major release at the start of the next year.

The point releases are development releases, says so right on the box ;)

Most of what you're saying isn't different to what I am saying, other than splitting hairs over the exact way to word it. The fact is that 6.x releases are development builds where all the new features go in. Then once a year they do a stable release which will be 7.0 and before that there's several Release Candidates to clean up issues from all the development builds.

Quoting: Liam DaweMost of what you're saying isn't different to what I am saying, other than splitting hairs over the exact way to word it.

Yes?

That the .0 stable releases get support and the dev releases don't is a distinction that I didn't think was conveyed by your wording which, to me, made the yearly releases seem like another point release. So I flagged it up, with caveats in case I was wrong, so that you could consider alternative wording, or so that it would at least be clarified in the comments. Both of which, I assume, have now been done.

In this wine version crashday (old release works in my case) with d9vk 1.8.1






Last edited by mrdeathjr on 13 March 2021 at 1:27 pm UTC

Quoting: PinguinoCould anyone give me a one-sentence summary on the difference between emulators and translation layers? I've done some searching and I think I got the gist of it (low-level emulators are basically trying to recreate the emulated OS instead of just wrapping individual functions), but I couldn't see much distinction between high-level emulation and a translator.

TLDR: A translation layer is passive while an emulator is active.

I think the cleanest way to explain is that in a translation layer, the target code is executed as is, natively. There is no action on the code itself, it runs normally on the hw, without any active layer in between. This means that the translation layer is completely passive, you just drop libraries that translate a windows call into a Linux one, and they are called transparently by the target code.

An emulator on the opposite is active, even for an "high level" emulator. There is an active piece of sw that reads the target code and modify it on the fly, executing the resulting code on the host. You can have various levels of emulation, if both target and host have the same CPU arch, you can for example only replace some bits of codes to call a different set of sw function, or you could translate older instructions into new optimized one. You can also emulate some target sw parts, such as the os, using a native library. So when you catch a call to a syscall used to print a char, instead of translating the target implem of that syscall, you will replace it with a call to the native version. And of course, you can also have a complete emulator (older consoles that don't really have an OS as an example) which will translate absolutely all the code, and also emulate the hw itself to have the best precision (accurate timing information as an example).


Last edited by 3zekiel on 13 March 2021 at 1:32 pm UTC

Quoting: PinguinoCould anyone give me a one-sentence summary on the difference between emulators and translation layers? I've done some searching and I think I got the gist of it (low-level emulators are basically trying to recreate the emulated OS instead of just wrapping individual functions), but I couldn't see much distinction between high-level emulation and a translator.

A one-sentence summary would be quite hard, but basically you have done it yourself. An emulator emulates the entire system, so WINE as an emulator would be emulating bios+cpu+kernel+windows (and a specific version of it), while WINE as a translator only translates as much of the system calls provided by the Windows kernel that applications and games needs in order to run, and the application is executed by Linux and not by any emulated Windows.

WINE the emulator would allow you to say run amd64 applications on your arm/sparc/68k machine while WINE the translator requires you to run on the exact same hardware that the Windows application thinks it runs on.

My take on low-level emulation vs high-level emulation is that low-level emulation would emulate the hardware on a chip basis while high-level emulation would be emulating the hardware on a functional level. I.e most software emulators are high-level (if they have any form of performance) while FPGA emulators (and some very very slow software emulators) are low-level emulators.

cursor appear in cod modern warfare 4, maybe fix call of duty 2 (show same issue with d9vk)






Last edited by mrdeathjr on 13 March 2021 at 1:59 pm UTC