repository·main·Indexed 21 days ago
https://github.com/bazelbuild/rules_rustBazel rules for building Rust projects, providing integration of the Rust toolchain into Bazel build pipelines. Includes crate_universe for generating Bazel build targets from Cargo, support for vendoring dependencies via crates_vendor, cross-compilation with LLVM and sysroots, and tools for managing target-specific compiler optimizations.
crate_universe is a collection of tools designed to bridge the Rust and Bazel ecosystems. It leverages Cargo to automatically generate Bazel build targets for Rust crates, allowing you to manage Rust dependencies using standard Cargo workflows while building within the Bazel ecosystem.wasm-bindgen within a Bazel build environment to generate Rust bindings for WebAssembly. They facilitate the integration of the wasm-bindgen toolchain into your Bazel-managed Rust projects.The rules_rust repository provides a comprehensive suite of rules for managing Rust development within Bazel. These are categorized into standard build rules, toolchain/linting rules, Cargo compatibility, and 3rd party integrations.
defs.md for rules to build and test libraries and binaries.rust_doc.md for generating and testing Rust documentation.rust_clippy.md for running clippy and rust_fmt.md for running rustfmt.cargo.md for rules dedicated to Cargo compatibility, such as handling build.rs scripts.crate_universe.md for rules that generate Bazel targets for external crate dependencies.rust_analyzer.md to generate rust-project.json files for rust-analyzer support.rust_bindgen.md for generating C++ bindings.rust_prost.md for generating Protobuf and gRPC stubs using prost.rust_pyo3.md for PyO3 integration.rust_wasm_bindgen.md for generating WebAssembly bindings.The rust_bindgen rules allow you to use bindgen to automatically generate Rust bindings for C and some C++ libraries within a Bazel workspace. This is useful for interfacing Rust code with existing C/C++ dependencies.
For detailed documentation and advanced configuration, refer to the official rules_rust documentation: https://bazelbuild.github.io/rules_rust/rust_bindgen.html
rules_rust_pyo3 extension provides Bazel rules specifically designed to facilitate the use of PyO3 within a Bazel build environment. This allows for building Rust extensions that can be imported and used by Python.When a rust_test target uses the crate attribute, the library source code is compiled directly into the test binary. In this mode, Rules Rust automatically determines if the underlying crate should be instrumented. This means library code compiled into the test binary will produce coverage data automatically, without requiring the --instrument_test_targets flag.
Note: Because the entire crate (including #[cfg(test)] code) is compiled as a single unit, test-specific code within the crate will also be instrumented. This differs from the standard Bazel convention where test code is typically only instrumented when --instrument_test_targets is explicitly set.
By default, rules_rust treats the entire project as a single workspace. For large monorepos where indexing the whole graph is too slow, you can use per-package workspaces.
Using per-package workspaces:
Run setup with the --per-package-workspaces flag. This scopes discovery to the saved file's package and its dependencies. rust-analyzer will reload when you jump to a different package.
Caveat: Because it is scoped, _dependents_ of the package you are currently working on are not indexed. This means "find usages" might miss callers located in other packages.
To switch back to a single workspace, re-run setup without the flag.
To ensure your build remains stable across rules_rust updates, only rely on APIs explicitly covered by the backwards compatibility policy.
Stable APIs:
//rust (anything directly accessible from this file)//cargoUnstable/Private APIs (Not guaranteed to be stable):
private/ (e.g., //**/private/...)//crate_universe, //examples, //extensions, //ffi, //nix, //test, //tools, and //util.Because Prost requires specific toolchain definitions to avoid dependency mismatches, you should define a custom toolchain. It is recommended to place this in a dedicated directory like tools/prost_toolchain/BUILD.bazel.
The toolchain definition requires:
rust_library_group for prost_runtime and tonic_runtime.rust_prost_toolchain to link the plugins (protoc-gen-prost, protoc-gen-tonic), the proto compiler, and the runtimes.toolchain rule that maps the implementation to the @rules_rust_prost//:toolchain_type.load("@rules_rust_prost//:defs.bzl", "rust_prost_toolchain")
load("@rules_rust//rust:defs.bzl", "rust_library_group")
rust_library_group(
name = "prost_runtime",
deps = ["@crates//prost"],
)
rust_library_group(
name = "tonic_runtime",
deps = [
":prost_runtime",
"@crates//tonic",
],
)
rust_prost_toolchain(
name = "prost_toolchain_impl",
prost_plugin = "@crates//protoc-gen-prost__protoc-gen-prost",
prost_runtime = ":prost_runtime",
prost_types = "@crates//prost-types",
proto_compiler = "@protobuf//:protoc",
tonic_plugin = "@crates//protoc-gen-tonic__protoc-gen-tonic",
tonic_runtime = ":tonic_runtime",
)
toolchain(
name = "prost_toolchain",
toolchain = "prost_toolchain_impl",
toolchain_type = "@rules_rust_prost//:toolchain_type",
)Rules Rust respects Bazel's standard --instrumentation_filter flag. Only targets whose labels match the provided regex are compiled with -Cinstrument-coverage. This allows you to include or exclude specific parts of your workspace from the instrumentation process.
# Restrict instrumentation to workspace targets (recommended for vendored deps)
coverage --instrumentation_filter=^//
# Include workspace targets but exclude third_party
coverage --instrumentation_filter=^//,-^//third_partyThe project follows SemVer 2.0.0.
BUILD files, bzl files, rust_toolchain definitions, platform definitions, or build settings.rules_rust state at HEAD.To use rules_rust in your Bazel project using Bzlmod, add the dependency to your MODULE.bazel file. It is recommended to use the latest version available from the GitHub Releases page.
bazel_dep(name = "rules_rust", version = "0.73.0")