Check out our Monthly Survey Page to see what our users are running.

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

By - | Views: 19,746

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, Who?
We do often include affiliate links to earn us some pennies. We are currently affiliated with GOG and Humble Store. See more here.
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.
See more from me
23 comments
Page: 1/3»
  Go to:

Pinguino 13 Mar
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 13 Mar
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 13 Mar
QuoteCould anyone give me a one-sentence summary on the difference between emulators and translation layers?
Emulators emulate, translation layers don't. :P
CatKiller 13 Mar
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 13 Mar
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 13 Mar
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 13 Mar
In this wine version crashday (old release works in my case) with d9vk 1.8.1

link




Last edited by mrdeathjr on 13 March 2021 at 1:27 pm UTC
3zekiel 13 Mar
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 13 Mar
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 13 Mar
cursor appear in cod modern warfare 4, maybe fix call of duty 2 (show same issue with d9vk)

link




Last edited by mrdeathjr on 13 March 2021 at 1:59 pm UTC
While you're here, please consider supporting GamingOnLinux on:

Patreon, Liberapay or PayPal Donation.

We have no adverts, no paywalls, no timed exclusive articles. Just 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!
Login / Register

Or login with...
Sign in with Steam Sign in with Twitter Sign in with Google
Social logins require cookies to stay logged in.

Livestreams & Videos
Community Livestreams
Latest Forum Posts