Compiling project from x86_64-unknown-linux-gnu to x86_64-apple-darwin

[Occhioverde]

Good morning.

As per the title, I'm trying to compile a Rust project from my Linux machine to x86_64-apple-darwin (and, possibly, to aarch64-apple-darwin).

Since there are no specific instructions in the documentation, I tried to adapt the "cross-windows" example, coming up with something like this:

{ meta, crane, fenix, nixpkgs }: {
  libcrossquil = let
    pkgs = import nixpkgs {
      localSystem = "x86_64-linux";
      crossSystem = "x86_64-darwin";
    };
    fenixPkgs = fenix.packages."x86_64-linux";
    toolchain = (with fenixPkgs;
      (combine [
        stable.cargo
        stable.rustc
        targets."x86_64-apple-darwin".stable.rust-std
      ]));
    craneLib = (crane.mkLib pkgs).overrideToolchain (_: toolchain);
    libcrossquilInfo = {
      pname = "libcrossquil";
      version = meta.version;

      src = craneLib.cleanCargoSource (craneLib.path ../.);
      doCheck = false;
      strictDeps = true;

      CARGO_BUILD_TARGET = "x86_64-apple-darwin";
    };
  in rec {
    cargoArtifacts = craneLib.buildDepsOnly libcrossquilInfo;
    target = craneLib.buildPackage (libcrossquilInfo // {
      inherit cargoArtifacts;
    });
  };
}

But as the build process immediately fails with this error, I think that I'm missing something:

error: Package ‘x86_64-darwin-cctools-1010.6’ in /nix/store/182c2qj20sfspzxcshd6p051qdx3mx5j-source/pkgs/by-name/cc/cctools/package.nix:160 is not available on the requested hostPlatform:
         hostPlatform.config = "x86_64-unknown-linux-gnu"
         package.meta.platforms = [
           "x86_64-darwin"
           "aarch64-darwin"
         ]
         package.meta.badPlatforms = [ ]
       , refusing to evaluate.

       a) To temporarily allow packages that are unsupported for this system, you can use an environment variable
          for a single invocation of the nix tools.

            $ export NIXPKGS_ALLOW_UNSUPPORTED_SYSTEM=1

          Note: When using `nix shell`, `nix build`, `nix develop`, etc with a flake,
                then pass `--impure` in order to allow use of environment variables.

       b) For `nixos-rebuild` you can set
         { nixpkgs.config.allowUnsupportedSystem = true; }
       in configuration.nix to override this.

       c) For `nix-env`, `nix-build`, `nix-shell` or any other Nix command you can add
         { allowUnsupportedSystem = true; }
       to ~/.config/nixpkgs/config.nix.

I therefore wanted to ask: what is the correct approach to build on Linux a crate for MacOS?

Sorry if this has been asked before, but I couldn't find anything relevant in the Issues and Discussions.

Thank you very much in advance.

[ipetkov]

Hi @Occhioverde! Cross compilation can be fraught with peril as sometimes dependency packages don't always work 😅

I've never actually tried cross compiling from Linux for Darwin so I'm not entirely sure whether that's currently possible/supported in nixpkgs. Based on the error my suspicion is that there is no build of darwin-cctools that can be built for Linux (but otherwise outputs instructions for Darwin) so we can't even start cross compiling dependencies before the crane derivations even have a chance to run.

You can always try to allow the unsupported system flag as hinted above and see how far you get, but I suspect its there for a reason and might not work. If anyone else has managed to make Linux -> Darwin cross compilation work with nixpkgs you could try adapting what they've done! But otherwise I'm not too sure what else to suggest besides give up on cross compilation and use a real Darwin runner if you care about Darwin builds

[Occhioverde]

Thank you very much for your reply.

Yeah, I think you are right, as the docs over at Nix.dev say that "macOS/Darwin is a special case, as not the whole OS is open-source. It’s only possible to cross compile between aarch64-darwin and x86_64-darwin."

I hoped that there was some known workaround at least for Rust, but I guess that I'll have to stick with the GitHub Actions runners.

Thanks again.