Pokemon FireRed in Full 3D: The Viral Clip Shows the One Version That Does Not Run FireRed's Code

2026-11-11 · News and analysis

Affiliate disclosure: This guide contains affiliate links. As an Amazon Associate, we earn from qualifying purchases at no extra cost to you. Learn more.

A clip went round on 11 November 2026 showing Pokemon FireRed as a fully 3D game. Pallet Town built out of Let's Go scenery, Red walking around with a real skeleton and animations, a free camera, Charizard rideable. It picked up thirty thousand views in a day and the write-ups followed within hours.

The hook in every version of the story was the same, and it is a genuinely interesting claim. The 3D game is supposedly only a new coat of paint: the decompiled GBA code was rewritten in Rust, Let's Go's models were bolted on, and underneath it all the battles and the trainer AI are still FireRed's own logic. Same Kanto, same mechanics, new perspective.

We went and read the project's documentation, because that claim has a specific shape and specific shapes are checkable.

It is not what the project says. The repository holds three separate projects, and its own summary table has a column headed "Runs the original code?" The 3D version in the video gets the answer "No, rewritten from scratch." The project that does run FireRed's original code is a different one, it is not 3D, and it is the only one of the three you can actually download.

So the most repeated fact about this project is attached to the wrong half of it. That is worth untangling, because once you separate the three the practical question for handheld owners gets a much clearer answer than "wait and see".

Everything here assumes you are playing games you already own. We do not link to game files, key files, firmware, or dumping tools, and we do not explain how to obtain any of them.

The Short Version

• It is three projects in one repository, not one. A C++ static recompilation, a Rust rewrite, and a 3D game built on the Rust rewrite.
• The 3D game does not run FireRed's code. The project states this plainly. It is a new Rust program that reimplements FireRed's rules, with Let's Go art on top.
• The 3D game is not Kanto. Pallet Town and Route 1 are playable. That is the current extent of it.
• 24 of 214 move effects are done. About 11%. Trainer AI is early-game commands only. Evolution and the HM field moves have not been started.
• There is nothing to download. The repository's own badge reads "downloads: not available yet" and its first callout says so again.
• Rust is about 5% of the repository. C++ is the largest part by a wide margin, because the C++ project is the finished one.
• The half that does run FireRed is real and shipping. The upstream static recompilation publishes Windows builds, the most recent on 1 November 2026, and people are downloading them.
• The Android question has a real answer. The GBA recompiler underneath that half supports Android and already ships an arm64 APK, for a different game. FireRed is not that game yet.
• Two dumps, not one. The 3D version needs your own FireRed cartridge dump and your own dumped Switch copy of Let's Go, because the Let's Go art is converted from your copy.
• The licence is not open source. The recompilation parts are PolyForm Noncommercial, which has consequences if you were hoping to see this packaged up for a handheld.
• It is an AI-assisted project and says so. The repository ships instructions for coding agents at its root, and the framework it is built on describes itself the same way.

The Three Projects

This is the thing to take away, so it goes first.

Read down that middle column and the confusion in the coverage explains itself. There genuinely is a version of this where FireRed's original code is running natively on a PC. It is the first row. It is also flat 2D, because it is the actual GBA game with a wider camera.

The 3D one everybody saw is the third row, and it is a reimplementation. Someone sat down with the decompilation and wrote the rules out again in a different language. That is a different kind of achievement, and arguably a harder one, but it means the sentence "it is still FireRed underneath" is doing something other than what readers think it is doing. It is still FireRed's rules, transcribed. It is not FireRed's code, running.

The project is clear about this in its own FAQ. Asked whether it is an emulator, it answers that the Remaster turns the game's machine code into native C++ ahead of time, and that FireRed Native and the Let's Go Remake "don't use the original code at all."

What "Rewritten in Rust" Actually Covers So Far

The Rust library is a real piece of work and we are not going to be sniffy about it. It is roughly 7,800 lines with 73 automated tests, ported from the FireRed decompilation at a pinned revision, and where a behaviour comes from a specific function in the original C the Rust code names that function so you can check the port against it. That is a conscientious way to do this.

It is also early, and the project publishes its own progress table rather than making you guess. The honest summary:

And the scope line that matters most, from the project itself: the Rust versions currently have Pallet Town and Route 1 fully playable, with battles and wild encounters.

That is not "the same Kanto". It is the opening fifteen minutes of Kanto, rendered beautifully. Both of those things can be true at once, and the second one is genuinely impressive, but a reader who installs this expecting to replay FireRed in 3D is going to be surprised twice: once by the two-area map, and once by discovering there is no installer at all.

One more detail that will catch people out later: the Rust version uses its own save format and it is not compatible with GBA save files. You cannot bring a FireRed playthrough into it.

There Is Nothing to Download

Worth stating on its own, because it is the single most practical fact and none of the coverage led with it.

The repository carries a status badge reading "downloads: not available yet", and immediately below it a highlighted callout that says everything is a work in progress and there are no builds to play. Its FAQ answers "Can I download and play this?" with "Not yet." There are no releases.

