CRAP (Compiler Replacement for Assembling Programs) is not a new compiler. It is a Gemma 4 E2B fine-tune that, given a prompt like 'generate a Linux x86_64 binary that prints boop', directly emits a working ELF file as hexadecimal. The author's idea, matthewhaynesonline, is to bypass the entire compilation chain: no assembler, no tool calls, just an LLM producing machine instructions.

Version 1.1 brings improvements on several fronts. On the held-out legacy set the model remains at 20/23; on novel strings it goes from 8 to 26 out of 40; on multi-turn from 0 to 10 out of 12; on doubled character strings from 2 to 18 out of 24; on random jank exit codes never seen in training it scores 23 out of 25. The author notes an instructive detail: one training run reached a loss of 0.038 while still failing 11 of its 12 trained exit codes. In other words, gradient descent does not equal task completion.

The demo runs in the browser through wllama on WebGPU. It loads the Q6_K GGUF of about 3.6 GiB, generates the hex, parses it into an ELF and hands it to the user, who must download and run it locally. On a Mac M4 Pro with Chrome, Q6_K scores 109/144 against the f16 model's 114/144; the five additional Q6_K failures are wrong values, not completely broken binaries. Q4_K_M collapses to 3/144, which is why the demo does not use it.

The drop between Q6_K and Q4_K_M is the most interesting signal for anyone looking at local inference. It is not a gradual degradation: at a certain level of quantization the model stops producing valid artifacts, not just less precise ones. For workloads that require exact outputs, like machine code generation, that is a structural constraint. In a chat assistant an imprecise token can be corrected on a second pass; in an ELF binary a wrong byte in a critical position makes the executable unusable.

CRAP's provocation is not about replacing a compiler. It shows that an LLM can learn an operational representation of a binary format but not that it is worth using for production. A compiler does it in milliseconds, deterministically and correctly; CRAP does it with several gigabytes of weights, more slowly and occasionally incorrectly. The difference is not one of scale but of guarantees. For those managing local or edge pipelines, the risk is not a model that is 'almost right', but the cost of verifying every output in a context where errors are not tolerated.

The exclusions in the title are the serious part: the model can only generate programs that print a string and exit. The rest is still compiler territory. But the fact that a Gemma 4 fine-tune reaches 109/144 with Q6_K in a browser, without passing through a cloud server, is a data point worth attention for anyone tracking the evolution of local inference.