Fenix

A Fenix toolchain is an attribute set containing various components and helper functions.

Components:

• cargo: The cargo package.
• rustc: The rustc package including rust-std.
• rustc-unwrapped: The rustc package without rust-std.
• rustfmt: An alias to rustfmt-preview.
• rust-src: The source code for the standard library.

Derivations:

• toolchain: A derivation containing all components.
• minimalToolchain, defaultToolchain, completeToolchain: Derivations based on specific profiles (not available in nightly toolchains).

Functions:

• withComponents : [string] -> derivation: Creates a derivation with a specific list of components.
• combine : [derivation] -> derivation: Combines a list of components into a single derivation (use withComponents if components are from the same toolchain).
• fromManifest, fromManifestFile, toolchainOf, fromToolchainFile, fromToolchainName: Functions to create toolchains from various manifest formats or names.

To use Fenix in a Flake-based project, add it to your inputs and access the toolchains via fenix.packages.<system>. This is the recommended method.

Example for a NixOS configuration within a flake:

{
  inputs = {
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    nixpkgs.url = "nixpkgs/nixos-unstable";
  };

  outputs = { self, fenix, nixpkgs }: {
    packages.x86_64-linux.default = fenix.packages.x86_64-linux.minimal.toolchain;
    nixosConfigurations.nixos = nixpkgs.lib.nixosSystem {
      system = "x86_64-linux";
      modules = [
        ({
          pkgs, ...
        }: {
          nixpkgs.overlays = [ fenix.overlays.default ];
          environment.systemPackages = [
            ({
              pkgs, ...
            }: {
              pkgs.fenix.complete.withComponents [
                "cargo"
                "clippy"
                "rust-src"
                "rustc"
                "rustfmt"
              ])
              pkgs.rust-analyzer-nightly
            })
          ];
        })
      ];
    };
  };
}

When cross-compiling with naersk, you can construct a custom toolchain using Fenix's combine function. This allows you to mix components like minimal.cargo, minimal.rustc, and specific target standard libraries (e.g., targets.${target}.latest.rust-std). You must also provide the appropriate linker via environment variables like CARGO_TARGET_<TARGET>_LINKER.

{
  inputs = {
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    flake-utils.url = "github:numtide/flake-utils";
    naersk = {
      url = "github:nix-community/naersk";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    nixpkgs.url = "nixpkgs/nixos-unstable";
  };

  outputs = { self, fenix, flake-utils, naersk, nixpkgs }: 
    flake-utils.lib.eachDefaultSystem (system: {
      packages.default = 
        let
          pkgs = nixpkgs.legacyPackages.${system};
          target = "aarch64-unknown-linux-gnu";
          toolchain = with fenix.packages.${system}; combine [
            minimal.cargo
            minimal.rustc
            targets.${target}.latest.rust-std
          ];
        in

        (naersk.lib.${system}.override {
          cargo = toolchain;
          rustc = toolchain;
        }).buildPackage {
          src = ./.;
          CARGO_BUILD_TARGET = target;
          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER = 
            let
              inherit (pkgs.pkgsCross.aarch64-multiplatform.stdenv) cc;
            in
            "${cc}/bin/${cc.targetPrefix}cc";
        };
    });
}

To use Fenix with crane, use the overrideToolchain method on the craneLib to inject a specific Fenix toolchain (e.g., stable.toolchain).

{
  inputs = {
    crane = {
      url = "github:ipetkov/crane";
      inputs = {
        flake-utils.follows = "flake-utils";
        nixpkgs.follows = "nixpkgs";
      };
    };
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    flake-utils.url = "github:numtide/flake-utils";
    nixpkgs.url = "nixpkgs/nixos-unstable";
  };

  outputs = { self, crane, fenix, flake-utils, nixpkgs }: 
    flake-utils.lib.eachDefaultSystem (system: {
      packages.default = 
        let
          craneLib = (crane.mkLib nixpkgs.legacyPackages.${system}).overrideToolchain fenix.packages.${system}.stable.toolchain;
        in

        craneLib.buildPackage {
          src = ./.;
        };
    });
}

You can use Fenix toolchains with Nixpkgs' makeRustPlatform by passing the Fenix toolchain to both the cargo and rustc arguments. This allows you to leverage Fenix's managed Rust versions within standard Nixpkgs build infrastructures.

{
  inputs = {
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    flake-utils.url = "github:numtide/flake-utils";
    nixpkgs.url = "nixpkgs/nixos-unstable";
  };

  outputs = { self, fenix, flake-utils, nixpkgs }: 
    flake-utils.lib.eachDefaultSystem (system: {
      packages.default = 
        let
          toolchain = fenix.packages.${system}.minimal.toolchain;
          pkgs = nixpkgs.legacyPackages.${system};
        in

        (pkgs.makeRustPlatform {
          cargo = toolchain;
          rustc = toolchain;
        }).buildRustPackage {
          pname = "example";
          version = "0.1.0";
          src = ./.;
          cargoLock.lockFile = ./Cargo.lock;
        };
    });
}