rules_rust

Rustc is very tightly coupled with cargo. Nothing stops you from calling rustc yourself, but you basically need to reverse engineer what cargo is doing. My reference for this is https://github.com/bazelbuild/rules_rust which needs to pass a bunch of CARGO_ envvars to get stuff to build, among various other required conventions.

The same reason Bazel builds avoid using Cargo when building Rust software, so I'll describe why Bazel would do this: - Bazel wants to cache remote resources, like each respective crate's source files. - Bazel then wants to build each crate in a sandbox, and cache the build artifacts. Because bazel owns this process, instead of Cargo, it can trivially distribute those build artifacts to other developers, or in CI, etc -- instead of everyone having to build everything from scratch. This is an established practice, and Nix wants to drive the build for the same reasons. See: - https://github.com/bazelbuild/rules_rust - https://github.com/google/cargo-raze

Oh wow. I'd be very interested in hearing how they sandbox rust-analyzer. I found a discussion of supporting the analyzer itself by generating config files [1][2], but not how you can sandbox it. That would be extremely useful as the analyzer is a pretty juicy target and also runs proc-macros/build.rs scripts. [1] https://github.com/bazelbuild/rules_rust/pull/384 [2] https://bazelbuild.github.io/rules_rust/rust_analyzer.html

Bazel doesn't allow targeting a lot of platforms (especially embedded) from Rust, even when the Rust ecosystem supports these targets. Something is off with its design if new work needs to be done for every platform that's already available behind an interface that's as consistent as what rustc gives. What is supported needs to be inferred from this file, as far as I can tell: https://github.com/bazelbuild/rules_rust/blob/main/rust/plat...

I think the newer version of this is https://github.com/bazelbuild/rules_rust which lets you either vendor the dependencies or pull them from your Cargo.toml directly every time. Per the article: bazel + rules_rust should have the flexibility to override the linker flags that Cargo may take as required since that would be a property of the bazel toolchain used. It's a nice amalgamation of how cargo works and how bazel works. In general bazel supports hermetic builds, multiple toolchains, cross complilation, and ways to compile multi-language projects. I still wish that Cargo.toml didn't support build.rs as it can cause a lot of system-dependent problems that bazel sidesteps entirely by being hermetic.

I'm surprised nobody has mentioned trying out using Google's Bazel build system with the Rust rules. Bazel provides relatively straightforward 'remote caching' of build artifacts via Google Cloud Storage or S3. https://github.com/bazelbuild/rules_rust

Rust integrates pretty seamlessly into Bazel projects via rules_rust (https://github.com/bazelbuild/rules_rust). The existing rules even allow for c calling rust and rust calling c. Example: https://github.com/bazelbuild/rules_rust/blob/main/examples/...

With any compiled language you can use the compiler and vendor your dependencies instead of using the language's conventional package manager. For example, nothing prevents skipping Cargo and building Rust directly with rustc the way Bazel does. https://github.com/bazelbuild/rules_rust

Internally at Google the vendor all source code and make it build using bazel. These rules also show some of the open source versions of this work: https://github.com/bazelbuild/rules_rust As well as the features that bazel provides you. The caching, packaging, code gen, cross-language deps/interfacing, and other magic that make bazel extremely amazing to use.

Bazel is generally much more useful when it can manage the entire build. https://github.com/bazelbuild/rules_rust implements this logic for rust. It calls rustc directly, without cargo for the build, and interacts with cargo through a shim to fetch/vendor dependencies. Google uses various non-cargo build systems to build rust. I don't think Google is actually using bazel for this internally, eg. Fuchsia uses https://fuchsia.googlesource.com/fuchsia/+/master/third_part...

Check out Bazel: http://bazel.build. I've been using it a lot to build several multi lingual projects that include Java, C++, embedded C, Javascript, CSS, and even Docker images. There are community Rust rules, that I haven't tried yet, but am planning on investigating soon: https://github.com/bazelbuild/rules_rust

Bazel already does have Rust support, by the way: https://github.com/bazelbuild/rules_rust