upvote

points

by jcalvinowens5 hours ago |
comments
upvoteby Philpax5 hours ago|
next
[-]
What Rust-based compiler is it plagiarising from?
reply
upvoteby rubymamis4 hours ago|
parent|
next
[-]
There are many, here's a simple Google search:

https://github.com/jyn514/saltwater

https://github.com/ClementTsang/rustcc

https://github.com/maekawatoshiki/rucc

reply
upvoteby jsnell4 hours ago|
parent|
next
[-]
Did you actually look at these?

> https://github.com/jyn514/saltwater

This is just a frontend. It uses Cranelift as the backend. It's missing some fairly basic language features like bitfields and variadic functions. And if I'm reading the documentation right, it requires all the source code to be in a single file...

> https://github.com/ClementTsang/rustcc

This will compile basically no real-world code. The only supported data type is "int".

> https://github.com/maekawatoshiki/rucc

This is just a frontend. It uses LLVM as the backend.

reply
upvoteby Philpax4 hours ago|
parent|
prev|
next
[-]
Look at what those compilers are capable of compiling and to which targets, and compare it to what this compiler can do. Those are wonderful, and I have nothing but respect for them, but they aren't going to be compiling the Linux kernel.
reply
upvoteby rubymamis4 hours ago|
parent|
[-]
I just did a quick Google search only on GitHub, maybe there are better ones out there on the internet?
reply
upvoteby luke544144 minutes ago|
parent|
prev|
next
[-]
Another one:

https://github.com/rustcoreutils/posixutils-rs/tree/main/cc

reply
upvoteby Philpax40 minutes ago|
parent|
[-]
Can't compile the Linux kernel, and ironically, also partly written by Claude.
reply
upvoteby chilipepperhott3 hours ago|
parent|
prev|
[-]
I found this one too: https://github.com/PhilippRados/wrecc
reply
upvoteby Philpax30 minutes ago|
parent|
[-]
A genuinely impressive effort, but alas, still missing some pretty critical features (const, floating point, bools, inline, anonymous structs in function args).
reply
upvoteby lossolo4 hours ago|
parent|
prev|
next
[-]
Language doesn't really matter, it's not how things are mapped in the latent space. It only needs to know how to do it in one language.
reply
upvoteby HDThoreaun2 hours ago|
parent|
[-]
Ok you can say this about literally any compiler though. The authors of every compiler have intimate knowledge of other compilers, how is this different?
reply
upvoteby jcalvinowens4 hours ago|
parent|
prev|
[-]
Being written in rust is meaningless IMHO. There is absolutely zero inherent value to something being written in rust. Sometimes it's the right tool for the job, sometimes it isn't.
reply
upvoteby modeless4 hours ago|
parent|
next
[-]
It means that it's not directly copying existing C compiler code which is overwhelmingly not written in Rust. Even if your argument is that it is plagiarizing C code and doing a direct translation to Rust, that's a pretty interesting capability for it to have.
reply
upvoteby seba_dos12 hours ago|
parent|
next
[-]
Translating things between languages is probably one of the least interesting capabilities of LLMs - it's the one thing that they're pretty much meant to do well by design.
reply
upvoteby jcalvinowens4 hours ago|
parent|
prev|
[-]
Surely you agree that directly copying existing code into a different language is still plagiarism?

I completely agree that "reweite this existing codebase into a new language" could be a very powerful tool. But the article is making much bolder claims. And the result was more limited in capability, so you can't even really claim they've achieved the rewrite skill yet.

reply
upvoteby Philpax4 hours ago|
parent|
prev|
next
[-]
Please don't open a bridge to the Rust flamewar from the AI flamewar :-)
reply
upvoteby jcalvinowens4 hours ago|
parent|
[-]
Hahaha, fair enough, but I refuse to be shy about having this opinion :)
reply
upvoteby 4 hours ago|
parent|
prev|
[-]
deleted
reply
upvoteby jeroenhd4 hours ago|
prev|
next
[-]
The fact it couldn't actually stick to the 16 bit ABI so it had to cheat and call out to GCC to get the system to boot says a lot.

Without enough examples to copy from (despite CPU manuals being available in the training set) the approach failed. I wonder how well it'll do when you throw it a new/imaginary instruction set/CPU architecture; I bet it'll fail in similar ways.

reply
upvoteby jsnell4 hours ago|
parent|
next
[-]
"Couldn't stick to the ABI ... despite CPU manuals being available" is a bizarre interpretation. What the article describes is the generated code being too large. That's an optimization problem, not a "couldn't follow the documentation" problem.

And it's a bit of a nasty optimization problem, because the result is all or nothing. Implementing enough optimizations to get from 60kB to 33kB is useless, all the rewards come from getting to 32kB.

reply
upvoteby jcalvinowens4 hours ago|
parent|
prev|
[-]
IMHO a new architecture doesn't really make it any more interesting: there's too many examples of adding new architectures in the existing codebases. Maybe if the new machine had some bizarre novel property, I suppose, but I can't come up with a good example.

If the model were retrained without any of the existing compilers/toolchains in its training set, and it could still do something like this, that would be very compelling to me.

reply
upvoteby anematode5 hours ago|
prev|
[-]
Honestly, probably not a lot. Not that many C compilers are compatible with all of GCC's weird features, and the ones that are, I don't think are written in Rust. Hell, even clang couldn't compile the Linux kernel until ~10 years ago. This is a very impressive project.
reply