10 years is far too pessimistic for this being a routine task, I think 2 years max. As you mentioned, you can already do this today by just giving GPT 5.5/Opus 4.8 an IDA/Ghidra tooling (a CLI or MCP, I have a custom CLI for it). You can start with the LLM going from the string anchors and renaming functions/globals, then when you have enough functions, the LLM can start working on typing - IDA has a very powerful typing API for HexRays-decompiled code, you can even type locals and it all persists in a DB.

My custom IDA CLI is just a simple thing on top of IDA Python's integration + ida-domain + some higher-level helpers, and works as a daemon with workers, so a stale/bad request doesn't corrupt an IDA DB (an issue I had when I was using idasql).

A bit offtopic, but: do you have any links to your efforts? I'm curious to see what other people do in this area.

Would you please explain more your Ghidra+LLM workflow? What you are doing and how does the LLM help you? Thanks!

I hope we get Skyblivion soon

Your take is very interesting, but please do not forget that pirating games is a crime.

I don't really get the Bun thing. Bun is running Claude Code which is probably the single most actively used development app there is. You say this was a bad use of LLMs, but it's been in production for a while and I haven't heard of any evidence that Claude Code has increased a significantly larger quantity of errors, segfaults, etc, than before.

I have a port of BuildGDX in the project backlog that was basically just throwing Claude at it to go from Java to .NET. The only thing it really got hung up on was Java's byte being signed.

What I ended up with was a port of Duke 3D that uses half the allocated RAM as DukeGDX.

IMHO, this is an actual good use of what sounds like a person guiding a model to do a mass conversion.

This is quite the understatement. Actually, it's probably the understatement of the year.

"Pretty good, not bad, great use case".

Dude. Fable fucking did what?

The model did the work, probably has it all in its context window, so it may actually be better placed here to write the docs.

That is really not a lot. A human could have easily done this. How much did it cost / how many tokens were spent?

Haha, I do that too sometimes.

It's a thing in some Germanic languages. Instinct is to merge nouns into word, e.g. 'lawnchair', but that gives you a red squiggly line, but 'lawn chair' also looks wrong, so 'lawn-chair' is the middle ground.

I’m (sorry for the lack of humbleness) a very fluent non-native speaker and writer, and this is by far my biggest challenge with Claude. It stitches together 2-4 advanced concepts into one or two words and I always have to ask it to “unpack”.

I don’t think it’s easy on native speakers when it happens, but it’s even harder when you’re not.

Maybe LLMs are just Germans.

Yes! It's infuriating. I've tried prohibiting them in my AGENTS.md but it's not 100% effective.

--- AGENTS.md ---

## Plain words, not jargon

Don't use jargon-as-shorthand. Say what you actually mean.

- Don't say "load-bearing assumptions". Say "the assumptions the xyz depends on".

- Don't say "cross-service". Name both services, e.g. "whether the X service can derive duration without calling the Y service". "Cross-X" is confusing because it hides which things are involved.

- Don't deliver verdicts as abstract noun-phrases like "Cross-RCA double-counting is unfounded". Say it plainly: "I checked whether the same root cause gets counted twice across RCA runs, and it doesn't."

## No earth-shattering declarations

Don't hype findings. Skip "a critical finding changes everything", "now I have the full picture", "this changes the game", etc. Just state what you found plainly. Most findings are ordinary; report them that way.

## Don't reflexively hedge a "yes"

When the answer is yes, say yes. Don't soften every positive answer with a caveat: it erodes confidence in the "yes". Only add a caveat when there's a genuine, specific uncertainty worth flagging.

Excessive-hyphenization is ai-hyperfixation

That’s… about how I might have written that.

That and finishing a statement with an em dash — that’s what AI does.

That, and also the very long comma-separated lists with sometimes 10+ items.

FYI, AI isn't fond of a goddamn thing. They have token prediction quirks that don't follow typical English.

I have a Renegade one going that does all of this from scratch (different engine) so it's def more than capable!

Right? All Fable did was a ported an already cross platform project to ios. Does not look like any sort of heavy lifting there, opus 4.6 would do just fine

This needs a backport to Winx64 since this game runs like crap on modern windows

I remember that game! Cinematics! and some units had dune realistic shields so when hit with laser, both attacker and defender died. I don't think i've finished it, ending had some worm timer mission i couldn't get to in time.

