Alternative to cargo per-package-target unstable feature?

[kuroahna]

Hi, is there an alternative to using cargo's per-package-target unstable feature?

I have a workspace that has 2 packages, one which builds to wasm32-unknown-unknown, and the other is a cargo xtask package that builds to the host's platform. Ideally, I'd like to use cargo xtask to handle the post install phase instead of using shell scripts

However, more generally, I'm curious as to what the common workaround is for when a cargo workspace has a package that builds to a separate platform from the host? The per-unstable-target feature in Cargo.toml seems to solve this, but I don't want to use unstable cargo

[ipetkov]

Hi @kuroahna! I know cargo allows configuring exactly which packages to build or exclude as part of the CLI arguments. For example I'd imagine you can do something like:

• set cargoExtraArgs = "--exclude your-wasm-package"; for the "native" derivation
• set cargoExtraArgs = "--target wasm32-unknown-unknown -p your-wasm-package"; for the wasm derivation

---

Ideally, I'd like to use cargo xtask to handle the post install phase instead of using shell scripts

Generally speaking you should be able to set installPhaseCommand (or installPhase if you want to control running pre/post hooks yourself) to any arbitrary invocation you'd like. Check out the API docs for the specifics.

Hope this helps!

[kuroahna]

Thanks for the reply @ipetkov ! This works great!

I created a derivation with buildDepsOnly which runs cargo {check,build,test} for both native and wasm targets. Then used that to build my wasm package, which runs the xtask package as a postInstall, reusing the artifacts from the previous step.

Here's my minimal example:

.
├── Cargo.lock
├── Cargo.toml
├── flake.lock
├── flake.nix
├── LICENSE
├── wasm
│   ├── Cargo.toml
│   └── src
│       └── lib.rs
└── xtask
    ├── Cargo.toml
    └── src
        └── main.rs

Top level Cargo.toml:

[workspace]
resolver = "2"
members = ["wasm", "xtask"]

[workspace.package]
version = "0.0.1"
edition = "2021"
license = "MIT"

[workspace.metadata.crane]
name = "wasm_nix"

wasm/Cargo.toml:

[package]
name = "wasm"
version.workspace = true
edition.workspace = true
license.workspace = true

[lib]
crate-type = ["cdylib"]

[profile.release]
lto = true

[dependencies]
wasm-bindgen = { version = "0.2.93", default-features = false }

[dev-dependencies]
wasm-bindgen-test = "0.3.43"

wasm/src/lib.rs:

use wasm_bindgen::prelude::wasm_bindgen;

#[wasm_bindgen]
pub fn add(a: u32, b: u32) -> u32 {
    a + b
}

#[cfg(test)]
mod test {
    use crate::add;
    use wasm_bindgen_test::wasm_bindgen_test;

    #[wasm_bindgen_test]
    fn test() {
        assert_eq!(add(1, 2), 3);
    }
}

xtask/Cargo.toml:

[package]
name = "xtask"
version.workspace = true
edition.workspace = true
license.workspace = true

[dependencies]
clap = { version = "4.5.20", features = ["derive"] }

xtask/src/main.rs:

use clap::{Parser, Subcommand};

#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    PostBuild,
}

fn main() {
    let cli = Cli::parse();

    match cli.command {
        Commands::PostBuild => {
            println!("Post build...");
            // ...
            println!("Post build complete");
        }
    };
}

And flake.nix:

{
  description = "wasm_nix";

  inputs = {
    flake-utils.url = "github:numtide/flake-utils";
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
    crane.url = "github:ipetkov/crane";
    rust-overlay = {
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs =
    {
      flake-utils,
      nixpkgs,
      crane,
      rust-overlay,
      ...
    }:
    flake-utils.lib.eachDefaultSystem (
      system:
      let
        targetSystem = "wasm32-unknown-unknown";

        pkgs = import nixpkgs {
          inherit system;
          overlays = [ (import rust-overlay) ];
        };

        craneLib = (crane.mkLib pkgs).overrideToolchain (
          p:
          p.rust-bin.stable.latest.default.override {
            targets = [ targetSystem ];
          }
        );
        src = craneLib.cleanCargoSource ./.;

        commonArgs = {
          inherit src;
          strictDeps = true;
        };

        commonWasmArgs = commonArgs // {
          cargoExtraArgs = "--frozen --target ${targetSystem} --workspace --exclude xtask";
        };

        cargoArtifacts = craneLib.buildDepsOnly (
          commonArgs
          // {
            buildPhaseCargoCommand = ''
              cargo check --profile release --frozen --all-targets
              cargo build --profile release --frozen --workspace --exclude wasm
              cargo build --profile release --frozen --target ${targetSystem} --workspace --exclude xtask
            '';
            checkPhaseCargoCommand = ''
              cargo test --profile release --frozen --workspace --exclude wasm --no-run
              cargo test --profile release --frozen --target ${targetSystem} --workspace --exclude xtask --no-run
            '';
          }
        );

        wasm_nix = craneLib.buildPackage (
          commonWasmArgs
          // {
            inherit cargoArtifacts;

            nativeBuildInputs = [
              pkgs.binaryen
              pkgs.wasm-bindgen-cli
            ];

            CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUNNER = "wasm-bindgen-test-runner";
            nativeCheckInputs = [
              pkgs.nodePackages_latest.nodejs
            ];

            postInstall = ''
              cargo run --release --package xtask -- post-build
            '';

          }
        );
      in
      {
        formatter = pkgs.nixfmt-rfc-style;
        packages.default = wasm_nix;
        devShells.default = craneLib.devShell {
          packages = [
            pkgs.rust-analyzer
          ];
        };
      }
    );
}

Generally speaking you should be able to set installPhaseCommand (or installPhase if you want to control running pre/post hooks yourself) to any arbitrary invocation you'd like. Check out the API docs for the specifics.

Yep, thanks. Fantastic documentation by the way!