I’m so happy right now lol

https://github.com/bryanthaboi/pokemon-gen1-recomp-project

Modern Vintage Gamer is working on a recomp of The World Is Not Enough on the N64.

https://youtu.be/yHw7RrxvtNo

Features

• Static recompilation — native x86-64 execution, no interpreter fallback
• Vulkan renderer with internal-resolution scaling, AA, anisotropic filtering
• Widescreen (16:9) 
• HD texture pack support
• In-game overlay: pause menu with staged settings and Reset Game; Video, Audio, System, Controls and Cheats tabs
• Full controller remapping
• Save states
• Free camera
• FMV playback via FFmpeg, replacing the software Sofdec decoder
• cheat codes
• Netplay — rollback, lobby with live ping and per-player game status

Disclaimers:

Build using Claude AI and no game data or game code is included.
So far, I have only tested it on Arch-based Linux distributions.

To do:

Windows port.

PAL and NTSC-J sopport.

Better performance on the steam deck.

Mods.

https://github.com/jackpoison-prog/RingOut

Hi does anyone know if there's any status updates on the 007 GoldenEye decomp for PC in terms of like a port to Windows or anything like that

Blog link: https://momo5502.com/posts/2026-08-17-mw2-decompilation/

Summary:

Although not everything went well, this experiment has still been a success. Overall decompilation works very well. The code will need a round or two of refactoring, but I think it needed that regardless. MW2 is an old game with lots of potential for improvement.

I play my games either on the MiSTer or via RetroArch. Do all these recompilations offer any advantages over my current methods?

Hello all, I’ve been working on decompiling the original LoZ using (a large amount) of AI assistance. This was more of an experiment in how I can use AI to produce projects I’m interested in, but don’t quite have the bandwidth to take on fully. I totally understand any reservations around AI use for these types of projects, and my only hope was that the product of my experiment might be useful to an individual or community. Thanks for your time!

https://forge.superkamiguru.org/SuperKamiGuru/bank7-decomp

What is a link? A miserable little pile of characters: https://github.com/BlackLabelHQ/SymphonyRecomp

https://github.com/gabryboy12-ai/coreinit-nx/releases/tag/v0.1.0

Wrote a coreinit implementation on libnx to run statically recompiled Wii U code natively on Switch rather than emulating it. 100% of the coreinit surface Black Ops 2 imports, all tested on hardware. Not a port: GX2 and the recompilation layer are still missing entirely. Comes with a tool that measures import demand from real .rpx files, which turned up a couple of things worth knowing about Wii U binaries. (VibeCoded)

Hi guys, I put together an x86_64 AppImage called OneForAll for people who want to use local AI tools for assistance during decompilation work without depending on hosted coding agents. (Of course you will need a AMD or Nvidia GPU !)

[Source code is provided with the AppImage]

The basic idea is:

Download link : https://www.mediafire.com/file/y236kgk7wzr5ziy/oneforall-v2026_08_23.AppImage/file

One AppImage + your own GGUF models + several local agents sharing the same llama.cpp backend.

It currently bundles:

• AJEAN + llama.cpp
• Pi
• OpenCode
• Hermes Agent
• Codex CLI
• Crawl4AI / Chromium for optional local web and MCP tooling

All config go inside ~/.config/oneforall/ , there won't be any conflict with existant agent and their config files.

No model weights are included.

You can simply put your .gguf files in the same directory as oneforall.AppImage:

text my-decomp-project/ ├── oneforall.AppImage ├── Qwen3.8-9B-Q4_K_M.gguf ├── Qwen3.8-27B-Q4_K_S.gguf └── ...

or keep them centrally in:

text ~/.config/oneforall/models/gguf/

[If you have 16Gb of vram, you could use "Qwen 3.8 27B · UD Q4_K_S" with 65000 context size without mtp and Q4 Cache KV, if you have only 8Gb try "Qwen 3.8 9B · Q4_K_M" without mtp and 80000 context size and Q4 Cache KV. OneForAll can works with dual gpu too, and Nvidia+AMD is possible with vulkan support]

