Winlator components: Wine, drivers, DX wrappers, runtimes explained

Published by WinlatorAPK, an independent guide site run by Android emulation enthusiasts. We are not affiliated with brunodev85 or the Winlator project. More about us.

Winlator looks like one app. Under the hood: Wine translates Windows calls, Box64 translates CPU instructions, DXVK translates graphics calls, and a GPU driver draws the result. On a Snapdragon phone, use the newest Turnip driver with DXVK for DirectX 9 to 11 games. That combination fits the large majority of games people run.

Knowing which layer is responsible turns hours of random guessing into a five-minute targeted fix when something breaks. New to Winlator entirely? Start with the main overview, then come back. Already tuning for speed? The performance settings guide lists what to change for each symptom; the parts below explain what each component actually does.

What does Wine actually do?

Wine is the heart of Winlator. It is not an emulator in the classic sense. It doesn't pretend to be a whole computer. Instead it's a compatibility layer (WineHQ documents the project): when a Windows program says "draw a window" or "open this file" or "play this sound," Wine translates that request into the equivalent call on the host system. On a desktop Linux PC, that's the Linux kernel. Inside Winlator, it's Android.

This is why Winlator runs Windows software without a copy of Windows and without the crushing cost of full hardware virtualization. Wine handles the Windows API, the thousands of functions programs expect to find. Other components handle the CPU instructions and the graphics. Wine handles the "Windows" part.

Winlator containers let you pick which Wine build a container uses. Newer Wine versions support more programs and fix long-standing bugs. Now and then a specific game prefers an older build. Start with the default and change it only when you have a reason. "The game crashes on launch and the driver, wrapper, and resolution are all correct" is a reason. Curiosity is not.

What are Wine Mono and Wine Gecko?

Two Wine sub-components come up constantly, so let's define them once:

If a program installer complains about missing .NET or dies on an embedded web page, the usual cause is a container created with a minimal startup selection. The fix is to recreate the container with the fuller component installation rather than hunting down individual pieces.

Box86 and Box64: the CPU translation layer

Here's the part people misunderstand most. Wine translates Windows API calls, but your phone's processor speaks a different language than a Windows PC's processor. PCs use x86 and x86-64 instructions. Android phones use ARM. Something has to translate the program's machine code, instruction by instruction, and that something is the CPU translation layer.

Winlator bundles both, and for most users they're invisible. You pick a game and the right translator handles it. You don't configure Box86 or Box64 directly in stock Winlator. They're worth understanding for one reason: they explain the performance cost. Every CPU instruction in the game gets translated on the fly, which is why Winlator needs a genuinely fast phone CPU and why some CPU-heavy games struggle even when the graphics look fine. When a game has a good framerate but stutters, or runs fine in menus but chokes in busy scenes, the translation layer is usually the bottleneck, and no graphics setting fixes that.

What is FEXCore?

You'll see FEXCore mentioned in community discussions, especially around Winlator forks and mods. FEXCore is an alternative x86-64 emulator: a different engine doing the same job Box64 does. Some community builds experiment with it, and threads compare the two on specific games. In stock Winlator, Box64 is the translation layer and FEX is a fork and mod topic. If you're curious about the builds that use it, the forks and mods guide covers that landscape.

Turnip vs VirGL: which driver fits your phone?

After Wine and the CPU layer, the graphics driver is the next link in the chain, and it's the one users actually choose in the container settings. Winlator offers drivers in two families.

Turnip: the Snapdragon choice

Turnip is an open-source Vulkan driver for Adreno GPUs, built on the freedreno project inside Mesa. On phones with Snapdragon chips, which means Adreno graphics, Turnip is the right choice, and it's not close. It's faster and more compatible than the generic fallback because it's a real driver written for exactly your GPU hardware.

Winlator typically ships several Turnip builds, newer and older. Start with the newest. If a specific game shows graphical corruption or crashes at a particular point, try an older Turnip. Driver regressions happen, and the community usually identifies which build works per game. Keep a note of what works for your games, because you'll want that information again.

VirGL: the fallback for everyone else

VirGL is the driver for Mali GPUs (Samsung Exynos, Google Tensor, most MediaTek Dimensity chips) and for any Adreno situation where Turnip misbehaves. It's a virtualized graphics path. It works, but it's slower and less compatible than Turnip on Adreno hardware. There is no setting that closes that gap. It's a driver architecture difference, not a tuning problem.