Try it before July 7 when Fable disappears from Claude Code subscription pricing.

This was one of the best RTS of the era. Still holds up today. The music was also very good.

Emperor was a great game. My only real complaint was the five sub-factions seemed to be imbalanced. I’d like to revisit to see if the was missing something.

Let me give it a go :)

This is not Dune 2000 ? https://www.openra.net/download/#linux

I loved this game. First RTS I ever played :)

You can do this yourself with LLMs, but I admit that it's still not a trivial process. For the actual best results and the highest chance of progressing quickly, you really need a $200 OpenAI/Anthropic sub and a lot of free time. I seriously recommend OpenAI over Anthropic for this, as in my experience GPT 5.5 is far more thorough in reverse engineering and makes mistakes less often.

Then, you first need some tooling, either Ghidra (open-source) or IDA (paid), and some tooling to expose them to an LLM. I have a custom IDA Python-based CLI that lets LLMs trivially call into IDA's Python APIs from CLI, but there are tens of different Ghidra/IDA MCP/CLI/SQL projects out there.

After that, it becomes more mechanical, you just let the agent (or multiple agents) explore and start renaming (easier to start with functions + globals), better if it's something that's directly applied to the suite you're using, so that all names show up everywhere. This is actually quite a quick process, especially for older/smaller games. After you have enough function names, you need to instruct and have LLMs add actual types, so that the decompile doesn't have raw casts and offsets, but real fields + types. They will also need to apply types to globals and functions.

Afterwards comes the hardest part - you can export this very well named/annotated decompile, and do one of:

1) Have the LLM try to directly polish the code enough to be compilable. Despite of the decompile quality, this isn't as hard as it sounds.

2) Have the LLM recreate the project from scratch in another language, something like https://banteg.xyz/posts/crimsonland/. This can be easier to get initial results, but you're sure to hit tons of bugs due to the differences in implementations.

The 1st approach is more thorough, especially because you can find a matching C/C++ compiler and start doing actual decomp.dev-like work - binary matching functions so your source code compiles down to the exact bytes as in the original binary. This is the longest, hardest part, human community projects take years to complete, and LLMs still struggle with getting matches for 100%, so you might spend weeks-months, and tons of LLM usage - an agent can take like an hour to match a single 1000-byte function in worst case.

As a small note - you do not need to binary match 100% to have the game be absolutely playable. Compilers are often very tricky to lead, so you might already have the code that does exactly the same thing, but just a different local variable layout might make the compiler use different registers.

This is a OS port (iOS) of an existing functional and maintained fork (MacOS) of the official release (Windows).

Most of these low-hanging bugs would have been caught upstream by now.

I’ve been using it to use Ghidra to do reverse engineering for modding Zelda: Tears of the Kingdom. Pre-ban it would flag immediately, post-ban it _rarely_ flagged anything and when it did I realized I could just make a memory telling it to convert reverse engineering speech into game development speech, not mentioning pointers, memory, addresses and decompiling. Then the flags mostly went away.

You can sidestep flags by just compacting and then changing the model back at any rate.

lol, I'd expect that as it starts reading of sections of code dealing with the chinese and terrorist factions.

Technically there're just 3 layers: DXVK over MoltenVK over Metal. D3D8 and Vulkan here are just the APIs implemented by those adapter layers.

There're some D3D implementations over Metal that could skip the Vulkan layer but none implement the old D3D8 so you'd still need another layer that implements e.g. D3D8 over D3D9-11. Also, DXVK and MoltenVK have got a lot of traction and fixes on their own, so they're probably the most accurate pipeline for D3D on Metal.

Apple never released a driver that supports Vulkan out of the box, therefore MoltenVK was born, which translates Vulkan IR to Metal source then recompiles to Metal shaders.

This was the pipeline in Proton for macOS (I'm not sure if it's still is the case, been quite a while since I checked).

He forked GeneralsX and added just the last few commits.

Probably not exclusively using Fable.

It wasn't, this is just another free marketing piece for Anthropic.

I've been doing something similar for some of my favourite older games. But the "byte for byte" claim has me worried. Isn't simply decompiling the sourcecode from the binary and releasing that problematic?

It's not the "clean room" approach and companies could still claim it violates some kind of copyright and get it taken down.

Sweet!!

