s-macke

Thanks to this project here:

https://github.com/s-macke/starflight-reverse

this has now become a piece of cake for the agent. The hard part has already been done. The question now is: how familiar is the agent with Forth?

Thanks. I’ll pass the feedback on to Opus 5.5 :-)

There isn’t that much to say. Start with an empty directory, put the XKCD image in it, add your ElevenLabs API key, and set up a Python virtual environment. Install ffmpeg.

Then start Claude. From that point on, it’s mostly prompting and evaluating the results. Like any good engineer, you shouldn’t simply start with “Create a video from this comic.” Instead, take a step-by-step approach: discuss the visual style, animations, ask for audio examples, create a script, and then develop a storyboard (ask for a .html document).

The important part is to break the whole generation process down into small, manageable steps. I also used the brainstorming skill from Superpowers for the discussions. It makes the whole process much easier when the AI asks the questions and I just have to answer them.

The result is 4500 line python code generated by Opus 5.5 and a lot of video and audio files.

Agreed. Just yesterday, I recreated the XKCD comic “A Bunch of Rocks” (https://xkcd.com/505/) as a video. It took me about five hours, using ElevenLabs for the audio and a step-by-step process involving brainstorming, planning, storyboarding, and so on. Opus 5.5 has become remarkably capable.

[0] https://simulationcorner.net/A_Bunch_of_Rocks.mp4

I have an example here. Took 3 hours with Pro Plan.

https://simulationcorner.net/chair/chair-evolution.gif

Exactly. I just give Astra an image such as furniture, and it creates an 3D reproduction in Blender. You don’t even need computer use. Codex and Blender’s scripting engine is enough.

I use a step-by-step approach:

1. For each topic, write a result Markdown file in `spec/`.

2. Identify the file formats.

3. Reverse Engineer and extract all assets, followed by manual review. This works in 90% of the cases.

4. Determine the compression/packing used for the executable. Most binaries used one of roughly five common executable packers.

5. Unpack the executable manually.

6. Use an ancient free IDA-Pro for disassembly, or a modified DOSBox to determine all code/data blocks and the relevant segment-register values for the 8086 architecture. In the second case I use my vibe-coded disassembler.

7. Identify the major functional domains in the disassembly and split the files accordingly.

   ...

Stunt Car Racer from Geoff Crammond published by MicroProse, not Stunts from Distinctive Software.

I would like to see all of them :-)

One of the most difficult reverse-engineering projects from that era for me was Stunt Car Racer on the C64 (also ported to DOS). It features a highly optimized 8-bit 3D graphics and physics engine. Fable was the first one that was able to generate a complete port of the game.

Now I am trying of Flight Simulator 4 and Wing Commander 1. Then maybe Frontier Elite 2. So much fun ....

The BSD Games collection has an ATC Simulator as well from around 1985:

https://github.com/vattam/BSDGames/tree/master/atc

Kennedy Approach was published around the same time.

https://en.wikipedia.org/wiki/Kennedy_Approach

Ask a coding agent to decode the assets. Works pretty often for such old games.

What I find fascinating is the fact that you can implement those few lines in an esoteric language such as FRACTRAN or Game of Life and even boot Linux on them. Seems doable now. In theory.

Yes, I’ve tried it. For example, this was my winning entry from a year ago [0]. The LLM only performs trivial obfuscation, not advanced transformations.

For example:

  if (x == 1 || x == 2) { ...

can be transformed into:

  if (!(2+x*x-3*x)) { ...

An LLM will do this if you explicitly ask it to, but not on its own.

[0] https://github.com/ioccc-src/winner/blob/master/2024/macke/p...

Here is the video:

https://www.youtube.com/live/MoWCwZx1Swc?si=eIOlRsKWNKRVRZeB...

Yes, you haven’t tried it. LLMs are actually awesome at deobfuscation, but terrible at obfuscation. They just can’t do it yet.

They also lack the creativity needed for those entries. Obfuscation is only one part of it. Coming up with the idea is another. Many entries also have special qualities that make them true works of art.

My favorite is the 366-byte C program emulator that can run Linux and Doom [0]. The VM implements an OISC - a One Instruction Set Computer [1].

[0] https://github.com/ioccc-src/winner/blob/master/2025/cable/p...

[1] https://github.com/ioccc-src/winner/blob/master/2025/cable/R...

This VM implements an OISC - a One Instruction Set Computer.

More information:

https://github.com/ioccc-src/winner/blob/master/2025/cable/R...

Because I haven't found the special case in the disassembly for these "flying" objects. Probably I misinterpret the object coordinate somehow.

Sorry, the maps are rendered in 3D so that you can fly around. I can of course make top-down screenshots of the maps. Thanks for your feedback.

Author here. The Ross’s Game Dungeon video was, to some degree, a motivation for me to start the reverse-engineering process, just for fun. The analysis took place over many years, and I figured out 95% of the format myself. AI helped me then with the coloring, which is pretty complex. I have read the Accursed Farms forum, of course. But it didn't help much.

The map mentioned there can be found as “Unknown Map” in the dropdown. However, I haven’t yet connected that map to the menu screen. It might be called “Tom’s Test Track,” because that string appears in the disassembly.

Integration into noclip might be easy, because I also have the geometry as a standalone .obj file.

I wish I had known this two years ago. I ended up writing my own embedded connection struct to trace these things [0].

  type Connection struct {
    net.Conn
    OnEventCallback func(clientClosed bool, serverClosed bool, err error)
  }

[0] https://github.com/s-macke/SlapperX/blob/master/src/tracing/...

On weekends, yes. During the week, that’s also true if they arrive within a short time frame, e.g., three minutes. Almost no one looks at “New”. That is the real issue.

Author here. Yes, it is integral. I chose this approach to first show how to draw it from back to front, because the code is easier to understand this way.

Nice to see an MCP integration here as well. In my experience, coding agents are great at analyzing MOS6502 code. Because the code is limited to only 64 kB, it does not overwhelm the agent. And in parallel it can write specs and even extract assets via normal coding tools.

Using my similar tool [0], I feel I get roughly a 100x speedup. I will definitely try regenerator2000.

[0] https://github.com/s-macke/OpcodeOracle

Exactly. And JSLinux is using one.

Most such emulators have Internet access on the IP level. Therefore, this is a very cheap way to test anything on the Internet.

    apk add nmap
    nmap your.domain.com

However, the speed is heavily throttled. You can even use ssh and login to your own server.

It can also be used as a very cheap way to provide a complete build environment on a single website, for example to teach C/C++. Or to learn the shell. You don't have to install anything.

To reverse engineer old C64 games using Coding Agents, I built a CLI and MCP flow disassembly tool. The agent can search the disassembly, provide annotations, manage symbols, and reinterpret code and data.

[0] https://github.com/s-macke/OpcodeOracle

AI is very effective for reverse engineering. Unless you’re doing it purely for fun, it makes sense to use AI where it helps.

I’ve tried to visualize the “navigate and modify” process you mentioned in [0]. It’s mesmerizing.

Because reverse engineering outcomes are comparatively easy to verify, it’s a good fit for training for AI. I expect major progress in the next few years, potentially to the point where reverse engineering many binaries becomes highly automated.

[0] https://github.com/s-macke/OpcodeOracle

About halfway through my reverse-engineering process, I came across those documents and realized that roughly 50% were missing. I searched pretty much the entire web to see if anyone had stored these files elsewhere, but so far I haven’t had any luck.