Hacker News Reader

Comment by slantyyz | Hacker News Reader

> it emulates API of an OS that has very large amount of software it runs

I thought WINE stood for Wine Is Not an Emulator - has that changed?

It's supposed to be an API translation layer. So there's no VM, no interpreting of machine code, none of the usual "emulation stuff." Running a Windows binary on Linux via WINE is your x86 processor directly executing the real x86 machine code, just with a compatibility layer providing equivalents whenever the binary tries to call Windows or DirectX APIs.

WSL1 did the same thing in reverse, though WSL2 abandoned that course and does in fact use virtualization.

I find the change in direction particularly interesting. Intuitively, virtualization would have been one of the first and easier suggestions for any system. But they decided to take on the monumental task of implementing a translation layer. It’s probably not their first time either since they did support POSIX in some old versions of Windows. Then they switched to virtualization. I’m guessing it was simply not a sustainable effort? Still a bold move and an interesting part of Windows history.

They had to use the syscall translation path because of the earlier plans.

WSL is what could be saved from the Astoria subsystem to run Android apps on Windows 10 Mobile, with the ARM virtualization story being nonexistent at the time for shipping smartphone SoCs.

If you're interested, the Build talk where WSL2 was introduced is pretty in-depth and does a great job of talking about the motivation. See starting around this point: https://youtu.be/lwhMThePdIo?t=1070

It emulates the OS, not the CPU or other hardware. So it's not what you'd expect if you wanted "an emulator", like DOSBox. But there's still some "emulation" going on.

They may be say that but if it isn't emulating Windows API what is it doing?

IMO (this is just a guess, and might be completely wrong) but I have a feeling that originally WINE stood for WINdows Emulator.

Emulation is typically reserved for processor emulation. A NES emulator works by simulating the CPU, PPU (GPU), bus and other parts of the NES system on the computer running the emulator. DOSEmu, QEmu, and Amiga Forever work in similar ways.

When Wine runs an application or game, that program is executing directly on the computer's CPU, so it is not an emulator.

Think of it like when you have a Qt/KDE or Gtk/Gnome application and run that on the other platform, or on Windows or Mac. You have the APIs the application is calling (Qt or Gtk) which are the same regardless of the platform they are running on; for Wine these are the Windows APIs. The libraries then map the library APIs to the platform APIs, like how Wine is mapping the Windows APIs to Linux/Mac/etc.

Word emulation means to pretend something else, just because most of the time emulating hardware is required doesn't mean that the meaning of the word change.

Since you mentioned Amiga, there was an MacOS emulator called ShapeShifter[1], it didn't emulate CPU since at the time MacOS used the same CPU as Amiga, but it still referred itself as an emulator. Actually I remember that MacOS run even faster on Amiga + ShapeShifter than original Mac with similar hardware.

If you are not convinced, what about FreeBSD capability to emulate Linux[2] ABI allowing to run linux binaries as if they were native. This also doesn't emulate the CPU and other hardware. And I suppose it is even closer to what WINE does.

[1] https://shapeshifter.cebix.net/

[2] https://www.freebsd.org/doc/en/articles/linux-emulation/free...

That's a lost etymological battle, just like we can forever repeat that "hacker" does not equal "cybercriminal": even though the thesaurus says otherwise, one narrower definition of the word has taken over.

I don't think this is comparable. World emulation exists outside of technology, and has specific meaning (pretending to be something else).

Also in this case (unlike word "hacker") the word isn't used incorrectly. It's just more broad than most people think. It's only WINE that claims itself to not be emulator, despite in early FAQ calling itself Windows Emulator.

WINE does two things. The first (and easier) thing they do is they implement a loader for the Windows executable file format(s); think of it as transpiling a Windows binary to a Linux binary. The second (and more difficult) thing they do is they provide an independent implementation of the Windows API.

These two things are largely orthogonal. WINE also provides Winelib, which lets you compile a Windows application into a Linux ELF binary--doing the second thing without the first one.

That's called emulating.

There are actually game console emulators that do transpilling[1] as well.

Anyway WINE originally stood for WINdows Emulator, which was reflected by the old FAQ still referring to it by that name.

Whomever came with backronym "WINE Is Not an Emulator" was simply wrong, and current FAQ actually tries to defend it, but then ultimately at the end states that more accurately it should be "WINE Is Not just an Emulator", because it does more than just emulating (for example it comes with Windows components, that you could even run on original windows).

I suppose they wanted to distance themselves from the notion that an emulator has to be slower, but this is not true. The ShapeShifter for Amiga was actually faster than MacOS with comparable hardware. Similarly all modern VMs now utilize hardware support so you're getting a native speed.

[1] not sure if this is the right word, since transpilling typically is used with source code, and I believe we are talking about translating machine code to another machine code.

Reply on news.ycombinator.com