How to use the Blitz3D Decompile and Port agent skill

What the skill makes the agent do

Blitz3D games ship as one exe. The runtime lives in the exe, and the compiled game sits in a resource module that the runtime links at load. Opening the exe in Ghidra shows only the runtime, so the skill uses B3DDecomp, which disassembles the module and decompiles it to Blitz source. That source becomes the spec for the port, and the original game is the reference you test against.

The skill covers the decompile step, finding the game's systems, porting the logic step for step, and verifying the port against the original's decompiled numbers. It also points the agent at a runtime reference for Blitz3D quirks such as the fixed tick, Animate, CurveValue, Euler angles, quaternions and Rnd.

• Decompile a .bb game to readable source with B3DDecomp
• Port logic to another engine, marking each deviation with a reason
• Convert animated .b3d viewmodels (bones and keyframes) into Roblox
• Check timing, rates and aim against the original game's numbers

Install the skill

Download the ZIP from the skill's page and unzip it into one of two places. For a personal install that works in every project, unzip into ~/.claude/skills/. For a single project, unzip into that project's .claude/skills/ folder.

In the Claude apps you can instead upload the ZIP under Settings → Capabilities → Skills.

• Personal: ~/.claude/skills/
• Per project: .claude/skills/ inside the project folder
• Claude apps: Settings → Capabilities → Skills, then upload the ZIP

Set up the tools before you start

The skill needs B3DDecomp, a C# tool under GPL-3 that you build yourself with a .NET 8 SDK. A user-local SDK can be installed without admin rights. The skill also needs Python 3 for the model scripts, and Blender with bpy, run in background mode, for the build and render steps. Converting to Roblox assumes Roblox Studio or tools for the Luau output and FBX import.

You also need a copy of the game executable that you have rights to study. The skill's build step is: dotnet build Blitz3DDecomp.sln -c Release, run from a clone of the B3DDecomp repository kept outside your project. If one function aborts the whole run, the skill includes a patch that makes the decompiler skip that function and log a step5 failed line instead.

• B3DDecomp (C#, GPL-3) built with a .NET 8 SDK
• Python 3 for b3d_skin.py and vm_anim_data.py
• Blender with bpy, in background mode, for vm_build.py and vm_render.py
• Roblox Studio or tools for Luau output and FBX import
• A copy of the game executable you have rights to study

Trigger the skill with natural requests

You don't need special syntax. Describe the goal in plain language and name the game or the model. The skill's description covers Blitz3D games such as SCP: Containment Breach and other .bb games, B3DDecomp, the runtime behaviour, and animated .b3d models going into Roblox.

Good requests say what you have, what you want, and what you own. Mention the rights position up front, because the skill checks it before porting.

• "Decompile my Blitz3D game's exe with B3DDecomp and show me the weapon fire code."
• "Port the fire rate and ADS behaviour of this Blitz3D weapon to Roblox, and check it against the original."
• "Convert this animated .b3d viewmodel with bones and keyframes into a Roblox rig."
• "Which file sets the shot delay in this Blitz3D game?"

Follow the workflow the skill enforces

The skill sets a clear order. First, keep every disassembly and decompile outside any repo, for example in ~/<game>-decomp/, and never publish them. Second, decompile with Blitz3DDecomp.exe, passing a copy of the game exe. The output goes to <game>_disasm/ and then <game>_decomp/. Third, find the system by grepping strings for the assets it loads and tracing constants to where they are set and read. Fourth, port in the same order with the same constants and the same tick. Fifth, verify each ported behaviour against a measured number from the engine. Notes go in the mod's MODLOG.md.

• Keep decompile output outside the repo and never publish it
• Decompile into <game>_disasm/ and <game>_decomp/
• Trace every number the port uses to the line that sets it and reads it
• Record each verification check and its result

Know where the skill stops

Some builds are protected against decompiling. A modified compiler and runtime may hash every function, type and builtin name, or the module may be encrypted. The skill tells the agent to stop in these cases and not defeat the protection. Before decompiling, it also tells you to list the exe's sections with objdump -h or a PE viewer, and to stop if one is present that B3DDecomp would need to undo.

Rights matter too. A port that re-expresses a game's logic, or converts its models, textures or sounds, redistributes that game once it is published or uploaded, including to Roblox. Port only games you own or openly licensed games on their terms. SCP: Containment Breach is open source under CC BY-SA 3.0, so credit it and keep the port under that licence, and check each asset's credits because fan games mix licences. Anything else stays a private study.

• Stop on protected builds rather than reversing the protection
• Port only games and models you own or have a licence for
• Credit SCP: Containment Breach and keep its CC BY-SA 3.0 terms
• Do not upload or publish anything from a private study

Safety notes: scripts and network access

The skill runs scripts and uses the network. The build step downloads and runs .NET tooling, and the Python and Blender scripts process your model files. Review the scripts in scripts/roblox/ before running them, and run them as the skill's references describe, with python -I for the Python scripts. Keep the decompile output and any game executable away from public repositories.

• Runs scripts: yes
• Uses network: yes
• Review scripts/roblox/ before running; Python scripts are run with python -I
• Don't commit disassemblies or decompiled source