Explain to me what's happening here.
Someone took their copy of Fire Emblem: Fortune's Weave, a Switch 2 exclusive, and turned it into a Mac app that runs on a base M4 Mac mini. The tool they used, nxnative, is not a regular emulator.
- How it works. A normal emulator pretends to be the whole console in software, which takes a lot of processing power. nxnative instead recompiles the game so it runs natively. That's possible because the Switch and Apple's chips both use the Arm64 instruction set, so the game's code already runs on Apple's processor.
- What still has to be swapped. A small host program stands in for the Switch's operating system, and the console's graphics calls are translated to Apple's Metal. The shader translation comes from Ryujinx, the Switch emulator that shut down in 2024 under pressure from Nintendo.
- "Building took 30 minutes." nxnative doesn't hand out games. You supply your own game files and decryption keys, and it builds an app for that one game.
- The stutters. The first time a new effect appears, its shader is translated to Metal, which causes a short hitch. After that it's cached.
- The overlay. Apple's Metal performance HUD shows 30 fps at 3200 × 1800. That's the game's normal frame rate, so "full speed" means it matches the console, not that it runs faster.
The catch. Each game needs its own adaptation work, and online play and amiibo aren't supported. Whether dumping and repackaging Switch games is legal is unsettled in many countries, and Nintendo has sued over similar projects before.
Could you give me a rundown of the individual pieces involved here? I do understand how games run on a very general scale, but I feel like a few things have been mentioned that we've never really talked about, even in our past chats. Could we start at a high level: what's happening, how do things run, and how is it connected to this? I don't have anything specific to ask, so maybe we can go on a very broad scale, and then deep dive on something I'm not familiar with or would be more interested in.
The CPU is the lucky break. A CPU understands one "language" of instructions, its instruction set. Most Windows PCs speak x86, while the Switch and Apple Silicon both speak Arm64. The game's code is already in a language the M4 understands, so most of it can run as it is. On an x86 PC every instruction would have to be translated, and that's where emulators spend most of their effort.
The operating system and the graphics are the real work. The game expects Nintendo's operating system to be there when it asks to load a save or read the controller, so nxnative puts a small program in its place that answers those requests using macOS. Graphics are the hardest part. The game sends commands written for the Switch's Nvidia chip, along with small GPU programs called shaders, and all of it has to be rewritten into Metal, Apple's graphics system.
Emulation against recompilation. An emulator is like a live interpreter translating a speech sentence by sentence while you listen, every time you play. Recompilation is translating the whole book once and then just reading it. The poster's 30-minute build was that one translation, and the result is a normal Mac app.
Any of these can go deeper: instruction sets, what a game asks an operating system for, graphics APIs and shaders, why recompiling goes one game at a time, or the legal side of game files and keys.
I would like to understand the graphics API a little bit more. I'm not too new to the idea of graphics and GPUs, but I've never really given it a second thought, especially when you mentioned DirectX and Vulkan. I've seen those a couple of times, but I never gave them a second thought. I've used shaders before on a website, for example. Let's just take it from the top: another rundown of what all these are, how they connect and what calls what.
The [[gpu]] is a chip with thousands of small, simple cores. They're good at doing the same small piece of maths on millions of things at once, like every pixel on the screen, but they have no idea what a character or a sword is. They only take very low-level commands.
The [[graphics-api]] is the set of requests an app is allowed to make. Think of it like a web API's spec: here's a 3D model, here's a texture, use this shader, now draw. It's a contract, and it doesn't do the work itself. The driver does. Nvidia, AMD and Apple each write drivers that turn those standard calls into commands their own chips understand. The game speaks the API, and the driver speaks the hardware.
Why there are so many: mostly platform politics and history.
- DirectX is Microsoft's, used on Windows and Xbox.
- Metal is Apple's, and the only one Apple supports on its devices.
- Vulkan is an open standard from Khronos, used on Linux, Android and Windows.
- OpenGL is Vulkan's older predecessor. [[webgl|WebGL]] is the browser version of it, and [[webgpu|WebGPU]] its newer replacement.
- NVN is Nintendo's own, built for the exact Nvidia chip in the Switch. Console hardware never changes, so it can be very low-level and squeeze out more performance.
A game written for one API can't run on a system that only offers another, which is exactly the Fortune's Weave problem: NVN calls in, and only Metal on the Mac.
[[shader|Shaders]] are where your website fits in. A shader is a small program that runs on the GPU, usually once per corner of a shape (to place it) or once per pixel (to colour it). Each API has its own shader language: GLSL for OpenGL and WebGL, HLSL for DirectX, MSL for Metal. Before a GPU can run one, the driver has to compile it into that chip's machine code, and that takes noticeable time.
Your web shaders already go through a translation like this. On a Mac, Safari and Chrome both use a translator called ANGLE that turns your WebGL calls and GLSL into Metal. nxnative does the same kind of job for Switch games.
On a Mac both translators write Metal, Apple's API, and both shaders are rewritten into MSL, Metal's shader language.
That's the stutter. Every Switch has the same GPU, so Nintendo ships the shaders already compiled for that chip, and there's nothing to compile while you play. On the Mac, each one has to be translated and then compiled the first time its effect shows up, mid-game, and that pause is the stutter. Once a shader is cached it never stutters again. PC games have the same problem for the same reason: thousands of GPU and driver combinations, so shaders can't be compiled ahead of time. Hence the "compiling shaders" screen at launch.
I understand API from a web technology perspective: web sockets, webhooks, SOAP, that's the context I have. And maybe a browser engine and the APIs it exposes, like the storage API, or I don't know if it's safe to call it a network API. But when you talk about an API in the context of GPUs, what does that look like? I'm trying to get a practical example, or something easy to understand it with.
You've already used one. WebGL is a browser API, just like localStorage or fetch. When your website's shader ran, your code was calling it.
The APIs you know are often on the other side of a network: you send a request and wait for a reply. The browser APIs are the better match. localStorage is a set of functions (setItem, getItem) the browser gives you, and the browser does the disk work. A graphics API is the same idea: a set of functions the system gives you, with the driver doing the work on the GPU behind them.
Drawing one triangle takes three steps, whatever the API: copy the three corner points into the GPU's memory, say which shader to use, and draw. In WebGL:
gl.createBuffer() reserves GPU memory, gl.bufferData() copies the three corners in, gl.useProgram() picks the shaders, and gl.drawArrays() draws the three points as a triangle.
The same in Metal, Apple's API, written in Swift: makeBuffer() copies the corners to the GPU, setRenderPipelineState() picks the shaders, and drawPrimitives() draws. Different names and a different structure for the same job. DirectX, Vulkan and NVN are a third, fourth and fifth version of it.
Every 3D scene comes down to these calls. A frame of Fortune's Weave is thousands of them: this character's mesh with the skin shader, draw; the flame effect with its shader, draw; about 30 times a second. Each draw is a . nxnative catches every NVN call and makes the matching Metal call, and your browser does the same on a Mac: your gl.drawArrays becomes a Metal drawPrimitives before it reaches the GPU.
One way this is like the network APIs: the calls don't run straight away. They're collected into a list, the command buffer, and sent to the GPU in one batch. The GPU works through it on its own while the CPU moves on to the next frame, a lot like firing off a fetch and not waiting for the response.
Really? Oh, okay, so I think I'm starting to understand the API here. Does it mean that my portfolio, which has a lot of shaders going on, is obviously WebGL because it's browser-based, but each of those shaders is translated to Metal? Wait, I'm confused. There's the WebGL API, and then the Metal API, and then the GPU. But I use Brave, which is Chromium, which uses Blink for drawing the pixels. So how do all those connect?
Yes, your portfolio's shaders are translated to Metal. Blink isn't the piece that sends anything to the GPU, though. There are two paths through the browser, one for ordinary page content and one for your WebGL, and they meet at Metal.
Blink is Chromium's rendering engine. It reads your HTML and CSS, works out where everything goes (layout), and writes down what needs drawing: text here, a rounded box there. It also provides the browser APIs your JavaScript calls, WebGL included. When your code calls gl.drawArrays, Blink doesn't draw anything. It records the call and passes it on.
The GPU process is a separate program Chromium runs. For security, the tab running your site isn't allowed to touch the GPU directly. It sends its commands over, and the GPU process carries them out: the command buffer, crossing from one process to another.
Skia is Chromium's 2D drawing library. It turns Blink's list into pixels, and on a Mac it does that through Metal too. ANGLE is the translator for your shaders: WebGL calls into Metal calls, GLSL into MSL.
At the end, Chromium's compositor puts the two results together: your shader's canvas goes into its place in the page, and the finished frame goes to the screen.
The translation happens when your page compiles its shaders, usually as it loads, not on every frame. That's why a shader-heavy page can take a moment before its first frame: the browser's version of the stutter in the Mac mini video. After that, every frame reuses the compiled version.
Wait, small confusion. What's the difference between WebGL and GLSL?
WebGL is the API: the JavaScript functions you call to manage the GPU. GLSL is the language the shaders themselves are written in, and that code runs on the GPU. In your code, the GLSL is a string, a few lines ending in color = vec4(0.6, 0.2, 1.0, 1.0);, which paints every pixel purple. Then WebGL calls, running on the CPU, hand it over: gl.createShader() makes a shader, gl.shaderSource() gives it the text, gl.compileShader() compiles it for this GPU.
Your JavaScript treats the GLSL as plain text. It ships it to the GPU through WebGL calls, the way fetch sends a JSON body without caring what's in it. WebGL handles the delivery and the instructions (use this shader, draw now); GLSL is the code that runs once it arrives.
- WebGL and OpenGL pair with GLSL.
- Metal pairs with MSL.
- DirectX pairs with HLSL.
That's why ANGLE has two jobs: it turns WebGL calls into Metal calls, and it rewrites your GLSL into MSL.
Let's circle back to what started this conversation, summarised well.
Someone turned their copy of a Switch 2 game into a normal Mac app with nxnative. It isn't an emulator pretending to be a Switch while the game runs; it's a one-time conversion, which is what the 30-minute build was. The game makes three kinds of request, and nxnative handles each:
- CPU code: the Switch and the M4 both use Arm64, so the game's logic runs mostly as it is. This is the lucky break that makes the whole thing practical.
- Operating system: the game expects Nintendo's OS to load files and read controllers. A small host program stands in and answers using macOS.
- Graphics: the game was built to call NVN. The Mac only has Metal, so nxnative catches each NVN call and makes the matching Metal call, the same job ANGLE does when it turns your WebGL into Metal.
Shaders explain the stutters. Nintendo ships them compiled for the Switch's Nvidia chip, so they can't run on the M4. The first time each appears it has to be translated into MSL (with code from the Ryujinx emulator) and compiled by Metal, which causes a short hitch; after that it's cached. It's the same reason a shader-heavy page can take a beat before its first frame.
The result was the game at its normal 30 fps on a $600 Mac mini, with no graphical glitches. The catches: every game needs its own build and fixes, online play doesn't work, and Nintendo has a history of suing projects like this.
Can we also dissect what this is about?
- Bevy is an open-source game engine written in Rust, with WebGPU support, building for Windows, macOS, Linux, iOS, Android and the web. That's where the 3D, the shaders and "can make games too" come from.
- Blitz, from Dioxus Labs, is like the Blink part of a browser pulled out on its own: it reads HTML and CSS and works out the layout, with none of the rest of the browser.
- wgpu ties this to the graphics conversation. It's the layer Bevy and Blitz both draw through, and a translator like ANGLE: you write against one API and it becomes Metal on a Mac, DirectX on Windows or Vulkan on Linux.
So "a bridge between the page and the 3D world" means your React layer (titles, captions, interface) is laid out by Blitz and drawn into the same GPU frame as Bevy's 3D scene. No browser is involved and no screenshots are taken: the frames are already on the GPU and can go straight to a video encoder.
Why it could be faster. The browser route redoes a lot of work every frame: lay out the page, paint it, copy the pixels out of the browser, hand them to FFmpeg. Real video footage is worst, because browsers aren't built to jump to an exact frame of a video over and over. A game engine is built to render frames on the GPU as fast as possible. The "10 to 20 times faster" is the author's own claim, not a benchmark.
To be sceptical of. Blitz is young and doesn't support all of CSS yet, so HTML that looks right in Chrome may not in Raea. Running TypeScript without a browser means bundling a JavaScript engine somewhere, and the post doesn't say which. And the opening lines are partly marketing at competitors: "infinite canvas startups" and "generative video snake oil". The real pitch is the last paragraph: agents write the code, and you keep direct control of the creative choices.