46 Million Lines of C: Rust Compiler Rewritten in C via New Toolchain

46 million lines of C, and it compiles a nightly Rust compiler from tip of branch. That's what FractalFir's crustc repo shows: rustc 1.98.0-nightly, translated in its entirety to C, capable of building core, alloc, and std.

What crustc Actually Is

This isn't a toy. Run make -j20 with a path to LLVM's libLLVM.so.22.1-rust-1.98.0-nightly and you get a binary that prints rustc 1.98.0-nightly (c712ea946 2026-06-16). That binary can compile Rust code. The generated C is 46 million lines—big, but buildable by GCC 13.3.0 and LLD 18.1.3 on ARM64 Linux.

crustc is the demo. The real product is cilly, a Rust library and compiler backend (plugin) that translates your Rust code to C for arbitrary targets. This is FractalFir's 14th attempt; the previous ones included the public rustc_codegen_clr. This one worked.

The cilly Toolchain Adapts to Anything with a C Compiler

cilly generates "witness" programs that probe the target C compiler's capabilities. For example, it checks _Thread_local support at compile time. Type layouts, sizes, alignments, character encodings, and integer formats are all queried for the specific platform. Fallbacks exist where possible. The output is compiler-specific—you can't take ARM64-generated C to RISC-V, but you can generate fresh C for RISC-V with the same source.

The toolchain supports network transparency: cilly can talk to a C compiler over TCP (or even UART) on a remote system. That solves the bootstrap paradox for platforms without a C cross-compiler. FractalFir has compiled small Rust programs for x86 Plan 9 VMs this way, running rustc on ARM64 Linux. It works.

Why This Matters: Rust on Blorbo OS

The primary goal is support for old/obscure hardware that lacks LLVM or GCC backends but has a C compiler. Every time a project moves from Rust to C or a Rust alternative appears, the lack of support for these targets is raised as a downside. cilly removes that objection by wrapping rustc and a C compiler, translating on the fly. The user just defines a target triple (e.g., sdcc_z180-unknown-none) and points to the C compiler executable.

ABI compatibility is mostly there, with caveats on platforms like ARM64 where rustc chooses a non-C-representable ABI. Still, this is the most credible attempt I've seen to dissolve the "Rust can't run on my weird hardware" argument.

FractalFir built crustc on an ARM64 Linux workstation (Linux 6.17.0, GCC 13.3.0, LLD 18.1.3). Reproducing it requires the same Rust nightly and LLVM libs. But the point isn't reproduction—it's what the approach enables. cilly aims to let Rust code run anywhere a C compiler exists. Even Blorbo OS.

Source: crustc: entirety of rustc, translated to C
Domain: github.com