cranelift

I'm hoping for Cranelift (https://github.com/bytecodealliance/cranelift) to deliver a more JIT-friendly alternative to LLVM (Though it can do AOT compilation too). Another very interesting project, even if it is slightly intimidating in scope, is GraalVM (https://www.graalvm.org).

It's in the works :) https://www.reddit.com/r/rust/comments/enxgwh/cranelift_back... https://github.com/bytecodealliance/cranelift

Depends. Package Management, compiler errors? Absolutely. IDE support? Not so much. I don't think it's fair to compare it to C# / JVM languages, but even compared to other languages, I wouldn't say the tooling is all that great. Macros make IDE support a lot harder than in other languages, the atrocious compile times sure do as well. While IntelliJ Rust and rust-analyzer both try to do their best (kudos to the teams working on them!), it's still nowhere near anything I'd call "stellar". There are mitigations being worked on right now, like compiling macros to WASM[0] and Cranelift[0], but these endeavours, while very promising, I wouldn't call production-ready yet. [0] https://github.com/dtolnay/watt [1] https://github.com/bytecodealliance/cranelift EDIT: Also, debugging. I'm not sure of the current state of it, but last time I checked, i

Thanks for the answer. Since you are working on debug-specific backend, have you considered Cranelift [1]? In case you never heard of it, it was especially intended for fast codegen (because it's being used to compile WASM in Firefox), and Rust wants to be able to use it for their own debug build. If you were aware of it and decided not to use it, I'd love to know what are your rationals. [1]: https://github.com/bytecodealliance/cranelift

> Any plan to use this in rustc? One of the primary expectations / use cases for cranelift is its use for rustc's debug builds: https://github.com/CraneStation/cranelift/blob/master/rustc....

If you want a simple modern compiler backend intended for production-readiness, consider Cranelift [1]. It's largely written by Dan Gohman, who is a longtime LLVM contributor (and a colleague of mine). It does a lot of the things LLVM's backend passes do, but it's cleaner and better factored, with the benefit of a decade of hindsight [2]. Cranelift should be great for teaching purposes. [1]: https://github.com/CraneStation/cranelift [2]: https://cranelift.readthedocs.io/en/latest/compare-llvm.html

Look at Cranelift [1], in particular "Cranelift compared to LLVM" [2]. Cranelift is in some ways an effort to rearchitect LLVM for faster compilation speed, written by some longtime LLVM contributors. For example, Cranelift has only one IR, which lets it avoid rebuilding trees over and over, and the IR is stored tightly packed instead of scattered throughout memory. [1]: https://github.com/CraneStation/cranelift [2]: https://cranelift.readthedocs.io/en/latest/compare-llvm.html

IIUC, for typical programs, most of Rust compilation time is spent waiting for LLVM to spit out results. There's a plan to use https://github.com/CraneStation/cranelift for debug builds instead of LLVM, which would make them faster at the cost of supporting fewer targets, and producing worse code.

> Mozilla has no plans to rewrite even parts of Spidermonkey in Rust. Here's a substantial part being rewritten in rust by Mozilla: https://github.com/CraneStation/cranelift/blob/master/spider...

The code generator that may complement/replace llvm for this use case is Cranelift. https://github.com/CraneStation/cranelift

I think the most promising thing on this front is Cranelift (https://github.com/CraneStation/cranelift). The idea is that, when cranelift is ready, we might use it for debug builds (but still use LLVM for release builds).

Another interesting flag I found was javascript.options.wasm_cranelift, which enables a WASM code generator written in Rust: https://github.com/CraneStation/cranelift

I'm amused by the "Lift" naming trend for code generators. Mozilla's next gen code generator for wasm will be called "Cranelift" [1]. Probably coincidence. [1]: https://github.com/CraneStation/cranelift

On a similar note, I have been watching this[0] project which provides an IR to target and optional optimizations. But I like the idea that the only difference between a JIT and an AOT compiler is optimization choice (assuming we don't include tracing as part of the JIT features). Also, this[1] blog series is a must-read for interested beginners. 0 - https://github.com/stoklund/cretonne/ 1 - https://eli.thegreenplace.net/2017/adventures-in-jit-compila...