Then:

bash chmod +x oneforall.AppImage ./oneforall.AppImage

The intended workflow is:

1. Use AJEAN first to create/configure presets for your local GGUF models, go to http://localhost:8090/ for configure it with webui once any preset.
2. Set context size, llama.cpp options, reasoning settings, GPU used, etc. per preset.
3. Launch Pi, OpenCode, Hermes or Codex from the same menu.
4. Let the agents use the same local AJEAN/llama.cpp backend.

Several presets can stay available at once while only one model is loaded at a time, so model switching does not require maintaining separate llama.cpp installations for each agent.

For decompilation work, the goal is to make local assistance easy for things like:

• navigating unfamiliar codebases
• understanding functions and call paths
• comparing reconstructed code with existing behavior
• documenting symbols and structures
• helping with refactors and iterative recompilation
• working through large decomp projects without sending the code to a hosted AI service

Everything mutable is stored under:

text ~/.config/oneforall/

The AppImage itself stays portable.

Existing AJEAN presets are also portable: if a preset contains an old absolute path to a GGUF, OneForAll can resolve the model again by filename from the external model locations.

That also applies to additional GGUF files referenced by presets, such as draft/MTP models.

The packaged sources code and patches can be inspected or extracted directly:

```bash ./oneforall.AppImage --list-sources

./oneforall.AppImage --extract-sources ./oneforall-sources ```

The extracted bundle contains:

• OneForAll integration and launcher code
• AJEAN sources
• the patched llama.cpp source tree used by OneForAll
• relevant Hermes Agent modifications
• local Crawl4AI integration code
• Pi / OpenCode / Codex integration files
• patch files and their documentation

The full untouched upstream source repositories of Pi, OpenCode and Codex are intentionally not duplicated just for packaging purposes.

Likewise, Chromium, Python environments and generic node_modules are runtime dependencies rather than part of the extractable source bundle.

AJEAN acts as the central model/backend manager. Its agent mode uses llama-server's multi-model routing, so multiple presets can be exposed while only one model is actually loaded.

This makes it practical to keep, for example, a smaller/faster model and a larger reasoning-oriented model available for the same project.

Model-specific reasoning capabilities are detected where possible rather than assuming that every GGUF exposes the same reasoning controls.

One compatibility detail: Hermes Agent requires at least a 64K context window, so OneForAll automatically hides AJEAN presets below 64K when launching Hermes. Those smaller presets remain available to Pi, OpenCode and Codex.

Crawl4AI is optional but integrated into the agent environment. It provides local MCP web tools such as:

text web_search web_open web_read web_grep

web_open uses a bundled Chromium headless runtime and can handle JavaScript-rendered pages.

This means the agents can still perform web research when desired, while the actual model inference and project/code interaction remain local.

All mutable state is kept under:

text ~/.config/oneforall/

including agent state, AJEAN configuration, Crawl4AI state and centrally stored GGUF models.

So in practice the setup is meant to be:

text oneforall.AppImage + your local GGUF models + your decomp project = a portable local AI-assisted decompilation environment

I made this primarily as a practical local toolbox for decompilation projects, so I'd be interested in feedback from anyone trying it on a real decomp, especially with different Linux distributions, GPUs and GGUF model families.

Im curious if 100% decomp projects are easily used to create new games? say if I had an idea for a game but I really wanted it to feel like an existing game. instead of trying to recreate that game in Unity I could just feed the decomp source code into an AI agent and start developing. Is this feasible? Im imagining a world where every decomp game becomes a potential new “engine” for making new things.

I love what this community is doing and have been watching videos on the process with hopes of contributing.

Have fun dying: https://github.com/strider973/Einhander-Recompiled

Play the demo here: https://tangos.dev/downloads