7 ms·
crustc: entirety of `rustc`, translated to C
- Tiberium 3mo agoI wonder how the performance looks like, because this can be interesting even for non-porting reasons ;)
- ronsor 3mo ago> I put my left hand in a blender. The blender won. (Still have all my fingers, just some stitches). I will not elaborate further. What a shame. I would've read an article about this.
- luke-stanley 3mo agoBut did it Blender open the source?
- cozzyd 3mo agoI mean I get confused every time I use blender too but not to the point of losing fingers...
- deleted 3mo ago[deleted]
- iwassayinbourns 3mo agoI desperately want to know more.
- RustyRussell 3mo agoNobody who would code this up would be entirely sane. But I can't help thinking "these are my people" when I read this...
- gpvos 3mo agoHe wrote 14 Rust to C compilers. Sanity has gone out of the window already.
- Cadwhisker 3mo ago> The primary goal of this is support for old/obscure hardware with no LLVM/GCC support. There are still some systems out there that don't support Rust but support C. The landing page mentions Plan 9 as one of the systems.
- lioeters 3mo ago> For the past 3 years, I have been working on compiling Rust to C. .. This is, by my count, the 14th attempt: cilly Gotta respect the dedication to a niche interest. > The primary goal of this is support for old/obscure hardware with no LLVM/GCC support. I remember reading about the bootstrapping question, how it typically requires a Rust compiler to build the Rust compiler from source. https://bootstrapping.miraheze.org/wiki/Bootstrapping_Specific_Languages https://bootstrapping.miraheze.org/wiki/Bootstrapping_Specif... Oh, but I see there's a C++ implementation of the Rust compiler. https://github.com/thepowersgang/mrustc https://github.com/thepowersgang/mrustc Anyway, this part sounds useful too, that crustc can compile across network and devices. > You build a small C server on your Blorbo OS, run rustc on some normal platform like Linux, and let cilly talk over the wire.
- zadikian 3mo agoSo the author made a Rust to C transpiler and immediately used it to transpile... the Rust compiler. I love it.
- Animats 3mo agoIt makes sense as a porting tool, if you need to port the Rust compiler to some target that has a C compiler. But it doesn't mean rustc generates code for that target, only that you can run it there. You'd still have to teach LLVM about the target. Although that might already have been done. It's not that useful for retro computers because the Rust compiler needs too much memory for most machines of the 32-bit era.
- taris2 3mo agoHave you tried Diverse Double-Compiling (DDC) to test if the official rust compiler has a backdoor? Use crustc to compile the rust source code, producing a new compiler. Then use this new compiler and the official rustc binary, both with deterministic flags, to compile the rust source code again. The two outputs should match bit for bit.
- amir734jj 3mo agoAwesome idea!
- swalberg 3mo agoThis reminds me of https://www.cs.cmu.edu/~rdriley/487/papers/Thompson_1984_ReflectionsonTrustingTrust.pdf https://www.cs.cmu.edu/~rdriley/487/papers/Thompson_1984_Ref...
- lioeters 3mo agoReflections on Trusting TRust.
- jagged-chisel 3mo agotRust
- laughinghan 3mo agoThe sole and entire purpose of Diverse Double-Compiling is addressing Thompson's Trusting Trust: https://dwheeler.com/trusting-trust/ https://dwheeler.com/trusting-trust/
- FergusArgyll 3mo agoI didn't know there's a solution, thanks!
- gmzamz 3mo agoI'm also a fan of https://www.teamten.com/lawrence/writings/coding-machines/ https://www.teamten.com/lawrence/writings/coding-machines/
- Imustaskforhelp 3mo agoThis could be used within https://bootstrappable.org/projects.html https://bootstrappable.org/projects.html to make bootstrappability of rust incredibly much easier other than the previous route of OCaml and other things. I know some folks within the bootstrappable OS projects community are on Hackernews and I hope that they could take a look at this. I feel as if this project could drastically shrink down the efforts needed to get a working rust compiler in a bootstrappable manner.
- hkalbasi 3mo agoNot really. This C code is more like a binary and compiler artifact than a source code. So it won't match the standards of bootstrap.
- afdbcreid 3mo agoDepending on what your goal is. If it is eliminating trusting trust attacks, yes this is no enough. But more commonly you only want to compile rustc for a platform it was never compiled on, and for that this project is definitely enough.
- lispwitch 3mo agomrustc (a handwritten Rust compiler in C++) is already used for that in Guix and likely other distros: https://guix.gnu.org/blog/2018/bootstrapping-rust/ https://guix.gnu.org/blog/2018/bootstrapping-rust/ This would have other benefits though, as it's both a second bootstrapping path and could potentially compile Rust programs for platforms not supported by LLVM
- levkk 3mo agoVery cool. At first, I thought it was yet another LLM-generated demo, but no: original work of art. Super cool. Transpiling into C does seem easier than LLVM IR, and letting GCC optimize seems like this might actually work. Excited to see the compiler implementation when it's out -- a lot to learn from.
- ahartmetz 3mo agoWait, I thought LLVM had a C backend which could be used for the purpose of transpiling Rust to C? Turns out not for a long time, but now maybe again: https://discourse.llvm.org/t/re-ann-llvm-c-backend-still-able-to-generate-c-code-from-c/90055 https://discourse.llvm.org/t/re-ann-llvm-c-backend-still-abl...
- simonask 3mo agoThis approach is harder than you might imagine. LLVM can do a lot of things that don't map to C language constructs. You cannot generally roundtrip arbitrary LLVM IR through some C representation. You can emulate most things, but you won't necessarily get the same LLVM IR in the other end.
- afdbcreid 3mo agoFWIW, Rust can also do a lot of things that do not easily map to C (at least standard C) constructs. For example: - You can compare any two pointers, while in C they must point to the same allocation. This is possible to solve by converting to integers first. - Signed integer overflow is UB in C, defined to wrap/panic in Rust. - Type-based alias analysis is a big one, does not exist in Rust.
- tialaramex 3mo ago> You can compare any two pointers, while in C they must point to the same allocation. This is possible to solve by converting to integers first. Indeed specifically Rust defines that pointer comparisons are done by address, whereas C doesn't specify what the rules are exactly. This gets sticky if the pointer was invalidated (e.g. you free'd the memory it was pointing at). Rust says - as you might expect - that you can still compare this invalid pointer to another pointer (which may or may not still be valid and indeed might be a valid pointer to the same address!) because we're only comparing the address - but C++ says you mustn't do that and I believe C has the same rule. > Signed integer overflow is UB in C, defined to wrap/panic in Rust. This doesn't feel like an interesting difference. C made a weird choice, which was maybe convenient for the usual Worse Is Better reasons 50+ years ago. LLVM doesn't care about that choice, LLVM can cheerfully simulate this behaviour in C if you want that. > Type-based alias analysis is a big one, does not exist in Rust. This also doesn't feel relevant but I guess I'm interested in why you think it would make "a big" difference? Edited: I confirmed C11 has "pointer zap" which is the behaviour I described above, and I believe C23 also still has pointer zap although paulmck and co. are trying to get rid of it or do something on this topic in C2y.
- SpecialistK 3mo agoI wonder if this could be used in PPC Mac OS X, where LLVM isn't supported and most graphical applications need to use GCC 4 with Apple's SDK.
- layer8 3mo agoFinally we can rewrite all the Rust in C. ;)
- dangoodmanUT 3mo agoi believe the author is confused this is the wrong direction (jk i read the readme)
- sylware 3mo agoNope, and c++ should get the same thing. But we now all know rust is microsoft and c++ ISO. I don't think we can trust much more ISO than microsoft to produce less feature creep over the currently known planned obsolescence cycle of 5-10 years.
- groos 3mo agoAs an ex C++ compiler developer, I heartily approve of this project. Kudos.
- nxtfari 3mo agothis is really cool but it seems very unlikely that someone targeting an exotic system not supported by rust (mostly embedded and ancient mainframe targets) would be willing to trust a beta transpiler to not inject any bugs or leaks in the process of turning rust to c. nevertheless, very cool.
- npalli 3mo agoRewrite in C is the new Rewrite in Rust.
- keyle 3mo agoGTA VI out in Rust before C++?
- roflcopter69 3mo agoWake me up when consoles officially support Rust. Until then there's no real way around C/C++ if you want to publish a real game to real consoles. But there's https://akaganite.com https://akaganite.com so it might become possible soon™
- maximilianburke 3mo agoThey don’t need to “officially support” Rust in order to ship code written with Rust. Just target the applicable architecture and ABI. It’s a lot easier now that the ABI’s are mostly standard now too. Source: I wrote a compiler and runtime that ran .NET code (AoT compiled with LLVM) on PS3/Xbox360/Wii and shipped a few games with it.
- pjmlp 3mo agoAs does Capcom with .NET and others. Still it is a matter of sinergy and culture sharing across studios, hence why despite gains achieved by engines like Unity, the huge success made by Minecraft, or Android owning a big chunk of casual mobile games market, most studios end up using C, C++ and the engines that get tier 1 support from platform owners. The culture in the games industry has always been that IP is what matters, the pain points getting it out there not only are secondary, they are also proudly used at some random GDC talk.
- roflcopter69 3mo agoThen why aren't there any public statements about games written in Rust being officially published on consoles? I know that it's technically possible but that does not help you when Nintendo, Sony or Microsoft just say "no" to you because you misuse their toolchains.
- CurbStomper 3mo ago[dead]
- linzhangrun 3mo agoQuite an interesting project, lol. I like the name `crustc` :)
- casey2 3mo agoNot to be confused with crust [1] the dialect of rust B [2][3] is written in. [1] https://github.com/tsoding/crust https://github.com/tsoding/crust [2] https://github.com/bext-lang/b https://github.com/bext-lang/b [3] https://www.nokia.com/bell-labs/about/dennis-m-ritchie/kbman.html https://www.nokia.com/bell-labs/about/dennis-m-ritchie/kbman...
- unjuno 3mo agoThe most interesting part of this to me is not “Rust to C” by itself, but the fact that it widens the pool of people who can help debug portability problems. There are relatively few people who understand Rust’s compiler internals, LLVM backends, and obscure target support deeply. But there are many engineers who understand C compilers, ABIs, linkers, makefiles, cross-compilation, old operating systems, and weird platform-specific compiler behavior. If Rust can be lowered into target-specific C, then some problems stop being exclusively “Rust compiler problems” and also become C toolchain problems. That means more people can inspect the generated C, build failures, linker errors, ABI mismatches, and compiler-specific behavior. C is obviously not a magic portability layer. ABI details, integer widths, alignment, TLS, aliasing, and undefined behavior still matter. But as an ecosystem boundary, C gives many more engineers a way to participate in debugging and porting work. I think that social/maintenance aspect may be more important than the language translation itself.
- jolmg 3mo agoGuideline: > Don't post generated text or AI-edited text. HN is for conversation between humans.
- jdw64 3mo agoI saw the reply, and it's not GenAI text. It's just that in the process of translation, people usually use machine translation or LLM translation. The problem is the vocabulary we East Asians use. I experience this issue too. Probably because in East Asia, we tend to emphasize things with things like "xx" a lot.
- jolmg 3mo agoI thought that may be the case. I shared the guideline so they'd know the likely reason all their comments die immediately. However, their comments are consistently long, so it may be GenAI after all. Their last comment in particular... https://news.ycombinator.com/item?id=48771339 https://news.ycombinator.com/item?id=48771339
- moezd 3mo agoLet Rust vs C battle commence with renewed haste!
- fithisux 3mo agoKudos.
- adithyassekhar 3mo agoI'll wait for rustcrustc
- valentynkit 3mo ago[dead]
- ivanjermakov 3mo ago> The primary goal of this is support for old/obscure hardware with no LLVM/GCC support Wouldn't it be easier to add old hardware support to LLVM/GCC instead? I adore the project scale and determination, but for this goal extending existing projects seems more logical than building a language translator.
- claudex 3mo agoSome architecture lacks documentation, if you have a working C compiler, it's easier to use it than working on a compiler to target it.
- Liquid_Fire 3mo agoPresumably you still need a C++ compiler for LLVM itself though. Or... a C++ to C translator. Edit: On second thought, that's only needed if you want to run rustc itself on the old hardware, which is probably not super useful given the main reason you would need to do this is if LLVM can't target that hardware. For building code written in Rust for such old hardware, this would be sufficient.
- Perz1val 3mo ago> Wouldn't it be easier to add old hardware support to LLVM/GCC instead? No, in fact it's much, much harded. You have no idea of the scope. I have no idea of the scope. Nobody does. There are obscure machines we've never heard about and there are C compilers for them. Targeting and supporting them from modern toolchains is a fool's errand.
- jitl 3mo agorust to c supports infinite platforms that already have a c compiler by implementing a single rust to c program on the other hand, porting llvm to an infinite number of platforms requires an infinite amount of work so, it is less work this way
- micheleeet 3mo agoRust is finally memory safe enough to become C
- db48x 3mo agoWe should port it to Rust.
- sylware 3mo ago[dead]
- westurner 3mo agoThere are discussions of round-trip between Rust and C; Would this be useful for this too? From https://news.ycombinator.com/item?id=46265855 https://news.ycombinator.com/item?id=46265855 : > To better port C to Rust: 3C (Checked C), c2rust, Crown ownership analysis, RustMap, c2saferrust (LLM), Laertes C -> Checked C -> Rust Because Checked C will annotate the raw and other C pointers first.
- icase 3mo ago[flagged]
- kube-system 3mo agoWhat sort of hardware would this be useful for?
- Archit3ch 3mo agoIf I understand this correctly, you could run this compiler on iPadOS (since it's plain C). But you cannot mark it's output executable, since that would require JIT entitlement.