Support us on Patreon to keep GamingOnLinux alive. This ensures all of our main content remains free for everyone. Just good, fresh content! Alternatively, you can donate through PayPal. You can also buy games using our partner links for GOG and Humble Store.
We do often include affiliate links to earn us some pennies. See more here.

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

By - | Views: 27,953

Not an emulator but a compatibility tool that translates Windows calls into language Linux can understand, Wine 6.4 is officially out now as the latest development release.

For newer readers and Linux users here's a refresher - Wine is a compatibility layer built for operating systems like Linux, macOS and BSD. The idea is to allow other platforms to run games and applications only built and supported for Windows. It's also part of what makes up Steam Play Proton. Once a year or so, all the development is bundled into a stable release.

Here's what's new in Wine 6.4:

  • Support for the DTLS protocol.
  • Fontset support in DirectWrite.
  • Dialog for editing Access Control entries.
  • Theming support for a few more common controls.
  • Support for Korean Wansung encoding.

There's also 38 bugs noted as fixed this time around. As usual some being quite old that were fixed a while ago, each release sees the team go over bugs to see what are still actually a problem. Like with this release a bug report from 2007 was finally marked as solved along with issues fixed for: Civilization IV, Soldiers of Anarchy, The Elder Scrolls V: Skyrim SE, Entropia Universe, Banished, Horizon Zero Dawn, Serious Sam 4, The Witcher 3 and more.

Article taken from GamingOnLinux.com.
19 Likes
About the author -
author picture
I am the owner of GamingOnLinux. After discovering Linux back in the days of Mandrake in 2003, I constantly came back to check on the progress of Linux until Ubuntu appeared on the scene and it helped me to really love it. You can reach me easily by emailing GamingOnLinux directly. Find me on Mastodon.
See more from me
The comments on this article are closed.
21 comments
Page: 1/3»
  Go to:

Pinguino Mar 13, 2021
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.
Xpander Mar 13, 2021
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
WorMzy Mar 13, 2021
QuoteCould anyone give me a one-sentence summary on the difference between emulators and translation layers?
Emulators emulate, translation layers don't. :P
CatKiller Mar 13, 2021
View PC info
  • Supporter Plus
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.
Liam Dawe Mar 13, 2021
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.
CatKiller Mar 13, 2021
View PC info
  • Supporter Plus
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.
mrdeathjr Mar 13, 2021
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
3zekiel Mar 13, 2021
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
F.Ultra Mar 13, 2021
View PC info
  • Supporter
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.
mrdeathjr Mar 13, 2021
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
While you're here, please consider supporting GamingOnLinux on:

Reward Tiers: Patreon. Plain Donations: PayPal.

This ensures all of our main content remains totally free for everyone! Patreon supporters can also remove all adverts and sponsors! Supporting us helps bring good, fresh content. Without your continued support, we simply could not continue!

You can find even more ways to support us on this dedicated page any time. If you already are, thank you!
The comments on this article are closed.