How to Run Heavy x86 Games and Software on Arm and RISC-V Processors

Imagine you bought a brand new Arm single-board computer or a powerful RISC-V server, installed Linux, and... hit a wall. Your favorite Steam game, proprietary work software, or good old Wine simply refuse to run. They're compiled for x86_64, but you have a completely different architecture. Usually, people suggest QEMU in such cases, but gaming through it is quite an experience: the lag is so bad you'd rather just turn it off.

The box64 project solves this problem elegantly. It's not just an emulator, but a layer that can "feed" native libraries from your system to the emulated application.

What makes this emulator special

Most emulators try to faithfully translate every CPU instruction. This is reliable but very slow. The developer of box64 (known as ptitSeb) took a different approach.

When an x86_64 program calls a system function — for example, wants to render graphics through OpenGL or allocate memory through libc — box64 doesn't emulate this call inside a virtual environment. Instead, it redirects the call directly to your device's native libraries (Arm64 or RISC-V).

As a result, heavy computations fall on the shoulders of the "native" hardware, and only the application's logic is emulated. This gives a colossal speed boost. According to the author's benchmarks, the combination with a dynamic recompiler (DynaRec) works 5–10 times faster than a regular interpreter.

What you can run

The project's compatibility list is huge. First and foremost, it's aimed at gamers and those using specialized software.

1. Steam games. Yes, you can run games on a Raspberry Pi 4 or 5 that were never ported to Arm.
2. Wine and Proton. This opens the way to running Windows applications. If you have both box64 and its "younger sibling" box86 (for 32-bit programs), you can make almost any software work.
3. Unity games. There's a nuance here: they often require a recent OpenGL. On some boards, you need to use environment variables to "trick" the driver and make the game work.

Interestingly, the project even supports specific architectures like LoongArch. It's clear the community actively helps with hardware: the acknowledgments list includes Adlink, Pine64, and even the Deepin development teams.

How it works in practice

Using the tool is surprisingly simple. If you've already compiled the project (the instructions in the repository are detailed, though they require installing a bunch of dependencies), launching looks like this:

box64 ./my_x86_64_program

If you need to run an entire installation script (for example, from GOG) that checks architecture via uname -m, you can do it like this:

box64 script.sh

Inside, box64 will spoof the system response, and the script will think it's running on a regular x86 processor.

For those who don't want to type the command every time, there's box64-bash — a familiar shell where all executables are automatically picked up by the emulator.

Nuances and pitfalls

Don't expect everything to work "out of the box" with perfect frame rates.

First, caching. On the first run, box64 generates optimized code and saves it to ~/.cache/box64. This speeds up subsequent runs, but can "eat" up to 2 GB of disk space. If space is at a premium, you'll need to limit this behavior through the config.

Second, graphics. On Raspberry Pi, you often have to set workarounds like:

MESA_GL_VERSION_OVERRIDE=3.2 BOX64_DYNAREC_STRONGMEM=1 box64 ./game

This is needed to avoid freezes due to differences in how x86 and Arm handle memory.

Third, 32-bit applications. Box64 only works with 64-bit binaries. If you need to run an old game, you'll have to install box86. Work on box32 is currently underway, but the author honestly states that the project is still experimental.

Is it worth trying

If you're a developer who wants to switch to an Arm Linux laptop, or an enthusiast with a RISC-V board — definitely yes. It's the most active and performant project in its niche.

Box64 doesn't try to replace full virtualization, it simply gives you the ability to use familiar software where it shouldn't exist. The project is written in C, very compact, and flexible in configuration.

Of course, the documentation is scattered across different files in places, and you'll have to dig through manuals to configure Wine, but the result is worth it. When software intended for powerful desktops runs on a tiny board for a couple of dozen dollars, it feels like a little magic.

You can check out the source code and build instructions in the official repository ptitSeb/box64. There are also links to game compatibility lists that are updated almost daily.