An AI model built for code migration just did something game developers have tried to pull off for more than a decade: it moved a modern, graphically demanding PC title onto Apple Silicon without a studio spending months on the port. According to a report from ProPakistani, Google’s Gemini 4 Argon was used in an experiment that converted Remedy Entertainment’s Alan Wake 2 from x86 Windows into native Arm64 code that runs on macOS, with the resulting build reportedly clearing 140 frames per second on an M3 Ultra Mac.
The experiment was described publicly by technology journalist and creator Max Weinbach, and it is already circulating widely because it touches a problem Apple, game studios, and Mac gamers have fought with since the PowerPC era: getting serious PC games to run on Mac hardware without years of dedicated engineering. Gemini 4 Argon did not just emulate the game. Reports say it rewrote the underlying instruction handling, translated the graphics pipeline, and compiled the result to run without Rosetta, Apple’s standard x86-to-Arm translation layer.
What follows is a breakdown of what is actually confirmed about the Alan Wake 2 experiment, what remains unverified, how this stacks up against existing Mac porting tools, and what it could mean for the next few years of gaming on Apple Silicon.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Gemini 4 Argon’s Alan Wake 2 Experiment, Explained
Alan Wake 2, Remedy Entertainment’s survival-horror sequel, was built for x86 Windows machines running DirectX. That architecture has nothing in common, at the instruction level, with the Arm64 chips inside modern MacBooks. Historically, bridging that gap required either a native development effort from the studio, a translation layer such as Rosetta, or a compatibility shim like Valve’s Proton or a third-party tool such as CrossOver.
According to the account shared by Max Weinbach and reported by outlets including Ground News, Gemini 4 Argon was tasked with handling that translation directly. The model reportedly generated Rust bindings mapping x86 instructions to their Arm equivalents, handled the broader Windows-to-macOS environment shift, and converted the game’s graphics shaders to Metal, Apple’s native graphics API. The claimed result was a working, native Arm64 build of Alan Wake 2 running on macOS, not an emulated or translated session riding on top of Rosetta.
That distinction is the whole story here. Running a Windows game on a Mac through Rosetta or Proton is not new. Producing a build that is compiled ahead of time for Arm64, with shaders rewritten for Metal rather than translated on the fly, is a materially different and more difficult outcome, and it is the part of the claim that has drawn the most attention from developers.
Who Is Max Weinbach, and What Did He Build
Weinbach is a technology journalist and creator who has built a following covering AI tooling and hardware experiments, and he is the source of record for this specific Alan Wake 2 conversion. In his own description of the project, he framed it as his favorite outcome from working with the model, writing that converting Alan Wake 2 from x86 and Windows to native Arm64 on macOS was the experiment he was proudest of (source).
Weinbach laid out the technical steps he said Argon handled: writing Rust bindings for x86 instructions and operations, mapping them to Arm, managing the Windows-to-macOS transition, converting the game’s graphics shaders to Metal, and doing all of it in a way that supports ahead-of-time compilation rather than relying on Rosetta at runtime. He summarized the outcome bluntly, saying it works and gets over 140fps on M3 Ultra.
It is worth being precise about what this is and is not. This is a single developer’s reported experiment, shared publicly, not a peer-reviewed benchmark, a Remedy-sanctioned port, or an Apple-certified compatibility test. The claim has not been independently reproduced in public as of this writing, and no third party has published its own frame-rate capture or build verification.
The Technical Pipeline: x86 to Arm64, Windows to macOS
Translating an entire game between instruction set architectures is a different problem from translating source code between programming languages. Compiled game binaries contain machine instructions, not human-readable logic, which is why traditional static recompilation projects have historically taken specialist engineering teams months or years per title.
The reported approach breaks the problem into three layers: instruction-level translation from x86 to Arm, operating-system-level translation from Windows APIs to macOS equivalents, and graphics-level translation from DirectX shaders to Metal shaders. Below is a simplified, illustrative sketch of the kind of binding layer this type of project typically needs, not actual code from the experiment, which has not been published.
// Illustrative only -- conceptual shape of an x86-to-Arm64 instruction binding,
// not source from the actual Gemini 4 Argon / Alan Wake 2 experiment.
fn translate_instruction(x86_op: X86Opcode) -> Arm64Instruction {
match x86_op {
X86Opcode::MovRegToReg(src, dst) => Arm64Instruction::Mov(dst, src),
X86Opcode::AddRegImm(reg, imm) => Arm64Instruction::AddImmediate(reg, imm),
_ => Arm64Instruction::Unsupported,
}
}Multiply that kind of mapping across every instruction and API call a modern game engine touches, and the scale of the task becomes clear. If Weinbach’s account holds up under scrutiny, it suggests Gemini 4 Argon was able to automate a meaningful share of that mapping work rather than requiring a human engineering team to hand-write it.
DirectX to Metal: Solving Graphics Translation
Shader conversion has historically been one of the hardest parts of any Windows-to-Mac port. DirectX’s HLSL shaders and Apple’s Metal Shading Language differ in syntax, resource binding models, and performance characteristics, and a naive translation often produces a shader that compiles but runs far slower than a hand-tuned equivalent.
Weinbach’s account specifies that the shaders were converted to Metal as part of the pipeline, rather than wrapped in a translation layer at runtime. That detail matters because runtime shader translation, the approach used by tools like Apple’s Game Porting Toolkit, carries an ongoing performance cost every time the game executes. A compiled, native Metal shader does not pay that tax on every frame, which is consistent with, though not proof of, the high frame rate Weinbach reported.
Skipping Rosetta With Ahead-of-Time Compilation
Rosetta is Apple’s dynamic binary translator, and it is the reason most Intel-era Mac software still runs on Apple Silicon at all. It works by translating x86 instructions to Arm at runtime, which is reliable but introduces overhead compared to code compiled natively for Arm from the start.
According to Weinbach, the pipeline was built so the converted Alan Wake 2 code could be compiled ahead of time, meaning the translation from x86 to Arm64 happens once, before the game runs, rather than on every execution. That is a materially different engineering outcome than simply running a Windows binary through Rosetta, and it is the piece of the claim most directly tied to the reported 140 FPS figure, since ahead-of-time compiled native code generally outperforms dynamically translated code on the same hardware.
The 140 FPS Number on an M3 Ultra, in Context
The headline figure in this story is that the converted build reportedly exceeded 140 frames per second on an M3 Ultra, Apple’s highest-end system-on-chip, available in the Mac Studio. That is a strong result for a 2023-era AAA survival-horror title with heavy lighting and particle effects, assuming the figure holds up.
Several details behind that number remain unconfirmed. Reports have not specified the exact Mac model or memory configuration tested beyond “M3 Ultra,” the resolution or graphics settings used during the test, how long the benchmark ran, or whether the result has been reproduced by anyone outside the original experiment. Readers should treat 140 FPS as a reported figure from a single source rather than a verified, repeatable benchmark until independent testing confirms it.
What Gemini 4 Argon Brings to Code Translation
Gemini 4 Argon is Google’s model aimed at handling the hardest categories of technical work, including large-scale code refactoring and migration, according to Google’s own announcement of the model (DeepMind). The Alan Wake 2 experiment is one of the more visible public demonstrations of that positioning applied to a genuinely difficult, real-world migration problem rather than a synthetic benchmark.
Separate coverage of the model has focused on how developers are using it for large codebase refactors and migrations, with outlets like FavTutor collecting examples of users testing the model against complex, multi-step engineering tasks. The game-porting experiment fits that broader pattern: it is a single, unusually dramatic example of an AI model being pointed at a cross-platform migration task that would traditionally require a specialized engineering team.
Tech-Insider has covered Gemini 4 Argon’s broader rollout extensively, including its integration into Android Studio’s coding agents, its adoption inside GitLab Duo’s agent platform, and the pricing shifts tracked in our report on Gemini 4 Argon’s price doubling relative to Claude Sonnet 5.5.
AI Porting vs. Traditional Mac Compatibility Tools
To understand why this experiment matters, it helps to see it next to the tools Mac gamers already rely on. Apple’s Game Porting Toolkit, built on top of Wine and Valve’s Proton-adjacent technology, lets developers test Windows games on Mac hardware without a full native rewrite, but it still runs through a translation layer rather than producing a truly native, ahead-of-time compiled build. CrossOver, from CodeWeavers, offers a similar consumer-facing approach. Both differ fundamentally from what Weinbach described, which skips the runtime translation step entirely.
| Approach | Translation Timing | Shader Handling | Needs Rosetta | Developer Effort |
|---|---|---|---|---|
| Native Mac port (studio-built) | Pre-compiled by developer | Hand-written Metal | No | Months to years |
| Apple Game Porting Toolkit | Runtime translation | Translated via Wine/D3DMetal | No (Arm-native wrapper) | Weeks, developer-driven |
| CrossOver (CodeWeavers) | Runtime translation | Translated via Wine layer | No | Minimal, consumer tool |
| Rosetta-only Windows build | Runtime translation | Translated at runtime | Yes | None, but highest overhead |
| Reported Gemini 4 Argon pipeline | Ahead-of-time, pre-compiled | Converted to native Metal | No | AI-automated, unverified scale |
If the reported approach can be generalized and verified, it would occupy a category of its own: native-equivalent performance without the multi-month developer commitment that a true first-party Mac port usually demands. For now, Mac owners wanting to play Windows titles still rely on streaming options like Xbox Cloud Gaming on Mac rather than a native, locally rendered build.
What’s Confirmed and What Isn’t: Remedy, Epic, and Official Status
It is important to separate the confirmed facts from assumptions that are circulating alongside this story. What is confirmed, based on Weinbach’s public account and the reporting around it: Google’s Gemini 4 Argon was used in an experiment involving Alan Wake 2; the experiment converted the game from x86 Windows to Arm64 macOS; the process reportedly involved Rust instruction bindings, Metal shader conversion, and ahead-of-time compilation without Rosetta; and the resulting build reportedly exceeded 140 FPS on an M3 Ultra.
What is not confirmed is at least as important. There is no indication that Alan Wake 2 has been officially released as a native MacBook or macOS title. Remedy Entertainment, the game’s developer, and Epic Games, which publishes Alan Wake 2, have not been reported as having endorsed, authorized, or distributed this conversion. The exact Mac model, memory configuration, display resolution, and graphics settings used in the reported test have not been disclosed. There is no reported purchase price or path to consumer availability for the converted build, and nothing published so far indicates this is a finished, stable, commercially distributable product rather than a one-off technical demonstration.
In other words, this is a proof-of-concept shared by one creator, not a shipping product. That framing matters for anyone searching for a way to actually play Alan Wake 2 natively on a Mac today: as of October 16, 2026, no official, purchasable version exists.
A Short History of Windows-to-Mac Game Porting
Mac gaming has spent close to thirty years fighting the same basic problem: the platform’s install base is a fraction of Windows’, so studios rarely justify a dedicated native port. Apple’s own hardware transitions made this worse before they made it better. The move from PowerPC to Intel in the mid-2000s briefly unified Mac and PC architecture at the chip level, which helped tools like Boot Camp and, later, Wine-based compatibility layers gain traction.
The 2020 shift to Apple Silicon reintroduced the architecture gap that Intel Macs had closed, since Arm64 chips do not natively run x86 code. Rosetta 2 papered over that gap reasonably well for everyday apps, but games, with their heavier compute and graphics demands, have remained the weakest part of the Apple Silicon software story. Apple’s Game Porting Toolkit, introduced to help developers test ports more cheaply, is itself an acknowledgment that the native library of AAA Mac games remains thin years into the Apple Silicon transition. An AI system automating the hardest part of that translation, if it holds up to scrutiny, would be addressing a gap Apple’s own tooling has not fully closed.
Market Impact: Apple Silicon’s Gaming Problem
Apple has spent several hardware generations building Mac chips with gaming-relevant specs, on paper, a push that extends into other Apple Silicon devices like the M4 iPad Air. The M3 Ultra used in this experiment packs substantial unified memory and GPU core counts, yet the Mac’s AAA game library remains far smaller than what Windows PCs, the Steam Deck, or even cloud gaming services can offer. That mismatch between hardware capability and available software is the core business problem any AI-assisted porting approach would need to solve to matter commercially.
If Google or a third party were to productize an approach like the one Weinbach described, the most direct winners would be Mac owners who already have capable Apple Silicon hardware sitting underused for gaming, and potentially smaller studios that cannot currently justify the cost of a dedicated Mac port. The most direct pressure would land on Windows-compatibility tool makers, since a pipeline that produces native, ahead-of-time compiled builds would outperform any runtime translation layer by design. It is worth noting that none of this changes the near-term reality: as of this report, no studio has confirmed plans to use AI-driven conversion for a shipping Mac release, and the legal and technical questions around AI-translated commercial game code remain untested.
Timeline: Key Moments in Mac Gaming Compatibility
| Period | Development | Significance |
|---|---|---|
| 2006 | Apple moves Macs from PowerPC to Intel x86 | Unified Mac and PC chip architecture, easing Boot Camp dual-booting |
| 2007-2015 | Wine and CrossOver mature as Windows compatibility layers | Let some Windows games run on Mac without native development |
| 2020 | Apple launches Apple Silicon (M1) and Rosetta 2 | Reintroduces x86-to-Arm architecture gap for all Mac software |
| 2023 | Apple releases Game Porting Toolkit | Lowers the cost for developers to test Windows games on Mac |
| October 2026 | Gemini 4 Argon reportedly converts Alan Wake 2 to native Arm64 macOS | First widely reported case of an AI model automating a full instruction-set and graphics-API game port |
Industry Voices on the Experiment
Because this story originates from a single creator’s public account rather than a company press release, the available commentary so far comes almost entirely from Weinbach himself. Describing the project, he said it was his favorite Gemini 4 Argon experiment, converting Alan Wake 2 from x86 and Windows to native Arm64 on macOS (source).
On the technical pipeline itself, Weinbach said Argon wrote Rust bindings for every x86 byte and operation to Arm as well as Windows to macOS, converted to Metal shaders, and did it in a way that can be ahead-of-time compiled without Rosetta. On performance, he was direct: it works, and gets over 140fps on M3 Ultra.
Looking ahead, Weinbach described his next step as having Argon build out generalized bindings for more games, to see if this could be applied to get fully native games on macOS without developers needing to support it. That statement is the clearest signal of where this experiment is heading: not a one-off party trick with a single title, but an attempt at a repeatable, generalized conversion pipeline.
What Happens Next: Generalized Bindings for More Games
The stated next step, generalizing the binding layer so it can handle more titles without per-game developer involvement, is where this story moves from curiosity to potential platform shift. A one-off conversion of a single popular game is impressive but limited. A generalized, repeatable pipeline that could be pointed at a large swath of the Windows game library would be a different kind of development entirely, and a much harder claim to verify.
There is no confirmed timeline for that generalized version, no confirmation from Google that this is an official or supported use case for Gemini 4 Argon, and no indication of how the approach would handle anti-cheat systems, DRM, licensing, or multiplayer netcode, all of which complicate automated porting far beyond what a single-player survival-horror game like Alan Wake 2 requires. Those unresolved questions are exactly why this remains an experiment to watch rather than a product to expect imminently.
Five Predictions for AI-Assisted Game Porting
Based on where this experiment stands and the broader trajectory of AI code-migration tools, here is how this is likely to play out over the next year or two.
- Expect more individual creators and developers to publish their own AI-assisted porting experiments on other titles, using Gemini 4 Argon or competing models, before any company formally productizes the approach.
- Expect Apple, which has repeatedly signaled interest in closing its gaming gap through tools like Game Porting Toolkit, to face renewed pressure to explain whether AI-assisted conversion fits into its own Mac gaming roadmap.
- Expect skepticism to grow until someone outside the original experiment independently reproduces a frame-rate result and publishes the build process, since a single unverified benchmark is not enough to establish a repeatable technique.
- Expect legal and licensing questions, rather than technical ones, to become the biggest obstacle to any commercial use of AI-converted game builds, since studios and publishers control distribution rights regardless of how good an unauthorized port performs.
- Expect rival AI labs to showcase similar code-migration demonstrations of their own, given how directly this kind of result validates claims about large models handling complex, real-world refactoring work rather than toy benchmarks.
FAQ
Is Alan Wake 2 officially available on Mac right now?
No. As of October 16, 2026, there is no confirmed official release of Alan Wake 2 for macOS. The conversion described in this story is a reported experiment, not a public product.
What is Gemini 4 Argon?
Gemini 4 Argon is a Google AI model positioned for demanding technical tasks, including large-scale code refactoring and migration, according to Google’s own model documentation.
Who ran the Alan Wake 2 conversion experiment?
Technology journalist and creator Max Weinbach publicly described running the experiment and shared the reported results, including the 140 FPS figure on an M3 Ultra.
Did Remedy Entertainment or Epic Games approve this port?
No endorsement, authorization, or involvement from Remedy Entertainment or Epic Games has been reported. This remains an independent, unofficial experiment.
How is this different from using Rosetta or Apple’s Game Porting Toolkit?
Rosetta and the Game Porting Toolkit translate x86 code and shaders at runtime, every time the game runs. The reported pipeline instead produced code compiled ahead of time for Arm64 with native Metal shaders, which, if accurate, would avoid that ongoing runtime translation overhead.
Can I try this conversion myself?
No build, tool, or public release has been made available. The reported process has not been published in a form that other users or developers can reproduce.
Is the 140 FPS figure verified by an independent source?
No. It is a figure reported by the person who ran the experiment. No independent benchmark or third-party reproduction has been published as of this report.
What’s the next step in this project?
According to Weinbach, the next step is building generalized bindings aimed at applying the same approach to additional games, with the goal of producing native macOS builds without requiring developer support.