So the video is a development capture. That is fine and normal, and the project is not pretending otherwise anywhere in its own documentation. It only looks like an announcement because of how it travelled.

The Half You Can Actually Play

Here is the part that got lost, and it is the useful part.

The Remaster is built on a GBA static recompilation framework that translates ARM and Thumb machine code from the cartridge into C++, compiles it into a native program, and links it against a runtime that models the GBA's hardware around it. The original game logic runs as native code. There is no full-system emulator in the middle.

That framework has an upstream FireRed and LeafGreen integration, and that one ships builds. Its most recent release landed on 1 November 2026, the eighth since July, and the FireRed download from it has been taken over a thousand times. Windows x64.

So if what you actually wanted from this story was "FireRed running natively on my PC instead of in an emulator", that exists today, it is the version with the real game code in it, and it is a different project from the one in the video.

What you get is FireRed in 16:9 with extra map visible at the edges, an optional HD redraw of the interface that can be switched on or off per element, fast forward, a rebindable control layout, and an experimental tilted 3D "diorama" view driven by a software renderer. With every extra switched off it is simply FireRed in widescreen. The game underneath is untouched, because it is the game.

Does Any of This Reach a Handheld?

The question we always ask, and this time the two halves give opposite answers.

The 3D Let's Go Remake: no, and not soon. It is Windows only by the project's own statement, and it is built on Bevy with HDR, bloom, shadows and anti-aliasing switched on. There is no build for anything. A Steam Deck could reasonably be expected to run a Bevy game eventually, and an Android handheld is a much longer conversation, but today there is no binary for any platform so the question is academic.

The Remaster: genuinely plausible, and here is the specific reason. The framework it sits on lists Android support among its features, and this is not a roadmap item. It has already shipped a public Android build: an experimental arm64 APK for WarioWare: Twisted!, complete with a touch-friendly setup flow and the phone's motion sensor standing in for the cartridge gyroscope.

That matters because arm64 is what your Retroid Pocket, your Odin, and every Android Anbernic actually runs. The framework clears the architecture bar already. And unlike the Switch projects we have been covering, a GBA recompilation has no instruction-set fight to lose: the output is C++, and C++ compiles for ARM as happily as for x86.

The caveat is the framework's own, and it is appropriately cautious. It describes Android as "a real framework path, but not yet a blanket release promise". One game has an APK and FireRed is not it. So the accurate position for a handheld owner is that the hard part looks solved and the FireRed build does not exist yet.

Until it does, mGBA is the answer on every handheld you own, and it is a very good answer. Our GBA on Steam Deck guide covers the Deck side.

The Two Dumps Problem

This one will stop more people than any technical limit.

The Remaster needs your own FireRed cartridge dump. That is the usual bar for this kind of project and most people reading this understand it.

The Let's Go Remake needs that and your own dumped Switch copy of Pokemon Let's Go, because the Let's Go art is not in the repository and never will be. The project ships a converter that reads Let's Go's own model, animation and texture formats out of your copy and turns them into a standard format the Rust game can load. No assets are distributed. Its own agent instructions spell out that models, textures, audio, Switch files and keys must never be committed.

That is the right call legally and it is also a serious practical gate. Dumping a GBA cartridge is a hobbyist task. Dumping a Switch game is a different project with its own hardware requirements, and it is the reason most people who want this will never run it even after builds appear.

The Licence, and Why It Blocks the Obvious Next Step

The recompilation components are under PolyForm Noncommercial 1.0.0. We checked the licence files rather than taking the summary badge at face value, and both the GBA framework and its FireRed integration carry it.

PolyForm Noncommercial is source-available, not open source. You can read it, build it and use it for anything non-commercial, and the distribution terms are narrower than the permissive licences this scene usually runs on.

The practical consequence is for anyone hoping to see this turn up as a one-tap install on a Linux handheld. A non-commercial, non-OSI licence is exactly the kind of thing that complicates packaging into a community store, and it is a question that would need answering before anyone built a port rather than after. Compare that with the AGPL-plus-extra-terms arrangement we picked apart in the SwitchRECOMP piece: different licence, same lesson, which is that in this scene the licence file is often more consequential than the feature list. If you want the realistic route to native games on cheap ARM hardware today, that is still PortMaster.

It Is an AI-Assisted Project, and It Does Not Hide It

We are reporting this because it is plainly visible in the project and because it lands in the middle of an argument we have already covered twice.

The repository's root contains a file of instructions for AI coding agents, titled as such, which states that it is read by several named coding assistants. There are setup scripts at the root for installing one of them. The project's internal rules include a preference for doing implementation work in cloud sessions of a particular assistant to reduce usage of another.

The framework underneath is the same story and is more upfront about it. Its README opens by describing the community behind it as a group for AI-assisted retro reverse engineering, decompilation and recompilation. It also notes, fairly, that its command-line tools and source workflow require no AI assistant at all.

We are not going to put a number on how much of this code was written by a model, because that is not knowable from outside and anyone claiming otherwise is guessing. What is knowable is that the project is organised around agent-assisted development as a matter of policy, and says so in writing.

