Pretty wild to me that AI has enabled the commoditization of one of the gnarliest engineering problems. Over the course of just a month, we now have three "viable" AI-driven iteration-focused Rust compilers: - https://github.com/makepad/relax - https://github.com/DioxusLabs/rustd/ - https://github.com/indexable-inc/blaze
I'd like to throw my low-token-budget hat in the ring:
https://github.com/haydenflinner/rust/blob/main/PLIRON.md
iteration-focus is slightly there, i.e. fast hotpatching. But been focused on beating LLVM's compiled runtime performance as of late.
Somehow always, someone somewhere rediscovers that cutting down the time between coding and code execution makes our lives easier and to a degree be able to write better programs.
Perhaps the earliest and best attempt was Lisp's computational model. Since then, the idea manifested itself again[1], again[2], and again[3] in different forms.
[1]: Inventing on Principle, Bret Victor: https://www.youtube.com/watch?v=PUv66718DII
[2]: REPL-Driven Development, Stuart Halloway: https://vimeo.com/223309989
[3]: LIVE, Live Programming workshop: https://liveprog.org/
Spot on, hence why having a mix of JIT/AOT tooling is such a great experience.
Besides your examples, Eiffel, Oberon, Java, .NET, C++ (yep even for it), Cedar, Standard ML, OCaml, Haskell, Prolog, BASIC, Forth
This implies that Rust build times haven't been a topic of discussion for the last 10 years. They don't have long build times just for funsies, Rust is completely different from Lisp.
I built something similar - tbd on maintaining it - but I got Rust Analyzer emitting code and as well as running in the web. This new concept of rust compile daemon is pretty sick.
Can build and iterate on Rust in the browser!
Rust is a nice language but it’s so heavy. Since our company switched from Go I’ve had to become used to my laptop being burning hot and stuttering whilst trying to do anything during compilation.
We have had good experience with kache so far to speedup builds in CI and local
How does it compare to sccache ?
Anyone know what effect it has on targets/ bloat and dev disk usage?
It should be lower, but I haven't optimized it too hard on disk size. It's about iteration latency for LLM's.
I've been using "mr boxington" (mbx) the past several weeks and it's been a big help. https://mr-boxington.jdx.dev/
> 0 crates.io dependencies, in 438k lines of Rust
It's great to have zero deps, but that's a lot of code to maintain.
AI maintains it, and its developer tooling really. The main use case is hotloading for LLM's to reduce wait-for-result time and to allow applications other be hot-debugged. Pause on panic is one of its main features I use all the time.
I knew that makepad devs were focused on build times, but didn't imagine this much!
Indeed but I could only do this in the age of AI. Before a project like this was just out of reach.
This is preposterously ambitious - a complete Rust re-implementation. Looks like it's mostly claude?
Yeah, this is pretty much a textbook example of what AI agents make possible these days: things that are ridiculously ambitious, but aren't conceptually very difficult (or, at least, are conceptually well-trodden ground). Things like emulators, language runtimes, platform reimplementations like Darling, etc.
JITting Rust isn't conceptually very hard: you just take rustc and make everything dynamic instead of static. The only thing that was stopping it before was the sheer amount of effort. Well, now we have a way to reduce that effort.
Yea it's claude+codex over the course of a month. It definitely isn't a one shot.
The world really needs something like this, but why such a slop UI website.
Just tell Opus 5.5 to "redesign the UI to not look like AI slop, design it like a human expert designer would" at bare minimum.
Its only prompt is 'make a flashy website for this project'. I think it's fine who reads websites anymore anyway. Readme.md for GitHub is the main thing.
The code is slop and the website too.
Perhaps a cynical take, but I feel sloppy content advertised seriously is enabling a transparent form of cross-domain self-selection which can be interesting to observe from the outside.
Common Lisp lurks in the shadows, watching its own reinvention comfortably, yet another time
moving errors from compile time to runtime is good?
For quick iterations it's perfectly fine. Change something, see if it works. If it doesn't keep changing until it works.
In runtimes that provide quick dev loops some developers have continiously running unit testing sessions. They just fire off every few seconds and give intimidate feedback.
For some use cases, like speeding up local development, it's an excellent trade off.
It's a technology to improve iteration time with agents, or humans for live coding but nobody really writes code anymore so.