Running Windows Apps on Linux Without the VM Tax
You've probably been here: there's a Windows program you need, and your options are a full virtual machine eating half your RAM or a pile of Wine configuration that breaks the moment an installer calls something unexpected. Raven takes a different approach. It's an open-source project that runs Windows applications on Linux by reimplementing the Windows kernel and its services rather than emulating a whole PC.
What It Does
Raven runs Windows applications on Linux. You install them with their own installers — the same ones you'd use on a Windows machine — and they start. No virtual machine, no winetricks, no DLL overrides.
The architecture is the interesting part. The program's code runs directly on your CPU, inside a sandbox where it can't reach Linux. Every system call it makes gets answered by Raven, which plays the part of the Windows kernel and its services: processes and threads, files, the registry, windows, and input. Graphics go out to Wayland and Vulkan, with DXVK and vkd3d-proton handling Direct3D. It's written in C++20, built with CMake, and targets x86_64 Linux.
Why It's Cool
-
It's a kernel reimplementation, not an emulator. Because the app's code executes natively on your CPU, you're not paying the performance cost of translation or virtualization. Raven intercepts the syscalls and answers them itself, which is a fundamentally different bet than running Windows inside QEMU or KVM.
-
Installers just work — that's the design goal. The README is explicit that you use the same installers you'd use on a PC, with no winetricks and no DLL overrides. Anyone who's spent an evening coaxing an installer past a missing
InitCommonControlscall knows why that matters. Raven builds its own common controls, shell dialogs, and installer services to make it happen. -
The sandbox is a real boundary. The program can't reach Linux directly because every call is mediated by Raven. That's a cleaner security story than handing a Windows binary broad access to your home directory and hoping for the best.
-
The component model is honest about complexity. Raven doesn't pretend a minimal build handles everything. A bare build runs console programs and simple windows; installers and most desktop apps need the provisioned components, built for both 64-bit and 32-bit. The provisioning scripts pull pinned versions of DXVK, vkd3d-proton, Skia, and root certificates, so you're not chasing dependency drift.
-
It's transparent about what's experimental. The X11 desktop path is labeled experimental, and OpenSSL is optional (needed for crypt32 certificate chains, Schannel, HTTPS, and CryptoAPI ciphers). That kind of labeling tells you the maintainers are being straight with you.
How to Try It
Raven is built from source for now. You'll need Linux on x86_64, CMake 3.20+, a C++20 compiler, Python 3.11+, and MinGW-w64 13+ for x86_64 and i686. Building the installer components also requires clang, widl, bison, and patch.
On Fedora, the dependencies come down to:
sudo dnf install cmake gcc-c++ clang python3 bison patch wine-devel mingw64-gcc mingw64-gcc-c++ mingw32-gcc mingw32-gcc-c++ \
wayland-devel libxkbcommon-devel pixman-devel freetype-devel vulkan-loader-devel vulkan-headers openssl-devel
Then clone and build:
git clone https://github.com/mirkobrombin/raven.git
cd raven
cmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo
cmake --build build -j2
A minimal build gets you console programs and simple windows. To run an installer or a real desktop app, you'll need the provisioned components first:
python3 scripts/provision-rtl.py --output components/rtl
python3 scripts/provision-controls.py --output components/controls
python3 scripts/provision-controls.py --arch x86 --output components/controls32
python3 scripts/provision-installer.py --output components/installer
python3 scripts/provision-installer.py --arch x86 --output components/installer32
python3 scripts/provision-graphics.py --destination components/graphics
python3 scripts/provision-roots.py --output components/roots
python3 scripts/provision-text.py --output components/text
Then reconfigure with the component paths passed in (the README lists the full set of -DRAVEN_* flags) and rebuild. To launch something:
export RAVEN_PREFIX="$HOME/.local/share/raven/my-app"
build/native/raven --run-process --execution=native --timeout-ms=600000 --desktop=wayland setup.exe
DXVK and vkd3d-proton are only needed if you're running Direct3D programs or games. Full details live at useraven.org, and the source is at github.com/mirkobrombin/raven.
Final Thoughts
Raven is early-stage and source-only, and the setup isn't trivial — provisioning components and passing a dozen CMake flags is not a double-click experience. But the core idea, answering Windows syscalls directly instead of virtualizing a machine, is a genuinely different path, and the README's candor about what a minimal build can and can't do is reassuring. If you're a Linux user with a stubborn Windows app and some patience for a build, this is worth following closely.
Follow @githubprojects for more developer tools and open source projects.