That is worth knowing because the decompilation scene spent October moving in the opposite direction. We covered the new rule against AI game recreations when it landed, and the broader vibe-coding argument before that. The main community index for game reverse engineering projects has stopped accepting new entries, with "bad actors" given as the reason. A project built this way is going to have a harder time being adopted by that scene than its screenshots suggest, regardless of how good the screenshots are.

None of which is a judgement on the code. It is context for why a polished-looking project may not travel the way you would expect.

Why We Keep Having to Do This

A brief note on method, because this is the fourth time in two months.

The pattern is consistent: a clip travels, a sentence in the caption becomes the fact everybody repeats, and the project's own documentation says something narrower. We hit it with the Gen 1 first-person recomp, with Pokemon Fulldex, and we hit it here.

The fix is boring and it works. Read the README, read the progress table, and look at whether a release exists. In this case all three were sitting in public and all three contradicted the headline. The repository was created on 10 October 2026, more than a month before the clip that made it famous, so none of this was hidden or new.

What to Watch Next

1. Whether any build ships at all. The Remaster side has a healthy release cadence upstream. The Rust and 3D side has none. Those are very different trajectories.
2. Whether FireRed gets an arm64 Android build. The framework can do it and has done it once. This is the single thing that would turn this story into something a Retroid owner cares about.
3. Whether the move-effect count moves. 24 of 214 is the number that tells you how far from a playable Kanto the 3D version is. Watch that figure rather than the screenshots.
4. Whether the licence question gets addressed. Non-commercial terms and community port stores do not currently fit together.
5. Whether the decomp scene accepts it. Given October's rule change, a project that ships agent instructions at its root is a test case.

Frequently Asked Questions

Can I download and play Pokemon FireRed in 3D right now?

No. The 3D version has no builds of any kind, and the project says so twice in its own documentation, once as a status badge and once as a highlighted notice. What you can download today is the separate 2D static recompilation of FireRed from the upstream project, which runs the original game code natively on Windows in widescreen.

Does the 3D version really run FireRed's original code?

No, and this is the main thing the coverage got wrong. The project's own summary table answers "Runs the original code?" with "rewritten from scratch" for the 3D version, and its FAQ says the Rust projects "don't use the original code at all". They reimplement FireRed's rules in Rust, ported from the decompilation. The version that does run the original code is the 2D C++ recompilation, which is a different project in the same repository.

How much of the game is actually playable in 3D?

Pallet Town and Route 1, with battles and wild encounters working. The project's progress table lists 24 of 214 move effects finished, about half of the field script commands, trainer AI limited to early-game behaviour, and evolution, the HM field moves, Safari Zone and double battles not started. 180 maps have been imported as data, which is not the same as being playable.

Will this run on my Retroid, Anbernic or Odin?

Not today, in either version. The 3D version is Windows only and has no builds. The 2D recompilation is Windows x64 for now, but the GBA framework it is built on already ships an experimental arm64 Android APK for a different game, so the architecture is not the obstacle. An Android FireRed build is plausible rather than promised. In the meantime mGBA runs FireRed perfectly on every handheld in this class.

What do I need to own to use it?

For the 2D recompilation, your own dump of a FireRed cartridge you own. For the 3D version, that plus your own dumped Switch copy of Pokemon Let's Go, because the models and animations are converted out of your copy by a tool in the repository rather than distributed with it. No game files, keys or assets are included in either case.

Can I use my existing FireRed save file?

Not with the Rust versions. They use their own native save format which the project states is not compatible with GBA save files. The 2D recompilation handles cartridge saves through its runtime, which is a different situation.

Is it open source?

Not quite. The recompilation components are under PolyForm Noncommercial 1.0.0, which makes the source available and allows non-commercial use but is not an open source licence. That distinction matters most if you were hoping to see the project packaged into a community port store for handhelds.

Is this an emulator?

The 2D Remaster is not. The cartridge's machine code is translated into C++ and compiled ahead of time, so there is no processor being simulated while you play, although a runtime still models the GBA's hardware around it. The 3D version is not an emulator either, but for a different reason: there is no GBA code in it at all, only a reimplementation of what that code did.

Related Reading

• FireRed in 2.5D through a browser harness — the other attempt at this idea, and why a harness is a different thing from a rewrite
• The Gen 1 recomp that turns Kanto first-person — the same trick on the older generation
• Gen1Recomp setup on a handheld — what it takes to actually run one of these
• What decompiled and recompiled games actually are — the technique behind all of this, from scratch
• Pokemon Fulldex — another project whose documentation told a narrower story than its clip
• The decomp scene's new rule on AI recreations — the argument this project walks into
• AI and vibe coding in the recomp scene — how the scene got here
• mGBA setup guide — how to play FireRed on your handheld today
• GBA on the Steam Deck — the Deck route
• The best GBA games — what else to put on the card
• The best Pokemon ROM hacks — the decomp-based scene this grew out of
• The legal status of emulation in 2026 — the backdrop

Written 11 November 2026. The 3D version had no builds at the time of writing and its progress figures were taken from the project's own table. If builds appear, or if the FireRed recompilation gets an arm64 Android release, we will update this page rather than quietly rewrite it.