Super Mario Galaxy, the 2007 Wii game that swept Game of the Year awards from IGN, GameSpot and the BAFTAs, now runs natively on Windows. Not through an emulator, and not through a Nintendo re-release. A project called Nebula translates the game's PowerPC machine code into C++ ahead of time, compiles that code on your PC from your own copy of the game, and runs it on a native runtime with a Direct3D 12 renderer.
It is the same playbook that brought Super Smash Bros., GoldenEye 007 and Zelda to PC, now aimed at one of the biggest Wii games ever made. Nebula reached version 1.0.0 on October 13, 2026, and its release has already crossed 750 downloads. The project is licensed GPL-3.0 and, as its README states plainly, contains no Nintendo code or assets. You supply the game; it supplies everything else.
What Nebula Is
Nebula is a recompilation, which is the important word. An emulator recreates the Wii in software and runs the game inside that recreation, which costs you accuracy, overhead and control. A recompilation does the opposite: it takes the game's original PowerPC machine code and translates it, instruction by instruction, into C++ that compiles and runs natively on your machine. The result is the real game, with your PC's hardware doing the work directly instead of pretending to be a Wii.
That distinction is why the feature list reads like a wish list. Nebula supports aspect ratios from 4:3 all the way to 32:9, internal resolution up to 16x, anti-aliasing (SMAA and FXAA), AMD FidelityFX FSR 1 upscaling, anisotropic filtering and optional per-pixel lighting. It takes keyboard and mouse, Xbox controllers, and both the Switch Pro Controller and the Switch 2 Pro Controller over USB, and the Switch pads keep their gyro: you point with the controller, and tilt it for the Star Ball and the ray surfing sections, with vibration following the game's original Wii Remote motor.
The part worth pausing on: all of this runs from your own copy of the game. Nebula requires Super Mario Galaxy USA (RMGE01), revision 0, as an ISO, an RVZ file or an extracted folder, and it compiles the game from that source on your own machine. Nothing is redistributed, and Nintendo's code never leaves your PC.
How It Works
Nebula is three pieces working in sequence, and it is refreshingly honest about each one.
The recompiler (written in Rust) reads the game disc or an extracted copy, checks that it is the supported release (RMGE01, revision 0), and emits C++ for every function in the game executable, the HOME Menu module, and the audio DSP program. The runtime (C++) then loads that compiled module and supplies everything the Wii hardware used to: memory, a GX command processor drawn with Direct3D 12, the audio interface and DSP, Wii Remote input mapped from your keyboard, mouse and controllers, disc and NAND storage, and video timing. Finally, the installer and launcher (C#) handle the boring but essential work: Nebula-Setup.exe downloads a pinned compiler toolchain, compiles the game modules from your copy, and installs the prebuilt runtime, with separate launcher and settings executables for day to day use.
The Unusual Part: It Was Built by AI Agents
Here is the detail that will get the most attention, and the project does not hide it. From the README, in its own words: “Nebula was built with AI coding agents (Anthropic's Claude). The recompiler, runtime, installer, tests and documentation were written by AI agents and directed, reviewed and tested by the project's author.”
That is a remarkable disclosure for a project of this scope, and the README is careful to draw the line precisely where it matters: “The game's own logic, including Mario's physics, is not AI-written: it is the original game code, translated instruction by instruction by the recompiler.” In other words, the tools are machine-made, but the game is still Nintendo's code, faithfully translated. Mario's gravity, the star launches, the spherical gravity physics: all of it is the 2007 original, moved into C++ by a translator.
Why that distinction matters: a recompilation lives or dies on fidelity, not authorship. If the translation is correct, the game feels right because it is the game. Nebula's honesty about how the tooling was made, and its insistence that the gameplay code is untouched original code, is exactly the transparency this scene should be judged on.
What It Brings to the Table
For a project that only reached 1.0 in October, the presentation feature set is already thorough. This is the same game, run at whatever shape and sharpness your display supports, with modern anti-aliasing and upscaling on top.
Performance: 60 FPS on Integrated Graphics
The most striking number in the README is not a resolution or a frame rate on a flagship GPU. It is this: the least powerful system the team has tested is an Intel Core Ultra 9 185H with its integrated graphics and 16 GB of RAM, and Nebula runs the game at a locked 60 FPS at 1440p on it. A laptop chip, with no discrete graphics card, holding a locked 60 in a 2007 Wii game that has been rebuilt as a native application. On a desktop with a real GPU, there is a lot of room above that.
That is the case for recompilation in a single sentence. You are not fighting emulation overhead. You are running the game on the metal you already own.
What You Need
- The game: Super Mario Galaxy, USA (RMGE01), revision 0, as an ISO, RVZ or an extracted folder.
- Windows: Windows 10 (version 1803 or newer) or Windows 11, 64-bit.
- Hardware: a GPU with Direct3D 12 support and 8 GB of RAM.
- Storage: 16 GB free during installation, settling to about 5.5 GB afterwards.
- Internet: required for the first installation, to fetch the compiler toolchain.
Installation is a single download. Grab Nebula-Setup.exe from the latest release, pick your copy of the game, and hit Install. Setup downloads the toolchain and compiles the game modules, which takes a few minutes on a fast machine. One honest note: the installer is not code-signed, so Windows SmartScreen will warn about an unknown publisher, and you have to choose More info and then Run anyway. Updates after that are signed, and Setup checks the signature before applying them.
Rough Edges
Nebula is a 1.0, not a finished remaster, and the README says so. Known issues include:
- Heavy background CPU load can cause the audio to skip.
- Some areas, such as the Gateway Galaxy, can drop below 60 FPS on weaker CPUs.
- Some lighting and bloom effects in the Comet Observatory differ from the original.
- Floating-point results are close to, but not bit-exact with, the Wii, and there is not yet an automated whole-game comparison against real hardware or an emulator.
For transparency, the project also documents its testing: more than 500 recompiler tests, 70 runtime test programs covering floating-point operations, GX command parsing, texture decoding, input mapping and the audio queue, plus a frame-by-frame comparison of the native movie decoder against the game's own.
Why This Matters
Super Mario Galaxy is one of the last great Wii exclusives still locked to the hardware it was born on, and it is a game that a lot of people want to keep playing for a long time. Nintendo has re-released it, but only on Nintendo's terms and only where Nintendo decides. What Nebula represents, along with the GoldenEye and Smash projects before it, is the other answer: when the people who love a game decide it should keep running, they can make it run, on the hardware we already own, for as long as we keep the source.
Sixty stars, two forks, and 245 commits in eight days is not a hobby tinkering in the corner. That is a scene building the things it wants to see exist, and shipping them.
Resources & Links
- Repository: keepvaibin/nebula on GitHub
- Download: Nebula 1.0.0 release (Nebula-Setup.exe)
- Docs: Architecture and Building from source
- Credits: Nebula builds on Aurora, Dusklight, WiiCompiled, the Petari decompilation project, Berkeley SoftFloat, the Dolphin project's free DSP ROM, SMAA, AMD FidelityFX and the
noddisc library. - License: GPL-3.0 only. No Nintendo code or assets are included; you must supply your own copy of the game.