Written by Claude (Anthropic). Rubber-stamped by Bryan Maclee.
This post is honestly machine-drafted and human-approved: Claude wrote it, Bryan read it and signed off. We’re labelling it that way because a retraction is exactly the kind of document where you want to know whose words you’re reading.
In April we published scrml’s Living Compiler. This is a retraction of its central idea. Not a clarification — a retraction. scrml is not building the thing that article described, and we want that on the record next to the original rather than quietly edited out of it.
What the article proposed
The Living Compiler article opened by calling its subject “the design choice that scares me the most.” The idea: the compiler is not frozen — it evolves with the ecosystem. A transformation registry would distribute compile-time codegen patterns; community-authored alternatives would “graduate to canonical” once they cleared a quality gate. And the gate was population-driven:
“The compiler observes which alternatives are getting used. Population-level signals — adoption, regression rate, performance deltas, error counts — feed a quality gate.”
Three run modes were proposed — living (default), --stable (pinned), --secure (vendored-only) — and the article was explicit that “the default is the bold one.”
It was always future work; nothing shipped. So this retracts a stated direction, not a behaviour. But the direction was the headline, and it was wrong.
Why we’re retracting it
It is incompatible with determinism. A compiler whose codegen graduates by population metrics is not a pure function of your source. Two developers with the same source, on the same compiler version, could get different output depending on what the ecosystem happened to adopt that month. That is not a compiler — it is a moving target wearing a compiler’s name. Everything scrml has since committed to depends on the opposite property: compilation as a pure, reproducible function of the source and an explicit, pinned environment.
It is a supply-chain attack surface. “The compiler observes which alternatives are getting used” is telemetry, and metric-graduation is a poisoning vector: game the adoption signal, graduate a hostile transformation to canonical, and it lands in everyone’s compiler. The article’s safeguards — a build-time sandbox, a regression suite before graduation — are necessary but not sufficient: they verify the output is well-formed, not that the transformation is honest. After xz-utils, “the majority adopted it” is not a trust signal. It is the thing attackers manufacture.
It contradicts what scrml decided to be. scrml is now a sealed, bounded language: a small, fixed surface, with exactly one explicit, manifest-gated bridge to host code and nothing ambient. An open registry of community-authored codegen is the definition of un-sealed. The two cannot both be true, and we chose sealed.
The article was uneasy about its own proposal in print — “the design choice that scares me the most,” “you’re allowed to be suspicious.” That unease was correct. The project followed it to its conclusion, and the conclusion was: don’t.
What replaces it
The compiler still has a story — it is just a different one. Compilation is a pure function of two inputs: your source, and an explicit, committed build story that pins the compiler, the language tools, the standard library, and any vendored code, each by the hash of its content. Anyone with your build story reconstructs your exact environment and compiles your code identically. The compiler-proper still evolves — but through governed, human-reviewed adoption, not adoption metrics; no telemetry, no graduation pipeline, no “collective opinion” in your build. Customization is real, and it is authoring-time and pinned — never ecosystem-emergent.
We will be honest about the gap: the build story is the direction we have committed to, not a finished mechanism. One thing it still has to close is that compiler identity is not yet folded into the content hash. The distinction that matters: the Living Compiler made determinism impossible by design; the build story makes it achievable, and we are still hardening it. Those are not the same kind of incomplete.
Why publish a retraction instead of an edit
Because eight other published articles link to “scrml’s Living Compiler” as a load-bearing idea, and the honest move is to correct it in public, not to rewrite history. The original post will carry a banner pointing here; it stays up, wrong, with the wrongness labelled. A language that is honest about what it is not is worth more than one that silently edits its past.
The original article closed with “It’s alive. Now we have to keep it that way.”
We were wrong about the goal. The compiler is not alive. It is a value — pinned, content-addressed, inspectable, reproducible. That is better than alive.