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.

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.

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

Could 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

Once 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.

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

Pretty much correct.

Every 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.

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.

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

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.

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

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.

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

Not an emulator but a compatibility tool

Love you :D <3

tried many games through lutris with new Wine and vulkan and must say it shows very good...even games not before running now works.

[quote=Guest]

A one-sentence summary would be quite hard

Challenge accepted.

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

Think of WINE as an interpreter for spoken languages. WINE translates the language between Windows and Linux, while an emulator attempts an exact recreation of hardware with software.

As pointed out earlier, this is actually not really correct or perhaps confusing -- the language on (most) Linux systems is x86, as is on (most) Windows. But, while the language is the same, Windows and Linux have different "higher level concepts", and Wine can sort of work as a dictionary for looking up the Windows "meaning". But the analogy falls apart rather fast.

The point is: An operating system doesn't execute a program, really, it just nudges the CPU to do the actual execution. The OS is just there for outsourcing some tasks that otherwise every program would need to do (much simplified). Programs ask the OS to do these tasks for them, however the interface b/w OS <-> program differs from Windows to Linux.

So, while most parts (in theory) of a Windows and a Linux binary are pretty much the same, they differ when it comes to asking the OS to do tasks like "render picture on screen". In that case, the program can then consult Wine and Wine tells Linux what to do.

Side note: Actually the complete Windows OS API is already such a translation layer. Because the "actual" OS (the Kernel) when using Windows doesn't "speak Windows" (win32) but NT. So while on Windows asking to render a picture looks like:

program -> Win32 API -> NT API

on Linux it looks like:

program -> Wine -> Linux API

So, basically, Wine is a Win32 API implementation (and program loader) for the Linux kernel instead of the NT kernel one.

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.

In narrow sense emulator can mean something that emulates hardware. I.e. imagine something that implements one CPU architecture in software to run on another CPU architecture (example - Qemu).

In a wider sense it means any kind of imitation. So in the first sense Wine is not emulating hardware. But in the second sense Wine is emulating Windows.


Last edited by Shmerl on 14 March 2021 at 2:40 am UTC

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.

In narrow sense emulator can mean something that emulates hardware. I.e. imagine something that implements one CPU architecture in software to run on another CPU architecture (example - Qemu).

In a wider sense it means any kind of imitation. So in the first sense Wine is not emulating hardware. But in the second sense Wine is emulating Windows.

Maybe, but I'm pretty sure the people who named Wine would beg to differ on that. I think the position would be something along the lines of, an emulator for Windows would be something that basically reproduced the Windows API-whatever in userspace and had Windows programs run in it, whereas what Wine was doing was just translating the Windows program's requests so Linux would understand them.

If Wine meant "Windows emulator" (which is totally why it's called what it is) then there would be potential trademark heat from 90s Microsoft on top of potential heat from the merits of Wine's functionality. Using the fashionable-at-the-time recursive acronym and actuallying the name by the 90s terminology meant that they got to keep the project name and not use anyone else's trademark.

When they talk about vulkan rendering fixes, has this any impact on VKD3D/D9VK or is this their Vulkan implementation they are talking about?

When they talk about vulkan rendering fixes, has this any impact on VKD3D/D9VK or is this their Vulkan implementation they are talking about?

The Wine release notes wouldn't list fixes to third-party software, so yeah, they're talking about WineD3D.

Maybe, but I'm pretty sure the people who named Wine would beg to differ on that. I think the position would be something along the lines of, an emulator for Windows would be something that basically reproduced the Windows API-whatever in userspace and had Windows programs run in it, whereas what Wine was doing was just translating the Windows program's requests so Linux would understand them.

Or you could apply duck typing here. I.e. if it behaves like Windows, it emulates Windows. How exactly it does it underneath is really not very important for the program for which Wine acts as Windows environment (thus emulating Windows).

[quote=Guest]

A one-sentence summary would be quite hard

Challenge accepted.

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

Think of WINE as an interpreter for spoken languages. WINE translates the language between Windows and Linux, while an emulator attempts an exact recreation of hardware with software.

As pointed out earlier, this is actually not really correct or perhaps confusing -- the language on (most) Linux systems is x86, as is on (most) Windows. But, while the language is the same, Windows and Linux have different "higher level concepts", and Wine can sort of work as a dictionary for looking up the Windows "meaning". But the analogy falls apart rather fast.

The point is: An operating system doesn't execute a program, really, it just nudges the CPU to do the actual execution. The OS is just there for outsourcing some tasks that otherwise every program would need to do (much simplified). Programs ask the OS to do these tasks for them, however the interface b/w OS <-> program differs from Windows to Linux.

So, while most parts (in theory) of a Windows and a Linux binary are pretty much the same, they differ when it comes to asking the OS to do tasks like "render picture on screen". In that case, the program can then consult Wine and Wine tells Linux what to do.

Side note: Actually the complete Windows OS API is already such a translation layer. Because the "actual" OS (the Kernel) when using Windows doesn't "speak Windows" (win32) but NT. So while on Windows asking to render a picture looks like:

program -> Win32 API -> NT API

on Linux it looks like:

program -> Wine -> Linux API

So, basically, Wine is a Win32 API implementation (and program loader) for the Linux kernel instead of the NT kernel one.

What exactly are you trying to prove with all that? because all I see is a kid just wanting to prove some one wrong on the internet again. See this is the reason I don't post here much, there is always some self proclaimed Linux GURU wanting to prove you wrong. It's petty.
I know all about coding, how operating systems work, and how API's communicate, you don't need to prove any thing to me. Don't just assume other people don't know any thing.
Technically, you're (almost) right, congratulations to you. But you missed one stupidly obvious and huge point, the OP's original question.
"Could anyone give me a one-sentence summary on the difference between emulators and translation layers?"
He wanted a short summary of the difference between them. Not a lecture of the in's and out's of how API's work.
So in a short summary, I am still right, because while WINE is an API (like you say), it still just [/i]acts as a translator/interpretor between Windows and Linux API's.
I could have always just said "kernel>api>wine api>api>kernel", but that's not what he asked for is it?

Dude, chill.