By A developer who goes by FractalFir on GitHub spent three years and fourteen attempts building a toolchain called cilly — a Rust-to-C compiler backend. This week, they used it to demonstrate something that sounds unreasonable: translating the entire Rust compiler into approximately 46 million lines of C. The result, crustc, lets you build a working rustc using only GCC and make. No LLVM. No prior Rust binary. It landed on Hacker News and sparked the kind of thread developers bookmark.
What crustc actually is
crustc is not a reimplementation of the Rust compiler. It is a translation of the actual rustc — specifically, rustc 1.98.0-nightly from June 16, 2026 — into C code that GCC can compile. That distinction matters more than it sounds. A reimplementation follows the same spec but makes independent decisions. A translation carries over the exact semantics of the original.
The output is rough by any measure: 46 million lines of C, generated mechanically, optimized for nothing. But it compiles. The translated compiler can build Rust’s core, alloc, and std libraries. FractalFir calls it a “demo/teaser” for cilly, the underlying toolchain that did the heavy lifting. cilly itself is not yet public.
The bootstrap trust problem
Here is why the security angle is worth taking seriously. The Rust compiler is written in Rust, which means building it requires a prior Rust compiler binary. That binary could, in theory, be compromised. Ken Thompson laid out exactly how in his 1984 Turing Award lecture: a compiler can insert a backdoor into every program it compiles, including into itself, and the backdoor never appears in the source code. Source review catches nothing.
This is a documented concern in the rust-lang repository. The known mitigation is Diverse Double-Compiling: compile the suspicious compiler using a completely different, trusted compiler, then compare outputs. If they match, no backdoor exists.
crustc makes that verification path possible for Rust. You compile rustc from C using GCC — a completely independent code path — then check whether the resulting binary matches the official release. As Rust moves deeper into critical infrastructure (Linux kernel, Android, cloud providers), the ability to independently verify the bootstrap chain stops being academic.
Rust on the platforms LLVM ignores
The second use case is more pragmatic. Standard rustc requires LLVM to generate machine code, and LLVM does not support every architecture. Legacy embedded systems, obscure DSPs, and vendor-specific microcontrollers often have mature C compilers and nothing else. Adding LLVM support for those targets is a multi-year project.
cilly sidesteps that by generating C instead. It probes each target compiler with small “witness programs” to learn what it supports, then generates C code the compiler will actually accept. It can even ship compilation work over TCP to a remote C compiler, useful when you cannot run rustc locally on the target at all. For teams maintaining Rust code on genuinely niche hardware, this is the first credible path that does not require rewriting the LLVM backend.
The existing alternative, mrustc, already handles bootstrapping for Guix and supports rustc up to version 1.74.0. But mrustc is a reimplementation in C++ — it independently encodes the same semantics, which introduces its own trust questions. crustc’s approach of translating the actual compiler is philosophically cleaner for trust verification.
What to watch for
The caveats are real. cilly is not yet publicly available — FractalFir says it needs more work before it is fit for others to use. The 46-million-line C output is not human-readable or maintainable. Performance of the C-compiled rustc will lag the official build. The HN thread surfaced legitimate skepticism about trusting a beta transpiler on exotic targets where debugging is already painful.
One observation from the thread stood out: more engineers understand C toolchains, linkers, and ABIs than understand rustc internals. A Rust compiler expressed as C widens the pool of people who can debug portability problems. That is a compounding benefit that goes beyond the immediate use cases.
This is attempt number fourteen. Forty-six million lines of C. When cilly goes public, it will be worth revisiting.