If you're on a Mali phone, Winlator still runs. The CPU translation layer doesn't care about your GPU brand. But your ceiling for 3D games is lower, and that's the honest state of it. The device guide has the full breakdown of what each hardware tier can expect.

When should you change the driver?

Change the driver when you have a symptom, not on a schedule:

If everything renders correctly, leave the driver alone. "Newer driver" is not a performance upgrade by itself.

DXVK, VKD3D, and WineD3D: the DX wrappers compared

The DX wrapper translates the game's DirectX graphics calls into an API your phone's GPU can execute. Winlator lets you choose per container:

The rule: match the wrapper to the game's API. DX9 game, DXVK. DX12 game, VKD3D. WineD3D only when something renders wrong and you're testing alternatives. A wrong wrapper is one of the most common reasons a game "doesn't work" on hardware that's otherwise fine, and it's a thirty-second fix once you know to look there.

What about Proton?

Proton is Valve's compatibility layer for running Windows games on Linux, and it's built from Wine plus DXVK plus VKD3D plus extras. People ask whether Winlator "uses Proton." The honest answer: Winlator uses the same family of components (Wine, DXVK, VKD3D) assembled for Android instead of desktop Linux. It's the same toolbox applied to a much harder problem, since desktop Linux doesn't have to translate ARM instructions. Knowing the components are cousins is useful because ProtonDB reports (which rate how games run on desktop Linux) can hint at whether a game's issues are Wine-level problems or Winlator-specific ones. If a game is rated broken on ProtonDB too, the problem is probably in the shared Wine/DXVK layer, not in your phone.

Proot vs glibc builds: what are they?

You'll see Winlator builds and forks described as "proot" or "glibc" versions. This refers to how the Linux-like environment inside the app talks to Android.

For most users this distinction doesn't matter. Stock Winlator handles it. It becomes relevant when you're comparing forks or following a community guide that specifies one or the other. If a guide says "this needs the glibc build," believe it and use that build rather than fighting the proot one.

Installing .NET Framework and DirectX components

Games and installers regularly ask for runtime components: .NET Framework versions, DirectX redistributables, Visual C++ runtimes. Inside a container, you handle these the same way you would on a PC: run the installer.

Practical notes: install components inside the same container as the game, because components install into that container's fake Windows environment. A runtime installed in container A does nothing for a game in container B. And let installers finish. Interrupting a .NET install halfway leaves the container in a state that's harder to fix than the original problem.

If you want the full error-by-error treatment, the troubleshooting guide maps symptoms to these components.

Frequently Asked Questions

What is Wine on Android?

Wine is a compatibility layer that translates Windows API calls into calls the host system understands. In Winlator it lets Windows programs run on Android without a copy of Windows. It doesn't emulate a whole PC; it translates the "Windows" part while Box64 translates the CPU instructions and DXVK translates the graphics.

Which graphics driver should I use in Winlator?

If your phone has a Snapdragon chip with an Adreno GPU, use a Turnip driver build (start with the newest). If your phone has a Mali GPU (Exynos, Tensor, most MediaTek), Turnip won't work for you, so use the VirGL fallback. Change driver builds when you have a rendering symptom like corruption or a repeatable crash, not on a schedule.

What is the difference between DXVK and VKD3D?

DXVK translates DirectX 9, 10, and 11 to Vulkan and is the right choice for most games. VKD3D translates DirectX 12 to Vulkan and is only for games that specifically require DX12. WineD3D translates DirectX to OpenGL and serves as a troubleshooting fallback. Match the wrapper to the game's DirectX version.

Do I need to install .NET Framework in Winlator?

Often Wine Mono, which Winlator installs with the standard container components, already covers it. If a program specifically demands a Microsoft .NET version, run the official .NET installer inside the container. Install runtimes in the same container as the game that needs them, and let the installer finish completely.

What are Box86 and Box64?

They're the CPU translation layers. PCs use x86/x86-64 instructions and phones use ARM, so every instruction has to be translated on the fly. Box86 handles 32-bit programs, Box64 handles 64-bit programs. You don't configure them directly in stock Winlator, but they explain the performance cost: translation is CPU-intensive, which is why Winlator wants a fast phone CPU and why CPU-heavy games can struggle.

Why does my game need the glibc build of Winlator?

Some community guides and forks specify glibc builds because certain components they rely on need the fuller GNU C library environment rather than the PRoot user-space translation. If a guide you're following says it needs the glibc build, use that build. Fighting the proot build into doing something it wasn't set up for wastes an evening.

Last updated: 2026-10-09