This project is a fork and all it does is add iOS support. Commits by the repo fork owner begin 19 hours ago, so very plausible those are done with Fable. But I agree it's very unclear to me if adding iOS support was some task only Fable could accomplish over prior models.

Looks like EA did open source the game (only the first maybe)

https://github.com/electronicarts/CnC_Red_Alert

This seems to be the most active port saying it works on a Mac/Linux https://github.com/Daft-Freak/CnC_and_Red_Alert

You can always play it in the browser https://news.ycombinator.com/item?id=45991853, sadly no Yuri's Revenge is possible there though

they lost the original assets so afaik they arent gonna make a remaster

cnc-ddraw i think would get it to run fine on a steam deck though, so you should be able to play it without much issue

Assuming nothing like DRM goes out of its way to prevent it, I’d be willing to bet significant money that by the time GTA6 is retro enough to require porting to “modern” platforms, precisely that sort of porting will not only be possible, it’ll be so commonplace that it won’t even merit an HN post when it happens.

It needs the assets from the original game. The creator of this project can’t legally redistribute those assets, so you have to provide them yourself.

Well interface on mobile devices vs traditional computers is a bit different. Game devs can’t even have consistent controller support. Supporting touch is almost never worth it.

The code appears to be based on other people's forks:

> The naive plan (port EA's raw source) is a multi-month job. The actual job was "port the best community fork," which was a one-session job.

https://github.com/ammaarreshi/Generals-Mac-iOS-iPad/blob/ma...

upstream is a MacOS+linux build. https://github.com/fbraz3/GeneralsX.

It seems it didn't:

> Built on EA's GPL v3 source release via fbraz3/GeneralsX (which did the heavy lifting of the macOS/Linux port — this fork adds the iOS/iPadOS port and a set of engine fixes)

Fable added 19 commits on top of the parent fork, which did not use AI.

You can see the diff of what Fable added here: https://github.com/ammaarreshi/Generals-Mac-iOS-iPad/compare...

I can't tell you how many new hours I've poured in it since bringing it to my iPad

fbraz3/GeneralsX

Right!!

32x memory isn't that big of a jump if you go from storing a bunch of low res, low color count textures to a bunch of high res, high color count ones. I don't know if that's what's going on here but given the advertised "DirectX 8 → DXVK → Vulkan → MoltenVK → Metal" rendering pipeline I could easily see some leaky abstractions there that end up consuming a bit more memory than originally.

The parent of the parent project has ground truth replays, which get compared to new PRs. The game uses lockstep networking, so this is required to prevent desyncs.

You take credit for porting it to "Apple Silicon" macOS, both here and in the title, but that already seems to work upstream? On a quick look I didn't see any commit message of yours addressing macOS rather than iOS. What exactly did you add there?

Great stuff

I found the bundle scripts already prefer VULKAN_SDK/VULKAN_SDK_ROOT, but the build script only scans ~/VulkanSDK

Don’t worry - China inf is for noobs

https://youtu.be/WqWFYOxjZ54?si=1pH6Z1D33TOT4Qmg&t=453

nice!

Given the game is stable and the changes would be at the integration points, and Fable was able to do the direct integration, why would the answer not be “it’ll maintain itself” at some abstract level. The decision to maintain open source is up to the maintainers and I think the answer is “no one” 99.99% of the time, but I’ll wager if someone is willing to spend the tokens on it, a CI reintegration agent would do just fine in keeping it working as the underlying dependencies have required changes (which would really be only major changes in apple apis that aren’t backwards compatible.”

Pylint is different because it’s working against a necessarily dynamic wavefront that it has to keep parity with as it advances. All python changes, ecosystem adaptations, etc - and maintaining that with an AI harness in CI would never work. It would require a concerted effort and thought along the way.

So it’s sort of a different beast all together. In fact I think this is a great demonstration of using AI to resurrect technology built for X to work with Y, where X is dead and Y is current. Automating this feels like a net positive and because the original software is “finished” there isn’t decision making and strategy required.

These LLMs are remarkable. I used Opus to revive for myself abandoned software and bring it up to date with the latest versions of the frameworks so I could add some features. And there's other software which I vendor and merge in upstream changes and self-manage. This would have been a near-impossibility in the past.

"Who will maintain this?" appears to be "Me with an agent". And it's great.

That was me! Checkout my latest Fable project with 4D splats: https://news.ycombinator.com/item?id=48786245