Skip to content
Blur Native

How it works

Blur was written for Windows PCs with Intel processors and DirectX. Apple Silicon Macs have a different processor, different graphics and sound systems, and no Windows underneath. Blur Native bridges all of that without emulating anything while you play.

The short version

Section titled “The short version”
  1. The game’s code is translated ahead of time. Every function in Blur is converted from Intel (x86) machine code into C++, then compiled into native Apple Silicon (arm64) code. This happens once, when the app is built, not while you play.
  2. Windows is rebuilt around it. The parts of Windows the game talks to (files, windows, threads, networking, sound, controllers) are reimplemented natively for macOS.
  3. DirectX becomes Metal. Every Direct3D 9 call the game makes is turned into Metal, Apple’s graphics API, and the game’s shaders are translated into Metal shaders.
  4. Your copy supplies the game. The installer copies the game files from your disc, ISO or Windows install. No game files ship with the app.

Why not just emulate it?

Section titled “Why not just emulate it?”

Emulators and compatibility layers like Rosetta and Wine translate the game while it runs. That works, but it costs speed and every layer adds its own quirks. Translating the code in advance means the processor runs real native instructions, the compiler can optimise them like any other Mac app, and nothing is being converted mid-race. That’s how Blur Native runs well over 100 fps at 2560×1600 with every setting maxed.

What replaces what

Section titled “What replaces what”
On Windows In Blur Native
x86 game code recompiled to native arm64
Direct3D 9 graphics and shaders Metal
DirectSound audio Core Audio
DirectInput controllers Apple’s Game Controller framework, plus keyboard
Windows system calls native macOS implementations
Activision’s online servers (closed) our own online service
Disc installer and 1.2 patch built-in installer that reads your disc, ISO or install

The translation, step by step

Section titled “The translation, step by step”
  1. Extract. The game’s program and the libraries it ships with are copied from your Blur files and checked against the exact versions the translator expects.
  2. Analyse. The Ghidra reverse-engineering tool walks the code and finds every function and jump, then describes each instruction in a neutral, machine-independent form.
  3. Generate. A translator turns that description into readable C++. Registers become local variables, jumps become plain control flow, and calls become ordinary function calls.
  4. Compile. Clang compiles the C++ into the native app, alongside the macOS replacements for Windows, DirectX and the rest.

Because the generated code comes from your game files, it is never published. Anyone building Blur Native from source runs the same steps on their own copy.

Fixes and new features

Section titled “Fixes and new features”

With the whole game running as native code, it can be changed like any other program. Blur Native uses that to fix bugs, add graphics options the original never had, and stream live race data for overlays and timing screens. Menu changes are made with small Lua patches that load alongside the game’s own menu scripts.

Go deeper

Section titled “Go deeper”