From 4dd46c5844a38f1ddff3696e63a3537a3b1362f0 Mon Sep 17 00:00:00 2001 From: Andrea Bedini Date: Tue, 15 Oct 2024 10:49:30 +0800 Subject: [PATCH 1/6] Reformat --- flake.nix | 347 +++++++++++++++++++++++++++++------------------------- 1 file changed, 186 insertions(+), 161 deletions(-) diff --git a/flake.nix b/flake.nix index 15ee49425d..9ee74bef37 100644 --- a/flake.nix +++ b/flake.nix @@ -99,17 +99,17 @@ traceNames = prefix: builtins.mapAttrs (n: v: if builtins.isAttrs v - then if v ? type && v.type == "derivation" - then builtins.trace (prefix + n) v - else traceNames (prefix + n + ".") v - else v); + then if v ? type && v.type == "derivation" + then builtins.trace (prefix + n) v + else traceNames (prefix + n + ".") v + else v); traceHydraJobs = x: x // { inherit (traceNames "" x) hydraJobs; }; # systems supported by haskell.nix systems = [ "x86_64-linux" - ] ++ (if runningHydraEvalTest then [] else [ + ] ++ (if runningHydraEvalTest then [ ] else [ "x86_64-darwin" "aarch64-darwin" ]); @@ -128,190 +128,215 @@ filterDerivations; flake = { - inherit config; - overlay = self.overlays.combined; - overlays = import ./overlays { sources = inputs; }; + inherit config; + overlay = self.overlays.combined; + overlays = import ./overlays { sources = inputs; }; - internal = { - nixpkgsArgs = { - inherit config; - overlays = [ self.overlay ]; - }; + internal = { + nixpkgsArgs = { + inherit config; + overlays = [ self.overlay ]; + }; - sources = inputs; + sources = inputs; - overlaysOverrideable = - lib.warn - "Using this attribute is deprecated. Import ${./overlays} directly or use the flake overlays output with override-inut." - (import ./overlays); + overlaysOverrideable = + lib.warn + "Using this attribute is deprecated. Import ${./overlays} directly or use the flake overlays output with override-inut." + (import ./overlays); - # Compatibility with old default.nix - compat = - lib.warn - "Using this attribute is deprecated. You can pass the same arguments to ${./default.nix} instead" - (import ./default.nix); - }; + # Compatibility with old default.nix + compat = + lib.warn + "Using this attribute is deprecated. You can pass the same arguments to ${./default.nix} instead" + (import ./default.nix); + }; - legacyPackages = forEachSystem (system: - import nixpkgs { - inherit config; - overlays = [ self.overlay ]; - localSystem = { inherit system; }; - }); + legacyPackages = forEachSystem (system: + import nixpkgs { + inherit config; + overlays = [ self.overlay ]; + localSystem = { inherit system; }; + }); - legacyPackagesUnstable = forEachSystem (system: - import nixpkgs-unstable { - inherit config; - overlays = [ self.overlay ]; - localSystem = { inherit system; }; - }); + legacyPackagesUnstable = forEachSystem (system: + import nixpkgs-unstable { + inherit config; + overlays = [ self.overlay ]; + localSystem = { inherit system; }; + }); - # Exposed so CI can check that `allow-import-from-derivation=false` works - # for core of haskell.nix E.g. this should always work: - # nix build .#roots.x86_64-linux --accept-flake-config --option allow-import-from-derivation false - roots = forEachSystem (system: - self.legacyPackagesUnstable.${system}.haskell-nix.roots compiler); + # Exposed so CI can check that `allow-import-from-derivation=false` works + # for core of haskell.nix E.g. this should always work: + # nix build .#roots.x86_64-linux --accept-flake-config --option allow-import-from-derivation false + roots = forEachSystem (system: + self.legacyPackagesUnstable.${system}.haskell-nix.roots compiler); - # Note: `nix flake check` evaluates outputs for all platforms, and haskell.nix - # uses IFD heavily, you have to have the ability to build for all platforms - # supported by haskell.nix, e.g. with remote builders, in order to check this flake. - # If you want to run the tests for just your platform, run `./test/tests.sh` or - # `nix-build -A checks.$PLATFORM` - checks = forEachSystemPkgs (pkgs: - builtins.listToAttrs ( - map - (pkg: { name = pkg.name; value = pkg; }) - (lib.collect - lib.isDerivation - (import ./test { - haskellNix.sources = inputs; - haskellNix.nixpkgsArgs = nixpkgsArgs; - compiler-nix-name = compiler; - inherit pkgs; - }) + # Note: `nix flake check` evaluates outputs for all platforms, and haskell.nix + # uses IFD heavily, you have to have the ability to build for all platforms + # supported by haskell.nix, e.g. with remote builders, in order to check this flake. + # If you want to run the tests for just your platform, run `./test/tests.sh` or + # `nix-build -A checks.$PLATFORM` + checks = forEachSystemPkgs (pkgs: + builtins.listToAttrs ( + map + (pkg: { name = pkg.name; value = pkg; }) + (lib.collect + lib.isDerivation + (import ./test { + haskellNix.sources = inputs; + haskellNix.nixpkgsArgs = nixpkgsArgs; + compiler-nix-name = compiler; + inherit pkgs; + }) ) - ) + ) ); - # NOTE: these are the hix cli utilities, which is a separate thing from - # the hix.nix overlays (which extends haskell.nix with hixProject). - packages = forEachSystemPkgs (pkgs: - (import ./hix/default.nix { inherit pkgs; }).apps - ); - apps = forEachSystemPkgs (pkgs: - builtins.mapAttrs (name: exe: { - type = "app"; - program = exe + "/bin/${name}"; - }) pkgs.haskell-nix.nix-tools-unchecked.exes - ); + # NOTE: these are the hix cli utilities, which is a separate thing from + # the hix.nix overlays (which extends haskell.nix with hixProject). + packages = forEachSystemPkgs (pkgs: + (import ./hix/default.nix { inherit pkgs; }).apps + ); + apps = forEachSystemPkgs (pkgs: + builtins.mapAttrs + (name: exe: { + type = "app"; + program = exe + "/bin/${name}"; + }) + pkgs.haskell-nix.nix-tools-unchecked.exes + ); - allJobs = forEachSystem (system: - stripAttrsForHydra (filterDerivations ( - # This is awkward. - import ./ci.nix { - inherit ifdLevel system; - haskellNix = self; - }))); + allJobs = forEachSystem (system: + stripAttrsForHydra (filterDerivations ( + # This is awkward. + import ./ci.nix { + inherit ifdLevel system; + haskellNix = self; + } + ))); - requiredJobs = forEachSystem (system: - let - inherit (self.legacyPackages.${system}) releaseTools; - in - lib.concatMapAttrs (nixpkgsVer: - lib.concatMapAttrs (compiler-nix-name: - lib.concatMapAttrs (crossPlatform: ghcJobs: - let - name = "required-${nixpkgsVer}-${compiler-nix-name}-${crossPlatform}"; - value = releaseTools.aggregate { + requiredJobs = forEachSystem (system: + let + inherit (self.legacyPackages.${system}) releaseTools; + in + lib.concatMapAttrs + (nixpkgsVer: + lib.concatMapAttrs (compiler-nix-name: + lib.concatMapAttrs (crossPlatform: ghcJobs: + let + name = "required-${nixpkgsVer}-${compiler-nix-name}-${crossPlatform}"; + value = releaseTools.aggregate { name = "haskell.nix-${nixpkgsVer}-${compiler-nix-name}-${crossPlatform}"; meta.description = "All ${nixpkgsVer} ${compiler-nix-name} ${crossPlatform} jobs"; constituents = lib.collect lib.isDerivation ghcJobs; - }; - in - lib.optionalAttrs - (crossPlatform != "recurseForDerivations" && crossPlatform != "meta") - { ${name} = value; }) + }; + in + lib.optionalAttrs + (crossPlatform != "recurseForDerivations" && crossPlatform != "meta") + { ${name} = value; }) ) ) self.allJobs.${system} - ); + ); - hydraJobs = forEachSystem (system: - let - # Include hydraJobs from nix-tools subflake. - # NOTE: These derivations do not depend on the haskell.nix in ./. but - # on the version of haskell.nix locked in the subflake. They are - # evaluated within their own flake and independently of anything - # else. Here we only expose them in the main flake. - nix-tools-hydraJobs = - let cf = callFlake { - inherit system; - pkgs = self.legacyPackages.${system}; - src = ./nix-tools; - }; - in cf.defaultNix.hydraJobs; - in - self.allJobs.${system} + hydraJobs = forEachSystem (system: + let + # Include hydraJobs from nix-tools subflake. + # NOTE: These derivations do not depend on the haskell.nix in ./. but + # on the version of haskell.nix locked in the subflake. They are + # evaluated within their own flake and independently of anything + # else. Here we only expose them in the main flake. + nix-tools-hydraJobs = + let + cf = callFlake { + inherit system; + pkgs = self.legacyPackages.${system}; + src = ./nix-tools; + }; + in + cf.defaultNix.hydraJobs; + in + self.allJobs.${system} // lib.optionalAttrs (ifdLevel > 2) - { nix-tools = nix-tools-hydraJobs.${system} or {}; } - ); + { nix-tools = nix-tools-hydraJobs.${system} or { }; } + ); - devShells = forEachSystemPkgs (pkgs: - let inherit (pkgs) mkShell nixUnstable cabal-install haskell-nix; - in { - default = - mkShell { - buildInputs = [ - nixUnstable - cabal-install - haskell-nix.compiler.${compiler} - ]; - }; - } - // - builtins.mapAttrs - (compiler-nix-name: compiler: - mkShell { - buildInputs = [ - compiler - haskell-nix.cabal-install.${compiler-nix-name} - ]; - }) - ( # Exclude old versions of GHC to speed up `nix flake check` - builtins.removeAttrs haskell-nix.compiler - [ "ghc844" - "ghc861" "ghc862" "ghc863" "ghc864" - "ghc881" "ghc882" "ghc883" - "ghc8101" "ghc8102" "ghc8103" "ghc8104" "ghc8105" "ghc8106" "ghc810420210212" - "ghc901" - "ghc921" "ghc922" "ghc923"]) - ); - }; in with (import nixpkgs { system = "x86_64-linux"; }); - traceHydraJobs (lib.recursiveUpdate flake (lib.optionalAttrs (ifdLevel > 2) { - hydraJobs.nix-tools = pkgs.releaseTools.aggregate { - name = "nix-tools"; - constituents = (if runningHydraEvalTest then [] else [ - "aarch64-darwin.nix-tools.static.zipped.nix-tools-static" - "x86_64-darwin.nix-tools.static.zipped.nix-tools-static" - "aarch64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd" - "x86_64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd" - ]) ++ [ - "x86_64-linux.nix-tools.static.zipped.nix-tools-static" - "x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64" - "x86_64-linux.nix-tools.static.zipped.nix-tools-static-no-ifd" - "x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64-no-ifd" - (writeText "gitrev" (self.rev or "0000000000000000000000000000000000000000")) - ]; - }; - })); + devShells = forEachSystemPkgs (pkgs: + let inherit (pkgs) mkShell nixUnstable cabal-install haskell-nix; + in { + default = + mkShell { + buildInputs = [ + nixUnstable + cabal-install + haskell-nix.compiler.${compiler} + ]; + }; + } + // + builtins.mapAttrs + (compiler-nix-name: compiler: + mkShell { + buildInputs = [ + compiler + haskell-nix.cabal-install.${compiler-nix-name} + ]; + }) + ( + # Exclude old versions of GHC to speed up `nix flake check` + builtins.removeAttrs haskell-nix.compiler + [ + "ghc844" + "ghc861" + "ghc862" + "ghc863" + "ghc864" + "ghc881" + "ghc882" + "ghc883" + "ghc8101" + "ghc8102" + "ghc8103" + "ghc8104" + "ghc8105" + "ghc8106" + "ghc810420210212" + "ghc901" + "ghc921" + "ghc922" + "ghc923" + ] + ) + ); + }; + in + with (import nixpkgs { system = "x86_64-linux"; }); + traceHydraJobs (lib.recursiveUpdate flake (lib.optionalAttrs (ifdLevel > 2) { + hydraJobs.nix-tools = pkgs.releaseTools.aggregate { + name = "nix-tools"; + constituents = (if runningHydraEvalTest then [ ] else [ + "aarch64-darwin.nix-tools.static.zipped.nix-tools-static" + "x86_64-darwin.nix-tools.static.zipped.nix-tools-static" + "aarch64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd" + "x86_64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd" + ]) ++ [ + "x86_64-linux.nix-tools.static.zipped.nix-tools-static" + "x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64" + "x86_64-linux.nix-tools.static.zipped.nix-tools-static-no-ifd" + "x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64-no-ifd" + (writeText "gitrev" (self.rev or "0000000000000000000000000000000000000000")) + ]; + }; + })); # --- Flake Local Nix Configuration ---------------------------- nixConfig = { # This sets the flake to use the IOG nix cache. # Nix should ask for permission before using it, # but remove it here if you do not want it to. - extra-substituters = ["https://cache.iog.io"]; - extra-trusted-public-keys = ["hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="]; + extra-substituters = [ "https://cache.iog.io" ]; + extra-trusted-public-keys = [ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ=" ]; allow-import-from-derivation = "true"; }; } From 2db2f5eff321707239e7bf8b509ac8c790b246bb Mon Sep 17 00:00:00 2001 From: Andrea Bedini Date: Tue, 15 Oct 2024 10:50:33 +0800 Subject: [PATCH 2/6] Replace nixUnstable with nixVersions.latest --- flake.nix | 4 ++-- overlays/haskell.nix | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/flake.nix b/flake.nix index 9ee74bef37..4dd770a9e6 100644 --- a/flake.nix +++ b/flake.nix @@ -263,12 +263,12 @@ ); devShells = forEachSystemPkgs (pkgs: - let inherit (pkgs) mkShell nixUnstable cabal-install haskell-nix; + let inherit (pkgs) mkShell nixVersions cabal-install haskell-nix; in { default = mkShell { buildInputs = [ - nixUnstable + nixVersions.latest cabal-install haskell-nix.compiler.${compiler} ]; diff --git a/overlays/haskell.nix b/overlays/haskell.nix index 8332ec839d..5cad91fc63 100644 --- a/overlays/haskell.nix +++ b/overlays/haskell.nix @@ -15,7 +15,7 @@ final: prev: { extraPkgconfigMappings = prev.haskell-nix.extraPkgconfigMappings or {}; # Nix Flake based source pins. # To update all inputs, get unstable Nix and then `nix flake update --recreate-lock-file` - # Or `nix-shell -p nixUnstable --run "nix --experimental-features 'nix-command flakes' flake update --recreate-lock-file"` + # Or `nix-shell -p nixVersions.latest --run "nix --experimental-features 'nix-command flakes' flake update --recreate-lock-file"` sources = sources; # We provide a `callPackage` function to consumers for From 869ee38b0183194c38836744712f558d9b16767c Mon Sep 17 00:00:00 2001 From: Andrea Bedini Date: Tue, 15 Oct 2024 11:37:17 +0800 Subject: [PATCH 3/6] Refactor devShells --- flake.nix | 81 ++++++++++++++++++++++++++----------------------------- 1 file changed, 38 insertions(+), 43 deletions(-) diff --git a/flake.nix b/flake.nix index 4dd770a9e6..256f660fc6 100644 --- a/flake.nix +++ b/flake.nix @@ -263,53 +263,48 @@ ); devShells = forEachSystemPkgs (pkgs: - let inherit (pkgs) mkShell nixVersions cabal-install haskell-nix; - in { - default = - mkShell { + let + mkHaskellNixShell = compiler-nix-name: + pkgs.mkShell { buildInputs = [ - nixVersions.latest - cabal-install - haskell-nix.compiler.${compiler} + pkgs.nixVersions.latest + pkgs.haskell-nix.cabal-install.${compiler-nix-name} + pkgs.haskell-nix.compiler.${compiler-nix-name} ]; }; - } - // - builtins.mapAttrs - (compiler-nix-name: compiler: - mkShell { - buildInputs = [ - compiler - haskell-nix.cabal-install.${compiler-nix-name} - ]; - }) - ( - # Exclude old versions of GHC to speed up `nix flake check` - builtins.removeAttrs haskell-nix.compiler - [ - "ghc844" - "ghc861" - "ghc862" - "ghc863" - "ghc864" - "ghc881" - "ghc882" - "ghc883" - "ghc8101" - "ghc8102" - "ghc8103" - "ghc8104" - "ghc8105" - "ghc8106" - "ghc810420210212" - "ghc901" - "ghc921" - "ghc922" - "ghc923" - ] - ) - ); + shells = lib.genAttrs + ( + # Exclude old versions of GHC to speed up `nix flake check` + lib.attrNames ( + lib.removeAttrs pkgs.haskell-nix.compiler + [ + "ghc844" + "ghc861" + "ghc862" + "ghc863" + "ghc864" + "ghc881" + "ghc882" + "ghc883" + "ghc8101" + "ghc8102" + "ghc8103" + "ghc8104" + "ghc8105" + "ghc8106" + "ghc810420210212" + "ghc901" + "ghc921" + "ghc922" + "ghc923" + ] + ) + ) + mkHaskellNixShell; + in + shells // { default = shells.${compiler}; }); }; + in with (import nixpkgs { system = "x86_64-linux"; }); traceHydraJobs (lib.recursiveUpdate flake (lib.optionalAttrs (ifdLevel > 2) { From d86768a7b6c227f84891ef3d901ae24dd38c9e8a Mon Sep 17 00:00:00 2001 From: Andrea Bedini Date: Tue, 15 Oct 2024 11:04:53 +0800 Subject: [PATCH 4/6] Improve formatting --- flake.nix | 38 ++++++++++---------------------------- 1 file changed, 10 insertions(+), 28 deletions(-) diff --git a/flake.nix b/flake.nix index 256f660fc6..4f46b79bc0 100644 --- a/flake.nix +++ b/flake.nix @@ -272,34 +272,16 @@ pkgs.haskell-nix.compiler.${compiler-nix-name} ]; }; - shells = lib.genAttrs - ( - # Exclude old versions of GHC to speed up `nix flake check` - lib.attrNames ( - lib.removeAttrs pkgs.haskell-nix.compiler - [ - "ghc844" - "ghc861" - "ghc862" - "ghc863" - "ghc864" - "ghc881" - "ghc882" - "ghc883" - "ghc8101" - "ghc8102" - "ghc8103" - "ghc8104" - "ghc8105" - "ghc8106" - "ghc810420210212" - "ghc901" - "ghc921" - "ghc922" - "ghc923" - ] - ) - ) + shells = lib.genAttrs ( + # Exclude old versions of GHC to speed up `nix flake check` + lib.attrNames ( + lib.removeAttrs pkgs.haskell-nix.compiler + ([ "ghc844" ] ++ + [ "ghc861" "ghc862" "ghc863" "ghc864" ] ++ + [ "ghc881" "ghc882" "ghc883" ] ++ + [ "ghc8101" "ghc8102" "ghc8103" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" ] ++ + [ "ghc901" ] ++ [ "ghc921" "ghc922" "ghc923" ]) + )) mkHaskellNixShell; in shells // { default = shells.${compiler}; }); From aa063150fad19c8df1b22eeffdeff2861962e94c Mon Sep 17 00:00:00 2001 From: Andrea Bedini Date: Tue, 15 Oct 2024 11:05:35 +0800 Subject: [PATCH 5/6] Remove unused bindings --- flake.nix | 7 ------- 1 file changed, 7 deletions(-) diff --git a/flake.nix b/flake.nix index 4f46b79bc0..1b963a7e1a 100644 --- a/flake.nix +++ b/flake.nix @@ -77,13 +77,6 @@ { self , nixpkgs , nixpkgs-unstable - , nixpkgs-2105 - , nixpkgs-2111 - , nixpkgs-2205 - , nixpkgs-2211 - , nixpkgs-2305 - , nixpkgs-2311 - , nixpkgs-2405 , flake-compat , ... }@inputs: From a6a964c7585739abe925225d07a534fe96e1d6a1 Mon Sep 17 00:00:00 2001 From: Andrea Bedini Date: Tue, 15 Oct 2024 11:11:03 +0800 Subject: [PATCH 6/6] Other small improvements in flake.nix - rename compiler to defaultCompiler - avoid using `with` above traceHydraJobs --- flake.nix | 48 ++++++++++++++++++++++++++---------------------- 1 file changed, 26 insertions(+), 22 deletions(-) diff --git a/flake.nix b/flake.nix index 1b963a7e1a..4d7a252e95 100644 --- a/flake.nix +++ b/flake.nix @@ -85,7 +85,7 @@ ifdLevel = 3; runningHydraEvalTest = false; - compiler = "ghc928"; + defaultCompiler = "ghc928"; config = import ./config.nix; inherit (nixpkgs) lib; @@ -163,7 +163,7 @@ # for core of haskell.nix E.g. this should always work: # nix build .#roots.x86_64-linux --accept-flake-config --option allow-import-from-derivation false roots = forEachSystem (system: - self.legacyPackagesUnstable.${system}.haskell-nix.roots compiler); + self.legacyPackagesUnstable.${system}.haskell-nix.roots defaultCompiler); # Note: `nix flake check` evaluates outputs for all platforms, and haskell.nix # uses IFD heavily, you have to have the ability to build for all platforms @@ -179,7 +179,7 @@ (import ./test { haskellNix.sources = inputs; haskellNix.nixpkgsArgs = nixpkgsArgs; - compiler-nix-name = compiler; + compiler-nix-name = defaultCompiler; inherit pkgs; }) ) @@ -191,6 +191,7 @@ packages = forEachSystemPkgs (pkgs: (import ./hix/default.nix { inherit pkgs; }).apps ); + apps = forEachSystemPkgs (pkgs: builtins.mapAttrs (name: exe: { @@ -277,28 +278,31 @@ )) mkHaskellNixShell; in - shells // { default = shells.${compiler}; }); + shells // { default = shells.${defaultCompiler}; }); }; in - with (import nixpkgs { system = "x86_64-linux"; }); - traceHydraJobs (lib.recursiveUpdate flake (lib.optionalAttrs (ifdLevel > 2) { - hydraJobs.nix-tools = pkgs.releaseTools.aggregate { - name = "nix-tools"; - constituents = (if runningHydraEvalTest then [ ] else [ - "aarch64-darwin.nix-tools.static.zipped.nix-tools-static" - "x86_64-darwin.nix-tools.static.zipped.nix-tools-static" - "aarch64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd" - "x86_64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd" - ]) ++ [ - "x86_64-linux.nix-tools.static.zipped.nix-tools-static" - "x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64" - "x86_64-linux.nix-tools.static.zipped.nix-tools-static-no-ifd" - "x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64-no-ifd" - (writeText "gitrev" (self.rev or "0000000000000000000000000000000000000000")) - ]; - }; - })); + traceHydraJobs (lib.recursiveUpdate flake (lib.optionalAttrs (ifdLevel > 2) + ( + let pkgs = nixpkgs.legacyPackages."x86_64-linux"; in + { + hydraJobs.nix-tools = pkgs.releaseTools.aggregate { + name = "nix-tools"; + constituents = (if runningHydraEvalTest then [ ] else [ + "aarch64-darwin.nix-tools.static.zipped.nix-tools-static" + "x86_64-darwin.nix-tools.static.zipped.nix-tools-static" + "aarch64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd" + "x86_64-darwin.nix-tools.static.zipped.nix-tools-static-no-ifd" + ]) ++ [ + "x86_64-linux.nix-tools.static.zipped.nix-tools-static" + "x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64" + "x86_64-linux.nix-tools.static.zipped.nix-tools-static-no-ifd" + "x86_64-linux.nix-tools.static.zipped.nix-tools-static-arm64-no-ifd" + (pkgs.writeText "gitrev" (self.rev or "0000000000000000000000000000000000000000")) + ]; + }; + } + ))); # --- Flake Local Nix Configuration ---------------------------- nixConfig = {