In reply to @dpc:matrix.org
But I can't figure out what exactly am I supposed to set to get something to run? I just need to chmod +x some files that were copied into the derivation.

Anyone know of a cross-compilation example that targets musl and uses rust-overlay?

I can't for the life of me figure this out. I've spent the past couple of hours trying to search and read up on it, but I feel like there's some crucial tidbits of ignorance that keep me in the dark.
All the rust docs refer to leveraging rustup, which AFAIU is kinda antheisis to the premise of Nix.

I'm finding the learning curve a bit too steep for me =/

I've attempted:

• rust-toolchain.toml; ```toml
  [toolchain]
  targets = ["x86_64-unknown-linux-musl", "x86_64-unknown-linux-gnu"]

  `flake.nix`: ```nix
    overlays = [
      (import rust-overlay)
      (self: super: {
        rustToolchain =
          let
            rust = super.rust-bin;
          in
          if builtins.pathExists ./rust-toolchain.toml then
            rust.fromRustupToolchainFile ./rust-toolchain.toml
          else if builtins.pathExists ./rust-toolchain then
            rust.fromRustupToolchainFile ./rust-toolchain
          else
            rust.stable.latest.default;
      })
    ]
  

  And finally; cargo build --target 'x86_64-unknown-linux-musl'

Anyone know of a cross-compilation example that targets musl and uses rust-overlay?

I can't for the life of me figure this out. I've spent the past couple of hours trying to search and read up on it, but I feel like there's some crucial tidbits of ignorance that keep me in the dark.
All the rust docs refer to leveraging rustup, which AFAIU is kinda antheisis to the premise of Nix.

I'm finding the learning curve a bit too steep for me =/

I've attempted:

• rust-toolchain.toml;

  [toolchain]
  targets = ["x86\_64-unknown-linux-musl", "x86\_64-unknown-linux-gnu"]
  
  

  flake.nix:

    overlays = [
      (import rust-overlay)
      (self: super: {
        rustToolchain =
          let
            rust = super.rust-bin;
          in
          if builtins.pathExists ./rust-toolchain.toml then
            rust.fromRustupToolchainFile ./rust-toolchain.toml
          else if builtins.pathExists ./rust-toolchain then
            rust.fromRustupToolchainFile ./rust-toolchain
          else
            rust.stable.latest.default;
      })
    ]
  

  And finally; cargo build --target 'x86_64-unknown-linux-musl'

As mentioned in the https://matrix.to/#/#nix:nixos.org channel, the end result I'm looking for is a reduction of my docker image;

# flake.nix
      # The rust binary
      cargo-details = (pkgs.lib.importTOML ./Cargo.toml);
      binary-name = cargo-details.package.name;
      binary-version = cargo-details.package.version;
      cargo-package = pkgs.rustPlatform.buildRustPackage {
        pname = binary-name;
        version = binary-version;

        src = self;
        cargoLock.lockFile = ./Cargo.lock;

        nativeBuildInputs = rust-tools;
        buildInputs = rust-tools;
      };

      # Docker image
      # TODO: Reduce container size (cargo release -> ~5MB vs docker image -> ~35MB)
      # Seems like glibc is at fault? Statically compile? Musl?
      #  -> $ tree -L 3 unpacked_dockerimage/layer/
      #  unpacked_dockerimage/layer/
      #  └── nix
      #      └── store
      #          ├── 39pvnhy2l6zlqrgh6vv861v8lj6wnz0r-assign-item-to-project-field-0.1.0
      #          ├── 6f66prpgx1qx4n6k450sxs3d157ia1ps-glibc-2.35-163
      #          ├── g7lwga9p547cqyi9ym35bk78m1r12rky-libunistring-1.0
      #          └── jna5qh81395w6xsalnl532pm9qvvvpjy-libidn2-2.3.2
      #
      #  6 directories, 0 files
      #  -> $ sudo du -hs unpacked_dockerimage/layer/nix/store/* | sort -h
      #  308K    unpacked_dockerimage/layer/nix/store/jna5qh81395w6xsalnl532pm9qvvvpjy-libidn2-2.3.2
      #  1,6M    unpacked_dockerimage/layer/nix/store/39pvnhy2l6zlqrgh6vv861v8lj6wnz0r-assign-item-to-project-field-0.1.0
      #  1,8M    unpacked_dockerimage/layer/nix/store/g7lwga9p547cqyi9ym35bk78m1r12rky-libunistring-1.0
      #  31M     unpacked_dockerimage/layer/nix/store/6f66prpgx1qx4n6k450sxs3d157ia1ps-glibc-2.35-163
      #
      docker-image = pkgs.dockerTools.buildImage {
        name = binary-name;
        tag = "v${binary-version}";
        config = {
          Cmd = ["${cargo-package}/bin/${binary-name}"];
        };
      }

Anyone know of a cross-compilation example that targets musl and uses rust-overlay?

