Skip to content

Rust

The languages.rust module adds the Rust compiler and common Rust development tools to your environment. You can use the toolchain from nixpkgs or select a toolchain with rust-overlay.

Getting started

Add this option to your devenv.nix:

{
  languages.rust.enable = true;
}

This option installs rustc, cargo, clippy, rustfmt, and rust-analyzer.

Toolchain management

You can get the Rust toolchain from nixpkgs or rust-overlay.

1. nixpkgs channel (default)

The nixpkgs channel is the default. It does not require an additional input. It uses the Rust version in your nixpkgs revision.

{
  languages.rust = {
    enable = true;
    channel = "nixpkgs"; # default
  };
}

2. rust-overlay channels

Use rust-overlay when you need a specific Rust channel, version, or compilation target. Before you select the stable, beta, or nightly channel, add the rust-overlay input to your devenv.yaml:

devenv.yaml
inputs:
  rust-overlay:
    url: github:oxalica/rust-overlay
    inputs:
      nixpkgs:
        follows: nixpkgs

Then select the channel in your devenv.nix:

{
  languages.rust = {
    enable = true;
    channel = "stable";
    version = "1.81.0";
  };
}

The version option uses "latest" by default. You can also set it to a specific Rust version or a nightly release date.

Examples

Use the latest stable toolchain

The stable channel uses the latest version by default:

{
  languages.rust = {
    enable = true;
    channel = "stable";
  };
}

Add components to a nightly toolchain

Set the channel to nightly. List each component that you need in the components option:

{
  languages.rust = {
    enable = true;
    channel = "nightly";
    components = [ "rustc" "cargo" "clippy" "rustfmt" "rust-analyzer" "miri" ];
  };
}

Add cross-compilation targets

Use the targets option to install additional compilation targets:

{
  languages.rust = {
    enable = true;
    channel = "stable";
    targets = [ "wasm32-unknown-unknown" "aarch64-unknown-linux-gnu" ];
  };
}

Install fewer components

Use the components option to install only the tools that you need:

{
  languages.rust = {
    enable = true;
    channel = "stable";
    components = [ "rustc" "cargo" "rust-std" ];
  };
}

Use rust-toolchain.toml

If your project has a rust-toolchain.toml file, set toolchainFile to its path. This option uses the rust-overlay input from the earlier example.

{
  languages.rust = {
    enable = true;
    toolchainFile = ./rust-toolchain.toml;
  };
}

For example, this rust-toolchain.toml selects the stable channel and two components:

[toolchain]
channel = "stable"
components = ["rustfmt", "clippy"]
profile = "minimal"

Integration with other tools

Git hooks

Git hooks can run Rust checks before each commit:

{
  languages.rust.enable = true;

  git-hooks.hooks = {
    rustfmt.enable = true;
    clippy.enable = true;
  };
}

Options

languages.rust.enable

Whether to enable tools for Rust development.

Type: boolean

Default:

false

Example:

true

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.channel

The rustup toolchain to install.

Type: one of “nixpkgs”, “stable”, “beta”, “nightly”

Default:

"nixpkgs"

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.clangLinker.enable

Use Clang as the Rust linker driver on Linux.

This avoids GCC’s collect2 wrapper, which can hit Argument list too long in large Nix development environments before the final linker receives Rust’s response file.

On x86_64 Linux (glibc), Clang uses LLD unless another linker is enabled.

Type: boolean

Default:

pkgs.stdenv.isLinux

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.components

List of Rustup components to install. Defaults to those available in nixpkgs.

Type: list of string

Default:

[ "rustc" "cargo" "clippy" "rustfmt" "rust-analyzer" ]

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.cranelift.enable

Use Cranelift as the codegen backend for dev builds.

Cranelift compiles significantly faster than LLVM at the cost of less optimized output. Requires the nightly channel.

Type: boolean

Default:

false

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.cranelift.excludePackages

List of crate names that should use the LLVM backend instead of Cranelift.

Generates per-package overrides in .cargo/config.toml.

Type: list of string

Default:

[ ]

Example:

[
  "aws-lc-sys"
  "aws-lc-rs"
  "rustls"
]

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.cranelift.forceBuildScriptsLlvm

Force build scripts and proc macros to use the LLVM backend.

Some build scripts may not work with Cranelift. Enable this to fall back to LLVM for build scripts while keeping Cranelift for regular code.

Type: boolean

Default:

false

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.import

Import a Cargo project using crate2nix.

This function takes a path to a directory containing a Cargo.toml file and returns a derivation that builds the Rust project using crate2nix.

Example usage:

let
mypackage = config.languages.rust.import ./path/to/cargo/project {};
in {
languages.rust.enable = true;
packages = [ mypackage ];
}

Type: function that evaluates to a(n) function that evaluates to a(n) package

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.lld.enable

Use lld as the linker.

lld is LLVM’s linker and is the recommended fast linker for Darwin. Works on both Linux and macOS.

Type: boolean

Default:

false

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.lsp.enable

Whether to enable Rust Language Server.

Type: boolean

Default:

true

Example:

true

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.lsp.package

The Rust language server package to use.

Type: package

Default: Depends on the configured toolchain:

  • nixpkgs channel: pkgs.rust-analyzer.
  • non-nixpkgs channel: the rust-analyzer component from the rust-overlay toolchain, with a fallback to pkgs.rust-analyzer if not present in the manifest.
  • toolchainFile: the aggregated toolchain package derived from the file.

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.mold.enable

Use mold as the linker.

mold is a faster drop-in replacement for existing Unix linkers. It is several times quicker than the LLVM lld linker.

Type: boolean

Default:

false

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.rustflags

Extra flags to pass to the Rust compiler.

Type: string

Default:

""

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.targets

List of extra targets to install. Defaults to only the native target.

Type: list of string

Default:

[ ]

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.toolchain

Rust component packages. May optionally define additional components, for example miri.

Type: open submodule of attribute set of package

Default:

nixpkgs

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.toolchain.cargo

cargo package

Type: null or package

Default:

pkgs.cargo

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.toolchain.clippy

clippy package

Type: null or package

Default:

pkgs.clippy

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.toolchain.rust-analyzer

rust-analyzer package

Type: null or package

Default:

pkgs.rust-analyzer

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.toolchain.rustc

rustc package

Type: null or package

Default:

pkgs.rustc

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.toolchain.rustfmt

rustfmt package

Type: null or package

Default:

pkgs.rustfmt

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.toolchainFile

Path to a rust-toolchain or rust-toolchain.toml file for automatic toolchain configuration.

When set, devenv will use rust-overlay’s fromRustupToolchainFile to automatically configure the toolchain based on the file contents (channel, components, targets, profile).

This follows the standard Rust toolchain file format documented at: https://rust-lang.github.io/rustup/overrides.html#the-toolchain-file

Cannot be used together with manual channel or version configuration.

Example:

languages.rust.toolchainFile = ./rust-toolchain.toml;

Type: null or absolute path

Default:

null

Example:

./rust-toolchain.toml

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.toolchainPackage

The aggregated toolchain package, which includes the configured components and targets. This is automatically set based on the channel and components configuration.

Type: package

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.version

Which version of rust to use, this value could be latest,1.81.0, 2021-01-01. Only works when languages.rust.channel is NOT nixpkgs.

Type: string

Default:

"latest"

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix

languages.rust.wild.enable

Use wild as the linker.

wild is a very fast linker for Linux.

Type: boolean

Default:

false

Declared by: - https://github.com/cachix/devenv/blob/main/src/modules/languages/rust.nix