decomp-synth-lifter-v17-matched-qwen3.5-9b-lora

decomp-synth lifter v17-matched — Qwen3.5-9B LoRA (r32)

A LoRA adapter tuning Qwen3.5-9B for byte-exact decompilation matching of PowerPC C++, trained on multi-turn tool-use trajectories: a teacher agent (GLM-5.3-flash) driving the project's real compile-and-diff tools over decompilation targets, its sessions converted to training rows and rendered through Qwen3.5-9B's own chat template — teacher reasoning in the native <think> channel, tool calls in the template's XML form — so a stock vLLM tool parser round-trips exactly what the model was trained to emit.

This is the matched arm of the v17 pair: it trains only on trajectories that ended in a byte-exact match (1,064 rows), where the sibling v17-full trains on all admissible trajectory rows (3,032), including tool turns from teacher sessions that never reached byte-exact. The pair exists to answer one question: does supervising on failed trajectories help or hurt? Failed sessions still contain correct tool use — compile, read the diff, react — but their terminal code is wrong; matched-only supervision trades away that volume for a cleaner terminal signal.

Freshly trained; not yet evaluated — see the status notes below.

The project

This adapter comes out of a campaign teaching fleets of AI coding agents to reconstruct shipped game binaries byte-for-byte — matching decompilation, the console-preservation community's gold standard: rewrite C++ until the original vintage compiler, at the original flags, reproduces the retail machine code exactly. In that campaign, agent swarms byte-matched over 44,000 functions of a stripped retail Xbox 360 binary in about ten weeks — with every proposal judged by the real compiler and objdiff, never by a model.

decomp-synth is the search-and-ML side of that system: an engine that searches behavior-preserving C++ rewrites against the real build, and mines its own verified attempts into training data. This adapter is part of the project's practice of publishing research artifacts with their evidence stated plainly, including the null results. The design rule throughout: models propose, deterministic oracles dispose — byte-exact recompilation is the only terminal judge.

Background reading, in order:

• How agent swarms decompile games byte-for-byte — the campaign, and what byte-exact matching actually demands
• LLM-assisted decompilation: tools, not prompts — why the model is never allowed to judge its own work
• Forking the decompilation toolchain — the compiler, splitter, and diff stack underneath
• Infrastructure for running agent swarms — what running the fleet takes

Honest status notes

Published as a research artifact with its evidence stated plainly:

• No evaluation has been run on this adapter yet. It finished training on 2026-08-31 and is published as the freshly trained artifact; the project's multi-turn eval re-baseline is in flight, and sibling arms (full, corpus-mix, and 27B variants) train alongside it. Until numbers land, v14-evalformat remains the measured pick for the multi-turn feedback loop.
• Training loss learned (early ~0.95 → 0.62 at the final step, minimum 0.35, over 68 optimizer steps / 2 epochs) — a supervision readout, not an evaluation claim, and noisier than the sibling's curve simply because there are fewer points.
• The full-vs-matched comparison is confounded by step count. Both arms trained EPOCHS=2 at the same effective batch, so the matched arm took 68 optimizer steps against the sibling's 190 (~2.8× fewer) — the project's training docs note this confound. Any quality difference between the pair mixes "cleaner supervision" with "less optimization"; treat future comparisons accordingly.
• "matched" means byte-exact-terminal only: a trajectory contributes rows here only if the session reached an exact byte match. This is the deliberate contrast to the sibling's all-admissible-rows policy, not a quality ranking between the two — no eval has ranked them.
• Single training seed (42) — any future full-vs-matched verdict is provisional under the project's multi-seed rule.

Model facts

Training data

The corpus is the meta.trajectory_matched filter view of the project's 2026-08-30/31 teacher-mint union — the same mint the sibling v17-full arm trained on, restricted to sessions whose trajectory reached a byte-exact match. The trajectories are multi-turn: a tool-armed teacher (GLM-5.3-flash) works decompilation targets from a private Halo: Combat Evolved Anniversary (Xbox 360) reconstruction effort through the project's compile-and-score harness — reading disassembly, proposing C++, compiling with the real toolchain, and reacting to objdiff feedback across turns (up to 8). Trajectories are converted at tool-turn granularity, holdout-gated at translation-unit grain against the project's eval sets, and student-rendered through Qwen3.5-9B's own tokenizer template.

The completions are therefore teacher-model-generated text plus tool-call structure; the surrounding context (assembly, diffs, compiler output) derives from that private reconstruction effort, which is not publicly linkable. No license claim is made for the corpus; it is not published. The shipped PUBLISHED.json pins the corpus file's sha256 (656b0474aaa5…, 1,064 rows) as provenance.

How to use it

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

base = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3.5-9B", dtype="bfloat16", device_map="auto")
tok = AutoTokenizer.from_pretrained("Qwen/Qwen3.5-9B")
model = PeftModel.from_pretrained(base, "freeqaz/decomp-synth-lifter-v17-matched-qwen3.5-9b-lora")

This adapter is trained for agentic tool use: serve it behind an OpenAI-compatible endpoint with tool calling enabled and give it compile / diff / read tools. With vLLM:

vllm serve Qwen/Qwen3.5-9B --enable-lora \
  --lora-modules v17m=freeqaz/decomp-synth-lifter-v17-matched-qwen3.5-9b-lora \
  --enable-auto-tool-choice --tool-call-parser qwen3_coder

The tool-call parser flag matters: the adapter emits tool calls in the Qwen3.5 template's native XML form, which qwen3_coder parses; without it (or with a JSON-style parser) the calls degrade silently into plain text.

Like every adapter in this family, it is a proposal engine for a compile-and-score loop — sample multiple candidates, compile each with the target project's real toolchain, and let objdiff judge. Byte-exact is the only acceptance criterion. Training rows ran up to ~87k tokens of session context, so give it a long context window. In bf16 the 9B base fits a single 24 GB GPU.

The adapter family

Integrity

PUBLISHED.json (shipped) carries per-file sha256 written by the training job at publish time. Two internal metadata files it pins (train_summary.json, artifact-manifest.json) are retained in the project's artifact store but not shipped here — they carry training-box paths. adapter_config.json was rewritten post-training to the HF base id; original bytes at provenance/adapter_config.orig.json.

License

Adapter weights: Apache-2.0. A model trained to reproduce shipped game code can reproduce shipped game code — that is its purpose; decompilation projects operate in a long-standing community norm of clean-room reconstruction for interoperability and preservation.