I can't for the life of me figure this out. I've spent the past couple of hours trying to search and read up on it, but I feel like there's some crucial tidbits of ignorance that keep me in the dark.
All the rust docs refer to leveraging rustup, which AFAIU is kinda antheisis to the premise of Nix.

I'm finding the learning curve a bit too steep for me =/

I've attempted:

• rust-toolchain.toml;

[toolchain]
targets = ["x86\_64-unknown-linux-musl", "x86\_64-unknown-linux-gnu"]

flake.nix:

  overlays = [
    (import rust-overlay)
    (self: super: {
      rustToolchain =
        let
          rust = super.rust-bin;
        in
        if builtins.pathExists ./rust-toolchain.toml then
          rust.fromRustupToolchainFile ./rust-toolchain.toml
        else if builtins.pathExists ./rust-toolchain then
          rust.fromRustupToolchainFile ./rust-toolchain
        else
          rust.stable.latest.default;
    })
  ]

And finally; cargo build --target 'x86_64-unknown-linux-musl'

Anyone know of a cross-compilation example that targets musl and uses rust-overlay?

I can't for the life of me figure this out. I've spent the past couple of hours trying to search and read up on it, but I feel like there's some crucial tidbits of ignorance that keep me in the dark.
All the rust docs refer to leveraging rustup, which AFAIU is kinda antheisis to the premise of Nix.

I'm finding the learning curve a bit too steep for me =/

I've attempted:

• rust-toolchain.toml;

[toolchain]
targets = ["x86\_64-unknown-linux-musl", "x86\_64-unknown-linux-gnu"]

flake.nix:

  overlays = [
    (import rust-overlay)
    (self: super: {
      rustToolchain =
        let
          rust = super.rust-bin;
        in
        if builtins.pathExists ./rust-toolchain.toml then
          rust.fromRustupToolchainFile ./rust-toolchain.toml
        else if builtins.pathExists ./rust-toolchain then
          rust.fromRustupToolchainFile ./rust-toolchain
        else
          rust.stable.latest.default;
    })
  ]

And finally; cargo build --target 'x86_64-unknown-linux-musl'

Anyone know of a cross-compilation example that targets musl and uses rust-overlay?

I can't for the life of me figure this out. I've spent the past couple of hours trying to search and read up on it, but I feel like there's some crucial tidbits of ignorance that keep me in the dark.
All the rust docs refer to leveraging rustup, which AFAIU is kinda antheisis to the premise of Nix.

I'm finding the learning curve a bit too steep for me =/

I've attempted:
rust-toolchain.toml;

[toolchain]
targets = ["x86\_64-unknown-linux-musl", "x86\_64-unknown-linux-gnu"]

flake.nix:

  overlays = [
    (import rust-overlay)
    (self: super: {
      rustToolchain =
        let
          rust = super.rust-bin;
        in
        if builtins.pathExists ./rust-toolchain.toml then
          rust.fromRustupToolchainFile ./rust-toolchain.toml
        else if builtins.pathExists ./rust-toolchain then
          rust.fromRustupToolchainFile ./rust-toolchain
        else
          rust.stable.latest.default;
    })
  ]

And finally; cargo build --target 'x86_64-unknown-linux-musl'

Zhaofeng Li: AFAICT this does not use rust-overlay?

I am for sure not able to parse your flake.nix. I looked into crane - and after reading what its README says, I can't tell how you add musl as a cross-compilation target?

In reply to @x10an14:matrix.org

Anyone know of a cross-compilation example that targets musl and uses rust-overlay?

I can't for the life of me figure this out. I've spent the past couple of hours trying to search and read up on it, but I feel like there's some crucial tidbits of ignorance that keep me in the dark.
All the rust docs refer to leveraging rustup, which AFAIU is kinda antheisis to the premise of Nix.

I'm finding the learning curve a bit too steep for me =/

I've attempted:
rust-toolchain.toml;

[toolchain]
targets = ["x86\_64-unknown-linux-musl", "x86\_64-unknown-linux-gnu"]

flake.nix:

  overlays = [
    (import rust-overlay)
    (self: super: {
      rustToolchain =
        let
          rust = super.rust-bin;
        in
        if builtins.pathExists ./rust-toolchain.toml then
          rust.fromRustupToolchainFile ./rust-toolchain.toml
        else if builtins.pathExists ./rust-toolchain then
          rust.fromRustupToolchainFile ./rust-toolchain
        else
          rust.stable.latest.default;
    })
  ]

And finally; cargo build --target 'x86_64-unknown-linux-musl'

I'm not able to make it work for nix build, yet I am able to make it work for cargo build --target... Here's a paste explaining my differences: https://paste.sr.ht/~x10an14/57e8d3d2014e44232692773affc74741b5776ddb

Could some kind samaritan take take a look and see if they can understand and tell me what's going on?