push sheeet

pkgs/development/compilers/abcl/default.nix

@@ -0,0 +1,74 @@
+{
+  lib,
+  stdenv,
+  writeShellScriptBin,
+  fetchurl,
+  ant,
+  openjdk17,
+  makeWrapper,
+  stripJavaArchivesHook,
+}:
+
+let
+  # https://armedbear.common-lisp.dev/ lists OpenJDK 17 as the highest
+  # supported JDK.
+  jdk = openjdk17;
+
+  fakeHostname = writeShellScriptBin "hostname" ''
+    echo nix-builder.localdomain
+  '';
+in
+stdenv.mkDerivation (finalAttrs: {
+  pname = "abcl";
+  version = "1.9.3";
+
+  src = fetchurl {
+    url = "https://common-lisp.net/project/armedbear/releases/${finalAttrs.version}/abcl-src-${finalAttrs.version}.tar.gz";
+    hash = "sha256-uwShIj06mGCS4BD/2tE69QQp1VwagYdL8wIvlDa/sv8=";
+  };
+
+  # note for the future:
+  # if you use makeBinaryWrapper, you will trade bash for glibc, the closure will be slightly larger
+  nativeBuildInputs = [
+    ant
+    jdk
+    fakeHostname
+    makeWrapper
+    stripJavaArchivesHook
+  ];
+
+  buildPhase = ''
+    runHook preBuild
+
+    ant \
+      -Dabcl.runtime.jar.path="$out/lib/abcl/abcl.jar" \
+      -Dadditional.jars="$out/lib/abcl/abcl-contrib.jar"
+
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p "$out"/{share/doc/abcl,lib/abcl}
+    cp -r README COPYING CHANGES examples/  "$out/share/doc/abcl/"
+    cp -r dist/*.jar contrib/ "$out/lib/abcl/"
+    install -Dm555 abcl -t $out/bin
+
+    runHook postInstall
+  '';
+
+  passthru.updateScript = ./update.sh;
+
+  meta = {
+    description = "JVM-based Common Lisp implementation";
+    homepage = "https://common-lisp.net/project/armedbear/";
+    license = with lib.licenses; [
+      gpl2
+      classpathException20
+    ];
+    mainProgram = "abcl";
+    teams = [ lib.teams.lisp ];
+    platforms = lib.platforms.darwin ++ lib.platforms.linux;
+  };
+})

pkgs/development/compilers/abcl/update.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env nix-shell
+#!nix-shell -i bash -p nix-update subversion
+
+new_version=$(svn ls https://abcl.org/svn/tags | tail -1 | tr -d /)
+nix-update abcl --version "$new_version"

pkgs/development/compilers/arocc/default.nix

@@ -0,0 +1,44 @@
+{
+  lib,
+  fetchFromGitHub,
+  callPackage,
+  zig_0_14,
+}:
+let
+  versions = [
+    {
+      zig = zig_0_14;
+      version = "0-unstable-2025-03-05";
+      src = fetchFromGitHub {
+        owner = "Vexu";
+        repo = "arocc";
+        rev = "8c6bab43ba351fc045a1d262d8a8da4a11215e37";
+        hash = "sha256-J5Cj9UMwAMwH2JGby13FIKl5Qbj4N4XpSSY7zL21aoY=";
+      };
+    }
+  ];
+
+  mkPackage =
+    {
+      zig,
+      version,
+      src,
+    }:
+    callPackage ./package.nix { inherit zig version src; };
+
+  pkgsList = lib.map mkPackage versions;
+
+  pkgsAttrsUnwrapped = lib.listToAttrs (
+    lib.map (pkg: lib.nameValuePair "${pkg.version}-unwrapped" pkg) pkgsList
+  );
+  pkgsAttrsWrapped = lib.listToAttrs (
+    lib.map (pkg: lib.nameValuePair pkg.version pkg.wrapped) pkgsList
+  );
+
+  pkgsAttrs = pkgsAttrsWrapped // pkgsAttrsUnwrapped;
+in
+{
+  latest-unwrapped = lib.last pkgsList;
+  latest = (lib.last pkgsList).wrapped;
+}
+// pkgsAttrs

pkgs/development/compilers/arocc/package.nix

@@ -0,0 +1,33 @@
+{
+  lib,
+  stdenv,
+  wrapCCWith,
+  overrideCC,
+  zig,
+  version,
+  src,
+}:
+stdenv.mkDerivation (finalAttrs: {
+  pname = "arocc";
+  inherit version src;
+
+  nativeBuildInputs = [ zig.hook ];
+
+  passthru = {
+    inherit zig;
+    isArocc = true;
+    wrapped = wrapCCWith { cc = finalAttrs.finalPackage; };
+    stdenv = overrideCC stdenv finalAttrs.passthru.wrapped;
+  };
+
+  meta = {
+    description = "C compiler written in Zig";
+    homepage = "http://aro.vexu.eu/";
+    license = with lib.licenses; [
+      mit
+      unicode-30
+    ];
+    maintainers = with lib.maintainers; [ RossComputerGuy ];
+    mainProgram = "arocc";
+  };
+})

pkgs/development/compilers/binaryen/default.nix

@@ -0,0 +1,94 @@
+{
+  lib,
+  stdenv,
+  cmake,
+  python3,
+  fetchFromGitHub,
+  emscripten,
+  gtest,
+  lit,
+  nodejs,
+  filecheck,
+}:
+let
+  testsuite = fetchFromGitHub {
+    owner = "WebAssembly";
+    repo = "testsuite";
+    rev = "e05365077e13a1d86ffe77acfb1a835b7aa78422";
+    hash = "sha256-yvZ5AZTPUA6nsD3xpFC0VLthiu2CxVto66RTXBXXeJM=";
+  };
+in
+stdenv.mkDerivation rec {
+  pname = "binaryen";
+  version = "124";
+
+  src = fetchFromGitHub {
+    owner = "WebAssembly";
+    repo = "binaryen";
+    rev = "version_${version}";
+    hash = "sha256-tkvO0gNESliRV6FOpXDQd7ZKujGe6q1mGX5V+twcE1o=";
+  };
+
+  nativeBuildInputs = [
+    cmake
+    python3
+  ];
+
+  strictDeps = true;
+
+  preConfigure = ''
+    if [ $doCheck -eq 1 ]; then
+      sed -i '/gtest/d' third_party/CMakeLists.txt
+      rmdir test/spec/testsuite
+      ln -s ${testsuite} test/spec/testsuite
+    else
+      cmakeFlagsArray=($cmakeFlagsArray -DBUILD_TESTS=0)
+    fi
+  '';
+
+  nativeCheckInputs = [
+    lit
+    nodejs
+    filecheck
+  ];
+  checkInputs = [ gtest ];
+  checkPhase = ''
+    LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD/lib python3 ../check.py $tests
+  '';
+
+  tests = [
+    "version"
+    "wasm-opt"
+    "wasm-dis"
+    "crash"
+    "dylink"
+    "ctor-eval"
+    "wasm-metadce"
+    "wasm-reduce"
+    "spec"
+    "lld"
+    "wasm2js"
+    # "unit" # fails on test.unit.test_cluster_fuzz.ClusterFuzz
+    # "binaryenjs" "binaryenjs_wasm" # not building this
+    # "lit" # fails on d8/fuzz_shell*
+    "gtest"
+  ]
+  ++ lib.optionals stdenv.hostPlatform.isLinux [
+    "example"
+    "validator"
+  ];
+
+  doCheck = (stdenv.hostPlatform.isLinux || stdenv.hostPlatform.isDarwin);
+
+  meta = with lib; {
+    homepage = "https://github.com/WebAssembly/binaryen";
+    description = "Compiler infrastructure and toolchain library for WebAssembly, in C++";
+    platforms = platforms.all;
+    maintainers = with maintainers; [
+      asppsa
+      willcohen
+    ];
+    license = licenses.asl20;
+  };
+  passthru.tests = { inherit emscripten; };
+}

pkgs/development/compilers/c0/default.nix

@@ -0,0 +1,88 @@
+{
+  lib,
+  stdenv,
+  fetchFromBitbucket,
+  mlton,
+  pkg-config,
+  getopt,
+  boehmgc,
+  darwin,
+  libbacktrace,
+  libpng,
+  ncurses,
+  readline,
+  unstableGitUpdater,
+}:
+
+stdenv.mkDerivation rec {
+  pname = "c0";
+  version = "0-unstable-2023-09-05";
+
+  src = fetchFromBitbucket {
+    owner = "c0-lang";
+    repo = "c0";
+    rev = "608f97eef5d81bb85963d66f955730dd93996f67";
+    hash = "sha256-lRIEtclx+NKxAO72nsvnxVeEGCEe6glC6w8MXh1HEwY=";
+  };
+
+  patches = [
+    ./use-system-libraries.patch
+  ];
+
+  postPatch = ''
+    substituteInPlace cc0/Makefile \
+      --replace '$(shell ./get_version.sh)' '${version}'
+    substituteInPlace cc0/compiler/bin/buildid \
+      --replace '`../get_version.sh`' '${version}' \
+      --replace '`date`' '1970-01-01T00:00:00Z' \
+      --replace '`hostname`' 'nixpkgs'
+  ''
+  + lib.optionalString stdenv.hostPlatform.isDarwin ''
+    for f in cc0/compiler/bin/coin-o0-support cc0/compiler/bin/cc0-o0-support; do
+      substituteInPlace $f --replace '$(brew --prefix gnu-getopt)' '${getopt}'
+    done
+  '';
+
+  preConfigure = ''
+    cd cc0/
+  '';
+
+  nativeBuildInputs = [
+    getopt
+    mlton
+    pkg-config
+  ]
+  ++ lib.optionals stdenv.hostPlatform.isDarwin [ darwin.sigtool ];
+
+  buildInputs = [
+    boehmgc
+    libbacktrace
+    libpng
+    ncurses
+    readline
+  ];
+
+  strictDeps = true;
+
+  installFlags = [ "PREFIX=$(out)" ];
+
+  postInstall = ''
+    mkdir -p $out/share/emacs/site-lisp
+    mv $out/c0-mode/ $out/share/emacs/site-lisp/
+  '';
+
+  passthru.updateScript = unstableGitUpdater {
+    url = "https://bitbucket.org/c0-lang/c0.git";
+  };
+
+  meta = with lib; {
+    description = "Small safe subset of the C programming language, augmented with contracts";
+    homepage = "https://c0.cs.cmu.edu/";
+    license = licenses.mit;
+    maintainers = [ ];
+    platforms = platforms.unix;
+    # line 1: ../../bin/wrappergen: cannot execute: required file not found
+    # make[2]: *** [../../lib.mk:83:
+    broken = stdenv.hostPlatform.isLinux;
+  };
+}

pkgs/development/compilers/c0/use-system-libraries.patch

@@ -0,0 +1,53 @@
+Use system libraries
+
+--- a/cc0/Makefile
++++ b/cc0/Makefile
+@@ -22,12 +22,12 @@ MLTON_BASIC = mlton $(MLTON_FLAGS) -verbose $(MLTON_VERB)  -output
+ MLTON_NATIVE := mlton -default-ann "redundantMatch error" -default-ann "sequenceNonUnit error"
+ MLTON_NATIVE += -link-opt "-lpthread -ldl -rdynamic" -cc-opt "-Iinclude" -default-ann "allowFFI true"
+ MLTON_NATIVE += -cc-opt "-I../externals/"
+-MLTON_NATIVE += -link-opt "../externals/readline/libreadline.a ../externals/readline/libhistory.a"
++MLTON_NATIVE += -link-opt "$(shell pkg-config readline --libs)"
+ MLTON_NATIVE += -link-opt "$(shell pkg-config libpng --libs)"
+ 
+ # libreadline dependencies
+ ifeq ($(PLATFORM),osx)
+-MLTON_NATIVE += -link-opt "-ltermcap"
++MLTON_NATIVE += -link-opt "-lncurses"
+ else
+ # (Assuming Linux)
+ MLTON_NATIVE += -link-opt "-ltinfo"
+@@ -122,9 +122,9 @@ endef
+ 
+ $(foreach rt,$(RUNTIMES),$(eval $(call runtime_template,$(rt))))
+ 
+-c0rt/$(call dllname,c0rt): gc libbacktrace
++c0rt/$(call dllname,c0rt):
+ 
+-unsafe/$(call dllname,unsafe): gc
++unsafe/$(call dllname,unsafe):
+ 
+ 
+ ### cc0 - the C0 compiler
+@@ -222,7 +222,6 @@ NATIVE_COIN    = $(NATIVE_CYMBOL) $(NATIVE_CALLING)
+ NATIVE_COIN += coin/c0readline.c
+ 
+ COIN_DEPS = $(CC0_DEPS) $(NATIVE_COIN) cymbol/cymbol*.cm cymbol/*.sml cymbol/*.mlb coin/coin*.cm coin/*.sml coin/*.sml
+-COIN_DEPS += readline
+ 
+ .PHONY: coin
+ coin: bin/coin
+--- a/cc0/lib.mk
++++ b/cc0/lib.mk
+@@ -15,9 +15,9 @@ TARGET = $(call dllname,$(LIBNAME))
+ endif
+ 
+ # These libs are handled specially by this file
+-NATIVELIBS = gc ncurses backtrace
++NATIVELIBS =
+ C0LIBS = $(filter-out $(NATIVELIBS),$(REQUIRES))
+-LIBS = -L$(abspath $(DEPTH)/lib) $(patsubst %,$(DEPTH)/lib/$(call dllname,%),$(C0LIBS))
++LIBS = -L$(abspath $(DEPTH)/lib)
+ LDFLAGS = 
+ 
+ # -fPIC is not supported on Windows and is not necessary there because we link statically

pkgs/development/compilers/ccl/default.nix

@@ -0,0 +1,121 @@
+{
+  lib,
+  stdenv,
+  fetchurl,
+  bootstrap_cmds,
+  coreutils,
+  glibc,
+  m4,
+  runtimeShell,
+}:
+
+let
+  options = rec {
+    # TODO: there are also FreeBSD and Windows versions
+    x86_64-linux = {
+      arch = "linuxx86";
+      sha256 = "0mhmm8zbk42p2b9amy702365m687k5p0xnz010yqrki6mwyxlkx9";
+      runtime = "lx86cl64";
+      kernel = "linuxx8664";
+    };
+    i686-linux = {
+      arch = "linuxx86";
+      sha256 = x86_64-linux.sha256;
+      runtime = "lx86cl";
+      kernel = "linuxx8632";
+    };
+    armv7l-linux = {
+      arch = "linuxarm";
+      sha256 = "1a4y07cmmn1r88b4hl4msb0bvr2fxd2vw9lf7h4j9f7a5rpq7124";
+      runtime = "armcl";
+      kernel = "linuxarm";
+    };
+    x86_64-darwin = {
+      arch = "darwinx86";
+      sha256 = "1xclnik6pqhkmr15cbqa2n1ddzdf0rs452lyiln3c42nmkf9jjb6";
+      runtime = "dx86cl64";
+      kernel = "darwinx8664";
+    };
+    armv6l-linux = armv7l-linux;
+  };
+  cfg =
+    options.${stdenv.hostPlatform.system}
+      or (throw "missing source url for platform ${stdenv.hostPlatform.system}");
+
+in
+stdenv.mkDerivation rec {
+  pname = "ccl";
+  version = "1.12.2";
+
+  src = fetchurl {
+    url = "https://github.com/Clozure/ccl/releases/download/v${version}/ccl-${version}-${cfg.arch}.tar.gz";
+    sha256 = cfg.sha256;
+  };
+
+  buildInputs =
+    if stdenv.hostPlatform.isDarwin then
+      [
+        bootstrap_cmds
+        m4
+      ]
+    else
+      [
+        glibc
+        m4
+      ];
+
+  CCL_RUNTIME = cfg.runtime;
+  CCL_KERNEL = cfg.kernel;
+
+  postPatch =
+    if stdenv.hostPlatform.isDarwin then
+      ''
+        substituteInPlace lisp-kernel/${CCL_KERNEL}/Makefile \
+          --replace "M4 = gm4"   "M4 = m4" \
+          --replace "dtrace"     "/usr/sbin/dtrace" \
+          --replace "/bin/rm"    "${coreutils}/bin/rm" \
+          --replace "/bin/echo"  "${coreutils}/bin/echo"
+
+        substituteInPlace lisp-kernel/m4macros.m4 \
+          --replace "/bin/pwd" "${coreutils}/bin/pwd"
+      ''
+    else
+      ''
+        substituteInPlace lisp-kernel/${CCL_KERNEL}/Makefile \
+          --replace "/bin/rm"    "${coreutils}/bin/rm" \
+          --replace "/bin/echo"  "${coreutils}/bin/echo"
+
+        substituteInPlace lisp-kernel/m4macros.m4 \
+          --replace "/bin/pwd" "${coreutils}/bin/pwd"
+      '';
+
+  buildPhase = ''
+    make -C lisp-kernel/${CCL_KERNEL} clean
+    make -C lisp-kernel/${CCL_KERNEL} all
+
+    ./${CCL_RUNTIME} -n -b -e '(ccl:rebuild-ccl :full t)' -e '(ccl:quit)'
+  '';
+
+  installPhase = ''
+    mkdir -p "$out/share"
+    cp -r .  "$out/share/ccl-installation"
+
+    mkdir -p "$out/bin"
+    echo -e '#!${runtimeShell}\n'"$out/share/ccl-installation/${CCL_RUNTIME}"' "$@"\n' > "$out"/bin/"${CCL_RUNTIME}"
+    chmod a+x "$out"/bin/"${CCL_RUNTIME}"
+    ln -s "$out"/bin/"${CCL_RUNTIME}" "$out"/bin/ccl
+  '';
+
+  hardeningDisable = [ "format" ];
+
+  meta = with lib; {
+    # assembler failures during build, x86_64-darwin broken since 2020-10-14
+    broken = (stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isx86_64);
+    description = "Clozure Common Lisp";
+    homepage = "https://ccl.clozure.com/";
+    license = licenses.asl20;
+    mainProgram = "ccl";
+    teams = [ lib.teams.lisp ];
+    platforms = attrNames options;
+  };
+}

pkgs/development/compilers/chicken/4/0001-Introduce-CHICKEN_REPOSITORY_EXTRA.patch

@@ -0,0 +1,157 @@
+From 2877f33747e3871c3a682b3a0c812b8ba2e4da5a Mon Sep 17 00:00:00 2001
+From: Caolan McMahon <caolan@caolanmcmahon.com>
+Date: Sat, 25 Jun 2016 11:52:28 +0100
+Subject: [PATCH] Introduce CHICKEN_REPOSITORY_EXTRA
+
+This environment variable works like CHICKEN_REPOSITORY but supports
+multiple paths separated by `:'. Those paths are searched after
+CHICKEN_REPOSITORY when loading extensions via `require-library' and
+friends. It can be accessed and changed at runtime via the new procedure
+`repository-extra-paths' which is analog to `repository-path'.
+
+Original patch by Moritz Heidkamp.
+Updated by Caolan McMahon for CHICKEN 4.11.0
+---
+ chicken-install.scm | 29 ++++++++++++++++++++++++-----
+ chicken.import.scm  |  1 +
+ eval.scm            | 37 +++++++++++++++++++++++++++++++------
+ 3 files changed, 56 insertions(+), 11 deletions(-)
+
+diff --git a/chicken-install.scm b/chicken-install.scm
+index 7bc6041..f557793 100644
+--- a/chicken-install.scm
++++ b/chicken-install.scm
+@@ -120,6 +120,19 @@
+ 		 (sprintf "lib/chicken/~a" (##sys#fudge 42)))
+ 		(repository-path)))))
+ 
++  (define (repo-paths)
++    (if *deploy*
++	*prefix*
++	(if (and *cross-chicken* (not *host-extension*))
++	    (list (make-pathname C_TARGET_LIB_HOME (sprintf "chicken/~a" C_BINARY_VERSION)))
++	    (cons
++	     (if *prefix*
++		 (make-pathname
++			*prefix*
++			(sprintf "lib/chicken/~a" (##sys#fudge 42)))
++		 (repository-path))
++	     (repository-extra-paths)))))
++
+   (define (get-prefix #!optional runtime)
+     (cond ((and *cross-chicken*
+ 		(not *host-extension*))
+@@ -226,10 +239,13 @@
+            (chicken-version) )
+ 	  ;; Duplication of (extension-information) to get custom
+ 	  ;; prefix.  This should be fixed.
+-          ((let* ((ep (##sys#canonicalize-extension-path x 'ext-version))
+-		  (sf (make-pathname (repo-path) ep "setup-info")))
+-	     (and (file-exists? sf)
+-		  (with-input-from-file sf read))) =>
++      ((let ((ep (##sys#canonicalize-extension-path x 'ext-version)))
++         (let loop ((paths (repo-paths)))
++           (cond ((null? paths) #f)
++                 ((let ((sf (make-pathname (car paths) ep "setup-info")))
++                    (and (file-exists? sf)
++                         (with-input-from-file sf read))))
++                 (else (loop (cdr paths)))))) =>
+            (lambda (info)
+              (let ((a (assq 'version info)))
+                (if a
+@@ -776,7 +792,10 @@
+ 		  "installed extension has no information about which egg it belongs to"
+ 		  (pathname-file sf))
+ 		 #f))))
+-      (glob (make-pathname (repo-path) "*" "setup-info")))
++      (append-map
++       (lambda (path)
++       (glob (make-pathname path "*" "setup-info")))
++       (repo-paths)))
+      equal?))
+ 
+   (define (list-available-extensions trans locn)
+diff --git a/chicken.import.scm b/chicken.import.scm
+index f6e3a19..be1637c 100644
+--- a/chicken.import.scm
++++ b/chicken.import.scm
+@@ -200,6 +200,7 @@
+    repl
+    repl-prompt
+    repository-path
++   repository-extra-paths
+    require
+    reset
+    reset-handler
+diff --git a/eval.scm b/eval.scm
+index 6242f62..f7d76d4 100644
+--- a/eval.scm
++++ b/eval.scm
+@@ -81,6 +81,7 @@
+ (define-constant source-file-extension ".scm")
+ (define-constant setup-file-extension "setup-info")
+ (define-constant repository-environment-variable "CHICKEN_REPOSITORY")
++(define-constant repository-extra-environment-variable "CHICKEN_REPOSITORY_EXTRA")
+ (define-constant prefix-environment-variable "CHICKEN_PREFIX")
+ 
+ ; these are actually in unit extras, but that is used by default
+@@ -1176,6 +1177,25 @@
+ 
+ (define ##sys#repository-path repository-path)
+ 
++(define ##sys#repository-extra-paths
++  (let* ((repaths (get-environment-variable repository-extra-environment-variable))
++	 (repaths (if repaths
++		      (let ((len (string-length repaths)))
++			(let loop ((i 0) (offset 0) (res '()))
++			  (cond ((> i len)
++				 (reverse res))
++				((or (= i len) (eq? #\: (string-ref repaths i)))
++				 (loop (+ i 1) (+ i 1) (cons (substring repaths offset i) res)))
++				(else
++				 (loop (+ i 1) offset res)))))
++		      '())))
++    (lambda (#!optional val)
++      (if val
++	  (set! repaths val)
++	  repaths))))
++
++(define repository-extra-paths ##sys#repository-extra-paths)
++
+ (define ##sys#setup-mode #f)
+ 
+ (define ##sys#find-extension
+@@ -1193,6 +1213,7 @@
+ 	(let loop ((paths (##sys#append
+ 			   (if ##sys#setup-mode '(".") '())
+ 			   (if rp (list rp) '())
++			   (##sys#repository-extra-paths)
+ 			   (if inc? ##sys#include-pathnames '())
+ 			   (if ##sys#setup-mode '() '("."))) ))
+ 	  (and (pair? paths)
+@@ -1252,12 +1273,16 @@
+ 	[string-append string-append]
+ 	[read read] )
+     (lambda (id loc)
+-      (and-let* ((rp (##sys#repository-path)))
+-	(let* ((p (##sys#canonicalize-extension-path id loc))
+-	       (rpath (string-append rp "/" p ".")) )
+-	  (cond ((file-exists? (string-append rpath setup-file-extension))
+-		 => (cut with-input-from-file <> read) )
+-		(else #f) ) ) ) ) ))
++      (let loop ((rpaths (cons (##sys#repository-path) (##sys#repository-extra-paths))))
++	(and (pair? rpaths)
++	     (let ((rp (car rpaths)))
++	       (if (not rp)
++		   (loop (cdr rpaths))
++		   (let* ((p (##sys#canonicalize-extension-path id loc))
++			  (rpath (string-append rp "/" p ".")) )
++		     (cond ((file-exists? (string-append rpath setup-file-extension))
++			    => (cut with-input-from-file <> read) )
++			   (else (loop (cdr rpaths))) ) )) ))) ) ))
+ 
+ (define (extension-information ext)
+   (##sys#extension-information ext 'extension-information) )
+-- 
+2.1.4
+

pkgs/development/compilers/chicken/4/chicken.nix

@@ -0,0 +1,112 @@
+{
+  lib,
+  stdenv,
+  fetchurl,
+  makeWrapper,
+  darwin,
+  bootstrap-chicken ? null,
+}:
+
+let
+  version = "4.13.0";
+  platform =
+    with stdenv;
+    if isDarwin then
+      "macosx"
+    else if isCygwin then
+      "cygwin"
+    else if (isFreeBSD || isOpenBSD) then
+      "bsd"
+    else if isSunOS then
+      "solaris"
+    else
+      "linux"; # Should be a sane default
+in
+stdenv.mkDerivation {
+  pname = "chicken";
+  inherit version;
+
+  binaryVersion = 8;
+
+  src = fetchurl {
+    url = "https://code.call-cc.org/releases/${version}/chicken-${version}.tar.gz";
+    sha256 = "0hvckhi5gfny3mlva6d7y9pmx7cbwvq0r7mk11k3sdiik9hlkmdd";
+  };
+
+  postPatch = lib.optionalString stdenv.hostPlatform.isDarwin ''
+    # There is not enough space in the load command to accomodate a full path to the store,
+    # so use `@executable_path` to specify a relative path to chicken’s lib folder.
+    sed -e '/POSTINSTALL_PROGRAM_FLAGS = /{s|$(LIBDIR)|@executable_path/../lib|}' \
+      -i Makefile.macosx
+  '';
+
+  setupHook = lib.optional (bootstrap-chicken != null) ./setup-hook.sh;
+
+  # -fno-strict-overflow is not a supported argument in clang on darwin
+  hardeningDisable = lib.optionals stdenv.hostPlatform.isDarwin [ "strictoverflow" ];
+
+  makeFlags = [
+    "PLATFORM=${platform}"
+    "PREFIX=$(out)"
+    "VARDIR=$(out)/var/lib"
+  ]
+  ++ (lib.optionals stdenv.hostPlatform.isDarwin [
+    "XCODE_TOOL_PATH=${darwin.binutils.bintools}/bin"
+    "C_COMPILER=$(CC)"
+    "POSTINSTALL_PROGRAM=${stdenv.cc.targetPrefix}install_name_tool"
+  ]);
+
+  # We need a bootstrap-chicken to regenerate the c-files after
+  # applying a patch to add support for CHICKEN_REPOSITORY_EXTRA
+  patches = lib.optionals (bootstrap-chicken != null) [
+    ./0001-Introduce-CHICKEN_REPOSITORY_EXTRA.patch
+  ];
+
+  nativeBuildInputs = [
+    makeWrapper
+  ]
+  ++ lib.optionals (stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64) [
+    darwin.autoSignDarwinBinariesHook
+  ];
+
+  buildInputs = lib.optionals (bootstrap-chicken != null) [
+    bootstrap-chicken
+  ];
+
+  preBuild = lib.optionalString (bootstrap-chicken != null) ''
+    # Backup the build* files - those are generated from hostname,
+    # git-tag, etc. and we don't need/want that
+    mkdir -p build-backup
+    mv buildid buildbranch buildtag.h build-backup
+
+    # Regenerate eval.c after the patch
+    make spotless $makeFlags
+
+    mv build-backup/* .
+  '';
+
+  postInstall = ''
+    for f in $out/bin/*
+    do
+      wrapProgram $f \
+        --prefix PATH : ${stdenv.cc}/bin
+    done
+  '';
+
+  # TODO: Assert csi -R files -p '(pathname-file (repository-path))' == binaryVersion
+
+  meta = {
+    homepage = "http://www.call-cc.org/";
+    license = lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [ corngood ];
+    platforms = lib.platforms.linux ++ lib.platforms.darwin; # Maybe other Unix
+    description = "Portable compiler for the Scheme programming language";
+    longDescription = ''
+      CHICKEN is a compiler for the Scheme programming language.
+      CHICKEN produces portable and efficient C, supports almost all
+      of the R5RS Scheme language standard, and includes many
+      enhancements and extensions. CHICKEN runs on Linux, macOS,
+      Windows, and many Unix flavours.
+    '';
+  };
+}

pkgs/development/compilers/chicken/4/default.nix

@@ -0,0 +1,24 @@
+{ lib, newScope }:
+let
+  callPackage = newScope self;
+
+  self = {
+    pkgs = self // {
+      recurseForDerivations = false;
+    };
+
+    fetchegg = callPackage ./fetchegg { };
+
+    eggDerivation = callPackage ./eggDerivation.nix { };
+
+    chicken = callPackage ./chicken.nix {
+      bootstrap-chicken = self.chicken.override { bootstrap-chicken = null; };
+    };
+
+    chickenEggs = lib.recurseIntoAttrs (callPackage ./eggs.nix { });
+
+    egg2nix = callPackage ./egg2nix.nix { };
+  };
+
+in
+self

pkgs/development/compilers/chicken/4/egg2nix.nix

@@ -0,0 +1,35 @@
+{
+  lib,
+  eggDerivation,
+  fetchFromGitHub,
+  chickenEggs,
+}:
+
+# Note: This mostly reimplements the default.nix already contained in
+# the tarball. Is there a nicer way than duplicating code?
+
+eggDerivation rec {
+  name = "egg2nix-${version}";
+  version = "0.5";
+
+  src = fetchFromGitHub {
+    owner = "the-kenny";
+    repo = "egg2nix";
+    rev = version;
+    sha256 = "sha256-5ov2SWVyTUQ6NHnZNPRywd9e7oIxHlVWv4uWbsNaj/s=";
+  };
+
+  buildInputs = with chickenEggs; [
+    matchable
+    http-client
+  ];
+
+  meta = {
+    description = "Generate nix-expression from CHICKEN scheme eggs";
+    mainProgram = "egg2nix";
+    homepage = "https://github.com/the-kenny/egg2nix";
+    license = lib.licenses.bsd3;
+    platforms = lib.platforms.unix;
+    maintainers = with lib.maintainers; [ corngood ];
+  };
+}

pkgs/development/compilers/chicken/4/eggDerivation.nix

@@ -0,0 +1,62 @@
+{
+  lib,
+  stdenv,
+  chicken,
+  makeWrapper,
+}:
+{
+  name,
+  src,
+  buildInputs ? [ ],
+  chickenInstallFlags ? [ ],
+  cscOptions ? [ ],
+  ...
+}@args:
+
+let
+  libPath = "${chicken}/var/lib/chicken/${toString chicken.binaryVersion}/";
+  overrides = import ./overrides.nix;
+  baseName = lib.getName name;
+  override = if builtins.hasAttr baseName overrides then builtins.getAttr baseName overrides else { };
+in
+stdenv.mkDerivation (
+  {
+    name = "chicken-${name}";
+    propagatedBuildInputs = buildInputs;
+    nativeBuildInputs = [ makeWrapper ];
+    buildInputs = [ chicken ];
+
+    CSC_OPTIONS = lib.concatStringsSep " " cscOptions;
+
+    CHICKEN_REPOSITORY = libPath;
+    CHICKEN_INSTALL_PREFIX = "$out";
+
+    installPhase = ''
+      runHook preInstall
+
+      chicken-install -p $out ${lib.concatStringsSep " " chickenInstallFlags}
+
+      for f in $out/bin/*
+      do
+        wrapProgram $f \
+          --set CHICKEN_REPOSITORY $CHICKEN_REPOSITORY \
+          --prefix CHICKEN_REPOSITORY_EXTRA : "$out/lib/chicken/${toString chicken.binaryVersion}/:$CHICKEN_REPOSITORY_EXTRA" \
+          --prefix CHICKEN_INCLUDE_PATH \; "$CHICKEN_INCLUDE_PATH;$out/share/" \
+          --prefix PATH : "$out/bin:${chicken}/bin:$CHICKEN_REPOSITORY_EXTRA:$CHICKEN_REPOSITORY"
+      done
+
+      runHook postInstall
+    '';
+
+    meta = {
+      inherit (chicken.meta) platforms;
+    }
+    // args.meta or { };
+  }
+  // (removeAttrs args [
+    "name"
+    "buildInputs"
+    "meta"
+  ])
+  // override
+)

pkgs/development/compilers/chicken/4/eggs.nix

@@ -0,0 +1,137 @@
+{ pkgs }:
+rec {
+  inherit (pkgs) eggDerivation fetchegg;
+
+  base64 = eggDerivation {
+    name = "base64-3.3.1";
+
+    src = fetchegg {
+      name = "base64";
+      version = "3.3.1";
+      sha256 = "0wmldiwwg1jpcn07wb906nc53si5j7sa83wgyq643xzqcx4v4x1d";
+    };
+
+    buildInputs = [
+
+    ];
+  };
+
+  defstruct = eggDerivation {
+    name = "defstruct-1.6";
+
+    src = fetchegg {
+      name = "defstruct";
+      version = "1.6";
+      sha256 = "0lsgl32nmb5hxqiii4r3292cx5vqh50kp6v062nfiyid9lhrj0li";
+    };
+
+    buildInputs = [
+
+    ];
+  };
+
+  http-client = eggDerivation {
+    name = "http-client-0.18";
+
+    src = fetchegg {
+      name = "http-client";
+      version = "0.18";
+      sha256 = "1b9x66kfcglld4xhm06vba00gw37vr07c859kj7lmwnk9nwhcplg";
+    };
+
+    buildInputs = [
+      intarweb
+      uri-common
+      simple-md5
+      sendfile
+    ];
+  };
+
+  intarweb = eggDerivation {
+    name = "intarweb-1.7";
+
+    src = fetchegg {
+      name = "intarweb";
+      version = "1.7";
+      sha256 = "1arjgn5g4jfdzj3nlrhxk235qwf6k6jxr14yhnncnfbgdb820xp8";
+    };
+
+    buildInputs = [
+      defstruct
+      uri-common
+      base64
+    ];
+  };
+
+  matchable = eggDerivation {
+    name = "matchable-3.7";
+
+    src = fetchegg {
+      name = "matchable";
+      version = "3.7";
+      sha256 = "1vc9rpb44fhn0n91hzglin986dw9zj87fikvfrd7j308z22a41yh";
+    };
+
+    buildInputs = [
+
+    ];
+  };
+
+  sendfile = eggDerivation {
+    name = "sendfile-1.8.3";
+
+    src = fetchegg {
+      name = "sendfile";
+      version = "1.8.3";
+      sha256 = "036x4xdndx7qly94afnag5b9idd1yymdm8d832w2cy054y7lxqsi";
+    };
+
+    buildInputs = [
+
+    ];
+  };
+
+  simple-md5 = eggDerivation {
+    name = "simple-md5-0.0.1";
+
+    src = fetchegg {
+      name = "simple-md5";
+      version = "0.0.1";
+      sha256 = "1h0b51p9wl1dl3pzs39hdq3hk2qnjgn8n750bgmh0651g4lzmq3i";
+    };
+
+    buildInputs = [
+
+    ];
+  };
+
+  uri-common = eggDerivation {
+    name = "uri-common-1.4";
+
+    src = fetchegg {
+      name = "uri-common";
+      version = "1.4";
+      sha256 = "01ds1gixcn4rz657x3hr4rhw2496hsjff42ninw0k39l8i1cbh7c";
+    };
+
+    buildInputs = [
+      uri-generic
+      defstruct
+      matchable
+    ];
+  };
+
+  uri-generic = eggDerivation {
+    name = "uri-generic-2.46";
+
+    src = fetchegg {
+      name = "uri-generic";
+      version = "2.46";
+      sha256 = "10ivf4xlmr6jcm00l2phq1y73hjv6g3qgr38ycc8rw56wv6sbm4g";
+    };
+
+    buildInputs = [
+      matchable
+    ];
+  };
+}

pkgs/development/compilers/chicken/4/eggs.scm

@@ -0,0 +1,5 @@
+;; Eggs used by egg2nix
+http-client
+intarweb
+matchable
+uri-common

pkgs/development/compilers/chicken/4/fetchegg/builder.sh

@@ -0,0 +1,5 @@
+echo "exporting egg ${eggName} (version $version) into $out"
+
+mkdir -p $out
+chicken-install -r "${eggName}:${version}"
+cp -r ${eggName}/* $out/

pkgs/development/compilers/chicken/4/fetchegg/default.nix

@@ -0,0 +1,33 @@
+# Fetches a chicken egg from henrietta using `chicken-install -r'
+# See: http://wiki.call-cc.org/chicken-projects/egg-index-4.html
+
+{
+  lib,
+  stdenvNoCC,
+  chicken,
+}:
+{
+  name,
+  version,
+  md5 ? "",
+  sha256 ? "",
+}:
+
+if md5 != "" then
+  throw "fetchegg does not support md5 anymore, please use sha256"
+else
+  stdenvNoCC.mkDerivation {
+    name = "chicken-${name}-export-${version}";
+    builder = ./builder.sh;
+    nativeBuildInputs = [ chicken ];
+
+    outputHashAlgo = "sha256";
+    outputHashMode = "recursive";
+    outputHash = sha256;
+
+    inherit version;
+
+    eggName = name;
+
+    impureEnvVars = lib.fetchers.proxyImpureEnvVars;
+  }

pkgs/development/compilers/chicken/4/overrides.nix

@@ -0,0 +1,10 @@
+{
+  setup-helper = {
+    preBuild = ''
+      substituteInPlace setup-helper.setup \
+        --replace "(chicken-home)" \"$out/share/\"
+
+        cat setup-helper.setup
+    '';
+  };
+}

pkgs/development/compilers/chicken/4/setup-hook.sh

@@ -0,0 +1,6 @@
+addChickenRepositoryPath() {
+    addToSearchPathWithCustomDelimiter : CHICKEN_REPOSITORY_EXTRA "$1/lib/chicken/8/"
+    export CHICKEN_INCLUDE_PATH="$1/share${CHICKEN_INCLUDE_PATH:+;$CHICKEN_INCLUDE_PATH}"
+}
+
+addEnvHooks "$targetOffset" addChickenRepositoryPath

pkgs/development/compilers/chicken/5/chicken.nix

@@ -0,0 +1,101 @@
+{
+  lib,
+  stdenv,
+  fetchurl,
+  makeWrapper,
+  darwin,
+  bootstrap-chicken ? null,
+  testers,
+}:
+
+let
+  platform =
+    with stdenv;
+    if isDarwin then
+      "macosx"
+    else if isCygwin then
+      "cygwin"
+    else if (isFreeBSD || isOpenBSD) then
+      "bsd"
+    else if isSunOS then
+      "solaris"
+    else
+      "linux"; # Should be a sane default
+in
+stdenv.mkDerivation (finalAttrs: {
+  pname = "chicken";
+  version = "5.4.0";
+
+  binaryVersion = 11;
+
+  src = fetchurl {
+    url = "https://code.call-cc.org/releases/${finalAttrs.version}/chicken-${finalAttrs.version}.tar.gz";
+    sha256 = "sha256-PF1KphwRZ79tm/nq+JHadjC6n188Fb8JUVpwOb/N7F8=";
+  };
+
+  # Disable two broken tests: "static link" and "linking tests"
+  postPatch = ''
+    sed -i tests/runtests.sh -e "/static link/,+4 { s/^/# / }"
+    sed -i tests/runtests.sh -e "/linking tests/,+11 { s/^/# / }"
+  '';
+
+  setupHook = lib.optional (bootstrap-chicken != null) ./setup-hook.sh;
+
+  makeFlags = [
+    "PLATFORM=${platform}"
+    "PREFIX=$(out)"
+    "C_COMPILER=$(CC)"
+    "CXX_COMPILER=$(CXX)"
+  ]
+  ++ (lib.optionals stdenv.hostPlatform.isDarwin [
+    "XCODE_TOOL_PATH=${darwin.binutils.bintools}/bin"
+    "LINKER_OPTIONS=-headerpad_max_install_names"
+    "POSTINSTALL_PROGRAM=install_name_tool"
+  ])
+  ++ (lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
+    "HOSTSYSTEM=${stdenv.hostPlatform.config}"
+    "TARGET_C_COMPILER=${stdenv.cc}/bin/${stdenv.cc.targetPrefix}cc"
+    "TARGET_CXX_COMPILER=${stdenv.cc}/bin/${stdenv.cc.targetPrefix}c++"
+  ]);
+
+  nativeBuildInputs = [
+    makeWrapper
+  ]
+  ++ lib.optionals (stdenv.hostPlatform.isDarwin && stdenv.hostPlatform.isAarch64) [
+    darwin.autoSignDarwinBinariesHook
+  ];
+
+  buildInputs = lib.optionals (bootstrap-chicken != null) [
+    bootstrap-chicken
+  ];
+
+  doCheck = !stdenv.hostPlatform.isDarwin;
+  postCheck = ''
+    ./csi -R chicken.pathname -R chicken.platform \
+       -p "(assert (equal? \"${toString finalAttrs.binaryVersion}\" (pathname-file (car (repository-path)))))"
+  '';
+
+  passthru.tests.version = testers.testVersion {
+    package = finalAttrs.finalPackage;
+    command = "csi -version";
+  };
+
+  meta = {
+    homepage = "https://call-cc.org/";
+    license = lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [
+      corngood
+      nagy
+      konst-aa
+    ];
+    platforms = lib.platforms.unix;
+    description = "Portable compiler for the Scheme programming language";
+    longDescription = ''
+      CHICKEN is a compiler for the Scheme programming language.
+      CHICKEN produces portable and efficient C, supports almost all
+      of the R5RS Scheme language standard, and includes many
+      enhancements and extensions. CHICKEN runs on Linux, macOS,
+      Windows, and many Unix flavours.
+    '';
+  };
+})

pkgs/development/compilers/chicken/5/default.nix

@@ -0,0 +1,90 @@
+{
+  lib,
+  newScope,
+  fetchurl,
+}:
+let
+  # Some eggs mistakenly declare dependencies on modules which are part of chicken itself and thus
+  # need not (and cannot) be installed as eggs. Instead of marking such eggs as broken, we remove
+  # these invalid dependencies.
+  invalidDependencies = [
+    "srfi-4"
+  ];
+in
+lib.makeScope newScope (self: {
+
+  fetchegg =
+    {
+      pname,
+      version,
+      sha256,
+      ...
+    }:
+    fetchurl {
+      inherit sha256;
+      url = "https://code.call-cc.org/egg-tarballs/5/${pname}/${pname}-${version}.tar.gz";
+    };
+
+  eggDerivation = self.callPackage ./eggDerivation.nix { };
+
+  chicken = self.callPackage ./chicken.nix {
+    bootstrap-chicken = self.chicken.override { bootstrap-chicken = null; };
+  };
+
+  chickenEggs = lib.recurseIntoAttrs (
+    lib.makeScope self.newScope (
+      eggself:
+      (lib.mapAttrs (
+        pname:
+        eggData@{
+          version,
+          synopsis,
+          dependencies,
+          license,
+          ...
+        }:
+        self.eggDerivation {
+          inherit pname version;
+          src = self.fetchegg (eggData // { inherit pname; });
+          buildInputs = map (x: eggself.${x}) (lib.subtractLists invalidDependencies dependencies);
+          meta.homepage = "https://wiki.call-cc.org/eggref/5/${pname}";
+          meta.description = synopsis;
+          meta.license =
+            (
+              lib.licenses
+              // {
+                "agpl" = lib.licenses.agpl3Only;
+                "artistic" = lib.licenses.artistic2;
+                "bsd" = lib.licenses.bsd3;
+                "bsd-1-clause" = lib.licenses.bsd1;
+                "bsd-2-clause" = lib.licenses.bsd2;
+                "bsd-3" = lib.licenses.bsd3;
+                "bsd-3-clause" = lib.licenses.bsd3;
+                "gpl" = lib.licenses.gpl3Only;
+                "gpl-2" = lib.licenses.gpl2Only;
+                "gplv2" = lib.licenses.gpl2Only;
+                "gpl-3" = lib.licenses.gpl3Only;
+                "gpl-3.0" = lib.licenses.gpl3Only;
+                "gplv3" = lib.licenses.gpl3Only;
+                "lgpl" = lib.licenses.lgpl3Only;
+                "lgpl-2" = lib.licenses.lgpl2Only;
+                "lgpl-2.0+" = lib.licenses.lgpl2Plus;
+                "lgpl-2.1" = lib.licenses.lgpl21Only;
+                "lgpl-2.1-or-later" = lib.licenses.lgpl21Plus;
+                "lgpl-3" = lib.licenses.lgpl3Only;
+                "lgplv3" = lib.licenses.lgpl3Only;
+                "public-domain" = lib.licenses.publicDomain;
+                "srfi" = lib.licenses.bsd3;
+                "unicode" = lib.licenses.ucd;
+                "unknown" = lib.licenses.free;
+                "zlib-acknowledgement" = lib.licenses.zlib;
+              }
+            ).${license} or license;
+        }
+      ) (lib.importTOML ./deps.toml))
+    )
+  );
+
+  egg2nix = self.callPackage ./egg2nix.nix { };
+
+})

pkgs/development/compilers/chicken/5/egg2nix.nix

@@ -0,0 +1,31 @@
+{
+  lib,
+  eggDerivation,
+  fetchFromGitHub,
+  chickenEggs,
+}:
+
+eggDerivation {
+  src = fetchFromGitHub {
+    owner = "corngood";
+    repo = "egg2nix";
+    rev = "chicken-5";
+    sha256 = "1vfnhbcnyakywgjafhs0k5kpsdnrinzvdjxpz3fkwas1jsvxq3d1";
+  };
+
+  pname = "egg2nix";
+  version = "c5-git";
+  buildInputs = with chickenEggs; [
+    args
+    matchable
+  ];
+
+  meta = {
+    description = "Generate nix-expression from CHICKEN scheme eggs";
+    mainProgram = "egg2nix";
+    homepage = "https://github.com/the-kenny/egg2nix";
+    license = lib.licenses.bsd3;
+    platforms = lib.platforms.unix;
+    maintainers = with lib.maintainers; [ corngood ];
+  };
+}

pkgs/development/compilers/chicken/5/eggDerivation.nix

@@ -0,0 +1,89 @@
+{
+  callPackage,
+  lib,
+  stdenv,
+  chicken,
+  makeWrapper,
+}:
+{
+  src,
+  buildInputs ? [ ],
+  chickenInstallFlags ? [ ],
+  cscOptions ? [ ],
+  ...
+}@args:
+
+let
+  nameVersionAssertion =
+    pred: lib.assertMsg pred "either name or both pname and version must be given";
+  pname =
+    if args ? pname then
+      assert nameVersionAssertion (!args ? name && args ? version);
+      args.pname
+    else
+      assert nameVersionAssertion (args ? name && !args ? version);
+      lib.getName args.name;
+  version = if args ? version then args.version else lib.getVersion args.name;
+  name = if args ? name then args.name else "${args.pname}-${args.version}";
+  overrides = callPackage ./overrides.nix { };
+  override = if builtins.hasAttr pname overrides then builtins.getAttr pname overrides else lib.id;
+in
+(stdenv.mkDerivation (
+  {
+    pname = "chicken-${pname}";
+    inherit version;
+    propagatedBuildInputs = buildInputs;
+    nativeBuildInputs = [
+      chicken
+      makeWrapper
+    ];
+    buildInputs = [ chicken ];
+
+    strictDeps = true;
+
+    CSC_OPTIONS = lib.concatStringsSep " " cscOptions;
+
+    buildPhase = ''
+      runHook preBuild
+      chicken-install -cached -no-install -host ${lib.escapeShellArgs chickenInstallFlags}
+      runHook postBuild
+    '';
+
+    installPhase = ''
+      runHook preInstall
+
+      export CHICKEN_INSTALL_PREFIX=$out
+      export CHICKEN_INSTALL_REPOSITORY=$out/lib/chicken/${toString chicken.binaryVersion}
+      chicken-install -cached -host ${lib.escapeShellArgs chickenInstallFlags}
+
+      # Patching generated .egg-info instead of original .egg to work around https://bugs.call-cc.org/ticket/1855
+      csi -e "(write (cons '(version \"${version}\") (read)))" < "$CHICKEN_INSTALL_REPOSITORY/${pname}.egg-info" > "${pname}.egg-info.new"
+      mv "${pname}.egg-info.new" "$CHICKEN_INSTALL_REPOSITORY/${pname}.egg-info"
+
+      for f in $out/bin/*
+      do
+        wrapProgram $f \
+          --prefix CHICKEN_REPOSITORY_PATH : "$out/lib/chicken/${toString chicken.binaryVersion}:$CHICKEN_REPOSITORY_PATH" \
+          --prefix CHICKEN_INCLUDE_PATH : "$CHICKEN_INCLUDE_PATH:$out/share" \
+          --prefix PATH : "$out/bin:${chicken}/bin:$CHICKEN_REPOSITORY_PATH"
+      done
+
+      runHook postInstall
+    '';
+
+    dontConfigure = true;
+
+    meta = {
+      inherit (chicken.meta) platforms;
+    }
+    // args.meta or { };
+  }
+  // removeAttrs args [
+    "name"
+    "pname"
+    "version"
+    "buildInputs"
+    "meta"
+  ]
+)).overrideAttrs
+  override

pkgs/development/compilers/chicken/5/overrides.nix

@@ -0,0 +1,314 @@
+{
+  stdenv,
+  pkgs,
+  lib,
+  chickenEggs,
+}:
+let
+  inherit (lib) addMetaAttrs;
+  addToNativeBuildInputs = pkg: old: {
+    nativeBuildInputs = (old.nativeBuildInputs or [ ]) ++ lib.toList pkg;
+  };
+  addToBuildInputs = pkg: old: {
+    buildInputs = (old.buildInputs or [ ]) ++ lib.toList pkg;
+  };
+  addToPropagatedBuildInputs = pkg: old: {
+    propagatedBuildInputs = (old.propagatedBuildInputs or [ ]) ++ lib.toList pkg;
+  };
+  addPkgConfig = old: {
+    nativeBuildInputs = (old.nativeBuildInputs or [ ]) ++ [ pkgs.pkg-config ];
+  };
+  addToBuildInputsWithPkgConfig = pkg: old: (addPkgConfig old) // (addToBuildInputs pkg old);
+  addToPropagatedBuildInputsWithPkgConfig =
+    pkg: old: (addPkgConfig old) // (addToPropagatedBuildInputs pkg old);
+  broken = addMetaAttrs { broken = true; };
+  brokenOnDarwin = addMetaAttrs { broken = stdenv.hostPlatform.isDarwin; };
+  addToCscOptions = opt: old: {
+    CSC_OPTIONS = lib.concatStringsSep " " ([ old.CSC_OPTIONS or "" ] ++ lib.toList opt);
+  };
+in
+{
+  breadline = addToBuildInputs pkgs.readline;
+  blas = addToBuildInputsWithPkgConfig pkgs.blas;
+  blosc = addToBuildInputs pkgs.c-blosc;
+  botan = addToBuildInputsWithPkgConfig pkgs.botan2;
+  cairo =
+    old:
+    (addToBuildInputsWithPkgConfig pkgs.cairo old)
+    // (addToPropagatedBuildInputs (with chickenEggs; [
+      srfi-1
+      srfi-13
+    ]) old);
+  cmark = addToBuildInputs pkgs.cmark;
+  epoxy =
+    old:
+    (addToPropagatedBuildInputsWithPkgConfig pkgs.libepoxy old)
+    // {
+      env.NIX_CFLAGS_COMPILE = toString [
+        (
+          if stdenv.cc.isClang then
+            "-Wno-error=incompatible-function-pointer-types"
+          else
+            "-Wno-error=incompatible-pointer-types"
+        )
+        "-Wno-error=int-conversion"
+      ];
+    };
+  espeak = addToBuildInputsWithPkgConfig pkgs.espeak-ng;
+  exif = addToBuildInputsWithPkgConfig pkgs.libexif;
+  expat =
+    old:
+    (addToBuildInputsWithPkgConfig pkgs.expat old)
+    // {
+      env.NIX_CFLAGS_COMPILE = toString [
+        (
+          if stdenv.cc.isClang then
+            "-Wno-error=incompatible-function-pointer-types"
+          else
+            "-Wno-error=incompatible-pointer-types"
+        )
+      ];
+    };
+  ezxdisp =
+    old:
+    (addToBuildInputsWithPkgConfig pkgs.xorg.libX11 old)
+    // {
+      env.NIX_CFLAGS_COMPILE = toString [
+        "-Wno-error=implicit-function-declaration"
+      ];
+    };
+  freetype = addToBuildInputsWithPkgConfig pkgs.freetype;
+  fuse = addToBuildInputsWithPkgConfig pkgs.fuse;
+  gl-math = old: {
+    env.NIX_CFLAGS_COMPILE = toString [
+      "-Wno-error=incompatible-pointer-types"
+    ];
+  };
+  gl-utils = addPkgConfig;
+  glfw3 = addToBuildInputsWithPkgConfig pkgs.glfw3;
+  glls = addPkgConfig;
+  glut =
+    old:
+    (brokenOnDarwin old)
+    // lib.optionalAttrs (!stdenv.hostPlatform.isDarwin) (
+      addToCscOptions [
+        "-I${(lib.getDev pkgs.libglut)}/include"
+        "-I${(lib.getDev pkgs.libGL)}/include"
+        "-I${(lib.getDev pkgs.libGLU)}/include"
+      ] old
+    )
+    // (addToBuildInputs pkgs.libglut old);
+  iconv = addToBuildInputs (lib.optional stdenv.hostPlatform.isDarwin pkgs.libiconv);
+  icu = addToBuildInputsWithPkgConfig pkgs.icu;
+  imlib2 = addToBuildInputsWithPkgConfig pkgs.imlib2;
+  inotify =
+    old:
+    (addToBuildInputs (lib.optional stdenv.hostPlatform.isDarwin pkgs.libinotify-kqueue) old)
+    // lib.optionalAttrs stdenv.hostPlatform.isDarwin (addToCscOptions "-L -linotify" old);
+  leveldb = addToBuildInputs pkgs.leveldb;
+  magic = addToBuildInputs pkgs.file;
+  magic-pipes = addToBuildInputs pkgs.chickenPackages_5.chickenEggs.regex;
+  mdh =
+    old:
+    (addToBuildInputs pkgs.pcre old)
+    // {
+      env.NIX_CFLAGS_COMPILE = toString [
+        "-Wno-error=implicit-function-declaration"
+        "-Wno-error=implicit-int"
+      ];
+    };
+  # missing dependency in upstream egg
+  mistie = addToPropagatedBuildInputs (with chickenEggs; [ srfi-1 ]);
+  mosquitto = addToPropagatedBuildInputs [ pkgs.mosquitto ];
+  nanomsg = addToBuildInputs pkgs.nanomsg;
+  ncurses = addToBuildInputsWithPkgConfig [ pkgs.ncurses ];
+  opencl = addToBuildInputs [
+    pkgs.opencl-headers
+    pkgs.ocl-icd
+  ];
+  openssl = addToBuildInputs pkgs.openssl;
+  plot = addToBuildInputs pkgs.plotutils;
+  postgresql = addToBuildInputsWithPkgConfig pkgs.libpq;
+  rocksdb = addToBuildInputs pkgs.rocksdb_8_3;
+  # missing dependency in upstream egg
+  s9fes-char-graphics-shapes = addToPropagatedBuildInputs (
+    with chickenEggs;
+    [
+      utf8
+      s9fes-char-graphics
+    ]
+  );
+  # missing dependency in upstream egg
+  s9fes-char-graphics = addToPropagatedBuildInputs (
+    with chickenEggs;
+    [
+      srfi-1
+      utf8
+      record-variants
+    ]
+  );
+  scheme2c-compatibility = addPkgConfig;
+  sdl-base =
+    old:
+    (
+      (addToPropagatedBuildInputsWithPkgConfig pkgs.SDL old)
+      //
+        # needed for sdl-config to be in PATH
+        (addToNativeBuildInputs pkgs.SDL old)
+    );
+  sdl2 =
+    old:
+    (
+      (addToPropagatedBuildInputsWithPkgConfig pkgs.SDL2 old)
+      //
+        # needed for sdl2-config to be in PATH
+        (addToNativeBuildInputs pkgs.SDL2 old)
+    );
+  sdl2-image =
+    old:
+    (
+      (addToPropagatedBuildInputsWithPkgConfig pkgs.SDL2_image old)
+      //
+        # needed for sdl2-config to be in PATH
+        (addToNativeBuildInputs pkgs.SDL2 old)
+    );
+  sdl2-ttf =
+    old:
+    (
+      (addToPropagatedBuildInputsWithPkgConfig pkgs.SDL2_ttf old)
+      //
+        # needed for sdl2-config to be in PATH
+        (addToNativeBuildInputs pkgs.SDL2 old)
+    );
+  soil = addToPropagatedBuildInputsWithPkgConfig pkgs.libepoxy;
+  sqlite3 = addToBuildInputs pkgs.sqlite;
+  stemmer = old: (addToBuildInputs pkgs.libstemmer old) // (addToCscOptions "-L -lstemmer" old);
+  stfl =
+    old: (addToBuildInputs [ pkgs.ncurses pkgs.stfl ] old) // (addToCscOptions "-L -lncurses" old);
+  taglib =
+    old:
+    (addToBuildInputs [ pkgs.zlib pkgs.taglib_1 ] old)
+    // (
+      # needed for tablib-config to be in PATH
+      addToNativeBuildInputs pkgs.taglib_1 old
+    );
+  uuid-lib = addToBuildInputs pkgs.libuuid;
+  webview = addToBuildInputsWithPkgConfig pkgs.webkitgtk_4_0;
+  ws-client = addToBuildInputs pkgs.zlib;
+  xlib = addToPropagatedBuildInputs pkgs.xorg.libX11;
+  yaml = addToBuildInputs pkgs.libyaml;
+  zlib = addToBuildInputs pkgs.zlib;
+  zmq = addToBuildInputs pkgs.zeromq;
+  zstd = addToBuildInputs pkgs.zstd;
+
+  # less trivial fixes, should be upstreamed
+  git =
+    old:
+    (addToBuildInputsWithPkgConfig pkgs.libgit2 old)
+    // {
+      postPatch = ''
+        substituteInPlace libgit2.scm \
+          --replace "asize" "reserved"
+      '';
+    };
+  lazy-ffi =
+    old:
+    (addToBuildInputs pkgs.libffi old)
+    // {
+      postPatch = ''
+        substituteInPlace lazy-ffi.scm \
+          --replace "ffi/ffi.h" "ffi.h"
+      '';
+    };
+  opengl =
+    old:
+    (brokenOnDarwin old)
+    // (addToBuildInputsWithPkgConfig (lib.optionals (!stdenv.hostPlatform.isDarwin) [
+      pkgs.libGL
+      pkgs.libGLU
+    ]) old)
+    // {
+      postPatch = ''
+        substituteInPlace opengl.egg \
+          --replace 'framework ' 'framework" "'
+      '';
+    };
+  posix-shm = old: {
+    postPatch = lib.optionalString stdenv.hostPlatform.isDarwin ''
+      substituteInPlace build.scm \
+        --replace "-lrt" ""
+    '';
+  };
+
+  # platform changes
+  pledge = addMetaAttrs { platforms = lib.platforms.openbsd; };
+  unveil = addMetaAttrs { platforms = lib.platforms.openbsd; };
+
+  # overrides for chicken 5.4
+  dbus =
+    old:
+    (addToBuildInputsWithPkgConfig [ pkgs.dbus ] old)
+    // {
+      # backticks in compiler options
+      # aren't supported anymore as of chicken 5.4, it seems.
+      preBuild = ''
+        substituteInPlace \
+          dbus.egg dbus.setup \
+          --replace '`pkg-config --cflags dbus-1`' "$(pkg-config --cflags dbus-1)" \
+          --replace '`pkg-config --libs dbus-1`' "$(pkg-config --libs dbus-1)"
+      '';
+    };
+  math = old: {
+    # define-values is used but not imported
+    # some breaking change happened now it needs to be done
+    # explicitly?
+    preBuild = ''
+      substituteInPlace *.scm **/*.scm \
+        --replace-quiet 'only chicken.base' 'only chicken.base define-values'
+    '';
+  };
+  socket = old: {
+    # chicken-do checks for changes to a file that doesn't exist
+    preBuild = ''
+      touch socket-config
+    '';
+  };
+
+  # mark broken
+  allegro =
+    old:
+    (broken old)
+    // {
+      # depends on 'chicken' egg, which doesn't exist, so we specify all the deps here (needs to be
+      # kept around even when marked as broken so that evaluation doesn't break due to the missing
+      # attribute).
+      propagatedBuildInputs = [
+        chickenEggs.foreigners
+      ];
+    };
+  ephem = broken;
+  canvas-draw = broken;
+  coops-utils = broken;
+  crypt = broken;
+  gemini = broken;
+  gemini-client = broken;
+  hypergiant = broken;
+  iup = broken;
+  kiwi = broken;
+  lmdb-ht = broken;
+  mpi = broken;
+  pyffi = broken;
+  qt-light = broken;
+  sundials = broken;
+  svn-client = broken;
+  tokyocabinet = broken;
+
+  # mark broken darwin
+
+  # fatal error: 'mqueue.h' file not found
+  posix-mq = brokenOnDarwin;
+  # Undefined symbols for architecture arm64: "_pthread_setschedprio"
+  pthreads = brokenOnDarwin;
+  # error: use of undeclared identifier 'B4000000'
+  stty = brokenOnDarwin;
+}

pkgs/development/compilers/chicken/5/read-egg.scm

@@ -0,0 +1,43 @@
+(import (chicken process-context)
+        (chicken format)
+        (chicken string))
+
+(define env-var get-environment-variable)
+(define ref alist-ref)
+
+(define egg (read))
+
+(printf "[~A]\n" (env-var "EGG_NAME"))
+
+(define dependencies
+  (map (lambda (dep)
+         (->string (if (list? dep)
+                       (car dep)
+                       dep)))
+       (append
+        (ref 'dependencies egg eqv? '())
+        ;; TODO separate this into `buildInputs` and `propagatedBuildInputs`
+        (ref 'build-dependencies egg eqv? '()))))
+(printf "dependencies = [~A]\n"
+        (string-intersperse (map (lambda (dep) (sprintf "~S" dep))
+                                 dependencies)
+                            ", "))
+
+(define license (ref 'license egg))
+(printf "license = ~S\n"
+        (if (not license)
+            ""
+            (string-translate (->string (car license))
+                              "ABCDEFGHIJKLMNOPQRSTUVWXYZ "
+                              "abcdefghijklmnopqrstuvwxyz-")))
+
+(printf "sha256 = ~S\n" (env-var "EGG_SHA256"))
+
+(define synopsis (ref 'synopsis egg))
+(printf "synopsis = ~S\n"
+        (if (not synopsis)
+            ""
+            (car synopsis)))
+
+(printf "version = ~S\n" (env-var "EGG_VERSION"))
+(print)

pkgs/development/compilers/chicken/5/setup-hook.sh

@@ -0,0 +1,6 @@
+addChickenRepositoryPath() {
+    addToSearchPathWithCustomDelimiter : CHICKEN_REPOSITORY_PATH "$1/lib/chicken/11"
+    addToSearchPathWithCustomDelimiter : CHICKEN_INCLUDE_PATH "$1/share"
+}
+
+addEnvHooks "$targetOffset" addChickenRepositoryPath

pkgs/development/compilers/chicken/5/update.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env nix-shell
+#! nix-shell -I nixpkgs=../../../../.. -i ysh -p oils-for-unix chicken nix-prefetch-git jq
+
+setglobal ENV.URL_PREFIX="https://code.call-cc.org/egg-tarballs/5/"
+cd $(nix-prefetch-git --deepClone --quiet \
+       https://code.call-cc.org/eggs-5-latest | jq --raw-output .path)
+
+echo "# THIS IS A GENERATED FILE.  DO NOT EDIT!" > $_this_dir/deps.toml
+for i, item in */*/*.egg {
+  setglobal ENV.EGG_NAME=$(dirname $(dirname $item))
+  setglobal ENV.EGG_VERSION=$(basename $(dirname $item))
+  setglobal ENV.EGG_URL="$[ENV.URL_PREFIX]$[ENV.EGG_NAME]/$[ENV.EGG_NAME]-$[ENV.EGG_VERSION].tar.gz"
+  setglobal ENV.EGG_SHA256=$(nix-prefetch-url $[ENV.EGG_URL])
+  csi -s $_this_dir/read-egg.scm < $item
+} >> $_this_dir/deps.toml

pkgs/development/compilers/clasp/default.nix

@@ -0,0 +1,88 @@
+{
+  lib,
+  llvmPackages_18,
+  fetchzip,
+  sbcl,
+  pkg-config,
+  fmt_9,
+  gmpxx,
+  libelf,
+  boost,
+  libunwind,
+  ninja,
+}:
+
+let
+  inherit (llvmPackages_18) stdenv llvm libclang;
+in
+
+stdenv.mkDerivation rec {
+  pname = "clasp";
+  version = "2.7.0";
+
+  src = fetchzip {
+    url = "https://github.com/clasp-developers/clasp/releases/download/${version}/clasp-${version}.tar.gz";
+    hash = "sha256-IoEwsMvY/bbb6K6git+7zRGP0DIJDROt69FBQuzApRk=";
+  };
+
+  patches = [
+    ./remove-unused-command-line-argument.patch
+  ];
+
+  # Workaround for https://github.com/clasp-developers/clasp/issues/1590
+  postPatch = ''
+    echo '(defmethod configure-unit (c (u (eql :git))))' >> src/koga/units.lisp
+  '';
+
+  nativeBuildInputs = [
+    sbcl
+    pkg-config
+    fmt_9
+    gmpxx
+    libelf
+    boost
+    libunwind
+    ninja
+    llvm
+    libclang
+  ];
+
+  ninjaFlags = [
+    "-C"
+    "build"
+  ];
+
+  configurePhase = ''
+    export SOURCE_DATE_EPOCH=1
+    export ASDF_OUTPUT_TRANSLATIONS=$(pwd):$(pwd)/__fasls
+    sbcl --script koga \
+      --skip-sync \
+      --build-mode=bytecode-faso \
+      --cc=$NIX_CC/bin/cc \
+      --cxx=$NIX_CC/bin/c++ \
+      --reproducible-build \
+      --package-path=/ \
+      --bin-path=$out/bin \
+      --lib-path=$out/lib \
+      --dylib-path=$out/lib \
+      --share-path=$out/share \
+      --pkgconfig-path=$out/lib/pkgconfig
+  '';
+
+  postInstall = ''
+    # --dylib-path not honored. Fix it in post.
+    mv $out/libclasp* $out/lib/
+  '';
+
+  meta = {
+    description = "Common Lisp implementation based on LLVM with C++ integration";
+    license = lib.licenses.lgpl21Plus;
+    teams = [ lib.teams.lisp ];
+    platforms = [
+      "x86_64-linux"
+      "x86_64-darwin"
+    ];
+    homepage = "https://github.com/clasp-developers/clasp";
+    mainProgram = "clasp";
+  };
+}

pkgs/development/compilers/clasp/remove-unused-command-line-argument.patch

@@ -0,0 +1,13 @@
+diff --git a/src/koga/units.lisp b/src/koga/units.lisp
+index 808cebd17..2bbf965fd 100644
+--- a/src/koga/units.lisp
++++ b/src/koga/units.lisp
+@@ -197,7 +197,7 @@
+                                :type :cxxflags)
+   #+darwin (append-cflags configuration "-stdlib=libc++" :type :cxxflags)
+   #+darwin (append-cflags configuration "-I/usr/local/include")
+-  #+linux (append-cflags configuration "-fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -fno-stack-protector -stdlib=libstdc++"
++  #+linux (append-cflags configuration "-fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -fno-stack-protector"
+                                        :type :cxxflags)
+   #+linux (append-cflags configuration "-fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -fno-stack-protector"
+                                        :type :cflags)

pkgs/development/compilers/cmucl/binary.nix

@@ -0,0 +1,76 @@
+{
+  lib,
+  stdenv,
+  fetchurl,
+  installShellFiles,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "cmucl-binary";
+  version = "21d";
+
+  srcs = [
+    (fetchurl {
+      url =
+        "http://common-lisp.net/project/cmucl/downloads/release/"
+        + finalAttrs.version
+        + "/cmucl-${finalAttrs.version}-x86-linux.tar.bz2";
+      hash = "sha256-RdctcqPTtQh1Yb3BrpQ8jtRFQn85OcwOt1l90H6xDZs=";
+    })
+    (fetchurl {
+      url =
+        "http://common-lisp.net/project/cmucl/downloads/release/"
+        + finalAttrs.version
+        + "/cmucl-${finalAttrs.version}-x86-linux.extra.tar.bz2";
+      hash = "sha256-zEmiW3m5VPpFgPxV1WJNCqgYRlHMovtaMXcgXyNukls=";
+    })
+  ];
+
+  sourceRoot = ".";
+
+  outputs = [
+    "out"
+    "doc"
+    "man"
+  ];
+
+  nativeBuildInputs = [
+    installShellFiles
+  ];
+
+  dontConfigure = true;
+  dontBuild = true;
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -pv $out $doc/share $man
+    mv bin lib -t $out
+    mv -v doc -t $doc/share
+    installManPage man/man1/*
+
+    runHook postInstall
+  '';
+
+  postFixup = ''
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
+      $out/bin/lisp
+  '';
+
+  meta = with lib; {
+    description = "CMU implementation of Common Lisp";
+    homepage = "http://www.cons.org/cmucl/";
+    license = licenses.publicDomain;
+    longDescription = ''
+      CMUCL is a free implementation of the Common Lisp programming language
+      which runs on most major Unix platforms.  It mainly conforms to the
+      ANSI Common Lisp standard.
+    '';
+    mainProgram = "lisp";
+    teams = [ lib.teams.lisp ];
+    platforms = [
+      "i686-linux"
+      "x86_64-linux"
+    ];
+  };
+})

pkgs/development/compilers/codon/Add-a-hash-to-the-googletest-binary.patch

@@ -0,0 +1,23 @@
+From 5c158213fc3afe39ee96be84e255c12d5886ca18 Mon Sep 17 00:00:00 2001
+From: Pavel Sobolev <paveloom@riseup.net>
+Date: Sat, 1 Apr 2023 17:38:37 +0300
+Subject: [PATCH] Add a hash to the `googletest` binary.
+
+---
+ CMakeLists.txt | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 0a06e6f..a614025 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -434,6 +434,7 @@ include(FetchContent)
+ FetchContent_Declare(
+   googletest
+   URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip
++  URL_HASH SHA256=5cf189eb6847b4f8fc603a3ffff3b0771c08eec7dd4bd961bfd45477dd13eb73
+ )
+ # For Windows: Prevent overriding the parent project's compiler/linker settings
+ set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+--
+2.39.2

pkgs/development/compilers/codon/default.nix

@@ -0,0 +1,143 @@
+{
+  cacert,
+  cmake,
+  fetchFromGitHub,
+  git,
+  lib,
+  lld,
+  ninja,
+  nix-update-script,
+  perl,
+  python3,
+  stdenv,
+}:
+
+let
+  version = "0.16.1";
+
+  src = fetchFromGitHub {
+    owner = "exaloop";
+    repo = "codon";
+    rev = "v${version}";
+    hash = "sha256-s2GqiFcekXRts8BU5CSmTrkFZ9xLqq4A5MybhB1o1Gg=";
+  };
+
+  depsDir = "deps";
+
+  codon-llvm = stdenv.mkDerivation {
+    pname = "codon-llvm";
+    version = "unstable-2022-09-23";
+
+    src = fetchFromGitHub {
+      owner = "exaloop";
+      repo = "llvm-project";
+      rev = "55b0b8fa1c9f9082b535628fc9fa6313280c0b9a";
+      hash = "sha256-03SPQgNdrpR6/JZ5aR/ntoh/FnZvCjT/6bTAcZaFafw=";
+    };
+
+    nativeBuildInputs = [
+      cmake
+      git
+      lld
+      ninja
+      python3
+    ];
+
+    cmakeFlags = [
+      "-DLLVM_ENABLE_RTTI=ON"
+      "-DLLVM_ENABLE_TERMINFO=OFF"
+      "-DLLVM_ENABLE_ZLIB=OFF"
+      "-DLLVM_INCLUDE_TESTS=OFF"
+      "-DLLVM_TARGETS_TO_BUILD=all"
+      "-DLLVM_USE_LINKER=lld"
+      "-S ../llvm"
+    ];
+  };
+
+  codon-deps = stdenv.mkDerivation {
+    name = "codon-deps-${version}.tar.gz";
+
+    inherit src;
+
+    nativeBuildInputs = [
+      cacert
+      cmake
+      git
+      perl
+      python3
+    ];
+
+    dontBuild = true;
+
+    cmakeFlags = [
+      "-DCPM_DOWNLOAD_ALL=ON"
+      "-DCPM_SOURCE_CACHE=${depsDir}"
+      "-DLLVM_DIR=${codon-llvm}/lib/cmake/llvm"
+    ];
+
+    installPhase = ''
+      # Prune the `.git` directories
+      find ${depsDir} -name .git -type d -prune -exec rm -rf {} \;;
+      # Build a reproducible tar, per instructions at https://reproducible-builds.org/docs/archives/
+      tar --owner=0 --group=0 --numeric-owner --format=gnu \
+          --sort=name --mtime="@$SOURCE_DATE_EPOCH" \
+          -czf $out \
+            ${depsDir} \
+            cmake \
+            _deps/googletest-subbuild/googletest-populate-prefix/src/*.zip
+    '';
+
+    outputHash =
+      if stdenv.hostPlatform.isDarwin then
+        "sha256-KfemYV42xBAhsPbwTkzdc3GxCVHiWRbyUZORPWxx4vg="
+      else
+        "sha256-a1zGSpbMjfQBrcgW/aiIdKX8+uI3p/S9pgZjHe2HtWs=";
+
+    outputHashAlgo = "sha256";
+  };
+in
+stdenv.mkDerivation {
+  pname = "codon";
+
+  inherit src version;
+
+  patches = [
+    # Without the hash, CMake will try to replace the `.zip` file
+    ./Add-a-hash-to-the-googletest-binary.patch
+  ];
+
+  nativeBuildInputs = [
+    cmake
+    git
+    lld
+    ninja
+    perl
+    python3
+  ];
+
+  postUnpack = ''
+    mkdir -p $sourceRoot/build
+    tar -xf ${codon-deps} -C $sourceRoot/build
+  '';
+
+  cmakeFlags = [
+    "-DCPM_SOURCE_CACHE=${depsDir}"
+    "-DLLVM_DIR=${codon-llvm}/lib/cmake/llvm"
+    "-DLLVM_USE_LINKER=lld"
+  ];
+
+  postInstall = lib.optionalString stdenv.hostPlatform.isDarwin ''
+    ln -s $out/lib/codon/*.dylib $out/lib/
+  '';
+
+  passthru.updateScript = nix-update-script { };
+
+  meta = {
+    description = "High-performance, zero-overhead, extensible Python compiler using LLVM";
+    homepage = "https://docs.exaloop.io/codon";
+    maintainers = [ ];
+    license = lib.licenses.bsl11;
+    platforms = lib.platforms.all;
+    broken = true; # `codon-llvm` build fails on darwin and linux
+  };
+}

pkgs/development/compilers/corretto/11.nix

@@ -0,0 +1,38 @@
+{
+  fetchFromGitHub,
+  gradle_7,
+  jdk11,
+  lib,
+  stdenv,
+  rsync,
+  runCommand,
+  testers,
+}:
+
+let
+  corretto = import ./mk-corretto.nix rec {
+    inherit
+      lib
+      stdenv
+      rsync
+      runCommand
+      testers
+      ;
+    jdk = jdk11;
+    gradle = gradle_7;
+    extraConfig = [
+      # jdk11 is built with --disable-warnings-as-errors (see openjdk/11.nix)
+      # because of several compile errors. We need to include this parameter for
+      # Corretto, too.
+      "--disable-warnings-as-errors"
+    ];
+    version = "11.0.26.4.1";
+    src = fetchFromGitHub {
+      owner = "corretto";
+      repo = "corretto-11";
+      rev = version;
+      hash = "sha256-buJlSvmyOVeMwaP9oDcHhG+Sabr1exf0nRUt4O7MaIY=";
+    };
+  };
+in
+corretto

pkgs/development/compilers/corretto/17.nix

@@ -0,0 +1,43 @@
+{
+  fetchFromGitHub,
+  fetchurl,
+  gradle_7,
+  jdk17,
+  lib,
+  stdenv,
+  rsync,
+  runCommand,
+  testers,
+}:
+
+let
+  corretto = import ./mk-corretto.nix rec {
+    inherit
+      lib
+      stdenv
+      rsync
+      runCommand
+      testers
+      ;
+    jdk = jdk17;
+    gradle = gradle_7;
+    version = "17.0.14.7.1";
+    src = fetchFromGitHub {
+      owner = "corretto";
+      repo = "corretto-17";
+      rev = version;
+      hash = "sha256-ohQrguEJ8QvTaNjyQxKFujGhXNxCQTGkLILurzD7cy0=";
+    };
+  };
+in
+corretto.overrideAttrs (
+  final: prev: {
+    # Corretto17 has incorporated this patch already so it fails to apply.
+    # We thus skip it here.
+    # See https://github.com/corretto/corretto-17/pull/158
+    patches = lib.remove (fetchurl {
+      url = "https://git.alpinelinux.org/aports/plain/community/openjdk17/FixNullPtrCast.patch?id=41e78a067953e0b13d062d632bae6c4f8028d91c";
+      sha256 = "sha256-LzmSew51+DyqqGyyMw2fbXeBluCiCYsS1nCjt9hX6zo=";
+    }) (prev.patches or [ ]);
+  }
+)

pkgs/development/compilers/corretto/21.nix

@@ -0,0 +1,33 @@
+{
+  corretto21,
+  fetchFromGitHub,
+  gradle_7,
+  jdk21,
+  lib,
+  stdenv,
+  rsync,
+  runCommand,
+  testers,
+}:
+
+let
+  corretto = import ./mk-corretto.nix rec {
+    inherit
+      lib
+      stdenv
+      rsync
+      runCommand
+      testers
+      ;
+    jdk = jdk21;
+    gradle = gradle_7;
+    version = "21.0.6.7.1";
+    src = fetchFromGitHub {
+      owner = "corretto";
+      repo = "corretto-21";
+      rev = version;
+      hash = "sha256-kF7Quf8bU5scfunmwfEYLkje/jEJOx7CFnBIUWCovzI=";
+    };
+  };
+in
+corretto

pkgs/development/compilers/corretto/mk-corretto.nix

@@ -0,0 +1,126 @@
+{
+  jdk,
+  version,
+  src,
+  lib,
+  stdenv,
+  gradle,
+  extraConfig ? [ ],
+  rsync,
+  runCommand,
+  testers,
+}:
+
+# Each Corretto version is based on a corresponding OpenJDK version. So
+# building Corretto is more or less the same as building OpenJDK. Hence, the
+# Corretto derivation overrides the corresponding OpenJDK derivation in order
+# to have access to all the version-specific fixes for the various OpenJDK
+# builds. However, Corretto uses `gradle` as build tool (which in turn will
+# invoke `make`). The configure/build phases are adapted as needed.
+
+# The version scheme is different between OpenJDK & Corretto.
+# See https://github.com/corretto/corretto-17/blob/release-17.0.8.8.1/build.gradle#L40
+# "major.minor.security.build.revision"
+let
+  majorVersion = builtins.head (lib.strings.splitString "." version); # same as "featureVersion" for OpenJDK
+  pname = "corretto${majorVersion}";
+in
+jdk.overrideAttrs (
+  finalAttrs: oldAttrs: {
+    inherit pname version src;
+    name = "${pname}-${version}";
+
+    nativeBuildInputs = oldAttrs.nativeBuildInputs ++ [
+      jdk
+      gradle
+      rsync
+    ];
+
+    dontConfigure = true;
+
+    postPatch =
+      let
+        extra_config = builtins.concatStringsSep " " extraConfig;
+      in
+      ''
+        # The rpm/deb task definitions require a Gradle plugin which we don't
+        # have and so the build fails. We'll simply remove them here because
+        # they are not needed anyways.
+        rm -rf installers/linux/universal/{rpm,deb}
+
+        # `/usr/bin/rsync` is invoked to copy the source tree. We don't have that.
+        for file in $(find installers -name "build.gradle"); do
+          substituteInPlace $file --replace-warn "workingDir '/usr/bin'" "workingDir '.'"
+        done
+
+        gradleFlagsArray+=(-Pcorretto.extra_config="${extra_config}")
+      '';
+
+    # since we dontConfigure, we must run this manually
+    preBuild = "gradleConfigureHook";
+
+    # The Linux installer is placed at linux/universal/tar whereas the MacOS
+    # one is at mac/tar.
+    gradleBuildTask =
+      if stdenv.hostPlatform.isDarwin then
+        ":installers:mac:tar:build"
+      else
+        ":installers:linux:universal:tar:packageBuildResults";
+
+    postBuild = ''
+      # Prepare for the installPhase so that it looks like if a normal
+      # OpenJDK had been built.
+      dir=build/jdkImageName/images
+      mkdir -p $dir
+      file=$(find ./installers -name 'amazon-corretto-${version}*.tar.gz')
+      tar -xzf $file -C $dir
+      mv $dir/amazon-corretto-* $dir/jdk
+    ''
+    + oldAttrs.postBuild or "";
+
+    installPhase = oldAttrs.installPhase + ''
+      # The installPhase will place everything in $out/lib/openjdk and
+      # reference through symlinks. We don't rewrite the installPhase but at
+      # least move the folder to convey that this is not OpenJDK anymore.
+      mv $out/lib/openjdk $out/lib/corretto
+      ln -s $out/lib/corretto $out/lib/openjdk
+    '';
+
+    passthru =
+      let
+        pkg = finalAttrs.finalPackage;
+      in
+      oldAttrs.passthru
+      // {
+        tests = {
+          version = testers.testVersion { package = pkg; };
+          vendor = runCommand "${pname}-vendor" { nativeBuildInputs = [ pkg ]; } ''
+            output=$(${pkg.meta.mainProgram} -XshowSettings:properties -version 2>&1 | grep vendor)
+            grep -Fq "java.vendor = Amazon.com Inc." - <<< "$output" && touch $out
+          '';
+          compiler = runCommand "${pname}-compiler" { nativeBuildInputs = [ pkg ]; } ''
+            cat << EOF  > Main.java
+            class Main {
+                public static void main(String[] args) {
+                    System.out.println("Hello, World!");
+                }
+            }
+            EOF
+            ${pkg}/bin/javac Main.java
+            ${pkg}/bin/java Main | grep -q "Hello, World!" && touch $out
+          '';
+        };
+      };
+
+    # Some of the OpenJDK derivation set their `pos` by hand. We need to
+    # overwrite this in order to point to Corretto, not OpenJDK.
+    pos = __curPos;
+    meta = oldAttrs.meta // {
+      homepage = "https://aws.amazon.com/corretto";
+      license = lib.licenses.gpl2Only;
+      description = "Amazon's distribution of OpenJDK";
+      maintainers = with lib.maintainers; [ rollf ];
+      teams = [ ];
+    };
+  }
+)

pkgs/development/compilers/crystal/build-package.nix

@@ -0,0 +1,210 @@
+{
+  stdenv,
+  lib,
+  crystal,
+  pcre2,
+  shards,
+  git,
+  pkg-config,
+  which,
+  linkFarm,
+  fetchgit,
+  fetchFromGitHub,
+  installShellFiles,
+  removeReferencesTo,
+}:
+
+{
+  # Some projects do not include a lock file, so you can pass one
+  lockFile ? null,
+  # Generate shards.nix with `nix-shell -p crystal2nix --run crystal2nix` in the projects root
+  shardsFile ? null,
+  # We support different builders. To make things more straight forward, make it
+  # user selectable instead of trying to autodetect
+  format ? "make",
+  installManPages ? true,
+  # Specify binaries to build in the form { foo.src = "src/foo.cr"; }
+  # The default `crystal build` options can be overridden with { foo.options = [ "--optionname" ]; }
+  crystalBinaries ? { },
+  enableParallelBuilding ? true,
+  # Copy all shards dependencies instead of symlinking and add write permissions
+  # to make environment more local-like
+  copyShardDeps ? false,
+  ...
+}@args:
+
+assert (
+  builtins.elem format [
+    "make"
+    "crystal"
+    "shards"
+  ]
+);
+let
+  mkDerivationArgs = removeAttrs args [
+    "format"
+    "installManPages"
+    "lockFile"
+    "shardsFile"
+    "crystalBinaries"
+  ];
+
+  crystalLib = linkFarm "crystal-lib" (
+    lib.mapAttrsToList (name: value: {
+      inherit name;
+      path = if (builtins.hasAttr "url" value) then fetchgit value else fetchFromGitHub value;
+    }) (import shardsFile)
+  );
+
+  # We no longer use --no-debug in accordance with upstream's recommendation
+  defaultOptions = [
+    "--release"
+    "--progress"
+    "--verbose"
+  ];
+
+  buildDirectly = shardsFile == null || crystalBinaries != { };
+
+  mkCrystalBuildArgs =
+    bin: attrs:
+    lib.concatStringsSep " " (
+      [
+        "crystal"
+        "build"
+      ]
+      ++ lib.optionals enableParallelBuilding [
+        "--threads"
+        "$NIX_BUILD_CORES"
+      ]
+      ++ [
+        "-o"
+        bin
+        (attrs.src or (throw "No source file for crystal binary ${bin} provided"))
+        (lib.concatStringsSep " " (attrs.options or defaultOptions))
+      ]
+    );
+
+in
+stdenv.mkDerivation (
+  mkDerivationArgs
+  // {
+
+    configurePhase =
+      args.configurePhase or (lib.concatStringsSep "\n" (
+        [
+          "runHook preConfigure"
+        ]
+        ++ lib.optional (lockFile != null) "cp ${lockFile} ./shard.lock"
+        ++ lib.optionals (shardsFile != null) [
+          "test -e lib || mkdir lib"
+          (
+            if copyShardDeps then
+              "for d in ${crystalLib}/*; do cp -r $d/ lib/; done; chmod -R +w lib/"
+            else
+              "for d in ${crystalLib}/*; do ln -s $d lib/; done"
+          )
+          "cp shard.lock lib/.shards.info"
+        ]
+        ++ [ "runHook postConfigure" ]
+      ));
+
+    CRFLAGS = lib.concatStringsSep " " defaultOptions;
+
+    PREFIX = placeholder "out";
+
+    inherit enableParallelBuilding;
+    strictDeps = true;
+    buildInputs =
+      args.buildInputs or [ ]
+      ++ [ crystal ]
+      ++ lib.optional (lib.versionAtLeast crystal.version "1.8") pcre2;
+
+    nativeBuildInputs =
+      args.nativeBuildInputs or [ ]
+      ++ [
+        crystal
+        git
+        installShellFiles
+        removeReferencesTo
+        pkg-config
+        which
+      ]
+      ++ lib.optional (format != "crystal") shards;
+
+    buildPhase =
+      args.buildPhase or (lib.concatStringsSep "\n" (
+        [
+          "runHook preBuild"
+        ]
+        ++ lib.optional (format == "make") "make \${buildTargets:-build} $makeFlags"
+        ++ lib.optionals (format == "crystal") (lib.mapAttrsToList mkCrystalBuildArgs crystalBinaries)
+        ++
+          lib.optional (format == "shards")
+            "shards build --local --production ${lib.concatStringsSep " " (args.options or defaultOptions)}"
+        ++ [ "runHook postBuild" ]
+      ));
+
+    installPhase =
+      args.installPhase or (lib.concatStringsSep "\n" (
+        [
+          "runHook preInstall"
+        ]
+        ++ lib.optional (format == "make") "make \${installTargets:-install} $installFlags"
+        ++ lib.optionals (format == "crystal") (
+          map (bin: ''
+            install -Dm555 ${
+              lib.escapeShellArgs [
+                bin
+                "${placeholder "out"}/bin/${bin}"
+              ]
+            }
+          '') (lib.attrNames crystalBinaries)
+        )
+        ++ lib.optional (format == "shards") "install -Dm555 bin/* -t $out/bin"
+        ++ [
+          ''
+            for f in README* *.md LICENSE; do
+              test -f $f && install -Dm444 $f -t $out/share/doc/${args.pname}
+            done
+          ''
+        ]
+        ++ (lib.optional installManPages ''
+          if [ -d man ]; then
+            installManPage man/*.?
+          fi
+        '')
+        ++ [
+          "remove-references-to -t ${lib.getLib crystal} $out/bin/*"
+          "runHook postInstall"
+        ]
+      ));
+
+    doCheck = args.doCheck or true;
+
+    checkPhase =
+      args.checkPhase or (lib.concatStringsSep "\n" (
+        [
+          "runHook preCheck"
+        ]
+        ++ lib.optional (format == "make") "make \${checkTarget:-test} $checkFlags"
+        ++ lib.optional (format != "make") "crystal \${checkTarget:-spec} $checkFlags"
+        ++ [ "runHook postCheck" ]
+      ));
+
+    doInstallCheck = args.doInstallCheck or true;
+
+    installCheckPhase =
+      args.installCheckPhase or ''
+        for f in $out/bin/*; do
+          if [ $f == $out/bin/*.dwarf ]; then
+            continue
+          fi
+          $f --help > /dev/null
+        done
+      '';
+
+    meta = args.meta or { } // {
+      platforms = args.meta.platforms or crystal.meta.platforms;
+    };
+  }
+)

pkgs/development/compilers/crystal/default.nix

@@ -0,0 +1,329 @@
+{
+  stdenv,
+  callPackage,
+  fetchFromGitHub,
+  fetchurl,
+  lib,
+  replaceVars,
+  # Dependencies
+  boehmgc,
+  coreutils,
+  git,
+  gmp,
+  hostname,
+  libevent,
+  libiconv,
+  libxml2,
+  libyaml,
+  libffi,
+  llvmPackages_19,
+  llvmPackages_20,
+  llvmPackages_21,
+  makeWrapper,
+  openssl,
+  pcre2,
+  pkg-config,
+  installShellFiles,
+  readline,
+  tzdata,
+  which,
+  zlib,
+}:
+
+# We need to keep around at least the latest version released with a stable
+# NixOS
+let
+  archs = {
+    x86_64-linux = "linux-x86_64";
+    i686-linux = "linux-i686";
+    x86_64-darwin = "darwin-universal";
+    aarch64-darwin = "darwin-universal";
+    aarch64-linux = "linux-aarch64";
+  };
+
+  arch = archs.${stdenv.system} or (throw "system ${stdenv.system} not supported");
+
+  nativeCheckInputs = [
+    git
+    gmp
+    openssl
+    readline
+    libxml2
+    libyaml
+    libffi
+  ];
+
+  binaryUrl =
+    version: rel:
+    if arch == archs.aarch64-linux then
+      "https://dev.alpinelinux.org/archive/crystal/crystal-${version}-aarch64-alpine-linux-musl.tar.gz"
+    else
+      "https://github.com/crystal-lang/crystal/releases/download/${version}/crystal-${version}-${toString rel}-${arch}.tar.gz";
+
+  genericBinary =
+    {
+      version,
+      sha256s,
+      rel ? 1,
+    }:
+    stdenv.mkDerivation rec {
+      pname = "crystal-binary";
+      inherit version;
+
+      src = fetchurl {
+        url = binaryUrl version rel;
+        sha256 = sha256s.${stdenv.system};
+      };
+
+      buildCommand = ''
+        mkdir -p $out
+        tar --strip-components=1 -C $out -xf ${src}
+        patchShebangs $out/bin/crystal
+      '';
+
+      meta.platforms = lib.attrNames sha256s;
+    };
+
+  generic =
+    {
+      version,
+      sha256,
+      binary,
+      llvmPackages,
+      doCheck ? true,
+      extraBuildInputs ? [ ],
+      buildFlags ? [
+        "all"
+        "docs"
+        "release=1"
+      ],
+    }:
+    stdenv.mkDerivation (finalAttrs: {
+      pname = "crystal";
+      inherit buildFlags doCheck version;
+
+      src = fetchFromGitHub {
+        owner = "crystal-lang";
+        repo = "crystal";
+        rev = version;
+        inherit sha256;
+      };
+
+      patches = [
+        (replaceVars ./tzdata.patch {
+          inherit tzdata;
+        })
+      ];
+
+      outputs = [
+        "out"
+        "lib"
+        "bin"
+      ];
+
+      postPatch = ''
+        export TMP=$(mktemp -d)
+        export HOME=$TMP
+        export TMPDIR=$TMP
+        mkdir -p $HOME/test
+
+        # Add dependency of crystal to docs to avoid issue on flag changes between releases
+        # https://github.com/crystal-lang/crystal/pull/8792#issuecomment-614004782
+        substituteInPlace Makefile \
+          --replace 'docs: ## Generate standard library documentation' 'docs: crystal ## Generate standard library documentation'
+
+        mkdir -p $TMP/crystal
+
+        substituteInPlace spec/std/file_spec.cr \
+          --replace '/bin/ls' '${coreutils}/bin/ls' \
+          --replace '/usr/share' "$TMP/crystal" \
+          --replace '/usr' "$TMP" \
+          --replace '/tmp' "$TMP"
+
+        substituteInPlace spec/std/process_spec.cr \
+          --replace '/bin/cat' '${coreutils}/bin/cat' \
+          --replace '/bin/ls' '${coreutils}/bin/ls' \
+          --replace '/usr/bin/env' '${coreutils}/bin/env' \
+          --replace '"env"' '"${coreutils}/bin/env"' \
+          --replace '/usr' "$TMP" \
+          --replace '/tmp' "$TMP"
+
+        substituteInPlace spec/std/system_spec.cr \
+          --replace '`hostname`' '`${hostname}/bin/hostname`'
+
+        # See https://github.com/crystal-lang/crystal/issues/8629
+        substituteInPlace spec/std/socket/udp_socket_spec.cr \
+          --replace 'it "joins and transmits to multicast groups"' 'pending "joins and transmits to multicast groups"'
+
+      ''
+      + lib.optionalString (stdenv.cc.isClang && (stdenv.cc.libcxx != null)) ''
+        # Darwin links against libc++ not libstdc++. Newer versions of clang (12+) require
+        # libc++abi to be linked explicitly (see https://github.com/NixOS/nixpkgs/issues/166205).
+        substituteInPlace src/llvm/lib_llvm.cr \
+          --replace '@[Link("stdc++")]' '@[Link("c++")]'
+      '';
+
+      # Defaults are 4
+      preBuild = ''
+        export CRYSTAL_WORKERS=$NIX_BUILD_CORES
+        export threads=$NIX_BUILD_CORES
+        export CRYSTAL_CACHE_DIR=$TMP
+        export MACOSX_DEPLOYMENT_TARGET=10.11
+        export SOURCE_DATE_EPOCH="$(<src/SOURCE_DATE_EPOCH)"
+      '';
+
+      strictDeps = true;
+      nativeBuildInputs = [
+        binary
+        makeWrapper
+        which
+        pkg-config
+        llvmPackages.llvm
+        installShellFiles
+      ];
+      buildInputs = [
+        boehmgc
+        pcre2
+        libevent
+        libyaml
+        zlib
+        libxml2
+        openssl
+      ]
+      ++ extraBuildInputs
+      ++ lib.optionals stdenv.hostPlatform.isDarwin [ libiconv ];
+
+      makeFlags = [
+        "CRYSTAL_CONFIG_VERSION=${version}"
+        "progress=1"
+      ];
+
+      LLVM_CONFIG = "${llvmPackages.llvm.dev}/bin/llvm-config";
+
+      FLAGS = [
+        "--single-module" # needed for deterministic builds
+      ];
+
+      # This makes sure we don't keep depending on the previous version of
+      # crystal used to build this one.
+      CRYSTAL_LIBRARY_PATH = "${placeholder "lib"}/crystal";
+
+      # We *have* to add `which` to the PATH or crystal is unable to build
+      # stuff later if which is not available.
+      installPhase = ''
+        runHook preInstall
+
+        install -Dm755 .build/crystal $bin/bin/crystal
+        wrapProgram $bin/bin/crystal \
+          --suffix PATH : ${
+            lib.makeBinPath [
+              pkg-config
+              llvmPackages.clang
+              which
+            ]
+          } \
+          --suffix CRYSTAL_PATH : lib:$lib/crystal \
+          --suffix PKG_CONFIG_PATH : ${
+            lib.makeSearchPathOutput "dev" "lib/pkgconfig" finalAttrs.buildInputs
+          } \
+          --suffix CRYSTAL_LIBRARY_PATH : ${lib.makeLibraryPath finalAttrs.buildInputs}
+        install -dm755 $lib/crystal
+        cp -r src/* $lib/crystal/
+
+        install -dm755 $out/share/doc/crystal/api
+        cp -r docs/* $out/share/doc/crystal/api/
+        cp -r samples $out/share/doc/crystal/
+
+        installShellCompletion --cmd ${finalAttrs.meta.mainProgram} etc/completion.*
+
+        installManPage man/crystal.1
+
+        install -Dm644 -t $out/share/licenses/crystal LICENSE README.md
+
+        mkdir -p $out
+        ln -s $bin/bin $out/bin
+        ln -s $bin/share/bash-completion $out/share/bash-completion
+        ln -s $bin/share/zsh $out/share/zsh
+        ln -s $bin/share/fish $out/share/fish
+        ln -s $lib $out/lib
+
+        runHook postInstall
+      '';
+
+      enableParallelBuilding = true;
+
+      dontStrip = true;
+
+      checkTarget = "compiler_spec";
+
+      preCheck = ''
+        export LIBRARY_PATH=${lib.makeLibraryPath nativeCheckInputs}:$LIBRARY_PATH
+        export PATH=${lib.makeBinPath nativeCheckInputs}:$PATH
+      '';
+
+      passthru.buildBinary = binary;
+      passthru.buildCrystalPackage = callPackage ./build-package.nix {
+        crystal = finalAttrs.finalPackage;
+      };
+      passthru.llvmPackages = llvmPackages;
+
+      meta = with lib; {
+        inherit (binary.meta) platforms;
+        description = "Compiled language with Ruby like syntax and type inference";
+        mainProgram = "crystal";
+        homepage = "https://crystal-lang.org/";
+        license = licenses.asl20;
+        maintainers = with maintainers; [
+          david50407
+          manveru
+          peterhoeg
+          donovanglover
+        ];
+      };
+    });
+in
+rec {
+  binaryCrystal_1_10 = genericBinary {
+    version = "1.10.1";
+    sha256s = {
+      x86_64-linux = "sha256-F0LjdV02U9G6B8ApHxClF/o5KvhxMNukSX7Z2CwSNIs=";
+      aarch64-darwin = "sha256-5kkObQl0VIO6zqQ8TYl0JzYyUmwfmPE9targpfwseSQ=";
+      x86_64-darwin = "sha256-5kkObQl0VIO6zqQ8TYl0JzYyUmwfmPE9targpfwseSQ=";
+      aarch64-linux = "sha256-AzFz+nrU/HJmCL1hbCKXf5ej/uypqV1GJPVLQ4J3778=";
+    };
+  };
+
+  crystal_1_14 = generic {
+    version = "1.14.1";
+    sha256 = "sha256-cQWK92BfksOW8GmoXn4BmPGJ7CLyLAeKccOffQMh5UU=";
+    binary = binaryCrystal_1_10;
+    llvmPackages = llvmPackages_19;
+    doCheck = false; # Some compiler spec problems on x86-64_linux with the .0 release
+  };
+
+  crystal_1_15 = generic {
+    version = "1.15.1";
+    sha256 = "sha256-L/Q8yZdDq/wn4kJ+zpLfi4pxznAtgjxTCbLnEiCC2K0=";
+    binary = binaryCrystal_1_10;
+    llvmPackages = llvmPackages_19;
+    doCheck = false;
+  };
+
+  crystal_1_16 = generic {
+    version = "1.16.3";
+    sha256 = "sha256-U9H1tHUMyDNicZnXzEccDki5bGXdV0B2Wu2PyCksPVI=";
+    binary = binaryCrystal_1_10;
+    llvmPackages = llvmPackages_20;
+    doCheck = false;
+  };
+
+  crystal_1_17 = generic {
+    version = "1.17.1";
+    sha256 = "sha256-+wHhozPhpIsfQy1Lw+V48zvuWCfXzT4IC9KA1AU/DLw=";
+    binary = binaryCrystal_1_10;
+    llvmPackages = llvmPackages_21;
+    doCheck = false;
+  };
+
+  crystal = crystal_1_16;
+}

pkgs/development/compilers/crystal/tzdata.patch

@@ -0,0 +1,12 @@
+diff --git a/src/crystal/system/unix/time.cr b/src/crystal/system/unix/time.cr
+index 333b66075..1c29a0e55 100644
+--- a/src/crystal/system/unix/time.cr
++++ b/src/crystal/system/unix/time.cr
+@@ -43,6 +43,7 @@ module Crystal::System::Time
+   # Many systems use /usr/share/zoneinfo, Solaris 2 has
+   # /usr/share/lib/zoneinfo, IRIX 6 has /usr/lib/locale/TZ.
+   ZONE_SOURCES = {
++    "@tzdata@/share/zoneinfo/",
+     "/usr/share/zoneinfo/",
+     "/usr/share/lib/zoneinfo/",
+     "/usr/lib/locale/TZ/",

pkgs/development/compilers/dart/default.nix

@@ -0,0 +1,100 @@
+{
+  lib,
+  stdenv,
+  fetchurl,
+  unzip,
+  bintools,
+  versionCheckHook,
+  runCommand,
+  cctools,
+  darwin,
+  sources ? import ./sources.nix { inherit fetchurl; },
+  version ? sources.versionUsed,
+}:
+
+assert sources != null && (builtins.isAttrs sources);
+stdenv.mkDerivation (finalAttrs: {
+  pname = "dart";
+  inherit version;
+
+  nativeBuildInputs = [ unzip ];
+
+  src =
+    sources."${version}-${stdenv.hostPlatform.system}"
+      or (throw "unsupported version/system: ${version}/${stdenv.hostPlatform.system}");
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -R . $out
+  ''
+  + lib.optionalString (stdenv.hostPlatform.isLinux) ''
+    find $out/bin -executable -type f -exec patchelf --set-interpreter ${bintools.dynamicLinker} {} \;
+  ''
+  + ''
+    runHook postInstall
+  '';
+
+  dontStrip = true;
+
+  doInstallCheck = true;
+
+  nativeInstallCheckInputs = [ versionCheckHook ];
+
+  versionCheckProgramArg = "--version";
+
+  passthru = {
+    updateScript = ./update.sh;
+    tests = {
+      testCreate = runCommand "dart-test-create" { nativeBuildInputs = [ finalAttrs.finalPackage ]; } ''
+        PROJECTNAME="dart_test_project"
+        dart create --no-pub $PROJECTNAME
+
+        [[ -d $PROJECTNAME ]]
+        [[ -f $PROJECTNAME/bin/$PROJECTNAME.dart ]]
+        touch $out
+      '';
+
+      testCompile =
+        runCommand "dart-test-compile"
+          {
+            nativeBuildInputs = [
+              finalAttrs.finalPackage
+            ]
+            ++ lib.optionals stdenv.hostPlatform.isDarwin [
+              cctools
+              darwin.sigtool
+            ];
+          }
+          ''
+            HELLO_MESSAGE="Hello, world!"
+            echo "void main() => print('$HELLO_MESSAGE');" > hello.dart
+            dart compile exe hello.dart
+            PROGRAM_OUT=$(./hello.exe)
+
+            [[ "$PROGRAM_OUT" == "$HELLO_MESSAGE" ]]
+            touch $out
+          '';
+    };
+  };
+
+  meta = {
+    homepage = "https://dart.dev";
+    maintainers = with lib.maintainers; [ grburst ];
+    description = "Scalable programming language, with robust libraries and runtimes, for building web, server, and mobile apps";
+    longDescription = ''
+      Dart is a class-based, single inheritance, object-oriented language
+      with C-style syntax. It offers compilation to JavaScript, interfaces,
+      mixins, abstract classes, reified generics, and optional typing.
+    '';
+    mainProgram = "dart";
+    platforms = [
+      "x86_64-linux"
+      "aarch64-linux"
+      "x86_64-darwin"
+      "aarch64-darwin"
+    ];
+    sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
+    license = lib.licenses.bsd3;
+  };
+})

pkgs/development/compilers/dart/package-source-builders/default.nix

@@ -0,0 +1,25 @@
+{ callPackage }:
+
+{
+  file_picker = callPackage ./file_picker { };
+  flutter_discord_rpc = callPackage ./flutter_discord_rpc { };
+  flutter_secure_storage_linux = callPackage ./flutter-secure-storage-linux { };
+  flutter_vodozemac = callPackage ./flutter_vodozemac { };
+  flutter_volume_controller = callPackage ./flutter_volume_controller { };
+  handy_window = callPackage ./handy-window { };
+  matrix = callPackage ./matrix { };
+  media_kit_libs_linux = callPackage ./media_kit_libs_linux { };
+  olm = callPackage ./olm { };
+  objectbox_flutter_libs = callPackage ./objectbox_flutter_libs { };
+  pdfrx = callPackage ./pdfrx { };
+  printing = callPackage ./printing { };
+  rhttp = callPackage ./rhttp { };
+  sentry_flutter = callPackage ./sentry_flutter { };
+  sqlcipher_flutter_libs = callPackage ./sqlcipher_flutter_libs { };
+  sqlite3 = callPackage ./sqlite3 { };
+  sqlite3_flutter_libs = callPackage ./sqlite3_flutter_libs { };
+  system_tray = callPackage ./system-tray { };
+  super_native_extensions = callPackage ./super_native_extensions { };
+  volume_controller = callPackage ./volume_controller { };
+  xdg_directories = callPackage ./xdg_directories { };
+}

pkgs/development/compilers/dart/package-source-builders/file_picker/default.nix

@@ -0,0 +1,26 @@
+{
+  lib,
+  stdenv,
+  zenity,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation {
+  pname = "file_picker";
+  inherit version src;
+  inherit (src) passthru;
+
+  postPatch = lib.optionalString (lib.versionOlder version "10.3.0") ''
+    substituteInPlace lib/src/linux/file_picker_linux.dart \
+        --replace-fail "isExecutableOnPath('zenity')" "'${lib.getExe zenity}'"
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r . $out
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/flutter-secure-storage-linux/default.nix

@@ -0,0 +1,27 @@
+{
+  stdenv,
+  libsecret,
+  jsoncpp,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation {
+  pname = "flutter-secure-storage-linux";
+  inherit version src;
+  inherit (src) passthru;
+
+  propagatedBuildInputs = [
+    libsecret
+    jsoncpp
+  ];
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p "$out"
+    ln -s '${src}'/* "$out"
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/flutter_discord_rpc/cargokit.patch

@@ -0,0 +1,90 @@
+--- old/cargokit/cmake/cargokit.cmake	2024-11-08 13:36:13.345889693 +0800
++++ new/cargokit/cmake/cargokit.cmake	2024-11-08 13:45:26.019632176 +0800
+@@ -17,83 +17,22 @@
+ function(apply_cargokit target manifest_dir lib_name any_symbol_name)
+ 
+     set(CARGOKIT_LIB_NAME "${lib_name}")
+-    set(CARGOKIT_LIB_FULL_NAME "${CMAKE_SHARED_MODULE_PREFIX}${CARGOKIT_LIB_NAME}${CMAKE_SHARED_MODULE_SUFFIX}")
+-    if (CMAKE_CONFIGURATION_TYPES)
+-        set(CARGOKIT_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>")
+-        set(OUTPUT_LIB "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/${CARGOKIT_LIB_FULL_NAME}")
+-    else()
+-        set(CARGOKIT_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+-        set(OUTPUT_LIB "${CMAKE_CURRENT_BINARY_DIR}/${CARGOKIT_LIB_FULL_NAME}")
+-    endif()
+-    set(CARGOKIT_TEMP_DIR "${CMAKE_CURRENT_BINARY_DIR}/cargokit_build")
+-
+-    if (FLUTTER_TARGET_PLATFORM)
+-        set(CARGOKIT_TARGET_PLATFORM "${FLUTTER_TARGET_PLATFORM}")
+-    else()
+-        set(CARGOKIT_TARGET_PLATFORM "windows-x64")
+-    endif()
+-
+-    set(CARGOKIT_ENV
+-        "CARGOKIT_CMAKE=${CMAKE_COMMAND}"
+-        "CARGOKIT_CONFIGURATION=$<CONFIG>"
+-        "CARGOKIT_MANIFEST_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${manifest_dir}"
+-        "CARGOKIT_TARGET_TEMP_DIR=${CARGOKIT_TEMP_DIR}"
+-        "CARGOKIT_OUTPUT_DIR=${CARGOKIT_OUTPUT_DIR}"
+-        "CARGOKIT_TARGET_PLATFORM=${CARGOKIT_TARGET_PLATFORM}"
+-        "CARGOKIT_TOOL_TEMP_DIR=${CARGOKIT_TEMP_DIR}/tool"
+-        "CARGOKIT_ROOT_PROJECT_DIR=${CMAKE_SOURCE_DIR}"
+-    )
+-
+-    if (WIN32)
+-        set(SCRIPT_EXTENSION ".cmd")
+-        set(IMPORT_LIB_EXTENSION ".lib")
+-    else()
+-        set(SCRIPT_EXTENSION ".sh")
+-        set(IMPORT_LIB_EXTENSION "")
+-        execute_process(COMMAND chmod +x "${cargokit_cmake_root}/run_build_tool${SCRIPT_EXTENSION}")
+-    endif()
+-
+-    # Using generators in custom command is only supported in CMake 3.20+
+-    if (CMAKE_CONFIGURATION_TYPES AND ${CMAKE_VERSION} VERSION_LESS "3.20.0")
+-        foreach(CONFIG IN LISTS CMAKE_CONFIGURATION_TYPES)
+-            add_custom_command(
+-                OUTPUT
+-                "${CMAKE_CURRENT_BINARY_DIR}/${CONFIG}/${CARGOKIT_LIB_FULL_NAME}"
+-                "${CMAKE_CURRENT_BINARY_DIR}/_phony_"
+-                COMMAND ${CMAKE_COMMAND} -E env ${CARGOKIT_ENV}
+-                "${cargokit_cmake_root}/run_build_tool${SCRIPT_EXTENSION}" build-cmake
+-                VERBATIM
+-            )
+-        endforeach()
+-    else()
+-        add_custom_command(
+-            OUTPUT
+-            ${OUTPUT_LIB}
+-            "${CMAKE_CURRENT_BINARY_DIR}/_phony_"
+-            COMMAND ${CMAKE_COMMAND} -E env ${CARGOKIT_ENV}
+-            "${cargokit_cmake_root}/run_build_tool${SCRIPT_EXTENSION}" build-cmake
+-            VERBATIM
+-        )
+-    endif()
+-
+-
+-    set_source_files_properties("${CMAKE_CURRENT_BINARY_DIR}/_phony_" PROPERTIES SYMBOLIC TRUE)
+ 
+     if (TARGET ${target})
+         # If we have actual cmake target provided create target and make existing
+         # target depend on it
+-        add_custom_target("${target}_cargokit" DEPENDS ${OUTPUT_LIB})
++        add_custom_target("${target}_cargokit" DEPENDS @output_lib@)
+         add_dependencies("${target}" "${target}_cargokit")
+-        target_link_libraries("${target}" PRIVATE "${OUTPUT_LIB}${IMPORT_LIB_EXTENSION}")
++        target_link_libraries("${target}" PRIVATE @output_lib@)
+         if(WIN32)
+             target_link_options(${target} PRIVATE "/INCLUDE:${any_symbol_name}")
+         endif()
+     else()
+         # Otherwise (FFI) just use ALL to force building always
+-        add_custom_target("${target}_cargokit" ALL DEPENDS ${OUTPUT_LIB})
++        add_custom_target("${target}_cargokit" ALL DEPENDS @output_lib@)
+     endif()
+ 
+     # Allow adding the output library to plugin bundled libraries
+-    set("${target}_cargokit_lib" ${OUTPUT_LIB} PARENT_SCOPE)
++    set("${target}_cargokit_lib" @output_lib@ PARENT_SCOPE)
+ 
+ endfunction()

pkgs/development/compilers/dart/package-source-builders/flutter_discord_rpc/default.nix

@@ -0,0 +1,48 @@
+{
+  lib,
+  rustPlatform,
+  stdenv,
+  replaceVars,
+}:
+
+{ version, src, ... }:
+
+let
+  rustDep = rustPlatform.buildRustPackage {
+    pname = "flutter_discord_rpc-rs";
+    inherit version src;
+
+    buildAndTestSubdir = "rust";
+
+    cargoHash =
+      {
+        _1_0_0 = "sha256-C9WDE9+6V59yNCNVeMUY5lRpMJ+8XWpHpxzdTmz+/Yw=";
+      }
+      .${"_" + (lib.replaceStrings [ "." ] [ "_" ] version)} or (throw ''
+        Unsupported version of pub 'flutter_discord_rpc': '${version}'
+        Please add cargoHash here. If the cargoHash
+        is the same with existing versions, add an alias here.
+      '');
+
+    passthru.libraryPath = "lib/libflutter_discord_rpc.so";
+  };
+in
+stdenv.mkDerivation {
+  pname = "flutter_discord_rpc";
+  inherit version src;
+  inherit (src) passthru;
+
+  patches = [
+    (replaceVars ./cargokit.patch {
+      output_lib = "${rustDep}/${rustDep.passthru.libraryPath}";
+    })
+  ];
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r . $out
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/flutter_vodozemac/default.nix

@@ -0,0 +1,72 @@
+{
+  lib,
+  rustPlatform,
+  writeText,
+  stdenv,
+}:
+
+{ version, src, ... }:
+
+let
+  rustDep = rustPlatform.buildRustPackage {
+    pname = "flutter_vodozemac-rs";
+    inherit version src;
+
+    sourceRoot = "${src.name}/rust";
+
+    cargoHash =
+      {
+        _0_2_2 = "sha256-Iw0AkHVjR1YmPe+C0YYBTDu5FsRk/ZpaRyBilcvqm6M=";
+      }
+      .${"_" + (lib.replaceStrings [ "." ] [ "_" ] version)} or (throw ''
+        Unsupported version of pub 'flutter_vodozemac': '${version}'
+        Please add cargoHash here. If the cargoHash
+        is the same with existing versions, add an alias here.
+      '');
+
+    passthru.libraryPath = "lib/libvodozemac_bindings_dart.so";
+  };
+
+  fakeCargokitCmake = writeText "FakeCargokit.cmake" ''
+    function(apply_cargokit target manifest_dir lib_name any_symbol_name)
+      set("''${target}_cargokit_lib" ${rustDep}/${rustDep.passthru.libraryPath} PARENT_SCOPE)
+    endfunction()
+  '';
+
+  getLibraryPath = ''
+    String _getLibraryPath() {
+      if (kIsWeb) {
+        return './';
+      }
+      try {
+        return Platform.resolvedExecutable + '/../lib/libvodozemac_bindings_dart.so';
+      } catch (_) {
+        return './';
+      }
+    }
+  '';
+in
+stdenv.mkDerivation {
+  pname = "flutter_vodozemac";
+  inherit version src;
+  passthru = src.passthru // {
+    # vodozemac-wasm in fluffychat will make use of it
+    inherit (rustDep) cargoDeps;
+  };
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r "$src" "$out"
+    pushd $out
+      chmod +rwx cargokit/cmake/cargokit.cmake
+      cp ${fakeCargokitCmake} cargokit/cmake/cargokit.cmake
+      chmod +rw lib/flutter_vodozemac.dart
+      substituteInPlace lib/flutter_vodozemac.dart \
+        --replace-warn "libraryPath: './'" "libraryPath: _getLibraryPath()"
+      echo "${getLibraryPath}" >> lib/flutter_vodozemac.dart
+    popd
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/flutter_volume_controller/default.nix

@@ -0,0 +1,26 @@
+{
+  stdenv,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation {
+  pname = "flutter_volume_controller";
+  inherit version src;
+  inherit (src) passthru;
+
+  postPatch = ''
+    substituteInPlace linux/CMakeLists.txt \
+      --replace-fail '# Include ALSA' 'find_package(PkgConfig REQUIRED)' \
+      --replace-fail 'find_package(ALSA REQUIRED)' 'pkg_check_modules(ALSA REQUIRED alsa)'
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir $out
+    cp -r ./* $out/
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/handy-window/default.nix

@@ -0,0 +1,32 @@
+{
+  stdenv,
+  lib,
+  writeScript,
+  cairo,
+  fribidi,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation rec {
+  pname = "handy-window";
+  inherit version src;
+  inherit (src) passthru;
+
+  setupHook = writeScript "${pname}-setup-hook" ''
+    handyWindowConfigureHook() {
+      export CFLAGS="$CFLAGS -isystem ${lib.getDev fribidi}/include/fribidi -isystem ${lib.getDev cairo}/include"
+    }
+
+    postConfigureHooks+=(handyWindowConfigureHook)
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p "$out"
+    ln -s '${src}'/* "$out"
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/matrix/default.nix

@@ -0,0 +1,31 @@
+{
+  stdenv,
+  lib,
+  writeScript,
+  openssl,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation rec {
+  pname = "matrix";
+  inherit version src;
+  inherit (src) passthru;
+
+  setupHook = writeScript "${pname}-setup-hook" ''
+    matrixFixupHook() {
+      runtimeDependencies+=('${lib.getLib openssl}')
+    }
+
+    preFixupHooks+=(matrixFixupHook)
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p "$out"
+    ln -s '${src}'/* "$out"
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/media_kit_libs_linux/default.nix

@@ -0,0 +1,38 @@
+{
+  lib,
+  stdenv,
+}:
+
+# Implementation notes
+
+# The patch exploits the fact that the download part is enclosed with "# ---"
+# To use this module you will need to pass the CMake variable MIMALLOC_LIB
+# example: -DMIMALLOC_LIB=${pkgs.mimalloc}/lib/mimalloc.o
+
+# Direct link for the original CMakeLists.txt: https://raw.githubusercontent.com/media-kit/media-kit/main/libs/linux/media_kit_libs_linux/linux/CMakeLists.txt
+
+{ version, src, ... }:
+
+stdenv.mkDerivation {
+  pname = "media_kit_libs_linux";
+  inherit version src;
+  inherit (src) passthru;
+
+  dontBuild = true;
+
+  postPatch =
+    lib.optionalString (lib.versionAtLeast version "1.2.1") ''
+      sed -i '/if(MIMALLOC_USE_STATIC_LIBS)/,/unset(MIMALLOC_USE_STATIC_LIBS CACHE)/d' linux/CMakeLists.txt
+    ''
+    + lib.optionalString (lib.versionOlder version "1.2.1") ''
+      awk -i inplace 'BEGIN {opened = 0}; /# --*[^$]*/ { print (opened ? "]===]" : "#[===["); opened = !opened }; {print $0}' linux/CMakeLists.txt
+    '';
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r . $out
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/objectbox_flutter_libs/CMakeLists.patch

@@ -0,0 +1,46 @@
+--- old/linux/CMakeLists.txt
++++ new/linux/CMakeLists.txt
+@@ -41,35 +41,6 @@
+ target_link_libraries(${PLUGIN_NAME} PRIVATE flutter)
+ target_link_libraries(${PLUGIN_NAME} PRIVATE PkgConfig::GTK)
+
+-# ----------------------------------------------------------------------
+-# Download and add objectbox-c prebuilt library.
+-
+-set(OBJECTBOX_VERSION 4.0.2)
+-
+-set(OBJECTBOX_ARCH ${CMAKE_SYSTEM_PROCESSOR})
+-if (${OBJECTBOX_ARCH} MATCHES "x86_64")
+-    set(OBJECTBOX_ARCH x64)
+-elseif (${OBJECTBOX_ARCH} MATCHES "^arm64" OR ${OBJECTBOX_ARCH} MATCHES "^armv8")
+-    set(OBJECTBOX_ARCH aarch64)
+-elseif (${OBJECTBOX_ARCH} MATCHES "^armv7")
+-    set(OBJECTBOX_ARCH armv7hf)
+-elseif (${OBJECTBOX_ARCH} MATCHES "^arm")
+-    set(OBJECTBOX_ARCH armv6hf)
+-endif ()
+-
+-include(FetchContent)
+-FetchContent_Declare(
+-    objectbox-download
+-    URL https://github.com/objectbox/objectbox-c/releases/download/v${OBJECTBOX_VERSION}/objectbox-linux-${OBJECTBOX_ARCH}.tar.gz
+-)
+-
+-FetchContent_GetProperties(objectbox-download)
+-if(NOT objectbox-download_POPULATED)
+-  FetchContent_Populate(objectbox-download)
+-endif()
+-
+-# ----------------------------------------------------------------------
+-
+ # List of absolute paths to libraries that should be bundled with the plugin.
+ # This list could contain prebuilt libraries, or libraries created by an
+ # external build triggered from this build file.
+@@ -77,6 +48,6 @@
+ # Note: do not link the ObjectBox C library; the Dart library looks for it in a lib subfolder
+ # where flutter build puts it when added below.
+ set(objectbox_flutter_libs_bundled_libraries
+-    "${objectbox-download_SOURCE_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}objectbox${CMAKE_SHARED_LIBRARY_SUFFIX}"
++    "@OBJECTBOX_SHARED_LIBRARY@"
+     PARENT_SCOPE
+ )

pkgs/development/compilers/dart/package-source-builders/objectbox_flutter_libs/default.nix

@@ -0,0 +1,50 @@
+{
+  lib,
+  stdenv,
+  fetchzip,
+  replaceVars,
+}:
+
+{ version, src, ... }:
+
+let
+  selectSystem =
+    attrs:
+    attrs.${stdenv.hostPlatform.system}
+      or (throw "objectbox_flutter_libs: ${stdenv.hostPlatform.system} is not supported");
+
+  arch = selectSystem {
+    x86_64-linux = "x64";
+    aarch64-linux = "aarch64";
+  };
+
+  objectbox-sync = fetchzip {
+    url = "https://github.com/objectbox/objectbox-c/releases/download/v4.0.2/objectbox-sync-linux-${arch}.tar.gz";
+    hash = selectSystem {
+      x86_64-linux = "sha256-VXTuCYg0ZItK+lAs7xkNlxO0rUPnbRZOP5RAXbcRyjM=";
+      aarch64-linux = "sha256-kNlrBRR/qDEhdU34f4eDQLgYkYAIfFC8/of4rgL+m6k=";
+    };
+    stripRoot = false;
+  };
+in
+stdenv.mkDerivation {
+  pname = "objectbox_flutter_libs";
+  inherit version src;
+  inherit (src) passthru;
+
+  patches = [
+    (replaceVars ./CMakeLists.patch {
+      OBJECTBOX_SHARED_LIBRARY = "${objectbox-sync}/lib/libobjectbox.so";
+    })
+  ];
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r . $out
+
+    runHook postInstall
+  '';
+
+  meta.sourceProvenance = with lib.sourceTypes; [ binaryBytecode ];
+}

pkgs/development/compilers/dart/package-source-builders/olm/default.nix

@@ -0,0 +1,31 @@
+{
+  stdenv,
+  lib,
+  writeScript,
+  olm,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation rec {
+  pname = "olm";
+  inherit version src;
+  inherit (src) passthru;
+
+  setupHook = writeScript "${pname}-setup-hook" ''
+    olmFixupHook() {
+      runtimeDependencies+=('${lib.getLib olm}')
+    }
+
+    preFixupHooks+=(olmFixupHook)
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p "$out"
+    ln -s '${src}'/* "$out"
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/pdfrx/default.nix

@@ -0,0 +1,26 @@
+{
+  stdenv,
+  pdfium-binaries,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation rec {
+  pname = "pdfrx";
+  inherit version src;
+  inherit (src) passthru;
+
+  postPatch = ''
+    substituteInPlace linux/CMakeLists.txt \
+        --replace-fail "\''${PDFIUM_DIR}/\''${PDFIUM_RELEASE}" "${pdfium-binaries}"
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir $out
+    cp -a ./* $out/
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/printing/default.nix

@@ -0,0 +1,37 @@
+{
+  stdenv,
+  pdfium-binaries,
+  replaceVars,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation rec {
+  pname = "printing";
+  inherit version src;
+  inherit (src) passthru;
+
+  prePatch = ''
+    if [ -d printing ]; then pushd printing; fi
+  '';
+
+  patches = [
+    (replaceVars ./printing.patch {
+      inherit pdfium-binaries;
+    })
+  ];
+
+  postPatch = ''
+    popd || true
+  '';
+
+  dontBuild = true;
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r . $out
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/printing/printing.patch

@@ -0,0 +1,45 @@
+--- old/linux/CMakeLists.txt	2024-07-16 18:45:19.000000000 +0800
++++ new/linux/CMakeLists.txt	2024-10-01 01:49:05.544910894 +0800
+@@ -16,6 +16,7 @@
+ set(PROJECT_NAME "printing")
+ project(${PROJECT_NAME} LANGUAGES CXX)
+
++set(PDFIUM_DIR @pdfium-binaries@)
+ set(PDFIUM_VERSION "5200" CACHE STRING "Version of pdfium used")
+ string(REPLACE "linux-" "" TARGET_ARCH ${FLUTTER_TARGET_PLATFORM})
+ set(PDFIUM_ARCH ${TARGET_ARCH} CACHE STRING "Architecture of pdfium used")
+@@ -32,18 +33,11 @@
+     )
+ endif()
+
+-# Download pdfium
+-include(../windows/DownloadProject.cmake)
+-download_project(PROJ
+-                 pdfium
+-                 URL
+-                 ${PDFIUM_URL})
+-
+ # This value is used when generating builds using this plugin, so it must not be
+ # changed
+ set(PLUGIN_NAME "printing_plugin")
+
+-include(${pdfium_SOURCE_DIR}/PDFiumConfig.cmake)
++include(${PDFIUM_DIR}/PDFiumConfig.cmake)
+
+ # System-level dependencies.
+ find_package(PkgConfig REQUIRED)
+@@ -67,7 +61,7 @@
+ target_link_libraries(${PLUGIN_NAME}
+                       PRIVATE PkgConfig::GTK PkgConfig::GTKUnixPrint)
+ target_link_libraries(${PLUGIN_NAME} PRIVATE pdfium)
+-get_filename_component(PDFium_lib_path "${PDFium_LIBRARY}" DIRECTORY)
++set(PDFium_lib_path "${PDFIUM_DIR}/lib")
+ set_target_properties(${PLUGIN_NAME}
+                       PROPERTIES SKIP_BUILD_RPATH
+                                  FALSE
+@@ -77,4 +71,4 @@
+                                  "$ORIGIN:${PDFium_lib_path}")
+
+ # List of absolute paths to libraries that should be bundled with the plugin
+-set(printing_bundled_libraries "${PDFium_LIBRARY}" PARENT_SCOPE)
++set(printing_bundled_libraries "${PDFIUM_DIR}/lib/libpdfium.so" PARENT_SCOPE)

pkgs/development/compilers/dart/package-source-builders/rhttp/cargokit.patch

@@ -0,0 +1,90 @@
+--- old/cargokit/cmake/cargokit.cmake	2024-11-08 13:36:13.345889693 +0800
++++ new/cargokit/cmake/cargokit.cmake	2024-11-08 13:45:26.019632176 +0800
+@@ -17,83 +17,22 @@
+ function(apply_cargokit target manifest_dir lib_name any_symbol_name)
+ 
+     set(CARGOKIT_LIB_NAME "${lib_name}")
+-    set(CARGOKIT_LIB_FULL_NAME "${CMAKE_SHARED_MODULE_PREFIX}${CARGOKIT_LIB_NAME}${CMAKE_SHARED_MODULE_SUFFIX}")
+-    if (CMAKE_CONFIGURATION_TYPES)
+-        set(CARGOKIT_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>")
+-        set(OUTPUT_LIB "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/${CARGOKIT_LIB_FULL_NAME}")
+-    else()
+-        set(CARGOKIT_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+-        set(OUTPUT_LIB "${CMAKE_CURRENT_BINARY_DIR}/${CARGOKIT_LIB_FULL_NAME}")
+-    endif()
+-    set(CARGOKIT_TEMP_DIR "${CMAKE_CURRENT_BINARY_DIR}/cargokit_build")
+-
+-    if (FLUTTER_TARGET_PLATFORM)
+-        set(CARGOKIT_TARGET_PLATFORM "${FLUTTER_TARGET_PLATFORM}")
+-    else()
+-        set(CARGOKIT_TARGET_PLATFORM "windows-x64")
+-    endif()
+-
+-    set(CARGOKIT_ENV
+-        "CARGOKIT_CMAKE=${CMAKE_COMMAND}"
+-        "CARGOKIT_CONFIGURATION=$<CONFIG>"
+-        "CARGOKIT_MANIFEST_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${manifest_dir}"
+-        "CARGOKIT_TARGET_TEMP_DIR=${CARGOKIT_TEMP_DIR}"
+-        "CARGOKIT_OUTPUT_DIR=${CARGOKIT_OUTPUT_DIR}"
+-        "CARGOKIT_TARGET_PLATFORM=${CARGOKIT_TARGET_PLATFORM}"
+-        "CARGOKIT_TOOL_TEMP_DIR=${CARGOKIT_TEMP_DIR}/tool"
+-        "CARGOKIT_ROOT_PROJECT_DIR=${CMAKE_SOURCE_DIR}"
+-    )
+-
+-    if (WIN32)
+-        set(SCRIPT_EXTENSION ".cmd")
+-        set(IMPORT_LIB_EXTENSION ".lib")
+-    else()
+-        set(SCRIPT_EXTENSION ".sh")
+-        set(IMPORT_LIB_EXTENSION "")
+-        execute_process(COMMAND chmod +x "${cargokit_cmake_root}/run_build_tool${SCRIPT_EXTENSION}")
+-    endif()
+-
+-    # Using generators in custom command is only supported in CMake 3.20+
+-    if (CMAKE_CONFIGURATION_TYPES AND ${CMAKE_VERSION} VERSION_LESS "3.20.0")
+-        foreach(CONFIG IN LISTS CMAKE_CONFIGURATION_TYPES)
+-            add_custom_command(
+-                OUTPUT
+-                "${CMAKE_CURRENT_BINARY_DIR}/${CONFIG}/${CARGOKIT_LIB_FULL_NAME}"
+-                "${CMAKE_CURRENT_BINARY_DIR}/_phony_"
+-                COMMAND ${CMAKE_COMMAND} -E env ${CARGOKIT_ENV}
+-                "${cargokit_cmake_root}/run_build_tool${SCRIPT_EXTENSION}" build-cmake
+-                VERBATIM
+-            )
+-        endforeach()
+-    else()
+-        add_custom_command(
+-            OUTPUT
+-            ${OUTPUT_LIB}
+-            "${CMAKE_CURRENT_BINARY_DIR}/_phony_"
+-            COMMAND ${CMAKE_COMMAND} -E env ${CARGOKIT_ENV}
+-            "${cargokit_cmake_root}/run_build_tool${SCRIPT_EXTENSION}" build-cmake
+-            VERBATIM
+-        )
+-    endif()
+-
+-
+-    set_source_files_properties("${CMAKE_CURRENT_BINARY_DIR}/_phony_" PROPERTIES SYMBOLIC TRUE)
+ 
+     if (TARGET ${target})
+         # If we have actual cmake target provided create target and make existing
+         # target depend on it
+-        add_custom_target("${target}_cargokit" DEPENDS ${OUTPUT_LIB})
++        add_custom_target("${target}_cargokit" DEPENDS @output_lib@)
+         add_dependencies("${target}" "${target}_cargokit")
+-        target_link_libraries("${target}" PRIVATE "${OUTPUT_LIB}${IMPORT_LIB_EXTENSION}")
++        target_link_libraries("${target}" PRIVATE @output_lib@)
+         if(WIN32)
+             target_link_options(${target} PRIVATE "/INCLUDE:${any_symbol_name}")
+         endif()
+     else()
+         # Otherwise (FFI) just use ALL to force building always
+-        add_custom_target("${target}_cargokit" ALL DEPENDS ${OUTPUT_LIB})
++        add_custom_target("${target}_cargokit" ALL DEPENDS @output_lib@)
+     endif()
+ 
+     # Allow adding the output library to plugin bundled libraries
+-    set("${target}_cargokit_lib" ${OUTPUT_LIB} PARENT_SCOPE)
++    set("${target}_cargokit_lib" @output_lib@ PARENT_SCOPE)
+ 
+ endfunction()

pkgs/development/compilers/dart/package-source-builders/rhttp/default.nix

@@ -0,0 +1,77 @@
+{
+  lib,
+  rustPlatform,
+  stdenv,
+  replaceVars,
+}:
+
+{ version, src, ... }:
+
+let
+  rustDep = rustPlatform.buildRustPackage {
+    pname = "rhttp-rs";
+    inherit version src;
+
+    sourceRoot = "${src.name}/rust";
+
+    unpackPhase = ''
+      runHook preUnpack
+
+      if [ -d $src/rhttp ]; then
+        cp -r $src/rhttp ${src.name}
+      else
+        cp -r $src ${src.name}
+      fi
+      chmod -R u+w -- "$sourceRoot"
+
+      runHook postUnpack
+    '';
+
+    cargoHash =
+      {
+        _0_9_1 = "sha256-ZVl1nesepZnmOWeJPOgE6IDCokQm5FedbA5MBvr5S8c=";
+        _0_9_6 = "sha256-vvzb+jNN5lmRrKJ3zqvORvdduqEHRmbp85L/9Zegh/E=";
+        _0_9_8 = "sha256-cwb1wYVXOE5YABlMxUDt+OMlDpIlipqeNI7ZFAGHCqo=";
+        _0_10_0 = "sha256-2SpAj53XvZXKRpMzFXJGcx7E2TlMUD+ooHkFwg/9fe4=";
+        _0_11_0 = "sha256-sngh5k9GoCZhnIFTpnAVHZjxTcOv+Ui6pJ2cFyriL84=";
+        _0_12_0 = "sha256-W2DcBy1n73nR2oZIQcFt6A+NElQWtfEtKB1YIweQUVo=";
+      }
+      .${"_" + (lib.replaceStrings [ "." ] [ "_" ] version)} or (throw ''
+        Unsupported version of pub 'rhttp': '${version}'
+        Please add cargoHash here. If the cargoHash
+        is the same with existing versions, add an alias here.
+      '');
+
+    env.RUSTFLAGS = "--cfg reqwest_unstable";
+
+    passthru.libraryPath = "lib/librhttp.so";
+  };
+
+in
+stdenv.mkDerivation {
+  pname = "rhttp";
+  inherit version src;
+  inherit (src) passthru;
+
+  prePatch = ''
+    if [ -d rhttp ]; then pushd rhttp; fi
+  '';
+
+  patches = [
+    (replaceVars ./cargokit.patch {
+      output_lib = "${rustDep}/${rustDep.passthru.libraryPath}";
+    })
+  ];
+
+  postPatch = ''
+    popd || true
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r . $out
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/sentry_flutter/default.nix

@@ -0,0 +1,35 @@
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+}:
+
+{ version, src, ... }:
+
+let
+  sentry-native = fetchFromGitHub {
+    owner = "getsentry";
+    repo = "sentry-native";
+    tag = "0.9.1";
+    fetchSubmodules = true;
+    hash = "sha256-1jyJGiIrX0TsRDzAeg3IuE1Vf5STAaG8JVxdbmPMXGQ=";
+  };
+in
+stdenv.mkDerivation (finalAttrs: {
+  pname = "sentry_flutter";
+  inherit version src;
+  inherit (src) passthru;
+
+  postPatch = lib.optionalString (lib.versionAtLeast version "8.10.0") ''
+    sed -i "s|GIT_REPOSITORY.*|SOURCE_DIR "${sentry-native}"|" sentry-native/sentry-native.cmake
+    sed -i '/GIT_TAG/d' sentry-native/sentry-native.cmake
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r . $out
+
+    runHook postInstall
+  '';
+})

pkgs/development/compilers/dart/package-source-builders/sqlcipher_flutter_libs/default.nix

@@ -0,0 +1,56 @@
+{
+  stdenv,
+  fetchurl,
+  lib,
+}:
+
+{ version, src, ... }:
+
+let
+  artifacts =
+    lib.mapAttrs
+      (version: hash: rec {
+        file = fetchurl {
+          inherit url hash;
+        };
+        url =
+          if lib.versionOlder version "v4_6_1" then
+            "https://storage.googleapis.com/simon-public-euw3/assets/sqlcipher/${version}.c"
+          else
+            "https://fsn1.your-objectstorage.com/simon-public/assets/sqlcipher/${version}.c";
+      })
+      {
+        v4_10_0 = "sha256-3njvCHy8Juj+WE3gXxeQ8+NIl9uHMegVTcZ00/LfKMs=";
+        v4_9_0 = "sha256-uqvW5BgMjCS0GzeEDeGskb4It0NkWjNUpyXpGlBSIlc=";
+        v4_8_0 = "sha256-nfYmi9PJlMbLqiFRksOIUXYHgD8LL2AVey9GCUc03Jw=";
+        v4_6_1 = "sha256-8kBJiy8g1odpBQQUF5A7f9g3+WStbJTARyfvAi84YVE=";
+        v4_5_7 = "sha256-lDgSEVGZcoruF7nAp0C2kr6TN7XllpMzMVi/R1XfGP4=";
+        v4_5_6 = "sha256-evZl3JUeyAfW0fGJ0EfFQs64Z/yRCZGeOeDGgXrFHFU=";
+      };
+in
+stdenv.mkDerivation rec {
+  pname = "sqlcipher_flutter_libs";
+  inherit version src;
+  inherit (src) passthru;
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r "$src" "$out"
+    _replace() {
+      # --replace-fail messes with the file if it fails (is empty afterwards) so we do this instead
+      if cat "$out/linux/CMakeLists.txt" | grep "$1" >/dev/null 2>/dev/null; then
+        substituteInPlace "$out/linux/CMakeLists.txt" --replace "$1" "file://$2"
+      else
+        return 2
+      fi
+    }
+
+    ${lib.concatMapAttrsStringSep " || " (_: v: ''_replace "${v.url}" "${v.file}"'') artifacts} || \
+    (echo "unknown version of sqlcipher, please add to pkgs/development/compilers/dart/package-source-builders/sqlcipher_flutter_libs" && cat linux/CMakeLists.txt | grep "https://storage.*" -o && exit 2)
+
+    runHook postInstall
+  '';
+
+  meta.sourceProvenance = [ lib.sourceTypes.binaryBytecode ];
+}

pkgs/development/compilers/dart/package-source-builders/sqlite3/default.nix

@@ -0,0 +1,31 @@
+{
+  stdenv,
+  lib,
+  writeScript,
+  sqlite,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation rec {
+  pname = "sqlite3";
+  inherit version src;
+  inherit (src) passthru;
+
+  setupHook = writeScript "${pname}-setup-hook" ''
+    sqliteFixupHook() {
+      runtimeDependencies+=('${lib.getLib sqlite}')
+    }
+
+    preFixupHooks+=(sqliteFixupHook)
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p "$out"
+    ln -s '${src}'/* "$out"
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/sqlite3_flutter_libs/CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.14)
+set(PROJECT_NAME "sqlite3_flutter_libs")
+project(${PROJECT_NAME} LANGUAGES C CXX)
+
+# This value is used when generating builds using this plugin, so it must
+# not be changed
+set(PLUGIN_NAME "sqlite3_flutter_libs_plugin")
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(SQLITE REQUIRED sqlite3)
+
+add_library(${PLUGIN_NAME} SHARED
+  "sqlite3_flutter_libs_plugin.cc"
+)
+
+target_compile_features(${PLUGIN_NAME} PUBLIC cxx_std_14)
+target_compile_options(${PLUGIN_NAME} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-O3>")
+
+set_target_properties(${PLUGIN_NAME} PROPERTIES
+  CXX_VISIBILITY_PRESET hidden)
+target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL)
+target_include_directories(${PLUGIN_NAME} INTERFACE
+  "${CMAKE_CURRENT_SOURCE_DIR}/include")
+target_link_libraries(${PLUGIN_NAME} PRIVATE flutter)

pkgs/development/compilers/dart/package-source-builders/sqlite3_flutter_libs/default.nix

@@ -0,0 +1,23 @@
+{
+  stdenv,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation {
+  pname = "sqlite3_flutter_libs";
+  inherit version src;
+  inherit (src) passthru;
+
+  postPatch = ''
+    cp ${./CMakeLists.txt} linux/CMakeLists.txt
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r . $out
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/super_native_extensions/default.nix

@@ -0,0 +1,95 @@
+{
+  lib,
+  rustPlatform,
+  pkg-config,
+  at-spi2-atk,
+  gdk-pixbuf,
+  cairo,
+  gtk3,
+  writeText,
+  stdenv,
+}:
+
+{ version, src, ... }:
+
+let
+  rustDep = rustPlatform.buildRustPackage {
+    pname = "super_native_extensions-rs";
+    inherit version src;
+
+    unpackPhase = ''
+      runHook preUnpack
+
+      if [ -d $src/super_native_extensions ]; then
+        cp -r $src/super_native_extensions ${src.name}
+      else
+        cp -r $src ${src.name}
+      fi
+      chmod -R u+w -- "$sourceRoot"
+
+      runHook postUnpack
+    '';
+
+    sourceRoot = "${src.name}/rust";
+
+    cargoHash =
+      rec {
+        _0_9_1 = _0_9_0-dev_6;
+        _0_9_0-dev_6 = "sha256-1yJIbBxScmkCwy/e+/z2cYA8qQBfT0yoIBmOSPVd4h4=";
+        _0_9_0-dev_5 = _0_8_22;
+        _0_9_0-dev_3 = _0_8_22;
+        _0_8_22 = "sha256-gYYoC3bGJrYY1uUHfqMv6pp4SK+P9fRoBsLtf34rsCg=";
+        _0_8_24 = _0_8_22;
+        _0_8_21 = _0_8_22;
+        _0_8_20 = _0_8_22;
+        _0_8_19 = _0_8_22;
+        _0_8_18 = _0_8_22;
+        _0_8_17 = _0_8_22;
+      }
+      .${"_" + (lib.replaceStrings [ "." ] [ "_" ] version)} or (throw ''
+        Unsupported version of pub 'super_native_extensions': '${version}'
+        Please add cargoHash to here. If the cargoHash
+        is the same with existing versions, add an alias here.
+      '');
+
+    nativeBuildInputs = [ pkg-config ];
+
+    buildInputs = [
+      at-spi2-atk
+      gdk-pixbuf
+      cairo
+      gtk3
+    ];
+
+    passthru.libraryPath = "lib/libsuper_native_extensions.so";
+  };
+
+  fakeCargokitCmake = writeText "FakeCargokit.cmake" ''
+    function(apply_cargokit target manifest_dir lib_name any_symbol_name)
+      target_link_libraries("''${target}" PRIVATE ${rustDep}/${rustDep.passthru.libraryPath})
+      set("''${target}_cargokit_lib" ${rustDep}/${rustDep.passthru.libraryPath} PARENT_SCOPE)
+    endfunction()
+  '';
+
+in
+stdenv.mkDerivation {
+  pname = "super_native_extensions";
+  inherit version src;
+  inherit (src) passthru;
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r "$src" "$out"
+    if [ -d $out/super_native_extensions ]; then
+      pushd $out/super_native_extensions
+    else
+      pushd $out
+    fi
+    chmod +rwx cargokit/cmake/cargokit.cmake
+    cp ${fakeCargokitCmake} cargokit/cmake/cargokit.cmake
+    popd
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/system-tray/default.nix

@@ -0,0 +1,23 @@
+{
+  stdenv,
+  libayatana-appindicator,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation rec {
+  pname = "system-tray";
+  inherit version src;
+  inherit (src) passthru;
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p "$out"
+    cp -r '${src}'/* "$out"
+    substituteInPlace "$out/linux/tray.cc" \
+      --replace "libappindicator3.so.1" "${libayatana-appindicator}/lib/libayatana-appindicator3.so.1"
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/volume_controller/default.nix

@@ -0,0 +1,26 @@
+{
+  lib,
+  stdenv,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation {
+  pname = "volume_controller";
+  inherit version src;
+  inherit (src) passthru;
+
+  postPatch = lib.optionalString (lib.versionAtLeast version "3.4.0") ''
+    substituteInPlace linux/CMakeLists.txt \
+      --replace-fail "# ALSA dependency for volume control" "find_package(PkgConfig REQUIRED)" \
+      --replace-fail "find_package(ALSA REQUIRED)" "pkg_check_modules(ALSA REQUIRED alsa)"
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r . $out
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/package-source-builders/xdg_directories/default.nix

@@ -0,0 +1,25 @@
+{
+  stdenv,
+  xdg-user-dirs,
+}:
+
+{ version, src, ... }:
+
+stdenv.mkDerivation rec {
+  pname = "xdg_directories";
+  inherit version src;
+  inherit (src) passthru;
+
+  postPatch = ''
+    substituteInPlace ./lib/xdg_directories.dart \
+      --replace-fail "'xdg-user-dir'," "'${xdg-user-dirs}/bin/xdg-user-dir',"
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    cp -r . $out
+
+    runHook postInstall
+  '';
+}

pkgs/development/compilers/dart/sources.nix

@@ -0,0 +1,23 @@
+let
+  version = "3.9.3";
+in
+{ fetchurl }:
+{
+  versionUsed = version;
+  "${version}-x86_64-darwin" = fetchurl {
+    url = "https://storage.googleapis.com/dart-archive/channels/stable/release/${version}/sdk/dartsdk-macos-x64-release.zip";
+    hash = "sha256-QnY9KG/zFj+5o/4wdR0lETHhRn3a6l340s/ybuNWxx0=";
+  };
+  "${version}-aarch64-darwin" = fetchurl {
+    url = "https://storage.googleapis.com/dart-archive/channels/stable/release/${version}/sdk/dartsdk-macos-arm64-release.zip";
+    hash = "sha256-aMSMOV5kzd48z5aQgjjpQoJNWznz4slrXSdC8LRe8u8=";
+  };
+  "${version}-aarch64-linux" = fetchurl {
+    url = "https://storage.googleapis.com/dart-archive/channels/stable/release/${version}/sdk/dartsdk-linux-arm64-release.zip";
+    hash = "sha256-iEfEhHv3eu2VjAYrzPjVlXle1ISHZxJoC69MbIMXw1Y=";
+  };
+  "${version}-x86_64-linux" = fetchurl {
+    url = "https://storage.googleapis.com/dart-archive/channels/stable/release/${version}/sdk/dartsdk-linux-x64-release.zip";
+    hash = "sha256-0ZMR3rNRBKQaQNt642xJaxUDdFpcrtWkFdMitMJz8ds=";
+  };
+}

pkgs/development/compilers/dart/update.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env nix-shell
+#!nix-shell -i bash -p curl jq common-updater-scripts
+
+set -euo pipefail
+
+latestVersion=$(curl -sL https://storage.googleapis.com/dart-archive/channels/stable/release/latest/VERSION | jq --raw-output .version)
+currentVersion=$(nix eval --raw -f . dart.version)
+
+if [[ "$latestVersion" == "$currentVersion" ]]; then
+  exit 0
+fi
+
+MY_PATH=$(dirname $(realpath "$0"))
+
+update-source-version dart $latestVersion --file=$MY_PATH/sources.nix
+
+systems=$(nix eval --json -f . dart.meta.platforms | jq --raw-output '.[]')
+for system in $systems; do
+  hash=$(nix hash convert --to sri --hash-algo sha256 $(nix-prefetch-url $(nix eval --raw -f . dart.src.url --system "$system")))
+  update-source-version dart $latestVersion $hash --file=$MY_PATH/sources.nix --system=$system --ignore-same-version --ignore-same-hash
+done

pkgs/development/compilers/djgpp/default.nix

@@ -0,0 +1,106 @@
+{
+  bison,
+  buildPackages,
+  curl,
+  fetchFromGitHub,
+  fetchurl,
+  file,
+  flex,
+  targetArchitecture ? "i586",
+  lib,
+  makeWrapper,
+  perl,
+  stdenv,
+  texinfo,
+  unzip,
+  which,
+}:
+
+let
+  s = import ./sources.nix { inherit fetchurl fetchFromGitHub; };
+in
+assert lib.elem targetArchitecture [
+  "i586"
+  "i686"
+];
+stdenv.mkDerivation rec {
+  pname = "djgpp";
+  version = s.gccVersion;
+  src = s.src;
+
+  patchPhase = ''
+    runHook prePatch
+    for f in "build-djgpp.sh" "script/${version}" "setenv/copyfile.sh"; do
+      substituteInPlace "$f" --replace '/usr/bin/env' '${buildPackages.coreutils}/bin/env'
+    done
+  ''
+  # i686 patches from https://github.com/andrewwutw/build-djgpp/issues/45#issuecomment-1484010755
+  # The build script unpacks some files so we can't patch ahead of time, instead patch the script
+  # to patch after it extracts
+
+  + lib.optionalString (targetArchitecture == "i686") ''
+    sed -i 's/i586/i686/g' setenv/setenv script/${version}
+    sed -i '/Building DXE tools./a sed -i "s/i586/i686/g" src/makefile.def src/dxe/makefile.dxe' script/${version}
+  ''
+  + ''
+    runHook postPatch
+  '';
+
+  nativeBuildInputs = [
+    makeWrapper
+  ];
+
+  buildInputs = [
+    bison
+    curl
+    file
+    flex
+    perl
+    texinfo
+    unzip
+    which
+  ];
+
+  hardeningDisable = [ "format" ];
+
+  # stripping breaks static libs, causing this when you attempt to compile a binary:
+  # error adding symbols: Archive has no index; run ranlib to add one
+  dontStrip = true;
+
+  buildPhase = ''
+    runHook preBuild
+    mkdir download; pushd download
+    ln -s "${s.autoconf}"   "${s.autoconf.name}"
+    ln -s "${s.automake}"   "${s.automake.name}"
+    ln -s "${s.binutils}"   "${s.binutils.name}"
+    ln -s "${s.djcrossgcc}" "${s.djcrossgcc.name}"
+    ln -s "${s.djcrx}"      "${s.djcrx.name}"
+    ln -s "${s.djdev}"      "${s.djdev.name}"
+    ln -s "${s.djlsr}"      "${s.djlsr.name}"
+    ln -s "${s.gcc}"        "${s.gcc.name}"
+    ln -s "${s.gmp}"        "${s.gmp.name}"
+    ln -s "${s.mpc}"        "${s.mpc.name}"
+    ln -s "${s.mpfr}"       "${s.mpfr.name}"
+    popd
+    DJGPP_PREFIX=$out ./build-djgpp.sh ${version}
+    runHook postBuild
+  '';
+
+  postInstall = ''
+    for f in dxegen dxe3gen dxe3res exe2coff stubify; do
+      cp -v "$out/${targetArchitecture}-pc-msdosdjgpp/bin/$f" "$out/bin"
+    done
+
+    for f in dxegen dxe3gen; do
+      wrapProgram $out/bin/$f --set DJDIR $out
+    done
+  '';
+
+  meta = {
+    description = "Complete 32-bit GNU-based development system for Intel x86 PCs running DOS";
+    homepage = "https://www.delorie.com/djgpp/";
+    license = lib.licenses.gpl2Plus;
+    maintainers = with lib.maintainers; [ hughobrien ];
+    platforms = lib.platforms.linux ++ lib.platforms.darwin;
+  };
+}

pkgs/development/compilers/djgpp/sources.nix

@@ -0,0 +1,82 @@
+let
+  # adapted from https://github.com/andrewwutw/build-djgpp/blob/master/script/12.1.0
+  gccVersion = "12.2.0";
+  binutilsVersion = "230";
+  djcrxVersion = "205";
+  djlsrVersion = "205";
+  djdevVersion = "205";
+  gmpVersion = "6.2.1";
+  mpfrVersion = "4.1.0";
+  mpcVersion = "1.2.1";
+  autoconfVersion = "2.69";
+  automakeVersion = "1.15.1";
+  djgppFtpMirror = "https://www.mirrorservice.org/sites/ftp.delorie.com/pub";
+  gnuFtpMirror = "https://www.mirrorservice.org/sites/ftp.gnu.org/gnu";
+in
+{ fetchFromGitHub, fetchurl }:
+{
+  inherit gccVersion;
+
+  src = fetchFromGitHub {
+    owner = "andrewwutw";
+    repo = "build-djgpp";
+    rev = "0dc28365825f853c3cc6ad0d8f10f8570bed5828";
+    hash = "sha256-L7ROTbnd/Ry/E9cP0N+l0y0cUzkkbC5B2aU9/r3rLQg=";
+  };
+
+  autoconf = fetchurl {
+    url = "${gnuFtpMirror}/autoconf/autoconf-${autoconfVersion}.tar.xz";
+    hash = "sha256-ZOvOyfisWySHElqGp3YNJZGsnh09vVlIljP53mKldoQ=";
+  };
+
+  automake = fetchurl {
+    url = "${gnuFtpMirror}/Automake/automake-${automakeVersion}.tar.xz";
+    hash = "sha256-r2ujkUIiBofFAPebSqLxgdmyTk+NjsSXzqS6JsZL7a8=";
+  };
+
+  binutils = fetchurl {
+    url = "${djgppFtpMirror}/djgpp/deleted/v2gnu/bnu${binutilsVersion}s.zip";
+    hash = "sha256-DSFQyFvswmP5/qYXbesFmUJ9tqEFJpILb0mGclfpXX0=";
+  };
+
+  djcrossgcc = fetchurl {
+    url = "${djgppFtpMirror}/djgpp/rpms/djcross-gcc-${gccVersion}/djcross-gcc-${gccVersion}.tar.bz2";
+    hash = "sha256-UL+wkeNv3LCQog0JigShIyBM7qJRqvN58Zitmti/BZM=";
+  };
+
+  djcrx = fetchurl {
+    url = "${djgppFtpMirror}/djgpp/current/v2/djcrx${djcrxVersion}.zip";
+    hash = "sha256-IidO2NXuV898zxYfXhaE/RwBkgaHJKfTThveFoBBymA=";
+  };
+
+  djdev = fetchurl {
+    url = "${djgppFtpMirror}/djgpp/current/v2/djdev${djdevVersion}.zip";
+    hash = "sha256-RVfftsFh0yZoCuX6cfAJisSUJaGxG5CgILgxYutwXdo=";
+  };
+
+  djlsr = fetchurl {
+    url = "${djgppFtpMirror}/djgpp/current/v2/djlsr${djlsrVersion}.zip";
+    hash = "sha256-gGkLbkT/i8bGCB/KH0+uuhWRxEkLdu8OyLNYR7ql3uo=";
+  };
+
+  gcc = fetchurl {
+    url = "${gnuFtpMirror}/gcc/gcc-${gccVersion}/gcc-${gccVersion}.tar.xz";
+    hash = "sha256-5UnPnPNZSgDie2WJ1DItcOByDN0hPzm+tBgeBpJiMP8=";
+  };
+
+  gmp = fetchurl {
+    url = "${gnuFtpMirror}/gmp/gmp-${gmpVersion}.tar.xz";
+    hash = "sha256-/UgpkSzd0S+EGBw0Ucx1K+IkZD6H+sSXtp7d2txJtPI=";
+  };
+
+  mpc = fetchurl {
+    url = "${gnuFtpMirror}/mpc/mpc-${mpcVersion}.tar.gz";
+    hash = "sha256-F1A9LDld/PEGtiLcFCaDwRmUMdCVNnxqrLpu7DA0BFk=";
+  };
+
+  mpfr = fetchurl {
+    url = "${gnuFtpMirror}/mpfr/mpfr-${mpfrVersion}.tar.xz";
+    hash = "sha256-DJij8XMv9spOppBVIHnanFl4ctMOluwoQU7iPJVVin8=";
+  };
+
+}

pkgs/development/compilers/dotnet/10/bootstrap-sdk.nix

@@ -0,0 +1,583 @@
+{
+  buildAspNetCore,
+  buildNetRuntime,
+  buildNetSdk,
+  fetchNupkg,
+}:
+
+# v10.0 (go-live)
+
+let
+  commonPackages = [
+    (fetchNupkg {
+      pname = "Microsoft.AspNetCore.App.Ref";
+      version = "10.0.0-rc.1.25451.107";
+      hash = "sha512-0wQQq3RPKM6EU5FXQT7bMvbPsKE+6UGlfP5FHQh/91fb09/lhVlFCO9oMUOkX8/ntQN4w+eqnrB2tPCHXu++iA==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NETCore.DotNetAppHost";
+      version = "10.0.0-rc.1.25451.107";
+      hash = "sha512-hMhKJaqLUWSaHBcNP/OLQ9RFIppWqztgWh1Mi28aCj6a1+aTfjLNc9NmAsGC27SeqIylMYC9zoKTp6BMPdF/fA==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NETCore.App.Ref";
+      version = "10.0.0-rc.1.25451.107";
+      hash = "sha512-j/HfJgOT/5dMNPQsEQvilDp5LyTRa5SIVHZ5dYsckLrnlff5KHot4lYoyPvQNfFzag1hxsgMUtOfbslDFHUEGQ==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.DotNet.ILCompiler";
+      version = "10.0.0-rc.1.25451.107";
+      hash = "sha512-0x4km79b8z+HFPd1qXOhx65BGDLRYECLKbjyzhrFaOx69zBNQHbL7nqTS+qXZ0BzckdGEBARrYa80QinpIIF6A==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NET.ILLink.Tasks";
+      version = "10.0.0-rc.1.25451.107";
+      hash = "sha512-XisyrroZsOir2prziGawVqx8sVAFvyamu5W5ordZYYuHIr/yeLlC6xDCgZ1CMhHE00ElUyc34ChHl6gUgQdCeg==";
+    })
+  ];
+
+  hostPackages = {
+    linux-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-arm";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-OaAv+l8BEw6MTrpB8e/j3QBGRR5IUr9pX5cjP5e0ooc71fl2JYVmcSgiY+D3diEHhkCMf5T9A+esQxctbZ1CIg==";
+      })
+    ];
+    linux-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-gh184Rc4Jappn49zJ8Buwv1IQYjnTsS5Y2NRM9Un9m9lazL4vGTrnn3JArCJhq30K9Fhs1CkOZdbqGT3RFNYcw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-qkVVYbGTFTdyrLjPTbzglGNdkL6R3z/DBs+rxcM/T7AVwP3Tz8WKkoFRZaRNclrwR2ZuEEACBvMULpTAF6HJqg==";
+      })
+    ];
+    linux-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-P0WUXdJK1STziFoDpTuMqPy8uU6ZyVaRe2zkoOZsQZi61wKjT2SDMvF9hn6qWlcOI9eUS9sriqRsErrdjiICAg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-x64.Microsoft.DotNet.ILCompiler";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-6z1jv0LvBwHU+vshvjc/PHb0f5QtKpTukl5QajjcwzP6sJ4tBKJejbNNYuFhUECsetMbtszBHhTuqSC/wTY71A==";
+      })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-EmYPxjHZfLErsOcJlqBwI/zk74tHsT46ItDhn+a8OzBWJkFBrjpbgjHwyx9kEYK+jrXZv+o2WpWVVtmBD/+zyA==";
+      })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-6W1aeaZGo6oQGRAN016jgsLev1RKqktn8w5+omWLgq5L8Rq1SCMp1qrutiJmMyKHS++9c+s34ze5uF8iz3jnUA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-pZ/VK7ghPyIZGg0GOJpc8PWuv1PZe30t49tkBpT7ge7w2CAs+JYHwLL1QpkRVuhlokL12ReASj06DNy6rAMV5g==";
+      })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-k43sAfvYJ8+dupxMpwBAuY8g8Zyqt6yvaZfguWfZDe0o7njGlVXhllq3IL+v9WGMjGf4Cg1WEXNDuldn9yVzhQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-Ikd+sEhKE0Tgl5jrGGQgKvVuk+/e3WmXZcUwheBmQqpggs7YMMD9k/BMxE5ro5G9ENEmP8hfJ9suJxG2OupDPA==";
+      })
+    ];
+    osx-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-FxbAID6dZL0aaKDFr0usSHWC7JZ0ZqZVMIP20rWZJ2Qsvg9C++yoMoRxvfj/WD6ZIbSaU0sg5HxS2OxR1N37Kw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-arm64.Microsoft.DotNet.ILCompiler";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-1PC+i3R6fAauQoxegCNPHaHx4hwkkHv6v2+OotoAGUf1Dz4YyED/Ho10HW+fCHklBmHkcg6CMMC3IzuPIo7IXw==";
+      })
+    ];
+    osx-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.osx-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-s6K4cCACFPHmvJddqn9zVrz1za9CjyOMNgsZA4Oi2ItTgsCB/pQzr6IpCUzZKrMWiojxHCSx/uch7V5kWE+GVA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-x64.Microsoft.DotNet.ILCompiler";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-SawdfjnEJnfC/W9ptl89rS83enNKCyoDN2x459bx7I90U6AfGumGd2r+phGBGyHRhhiLHt7+z+3mzs2uuId6Rg==";
+      })
+    ];
+    win-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.win-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-rHnlR/R0UqASrXuSQD2rJoN4iOrJcexSHmk9nPfCDIgNYSd8c/8JE17SGU7Y6ufR0JuiP1f09KV2jibaKutHEQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-arm64.Microsoft.DotNet.ILCompiler";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-CrFnRAHFOQUFaU3Q2XlJeWN9pKUX1YVZDTHpZ/e0+t1ZfCuu28CRmCdaB7OoWcwRRA3z8CqniK/sUpg+VmJhfw==";
+      })
+    ];
+    win-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.win-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-mnfrlJ2jELYNVRZEXsgJdseeiEIkjIME6I/GFO8jUaXW1v1ydYSs+AycagoNqNb4Ac231DLnLu8LU15M2YJljA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x64.Microsoft.DotNet.ILCompiler";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-ELGeVjCCBpYHZFl0wYqztcb53M8fHcuhX8g5Hp6ycUlc9sD6Zg7lXOh3fXSHOf73wEG9125DvC9U0eMnnugV7w==";
+      })
+    ];
+    win-x86 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.win-x86";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-DQ4H2zfLSkyh8LyfdUUhgaWIZWBsuK++gE0++1KVgm6MceKAuoShj2vJ7bdGSaSJIrlg2Mcc/USgNpdRcXt4vQ==";
+      })
+    ];
+  };
+
+  targetPackages = {
+    linux-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-arm";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-V76NEL8Pf7FMvaglUhYTWvmbQlQHF4MKTWXU5z6l/63E/NE/GijuXi9+otgGmlfxBKCsdbCm6+JoMx3H1YQy5Q==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-arm";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-HVKJb0V/eNXtq5wqhN/cSYcTWpTVtGQCg1ZhfVdAftkscOYkSv+IoDWMptmoMnmW91jTpe62+KkqoymNRQ8uqQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-arm";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-XooWEHZOLNd9G9+/Vh6zb7dP+FiW5l5DhLeWLreThBr6PVvojYf8fSB/J7gqk59x+mjgp+7JyLWDRBljiUbM6Q==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-Z3tvIyDNhcR0Io5A/SxfhegCxX7wZwja9v9o/PJbwFgAJKby3YLv4Z0bFVt6h7UgtcMZQqzHFOn/pwsTEub0Zw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.linux-arm";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-MR2RtWm4VBoGST8XUmdEIQrLVktNkp92pblT1NSd5M09v3pU7eNeKwt/BvO/BE+UVrsLbHXrXAJ+rP3Ycw7qqw==";
+      })
+    ];
+    linux-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-/za89BIwa39QXQOKX9S91MAJqnO9Xuc3s+LTiTK2/rwNYJy2TwB+wB8RKqjGg/Z8nejgHrjC4+7V4krvVBf5Rg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-a5mSgakxI87jUB3EhXje0LbbU+RpYFq+kI169o7dLH4jg2nDE173cvh19psJrM08ktwOYClGyvIAuvmeEwX1RA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-zR78sN00inx8O5CyDdDcwuvwUApTZlYSmA5t+wd9mzzKVIGbZ4Cz9vEcpN8aHUN1XDEBATbx5wSkjB5GepfNVQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-BJURYGy/fPMPR2V2ba/rtHCTpUfJzioEYLZcckSUj3+wYsrMyy55sF0nI9Ds2p8Fg/EalCFXoHYP8/2euX5Vlw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.linux-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-oM+nJTEa7d9PHjAMuUCvKDtqqPPrFXJpoMacVPgYw3pAOsSp/g9mrULkD/h5paeL5v7cAsSf6bvHZEUkoWwbIQ==";
+      })
+    ];
+    linux-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-znRScAxeGIwwg6vKV2ADd2EDvfQLIubASsgoVLLVAOIW+W2LGF2Ia3uxgozn0b9wf2fV29w0S5DaeY97xl8DXg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-xA5c2BK8D2p5xsJXvlIutBAjVBUWUVM1f85doMoIgzPwUaceyl6eFsEQ2zjDh1HCgtdkGFeJpGQ4aDzpKlpa3Q==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-K9FqPXfxZLiWkreTc8hXclaxo9mQ4EkHeAihT4NARE9O9lkVOZTBEZo+BcZuZxLZgO3Pj6GtBncMvTBKn6r/Hg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-a6OPa8GApjr1CuaIREog/GL9pzxHiorvCP/YaYZtW0yNtRSv06cbdwEB+FYxc6tDSMIClzrUwshyR/hV5nSd0Q==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.linux-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-ed/97KH2jVc0oedjN2EbzkMpiynEMr6YEhQWvGE0NKugdGLLR6Z72b1NyImy64UOs2FZX3zWg7tBBq+rDwlo1A==";
+      })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-LzquzSN4IqJg/EADkUT8l+PCgGyuPcb2K80Oq9MXSgAEVCD2SRd3GepER785CpIlZfeXQsd4lsaklBo7GSoTBw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-musl-arm";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-IFge3TxF+cZHd1z2RPokKpGiqNtSp2WtGza0HX9RYRHewP0hARf0d3hq1bDQAMLjJxf8mvoakDoH190dyXQITA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-0G7roKbZ3URRaC+cOLAGkGADaZpUD4AJoYJBVnaH3HRsizbG7gASjmLfEiN6kvMnJI9Wf6K1f2yXVQeBryIzdQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-oWghxDXOEcNSUvjUuH+2OfqT0A1+MWf8YTNwMgRsxKQR/1XFtKthjR2oNnji7Jy3+2Tigmh4qeOOqk5VFNWeIg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.linux-musl-arm";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-AXyNqsmO+buzieRznlOThn0IiFWyTKInH9+7yq6EceZUFBmEanPrgKDZAOxqSjJ6wtOPo4vBkKhO0/7JB8kOeQ==";
+      })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-siYdx85ZKIejQRsVe2+kQi9b2u1/6PXu0meoCoG/VQdl3zVXueKCsZwZne3yCou4lvxX+PnnGkYXk2tr9vVf4A==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-musl-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-bOcl+8cIvTOtlYHJaHA9A5ebYma4XYjv2L3ziW+gG9HTOAgJjs82ql5RF7yRnHc/dPfvteeAOQzmaNJYFA7yvQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-nRq3fnqsD3vc7M9GewuY8eX9spFG10t5NbrBAwMZ0EyZXbN5oj8oX+O3croxGLvmED9E4OhTY5Fn30EoKTnYMQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-7uMe/dvlcUoQbQ4U4V1esj2kdzR+d2G1IDqW7PEO46Je7alN9dGCaFjrYfg4H16g2p/nkguqregXXt51Nv2Tog==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.linux-musl-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-65sKH2vG/00xutyEIPB9exGkhpG4cwlYvkty6AdI/2g7Zvfke5WT2UW2aME9vVEmB4Zn+gNDTaRjRyFVK3n7SQ==";
+      })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-wAhZFtY3E/JEIfkGdX/P2MzYj09G1tDrPi4+zaCxFjXzgcxfU6vLPNzaR/EMQb82ibluhiriFTG1aeCJBd2qpQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-musl-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-ALDcdrSuoBXDekpuPy3J+RS8vu6d3vt5HTaZkfT6VpJGotv9qq7cvm6kZ10VfFmZ//UbC8LibDsJk/jbzGf0LA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-2MkZiOoWMIBfx1a/lN3Yz4qWszpjkynS6LR4nT89uCjk4riE+xpx2JQb5FDxVfxLFBoYlis4wyMmSrqLSd1pMQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-7x0L8WWLcShkEROnccmVsvAEB11yfvV21lngDLlgWPKH7b/YBHjziS4rlN6pzuA1xozViQkUByyiRaMIwRm4iA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.linux-musl-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-kl/eWcRGhOnIFhwPexi0qRLw2x/hV7SNkX9FyasNUkYi/6HwMOBViB7RnZe1iV4NRZF6153Nv7Z949/DkUFb2A==";
+      })
+    ];
+    osx-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-LNwqyHG1K2o2olSjErf8m+O6vxh3iPHLu05s4GRDYjyUz5uaunEwKVi3m7Nj3EmlQdxnfrpoLH3cfXuA7/mNsg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.osx-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-1YxkbUSrVZXo2IXlIrB0z3B0wrkHtgIcVn1M+7b7qM0Si9KGFkZzsI7T2X7CQwW01jpRbv1NcQW8A528i1DOWw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.osx-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-Z5Rhv4e0FljV3m+w4F0Ek4SMuRMpvDs/tsrYmwZboj7KAECrQ7PXWee93FbcecK6Tu64ZtvsU8fkWmffRqfp+Q==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-McSCf7ELjtNy6gbV2EFU+D1XEi7lw1xI2eqv8VGqX8FyOHlC1nofhyb0PLd7OQLelQpR9Xajv1JuhzUtPkhgPg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.osx-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-RmJ88+HJ9AqPIMwIlJs/Qujmab64997iyQ3kKdORrFIezKd85+zKgHbnM+CUbxAzqpBNufECmhWm7oXMjyoPTw==";
+      })
+    ];
+    osx-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.osx-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-ORvugqCwtaRhQ1T9v9LPNI1TO0R3WUYsCyHPU+eBSmoesTql5/I6fEVqyuRrKGf94PlJAyY2w6tSeluV45B9ow==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.osx-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-sK/K13o1GY/6MWR0ZrqhhnG9wXtZSISTSXOo8hA/SL/OXEyucXlXyxgXaF5bGtwnUjgibObA5B+4Z8RJlMal0A==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.osx-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-um50+EJ40pHY1ufx5lcVPWjl5eWfHF8Jg/d90XMRD69R1DJ8oOhPTWYSlia6F1AWyW/DQ/ncf4SphUzLNFpdOA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-0OuXkUPLTxK9aOijYilEOvJI/wAA9ohXy7Y10tRwaNX70oNkUA8C5VUuW1rrdMqhrGk1tLaE98DrN9IXXyP3ag==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.osx-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-B8T4TBq/pkJxzqC/GgJ4UmV1xEeMsLjnnyeaFWXfN06HGrlIumFLR0GQu5PFmwEDjgS9m+sJ1m2CYP3FGAeaRA==";
+      })
+    ];
+    win-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.win-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-46d5U65sw8Qr2qXegWUtZ822g+AYLGMNo+BVKnU8xZQNyom7Kib0bFHnqJ2b0vQtYP/Z0tEhOvKc7cwu1Yox4g==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.win-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-RdNmEOu3U0aPwLKL0mTo48/Ou9RBg/3lVcp21iVQyqDmqRBJSSWnxzPwqQURUvY8GbYb//gSezJYBll4BgqgRg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.win-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-yDZ/fSQckLPS0rsYRBMIgAMcm1ZJspToWoHrM2OuMjkoZU8JPGebekOAmW19EsAz9NzEiVoAae4vOVCQSQEWAA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-OEb/13XW+yXDYWTZIV9qspJ/ahWY5j7UdJo+vuwW6VOxHv234ZHHh9jV6jQxFxkipaq7FgtWXUqk4oBDGVF7/g==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.win-arm64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-Le2dxO6rTOvCVdWoITiMzo9H8oTWqyOHW+dvU6dXNVVNHnM3N40ppXKaDjA7jhFc0kJUjrTj2anQcdSFdmgUzA==";
+      })
+    ];
+    win-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.win-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-G9CQRcLF8jfnqWkqXdrVTGO9Z5Jie4HTJZ0MUJl9wlIbKT+U2gPQq0PPEHOtPkbuQuJHyxFg/v/i9Dy8/v41QA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.win-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-GHAP5bqAaWMg5SlrQNPJxSsCKM7Wc8JfFBDxJKdwBFe+zb7WHJdk4cNftM2HKlM9aFaljKVx5zyLuky1yI8fTw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.win-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-grvZytFhVIuIOicS6Fdbf2YMqZ7rZ8TbIac4MBeDDlTWkCO62EbL+lUZbUStHnmnDdOnkOa2OtNsuCQCKr5ftQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-EciQy/vlJDOXBDDvCiMfwdRmrqL8p6K5DahT3cjJ5R2g0vVDQ9M3oEUqjQhqIhNZddL3EVqaAIr/JVk9DW4NXQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.win-x64";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-lBu7jV6lNTX2YJ+sNh25yvQh/15zw1vrzMZy7zypuXi7dwy4TNCf1AyJzc4YYTpkVAsQLStEofQhZ8acNweY6g==";
+      })
+    ];
+    win-x86 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.win-x86";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-c1BeA+VI35IumWblDAB7kXHPTWA/CBexyySFbT5MizGa8tcjL3RPr5sYctyAN3wQ+bt47X1XpWxibBzERXj6qA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.win-x86";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-Pa2P9F6OZ8GTmGk4hPqBq0av9r11gicHEteG0l8tV+8vpvbcwFGDS04dYJkDehoCMhyDpVI1N1h2oEzN62bSGg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.win-x86";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-Z2Hcf39NRB0bZwVZ5y3Wf8ETRkGCxkCjh9VpNlHUctWxYzGkGi9/Rei6wJNVh/XT1zhyN5eh3uH8SukbfCErzg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-mzXyLP0VOi4QTII1lfVoDx/vZ/1SQD+cDsjjcNDdPLr3ufptEg2j2SAFnvKyurOnzlbnZdO1ogip0VLGYUFnyw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.NativeAOT.win-x86";
+        version = "10.0.0-rc.1.25451.107";
+        hash = "sha512-7vF41HU0xbpHBA7IX3Fs0HtKOgtXplTIkPWJ1FOpDxjH/R6xPCWxv8sRUNeh8SGhs7mGpf7rwcDGIEIapVLcBQ==";
+      })
+    ];
+  };
+
+in
+rec {
+  release_10_0 = "10.0.0-rc.1";
+
+  aspnetcore_10_0 = buildAspNetCore {
+    version = "10.0.0-rc.1.25451.107";
+    srcs = {
+      linux-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/10.0.0-rc.1.25451.107/aspnetcore-runtime-10.0.0-rc.1.25451.107-linux-arm.tar.gz";
+        hash = "sha512-gQWKGGYpZ+glr9syJBA/2xEc4cD8MDCFfGLMStHHAW9JdH1zPXWM4eyoAXLeJmyBEmr4mB6+HA1d9yZGZPm2eg==";
+      };
+      linux-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/10.0.0-rc.1.25451.107/aspnetcore-runtime-10.0.0-rc.1.25451.107-linux-arm64.tar.gz";
+        hash = "sha512-vYa6xIQFCE/sthAmDmCh9kXeRV368gjK7JdxrxYP0de9yZpKH4gWnBzvdZVTbVXcVxRyynoVkoJx1ArkX97e+g==";
+      };
+      linux-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/10.0.0-rc.1.25451.107/aspnetcore-runtime-10.0.0-rc.1.25451.107-linux-x64.tar.gz";
+        hash = "sha512-0iGYUMq3POvjYlo+UyHGfikh07/vtsI4BEoh2KlcoHynMVB7p8AnqLA/6O66fyPY2ITTTwJDfWpYMEI0hAU9cA==";
+      };
+      linux-musl-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/10.0.0-rc.1.25451.107/aspnetcore-runtime-10.0.0-rc.1.25451.107-linux-musl-arm.tar.gz";
+        hash = "sha512-AGgWPjB0ejP5EVLthi8okS/4A9rxK9kVpS/rL/0GqLFTwMidnbllZ0oR/9ct8rE8uikSTCqXkL3jjWDelxrNeg==";
+      };
+      linux-musl-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/10.0.0-rc.1.25451.107/aspnetcore-runtime-10.0.0-rc.1.25451.107-linux-musl-arm64.tar.gz";
+        hash = "sha512-0w4mUoypPzUn81NduD4eGazxLXhwj0si9c4pdTS0fYMHqeNGpYgqrxWfpzuATN9x9cWeLtOUjKuu1cc3kQr7NQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/10.0.0-rc.1.25451.107/aspnetcore-runtime-10.0.0-rc.1.25451.107-linux-musl-x64.tar.gz";
+        hash = "sha512-hs//dBAVHciEJ9C5x5UZTnnYE5Ya+SoCYE3UenPIemLMtsvf1m7824oQlu59FTjFNfgBbXZ6Gbz3jM26vs8X4A==";
+      };
+      osx-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/10.0.0-rc.1.25451.107/aspnetcore-runtime-10.0.0-rc.1.25451.107-osx-arm64.tar.gz";
+        hash = "sha512-4erPMY9DFFB8uXn7jw7ldK1FCumPa+K8CzXcSt+EeKq0vs1q98DSrFaCundnoRkKT7X8mze2a1rTYmBt2YGk1g==";
+      };
+      osx-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/10.0.0-rc.1.25451.107/aspnetcore-runtime-10.0.0-rc.1.25451.107-osx-x64.tar.gz";
+        hash = "sha512-XWSTyx94DCBb0hjJmQ7p6KvES8gdho0ZYEbWj/MN8LcHJe/67i7jez6CrnW7DRoUtWwKOWQreubQp1LGvJ6piw==";
+      };
+    };
+  };
+
+  runtime_10_0 = buildNetRuntime {
+    version = "10.0.0-rc.1.25451.107";
+    srcs = {
+      linux-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/10.0.0-rc.1.25451.107/dotnet-runtime-10.0.0-rc.1.25451.107-linux-arm.tar.gz";
+        hash = "sha512-k5DvoQVATX3xd52jDNO5Ufta5oFU4dzqKA9BclduVGpOJuEWgqgHi4N+CWWoDgbqxdrLtWzXBFpEzP65AdJisw==";
+      };
+      linux-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/10.0.0-rc.1.25451.107/dotnet-runtime-10.0.0-rc.1.25451.107-linux-arm64.tar.gz";
+        hash = "sha512-jXbk5mWvff26Xkoxy28buxh7wrm43lZe9e1xV2ja6FkSMEKvezhHZAltDLiaPWCfnkm8J8Ip0sEWVM1IiJYmPw==";
+      };
+      linux-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/10.0.0-rc.1.25451.107/dotnet-runtime-10.0.0-rc.1.25451.107-linux-x64.tar.gz";
+        hash = "sha512-v2t/ca+OsG6guof80owXgiLQ/JOlscqTZgA8JPyvvcSXs4gJ5DEKl7+wT9J6C26JLnbo1AP2AY1vyViMajgXDw==";
+      };
+      linux-musl-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/10.0.0-rc.1.25451.107/dotnet-runtime-10.0.0-rc.1.25451.107-linux-musl-arm.tar.gz";
+        hash = "sha512-GXH4Fi6PENK4qKMT7s1BgF00kdKHLGIrzxhdnBf+ghg3CvAhkg0AKXnOa7EEO/eg2RPi8nNG1kveoXxJmTWVIg==";
+      };
+      linux-musl-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/10.0.0-rc.1.25451.107/dotnet-runtime-10.0.0-rc.1.25451.107-linux-musl-arm64.tar.gz";
+        hash = "sha512-KU3/OCc6q1Muqu15ATmRJQkGEvIfjC45OIXGG2Saq/WkzLhQ2GYvBI1aIfNb8wArA+AcVJd0d6NRkAhKbtJfWQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/10.0.0-rc.1.25451.107/dotnet-runtime-10.0.0-rc.1.25451.107-linux-musl-x64.tar.gz";
+        hash = "sha512-FHVFTKpRnNOvpr+3qVF1B8SRTFPQp5KO9/XTQqVr2jUaUL3ClCT648tezazSPX7zwYfdx5kyzKRjm5qkMbElbQ==";
+      };
+      osx-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/10.0.0-rc.1.25451.107/dotnet-runtime-10.0.0-rc.1.25451.107-osx-arm64.tar.gz";
+        hash = "sha512-2faVsHe0g93Wririe3Hn3hY5sR+jGQVIKhvJdXSHrNVL9qR4FrAkQVjZG3ZCPFQsaiguR3BaFFJXYergsvpQRw==";
+      };
+      osx-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/10.0.0-rc.1.25451.107/dotnet-runtime-10.0.0-rc.1.25451.107-osx-x64.tar.gz";
+        hash = "sha512-XOjEkl0dL3D2/NbRpP0AH6wFowKWElGaHpbNeE1WmkgT6PHIWlE463WiLdPE7C2acEZciQQqaFdqeWWZbl7agw==";
+      };
+    };
+  };
+
+  sdk_10_0_1xx = buildNetSdk {
+    version = "10.0.100-rc.1.25451.107";
+    srcs = {
+      linux-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/10.0.100-rc.1.25451.107/dotnet-sdk-10.0.100-rc.1.25451.107-linux-arm.tar.gz";
+        hash = "sha512-SnuClIY0v0mB5HspK/xPlAeSWTbqc2QgpRrM8OzQXG4aqhx/+UDvV1CxHNe5AkkLii9NpzDtcphGJwdR860LVg==";
+      };
+      linux-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/10.0.100-rc.1.25451.107/dotnet-sdk-10.0.100-rc.1.25451.107-linux-arm64.tar.gz";
+        hash = "sha512-calHXMECIFjzOR7vhQtRhEDS4TTeY7HLi+BIqw3NwTOSiMVlboBrEJemA/0cJl1OZ3NZCCYRRiSC7kAvr/rD0g==";
+      };
+      linux-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/10.0.100-rc.1.25451.107/dotnet-sdk-10.0.100-rc.1.25451.107-linux-x64.tar.gz";
+        hash = "sha512-uzS5PVriMQHmd0gA1hJDwjatAfJ7IqFnDZh8EGjOB1YBtN/VITIKclplS2Vf/ZEoeLL8hDYXoLOMWmHzCkzSnw==";
+      };
+      linux-musl-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/10.0.100-rc.1.25451.107/dotnet-sdk-10.0.100-rc.1.25451.107-linux-musl-arm.tar.gz";
+        hash = "sha512-YdcnEuKVJQ89I0OvqXvnwnK34pIn3Prb0G2aR+wrhxWNOi7B9VnpiZekz3mlQQuFAhpmkKi941BnKEkmsjQusA==";
+      };
+      linux-musl-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/10.0.100-rc.1.25451.107/dotnet-sdk-10.0.100-rc.1.25451.107-linux-musl-arm64.tar.gz";
+        hash = "sha512-/1HV6qNuFkmAr0f5nuX2CbGf188Mr34WfUDG8wMkByshdhUo8mbGuSHAfn+sIkBwHn0bmvirVIvNBdNyCKpVlQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/10.0.100-rc.1.25451.107/dotnet-sdk-10.0.100-rc.1.25451.107-linux-musl-x64.tar.gz";
+        hash = "sha512-zH65o01c6pdXkRWRpFX/IJDTIcP/XioWyBGe3+0Tzn7/H/9AgTTYtaYr/7sbiH6mzLYKdJd6XOd6KZc18J4Ciw==";
+      };
+      osx-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/10.0.100-rc.1.25451.107/dotnet-sdk-10.0.100-rc.1.25451.107-osx-arm64.tar.gz";
+        hash = "sha512-Q8Uy7gqgPwJF7wVXh4nASCLqacOOhS9XuwobSzR1D20PjHeghcTrDWEwGPg2dK+5CW6Z/OZoqHYwmKvoIbm34A==";
+      };
+      osx-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/10.0.100-rc.1.25451.107/dotnet-sdk-10.0.100-rc.1.25451.107-osx-x64.tar.gz";
+        hash = "sha512-k3DDv4JJjXPBc4FCN+zhCMIHWOhCk+dlMoN9h3vn6+mqinL/7os3G7wKzqokEQ03eHFTIneKQhWb0ykQ2p8HaA==";
+      };
+    };
+    inherit commonPackages hostPackages targetPackages;
+    runtime = runtime_10_0;
+    aspnetcore = aspnetcore_10_0;
+  };
+
+  sdk = sdk_10_0;
+
+  sdk_10_0 = sdk_10_0_1xx;
+}

pkgs/development/compilers/dotnet/10/default.nix

@@ -0,0 +1,12 @@
+{
+  callPackage,
+  dotnetCorePackages,
+}:
+callPackage ../dotnet.nix {
+  releaseManifestFile = ./release.json;
+  releaseInfoFile = ./release-info.json;
+  bootstrapSdkFile = ./bootstrap-sdk.nix;
+  allowPrerelease = true;
+  depsFile = ./deps.json;
+  fallbackTargetPackages = dotnetCorePackages.sdk_10_0-bin.targetPackages;
+}

pkgs/development/compilers/dotnet/10/deps.json

@@ -0,0 +1,50 @@
+[
+  {
+    "pname": "runtime.linux-arm64.Microsoft.NETCore.ILAsm",
+    "sha256": "f4222e017b34fd1aab9c18f83a800c6ad506aa9de9c2dbc01ff0d08ee77c64d1",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/299b99f1-f3f1-4630-81e2-4fb223c52e70/nuget/v3/flat2/runtime.linux-arm64.microsoft.netcore.ilasm/10.0.0-rc.1.25420.111/runtime.linux-arm64.microsoft.netcore.ilasm.10.0.0-rc.1.25420.111.nupkg",
+    "version": "10.0.0-rc.1.25420.111"
+  },
+  {
+    "pname": "runtime.linux-arm64.Microsoft.NETCore.ILDAsm",
+    "sha256": "3020dae646564df57f13443c749afdbe02fe696ea6f795657d431e5f134dec5d",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/299b99f1-f3f1-4630-81e2-4fb223c52e70/nuget/v3/flat2/runtime.linux-arm64.microsoft.netcore.ildasm/10.0.0-rc.1.25420.111/runtime.linux-arm64.microsoft.netcore.ildasm.10.0.0-rc.1.25420.111.nupkg",
+    "version": "10.0.0-rc.1.25420.111"
+  },
+  {
+    "hash": "sha256-6CKoHQ6npL+zAKjx3hgAKAQnMvHC2jircy5A5i41SNA=",
+    "pname": "runtime.linux-x64.Microsoft.NETCore.ILAsm",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/299b99f1-f3f1-4630-81e2-4fb223c52e70/nuget/v3/flat2/runtime.linux-x64.microsoft.netcore.ilasm/10.0.0-rc.1.25420.111/runtime.linux-x64.microsoft.netcore.ilasm.10.0.0-rc.1.25420.111.nupkg",
+    "version": "10.0.0-rc.1.25420.111"
+  },
+  {
+    "hash": "sha256-VNhtqxkzIYd6KHZK86ZagD4P6HCYzgIGERPjhZgDq1U=",
+    "pname": "runtime.linux-x64.Microsoft.NETCore.ILDAsm",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/299b99f1-f3f1-4630-81e2-4fb223c52e70/nuget/v3/flat2/runtime.linux-x64.microsoft.netcore.ildasm/10.0.0-rc.1.25420.111/runtime.linux-x64.microsoft.netcore.ildasm.10.0.0-rc.1.25420.111.nupkg",
+    "version": "10.0.0-rc.1.25420.111"
+  },
+  {
+    "pname": "runtime.osx-arm64.Microsoft.NETCore.ILAsm",
+    "sha256": "609cd171ad2358ec195d19b9d466a954e8b7ec20b1af6143741aa03840d535b6",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/299b99f1-f3f1-4630-81e2-4fb223c52e70/nuget/v3/flat2/runtime.osx-arm64.microsoft.netcore.ilasm/10.0.0-rc.1.25420.111/runtime.osx-arm64.microsoft.netcore.ilasm.10.0.0-rc.1.25420.111.nupkg",
+    "version": "10.0.0-rc.1.25420.111"
+  },
+  {
+    "pname": "runtime.osx-arm64.Microsoft.NETCore.ILDAsm",
+    "sha256": "7fd9df0ebb210b51a3586afcaf1eea269c7d4d9fb9cffd5931cfacf28c298095",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/299b99f1-f3f1-4630-81e2-4fb223c52e70/nuget/v3/flat2/runtime.osx-arm64.microsoft.netcore.ildasm/10.0.0-rc.1.25420.111/runtime.osx-arm64.microsoft.netcore.ildasm.10.0.0-rc.1.25420.111.nupkg",
+    "version": "10.0.0-rc.1.25420.111"
+  },
+  {
+    "pname": "runtime.osx-x64.Microsoft.NETCore.ILAsm",
+    "sha256": "6107d07f2e0754efe41ef87de31219e7468e7fd305c2c9f2925cb607e7b3c6d0",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/299b99f1-f3f1-4630-81e2-4fb223c52e70/nuget/v3/flat2/runtime.osx-x64.microsoft.netcore.ilasm/10.0.0-rc.1.25420.111/runtime.osx-x64.microsoft.netcore.ilasm.10.0.0-rc.1.25420.111.nupkg",
+    "version": "10.0.0-rc.1.25420.111"
+  },
+  {
+    "pname": "runtime.osx-x64.Microsoft.NETCore.ILDAsm",
+    "sha256": "acb299873fdfea3672631696b78fc40f23347783b43b8464eff262a8598f9bb3",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/299b99f1-f3f1-4630-81e2-4fb223c52e70/nuget/v3/flat2/runtime.osx-x64.microsoft.netcore.ildasm/10.0.0-rc.1.25420.111/runtime.osx-x64.microsoft.netcore.ildasm.10.0.0-rc.1.25420.111.nupkg",
+    "version": "10.0.0-rc.1.25420.111"
+  }
+]

pkgs/development/compilers/dotnet/10/release-info.json

@@ -0,0 +1,5 @@
+{
+  "tarballHash": "sha256-irvbvBrENVa+7C0Vm7bQMcUoirwxwha4BoOiLhD7F4Y=",
+  "artifactsUrl": "https://builds.dotnet.microsoft.com/source-built-artifacts/assets/Private.SourceBuilt.Artifacts.10.0.100-rc.1.25420.111.centos.10-x64.tar.gz",
+  "artifactsHash": "sha256-vXoVORa2ZB7HQ3gUy1L9xZaqBDO/fbTcMt0HlqmcWGA="
+}

pkgs/development/compilers/dotnet/10/release.json

@@ -0,0 +1,11 @@
+{
+  "release": "10.0.0-rc.1",
+  "channel": "10.0",
+  "tag": "v10.0.100-rc.1.25451.107",
+  "sdkVersion": "10.0.100-rc.1.25451.107",
+  "runtimeVersion": "10.0.0-rc.1.25451.107",
+  "aspNetCoreVersion": "10.0.0-rc.1.25451.107",
+  "sourceRepository": "https://github.com/dotnet/dotnet",
+  "sourceVersion": "2db1f5ee2bdda2e8d873769325fabede32e420e0",
+  "officialBuildId": "20250901.7"
+}

pkgs/development/compilers/dotnet/8/bootstrap-sdk.nix

@@ -0,0 +1,748 @@
+{
+  buildAspNetCore,
+  buildNetRuntime,
+  buildNetSdk,
+  fetchNupkg,
+}:
+
+# v8.0 (active)
+
+let
+  commonPackages = [
+    (fetchNupkg {
+      pname = "Microsoft.AspNetCore.App.Ref";
+      version = "8.0.19";
+      hash = "sha512-P0MXwA3k7np2YGyPmYZSWIICTCwzGGka350Xqa+EucRAn9aoyurrm+ZjCJKzA+N9gRc9BaFLaE8p4vLDzQJSww==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NETCore.DotNetAppHost";
+      version = "8.0.19";
+      hash = "sha512-VhKbsaln9sfOfDvxFh3eVnIQEZhfPnXG9bV9N+unU1GqcZ/CaTSfe1ASAJ230LtMlrtxNk3EqUgSQGX0TQITLQ==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NETCore.App.Ref";
+      version = "8.0.19";
+      hash = "sha512-qtdfpsuFFEQx+26ZUv/95fSUYSpZ6r2Ch0vFKgIwnnwtEOEw7B6h8D8t9P1XkYn6tJvHTdSC0ohcOk+HwELU0Q==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NETCore.DotNetHost";
+      version = "8.0.19";
+      hash = "sha512-PMYSj+WRBCmeERhq7w+qzqCDAKNR5t2EAMv5w+TFzehtfqQQR8rKZDpYAmzYFaWl6Rn1wOZmjHqsaGbvoL+eMg==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NETCore.DotNetHostPolicy";
+      version = "8.0.19";
+      hash = "sha512-42gDcb3t2l6sjYOGsDtZiR/PuY99Ctj0UnUgY+BeavYXqM2huKLa+r0Yg8YRJLkLeWF/MT3KXRReUE5Dnu0daw==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NETCore.DotNetHostResolver";
+      version = "8.0.19";
+      hash = "sha512-lvC9ihhOhbjbAwG90fnb6BIHnB/kz3HDz+9JSTaoBIyd+XBnckIWdtDxPtroWrvoWqydk0TPYxPXNGDY+I4E3A==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.DotNet.ILCompiler";
+      version = "8.0.19";
+      hash = "sha512-oADBsA42EoW8MmpuTl5e5TrNZSNtlpOPsSWtY/dmVdK7EJf1QAQdvHAxZQ6IGDNsKrI4h0VEo+75Grmmc41RTQ==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NET.ILLink.Tasks";
+      version = "8.0.19";
+      hash = "sha512-GoPqp8InCwdG8uqW1M5KOqlBHyYLFRuHRQxhBKNJCVwv+EIkCbVkxE+SzLYQaqMZZGOl86WFBLDMdTq0d9+Tag==";
+    })
+  ];
+
+  hostPackages = {
+    linux-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-arm";
+        version = "8.0.19";
+        hash = "sha512-CBq+wJbsMgLVJJLS7vDyefSpH4f5VT0+m80rmB/XtwiFNe8oQJHs3bRpSef+JnKCJoU62ijGs8IQMFsXYbraYQ==";
+      })
+    ];
+    linux-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64";
+        version = "8.0.19";
+        hash = "sha512-jTF36xYRwLtBq67lUy2IBUZzsRK6nTQuduGtaaWUqO6YcTb15SzN17MeJWanD1nEeleKWR1AL1GJb2cAsEnUiQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler";
+        version = "8.0.19";
+        hash = "sha512-EryMsQIZXDc3NLdZ2c14LV7XxkTtIJrF2e4uVE8Ycvqo6PiBZdUiuNEe5HI/wsMyOx5TJJWVW8M5bvykSFNUpQ==";
+      })
+    ];
+    linux-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-x64";
+        version = "8.0.19";
+        hash = "sha512-ovKKlV/bfPMcOX2NIr7QXZwZceFSqFwwzLdYNZI1sm9WsXuc3oYrwUoWwcyjXobAQGo1pY1QW6l2eU6TFIDBVA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-x64.Microsoft.DotNet.ILCompiler";
+        version = "8.0.19";
+        hash = "sha512-YuSYCslUdV+10cBI5q3oIxVPFWeQPXMAnkdKpZtOFNCPy+1I11cali6yKe++Dq1LeYAhviLbYnnL+1nFPP9jPA==";
+      })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm";
+        version = "8.0.19";
+        hash = "sha512-KHOxnCTTVWjYhItEHUi437lfjTz7GJDN7UjUILN1qe0q1i0kFA+2HdQwKt/SKBdF9iMJiDS/XotD+EOYbWSS6g==";
+      })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64";
+        version = "8.0.19";
+        hash = "sha512-cDvawzOkUtG+BMHhqrwAu3F0AZIXoeMOMAx43x5zH1XerKAGh09ggu53jnIByHmYHI2F9Wze2fSwcmNm2akkgg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler";
+        version = "8.0.19";
+        hash = "sha512-X4Ku+V3mehusrwoGqQ6PSoWfvCe5cMepsoKG3JSylJsd6CL2MzMBQa6CZU8ByB29JE/dwOo7MmYbNsxdDACq3Q==";
+      })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64";
+        version = "8.0.19";
+        hash = "sha512-MnPFQfcebuYBLfIxKrzO/z6fNGhUpm8JMtDkoX9zm/OitWkHBpYhPANnz4baao8t/X6xvLY4jgURXurqt8VWIw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler";
+        version = "8.0.19";
+        hash = "sha512-eGiP0kagfsqjLFYuW21kAriFJ0EdThyCpPoB1657p24cg4Xhd2Yeh97FU9pb0UAZA4zqjhqcCmqWvcAbyx5Oig==";
+      })
+    ];
+    osx-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64";
+        version = "8.0.19";
+        hash = "sha512-pBo4JhEGeCG627NFpSO7+KJgh/DPcjuz/bEgZ6dRHXZI/bDmyjLTGJQvyvonW7jhgbxgBbo2WayHCrgHFA74Zg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-arm64.Microsoft.DotNet.ILCompiler";
+        version = "8.0.19";
+        hash = "sha512-0+1JQFBD8qKmK1j+5VyY/5fLUU5lKt3oKLqDnIE0KZlJc9uJSi174JsEqF6rjrEtWRPXSaDd5QuwCUzeEuKd2A==";
+      })
+    ];
+    osx-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.osx-x64";
+        version = "8.0.19";
+        hash = "sha512-dBj8Xuk6EbKF/UdeP7e40ULe1XDBTBy4W2EzYBJoaZ8+Qi9LY9PbsEfrXEc94/o0cBM6vPiBNahEpJcS+ao1iw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-x64.Microsoft.DotNet.ILCompiler";
+        version = "8.0.19";
+        hash = "sha512-Jfu88czW2sKACGPJ/yMV6UEiPUI8yiodPd24p6LAPRUCX6CI7UbEc30cCAmkN9TuEt/zAK4dKG2hs3isfdjpNA==";
+      })
+    ];
+    win-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.win-arm64";
+        version = "8.0.19";
+        hash = "sha512-UjZI9mQLY4k8jwdq9NgyzfPwWxDmEiT2ahqV8a9AXa33AUKhXr1X4aW22e5QSUZF997psI0HI4DAYgnRrZN6vQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-arm64.Microsoft.DotNet.ILCompiler";
+        version = "8.0.19";
+        hash = "sha512-MV6poe/eVPrbO3CQvQNn3RNIymVBNWJ7updS3aSZVhlL9IZUuw0Oyn92pi8Fd3qOWvZQcdireVua0AWBmD14Hg==";
+      })
+    ];
+    win-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.win-x64";
+        version = "8.0.19";
+        hash = "sha512-AQJC7awIrQnM6TIj1ZrWaRc3HveorRrQaGxfCd4Gdn/RFJXkiETDSUZuakkHLmND1HUcBWZ003UlJasJoDe57A==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x64.Microsoft.DotNet.ILCompiler";
+        version = "8.0.19";
+        hash = "sha512-zkLC9ydX+0bsZWrJxWsWM/8LPujWC7Z0L6QHdYehClKa4Lrk3glBex2O5q2QirqLjCFDjYRMw7KSyO4CUGv5ng==";
+      })
+    ];
+    win-x86 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.win-x86";
+        version = "8.0.19";
+        hash = "sha512-ECYlGtxCIAHIMQRTjTrrAG6O+iTP+2LV8g02ttgII6BPw7fpsViPtYpgXAKMx2SW3NjlS9ePxXS+LsDmJ6peKA==";
+      })
+    ];
+  };
+
+  targetPackages = {
+    linux-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-arm";
+        version = "8.0.19";
+        hash = "sha512-CXwG/jLFrC1njHjZnwI0cDjd7Q1CQPGAn0HFM9BekI3xJb3MtlfPyyx0jN7NMsejToWeXgw6wlQ7rLCxwcGREg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-arm";
+        version = "8.0.19";
+        hash = "sha512-He223oJT1MMpZKYApV4yb8KFrP4x1Ei+Z2ovHubJ9IYJxApvw17R8GfCVWYDwQiUITd5xxfXQZAvq9Uhzrdumw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-arm";
+        version = "8.0.19";
+        hash = "sha512-Bb8wAYk8zTCXwd25mOhVQg/wXQrRxQplxD0t189tfRox90zE4QSWPljMR61AAeuFvnAmFHX2/WJtYXq3tjSrRQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-kaSQrToRQW4cNifw0bHzfFt8bXJb0bxYYXzOm6sKdw+MAMO5fIIybr3DpLSGLmqqz/B63Jz22Fx6OoVFw7G+tQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-XNqp2Kf81OCORVhDCLUUVIyQWmnTW+xqdeKcv1/DWUwE0Bs5jzhpk/LmE0yRoduTpXAyYkPRWpxWZGOVa2twVg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-91csMX2qwGariQVFLhCOX6sRywEuX+qoOht0GgjmqmaKI2JxEleCJEMcJ+n7RqieSia2txmVzeHYDED3+5xlKQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-fivtZRiA9IH/8JqTnXxVfQ4cak3hnte3tZLgPQ4z47/xAxcvz1nRjHRbblIl3FEfGvj3oHJakbgttSvvwdrI3g==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm";
+        version = "8.0.19";
+        hash = "sha512-gP/Qk9rYTT7upplXUbUmhMnxUC8KcJWZ3dLFdW0zQ78zxkfkIDbJ60HQQetEohnhUbOCX+/j2N/oEzeLrESGFw==";
+      })
+    ];
+    linux-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64";
+        version = "8.0.19";
+        hash = "sha512-RZ4+PXfM587j+4jVt5fMFvx3qy1OkR1q4Ztj7LekJBCidfkNcmHI64sVm+ev1nS1xhBQNgdCLRFa8VUqqPSgFw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-arm64";
+        version = "8.0.19";
+        hash = "sha512-Y3BL9qgrcCZBZVlM3anKLX8F2atrzvCm4gxED1hTxJGQyCp24xEaGKa6BRfq5NdQO4sKOS3UWDM/XB6qr4yx+A==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-arm64";
+        version = "8.0.19";
+        hash = "sha512-29KXiTrQ5adugytgWnZfdBSyBQHvlPwuClP4RyR0DRERHfMFWfZc+IFYCvqr1LLquPBR2Ev/xO4SgOfgQyu9kQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-ppU9Qz/PQ6ilQze2Ep7iG7KCzjMMWnd/JxY0c7oYeJfT9yTjBZOZeu4CHM8Vi0qewih1fI521CsIbvBKLHndSA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-jIThUl9XLKaVo+bTUtNzO03JAvmP/mc8Tqcc9xSCvf9TzroV/MrapKju/iN+zNFeS5OnJIF3doKEbYnKnCWs7g==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-zQlXKZ7Lcmy5iGGIFj1dGAdAGysgJm0r67quupe3tlBxHvi17Pntb+zesPSp31kaX+gqLdVWLylBLnb2EF41bg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-XuYUWuqO1rOCKgU0T0OHgjdlYg1xYzZC/LnIoM1UBV+RiByUVCDlNmctSNlNm9nNOHVDxrDGMJmjG0LH2/66dg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.Mono.linux-arm64";
+        version = "8.0.19";
+        hash = "sha512-+tKz3/AS0uatyMFciALifG0HF25uRxYOGfMZy8FIg2xrkjW1xDKg/Aqk2kHu5K+yxpO3ez8yutqG7AZjGO2bAw==";
+      })
+    ];
+    linux-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-x64";
+        version = "8.0.19";
+        hash = "sha512-OVA3+spWeTytk2DCo9syBHUmc0K0Yqyh+AvULvV9S4rAsdmgjKDARVNYcImDhMqRTTzX5r4uczoWnBN7wPqEtg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-x64";
+        version = "8.0.19";
+        hash = "sha512-A3KMblUwJ9Zezrr/lX753sK8JamQbN8T7W/c73PXXlnikdvGSDJh78VtyMAeMPfYlwJQlunSAK0GmYBTaT6hnA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-x64";
+        version = "8.0.19";
+        hash = "sha512-vKT8qP8s2Q+Eef3gvp8dBhqAmspLUjrc5EpfGBuy8ALUhZhKCZUXPuvwx5QjkPTcOb1hOUmEcOAenQ+WEbvnFQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-6OEEohAtoOS4ep+vSrKXi8/Vu4jIRD8woZkwh3Tt0QtT8xV1tmWeNH2jCr76sP3FbIJaVZ6NHQRkrZfov9yxig==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-GLxAezIXi563N2/q3n8KRxYuhcJaLGJth1gd+G+sQJw6uEv51YPP6s7DsBgewF6VyXDDnesLTGnkv8fkPyWPKw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-H7e34VBAQ8P9afWKyKn8u2FMGkx6SPqwxk59KvvJNXGE1tt64Y1xcjtoKWU7yY/xgRNyW/7BxBjyjGs96HG9BA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-x64.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-MaZramDW2KIdn5sn5IaHGpdr9AvLbBwh6TNzDb8GyzJX1BXzy0QIQPBGM95uiZ7bPZXovgvM/P2myS3aChOX+g==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.Mono.linux-x64";
+        version = "8.0.19";
+        hash = "sha512-Elc+6ExneINHtEnt4Iq5M9s3t0HEJN0dqPaWMHsag5dzGi6Qx69XboScBNWQhRTKMxoKYihPOL3pk5t4Df5rOw==";
+      })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm";
+        version = "8.0.19";
+        hash = "sha512-vl83UEXMS2sVQ5vPRPAr/KX/6gqA3VxVuuzdN4rAo/d1dFK6cFyMLVubcCxIYxSIetaLXLagjWxwKT7TE/E6Zw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-musl-arm";
+        version = "8.0.19";
+        hash = "sha512-qt3IKRfsRC01XEGZYcMK2Na4Ji9J8BFoLTccxVweCNiWxr5QYCTXuAlSCtXPaYtxM0W257peDibq5GIVD2afzQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm";
+        version = "8.0.19";
+        hash = "sha512-GfV9610N8O7/5aKSauBTA96FAk64ukA3tCZXRjwZrFM3OENfZV2T8NsVSC34lslpaotKxUC7nmQp0ey5nzaPYw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-3z1K3i+s6eyJ0/8OXrW3J6n4pIDv2bQ0pptDpqUuPv1ghiw5BJiF9Vmm1xxhi+HLZkc0wz9Qfg4OAoAyiYE7xA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-W39Zdgq9WUqwd0jY68BWcl9ufhSWtDYwoZB+VAkNauBs0r5yetHsvnkXJAQPli7/d7EVLfhpqhQb+KKcJdFpRQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-kRSdI5ex95sqFc2DBQ9sddp0cRLAdy150AFVdK1LbwyoYceP9OrEgp2gImAC2nvsFPh/ol8XioV4SHwPss1haA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-bTvHoP75ZewPL2+dt0fdwKBgEGxZxyQLLc4KspJ2z728QXBtAdvdjoMoHwbOyC//oApzcB68v7jP5ADmfzk5Rw==";
+      })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64";
+        version = "8.0.19";
+        hash = "sha512-bBiA+tLA5pZOrtC4u9KhUlh8mcXFMZoUmGLDII4Iu5uJxWoq2tox70OHOgjwbHF83Q5600xAX/lJ4cNw9WVIJg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-musl-arm64";
+        version = "8.0.19";
+        hash = "sha512-rTUR6aubOfJFQOnmWuYhhzWQfT2SgnMXNglHXNTk9uod+C+P20ZaiJGU0YUObsNhi52MeTObNXPorBBqk5yKqQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64";
+        version = "8.0.19";
+        hash = "sha512-s4W4o/3xrWkMYmpYeRVk/POlelIZ1XuHvVFhC760mVp8jN1zvyhJ5anAR2DKBOP8RhrMRQAyvv6g+5yYG/b1HQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-nFTMBMKK0daVxvMxE0ORujxVBRSbdfBDZ9em4i4rbipCjmy9tFMbyzTccG3HykaG5X8czARrWs2zZMMRjwnNRQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-Jvzq5CmlYbc31/jf36++T/7PLMzkD5PemLeIM9i1lo8R53yRT8CjoyJhJ1GXWrdRCdwEqbGU2LDDCp10lWSyhw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-ZEiEHIQnRNuCJpyuUqtIDgS+m6ZtlHSuDwqxdnEUV8RQtsgcLGF4kMnr7sfw/BjjRqLwf79lcRCiOFWVrwiiZQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-pdJKTqFZEnWjO7YX3c1FU+gGB4/l+tILT5cDzRUUxf3hkUT8FeWzxcYLUySWk1MyoQcHLbyLvR1rygGbOf2y0w==";
+      })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64";
+        version = "8.0.19";
+        hash = "sha512-+I52qNaW8BZAbCUO26826ZCHUjXB7OXdMbS+bAOOv3gt/yAZ3NiN7RSj7BhO3yfQdam5YBbuj0cBiqdrayJhNA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-musl-x64";
+        version = "8.0.19";
+        hash = "sha512-dV/b0WViiujT19HQwz6fLKUB/orjGRJudQIQFmHM1Q/0mJ2Hr8GK103ZMpXHHGH+Fl/TqSCQzu8t/U0F9q3+Kw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64";
+        version = "8.0.19";
+        hash = "sha512-S9oXhzzMHc7eNO+f6qwEDddpBzzeTqtasZ+HpSFPkCQwolaJ+FMe+YoDDvsvsyzr55rCIhjl1HlhzMyv18TFtg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-PwRDoFO8M8OPF6RzJfXYamSsXKCNqbZBS075eSp7b/+gGusjVHZ0ZAcVpLCQJWQmcR0AVx5g0VfN+Yu9F7NDvA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-9OHIz+fXQuYSL90LYJaPctGzan90FFiwJRDCTA4Zc32vDaXagKtJ/QCiTnqomCsyo7JZDLTkKdasArGfvdbZRw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-VcehwYA/43AmPo9udZYDx6UMQXxI5hMh0h9gKK8qrdT9B0dJaVfdlKvlAs6uN/wGQId6ggVRJbRUZnKLpdoDsg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-g/LtDzB8jRYARNCN2q878xlDIeuRifUl3kSucaLoh30Z3cngd6+Aej3+cpZYMgM7jz+llfow0Bn4OJWvt1gqpQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.Mono.linux-musl-x64";
+        version = "8.0.19";
+        hash = "sha512-k0G2wrG2HHgC9p3BlePoshY+dhCtTHIvwaOd10DP0Uxanc2p1A1DAiekzJJPyigijzNXVX485Dp+muCPcfOjhA==";
+      })
+    ];
+    osx-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64";
+        version = "8.0.19";
+        hash = "sha512-KUPz6ft9EX6olnkY4hJESg7vX00GBD8VF9J5d1kV7E50sUNAT1csl69MzINcdtFHoc5DXF+rEB6lVGH05h1u9w==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.osx-arm64";
+        version = "8.0.19";
+        hash = "sha512-+x0kVdmffJet7+YuFHKcREPMBV37bx7e4kfAjbD+5/+dA5KyAffcrQore4+gp8y9GY5q/lxgHpLdT9YF4X8ZVQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.osx-arm64";
+        version = "8.0.19";
+        hash = "sha512-v+Q43E/2RVECjIjyU/yIaKAdK2ipwf9iJ95LlFtBVaIxev+/CuFI6qiZ7TPWmh6ZmdlilqNdqFQj7qngTZG+fw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-FjuQE98YBxVTdMqhMN6ciE8af/J6EwkpW4XYC7vcJz53gSWJvB416C9Bs/1R09hP7Mua3lxTCzhKfnxWUmxCCw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-fWdoxak72kgmdK/e31YPvADhoFXjIOuUTe5BfhNr+oXFX6jCGxttf3L/W3NKzMntuHqpy303d3IrtgICJu75EA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-P1RHomV7Ei5h31DTIQOtUNMq/CziuWdfjmtU9ykBOWyWBH3aCl1K3jDm2hUs88C8Cb7NuOP0FI6So59ic8lhmQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-olOQVkYIeCv0FFYfrV9IfFJVLAnhjk1T/HDIRiNnyJ7JH8HFVytxAx8hQaIPL5xLGQquM/mxPlAoH0Tm2+k6XA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.Mono.osx-arm64";
+        version = "8.0.19";
+        hash = "sha512-4tRtmqt7/dUFo5EUzDwZ7CWYn3mOXbLO8+kQ23+CwPaTmkisNhOVX8oAAG6U2LZ2lCms6bFz0SI/C9zSMd+2Xw==";
+      })
+    ];
+    osx-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.osx-x64";
+        version = "8.0.19";
+        hash = "sha512-Q5PYdYTILXVSPTTXfKn+O8IvUH7kxY1YHc+Xl3r2aIUS7cAbKaWAV2S2WGUwlrC64E+ECyApC8hkJo8z7VOjHw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.osx-x64";
+        version = "8.0.19";
+        hash = "sha512-2vg1H2cjXAZAiFqhuej6VRDPyFuiye5t6T4wdtCtQtE/xQYY2T2CgU1ibeLEFusezKhPYLHV5lJn040UevXhpA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.osx-x64";
+        version = "8.0.19";
+        hash = "sha512-Ci70ENA+3UZOxnQWgPUXuAuiWX9vtQVewQjkgds9plKsZTz9d1YsIsJcZy6yHeoOsJshiWmOfmTI2BlXtUsRIA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-aA/2lxsdfu47/Jy97k0WO3jbA/8TCtc4eXli0zlHw9g3WFE7PcHlw52nLoY8nvTh6baB98f0mNE7nHqyWQ58mQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-L0EG4UgRxbfDAXXMBIOCGt6MFCjEvasR0xUkriJZgK4YBldO47mePbesFxSGVCAtz0+t0hH2JNPZXBpKPajjBQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-MKWcwNJiO1e0fBQVHcJWnAYwwLqe78HtaCrWr9Bhe00bTeZb38+e/59tW68O+W81RbGJ9teBuUWHnk8MGQsTuQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-x64.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-QLYgv1LYdehkZ64BaCQ/tAjhPdGDHEq4TmLY9Afh3Hi18UNZ43HldL5v3bJ8rHsScoRf6mNCOjtiahBU1ziPVg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.Mono.osx-x64";
+        version = "8.0.19";
+        hash = "sha512-cesMCMuSgKdhTe0G1Ix+RJ0dzrZa0r7SYsH6uQSXIR9zbSlyqs9EhqSP4GWoF8YuBc76AxYTSOuXp2hwqkmHCA==";
+      })
+    ];
+    win-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.win-arm64";
+        version = "8.0.19";
+        hash = "sha512-C/MtxBxoEnhHwQUdz776+FBVSuJgxqcaVp9IqoXjsE6axAq5M4opbs0DeaMyeiSCbHcsiihCDjnLnFb3uSVCVQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.win-arm64";
+        version = "8.0.19";
+        hash = "sha512-K8JWBy0ampzz8lsHMAnnZY1m74C2aVQ8QTi77rQZpDFmDxXDwgvW8FArmRyN1eJC8cO0B/XKK+Ytwug0EqTTwA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.win-arm64";
+        version = "8.0.19";
+        hash = "sha512-y7SMliDR8ePTMmVj/VJWYI5R6kXeUuZDPfhyF0E7m+FzXaSbe7OgLGJbslkeoglZbyQ+GFPBeE/HqvHZwfrOMA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-QEQSSsQ9tijRXHU6Xe1z4Xm+nLP0xSyG0pm4QV4IyNGCZGRYJ2B1WDKRRUR2yddaiZ4ic5ZyDFdUFFx7oHpzkQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-4pRwedZaoa+WHS87F9xWVbOGLXnOAHMjgUhApg2rqAjXFmPNbgNJsXNe79WRin5b8F0A9RH7WqwCW0dC1MgJVA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-XTk+WJsxDOqUeAe6PLTNEPohOURWpufLTtnoLAB7jey4yRTs4BN1RVHB1fzb2JVYt0ZrmAGhFl65U2HP8freow==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-arm64.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-HJm2e3BmQp1AmtazVr5GgRn3JDnvG/3Wy0b8PE3zToMKJ/ibUrjpmdxsCPjn1ZCJLTTwGf4rJGVj7ivivNBgkw==";
+      })
+    ];
+    win-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.win-x64";
+        version = "8.0.19";
+        hash = "sha512-CW2COJrFqYMeWd7hkNXlE3X05+9wEsxmAjW7oeGaU9FimgB9ksCOv9mqsf5Cu4IPDYHwQOuazvd63+89UjFBXQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.win-x64";
+        version = "8.0.19";
+        hash = "sha512-3xbWEAv/E2aKa+0x6LIVsDFnjuLzyU5H/2ozDW8+nnA/JPdI1YWTTM5naxdIyWzRuGmxowfoUKd2aA2+qtt0Zw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.win-x64";
+        version = "8.0.19";
+        hash = "sha512-E/C4I96r86EjKqW2Tn2zN8390oSymQei/YhXg9QK7x2kBwuwCs5gTHaApUXxRp4d6BqqUaX7GNZesKq1FLqxNQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-pGUh9N4I8QFfZ40Rmlyed7ATMT1boIYM+dLNdqhJPttttQzmv5gbFb0ed6sz7HvCYcfJTFWv32F8lTcLjp92GQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x64.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-qAMK+KMMJqvY0U8L3knVx1zFK6G6nLvr7Pes2LGQQ5o/WXHGEIzju9Ga65NeF4thn/teXx+Cm2l41/QxiyJARg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-Uu8uktFHgeD0K2HblQxoSpW9QXL/1QT1IDNQ9PTPQ0+qHUkASxpVmW22Q/OuLqjmhLoDuTwBQbzHTt1726hXow==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x64.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-Ai4Ufjt0Ax7HrQE8JtH7Y/zT4yas0XukRWRDBUrsuCIyddx4gm5u1lNCOZvJFIDerEacnWoRiUFW6CaKVlw1gg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.Mono.win-x64";
+        version = "8.0.19";
+        hash = "sha512-u9qb/jJRjGTjkFRkSKQC9hfnK7IHDmP/PCbhYF7PiJH8/XlSpKcM5fhfZ68UxEuOnRpwTJNXxLISqgjffDorAQ==";
+      })
+    ];
+    win-x86 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.win-x86";
+        version = "8.0.19";
+        hash = "sha512-aqqj3wMguPyHC9A+Za59KfhfKqKTZrX0b8YI5p2oQME6KL6FnUqnOBtMWA+EqVRmpnstuWbNQr7fYEZ6AkfZWw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.win-x86";
+        version = "8.0.19";
+        hash = "sha512-4hGpGg8mphHFlJ/Z9q1VBUucrTrayVz8yf7Q01nheO3TIeJzR6oBif2CiiBggZWGjyze5om29FWUes3dku2Ddg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.win-x86";
+        version = "8.0.19";
+        hash = "sha512-M3DsPVjB/r8D0jQzJdPq0TetSSc1TbafVfzRMNfdzeXH8tLEjoW+f7X+/H8pRpFifnf1je/ZudShNx43EcStdA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost";
+        version = "8.0.19";
+        hash = "sha512-CV648uVcnDWldJRlFFi8Ew2nvp5KnJnnQEfPUoQKFATFHkAQbUIRNovRHfaNawXWGmKKn4/nzxKH+0lxs+VdBg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x86.Microsoft.NETCore.DotNetHost";
+        version = "8.0.19";
+        hash = "sha512-qGcn373HrhZLCxZf/hLlG/OgrmZ5XZkh2mzVci5IPsp8jzqimStPcI4M7jgpYXfAkP3KJ1DsgtcqnSSHxz1Q8A==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostPolicy";
+        version = "8.0.19";
+        hash = "sha512-BzT/17Ig4SqQIvkK42a3BcCQZMupZbtPTHBTdQn3qpgeZjXMiqxIxlbmrVqQcAMgFDo3EJlevy5hcDTLHd6YAQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x86.Microsoft.NETCore.DotNetHostResolver";
+        version = "8.0.19";
+        hash = "sha512-X2QLkgVo+ECd4ToqoXJs252UvB0gLF/pVzIADzczVmwnnZ3xw3QscvkEBQxTJRxfzH8y2n5BTJ7WXKVHPs6Gpw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.Mono.win-x86";
+        version = "8.0.19";
+        hash = "sha512-h422hRX55IIMQzTpHJXsKHWYTjmQhnu9SqH5etR8RToZpL9nIHXo0dWpl3bmsBpfKPhy+UUXU0OaR8OSbgzETA==";
+      })
+    ];
+  };
+
+in
+rec {
+  release_8_0 = "8.0.19";
+
+  aspnetcore_8_0 = buildAspNetCore {
+    version = "8.0.19";
+    srcs = {
+      linux-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/8.0.19/aspnetcore-runtime-8.0.19-linux-arm.tar.gz";
+        hash = "sha512-a0r+fc5qsucGLLSFxGEm3OnP2wADch4NiIbM+qmm3uw+66+KTeaevklGOUDGyO9a3cRRLZwiY9gXELk09BuR6A==";
+      };
+      linux-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/8.0.19/aspnetcore-runtime-8.0.19-linux-arm64.tar.gz";
+        hash = "sha512-zBRQPlwdlKMz/YBI9ih2D23ysqzU4NXvRly7/ME1F3U9b9Wx1f5LOLB3BEGKcT4TOABUU6fLuPs/MAdg0A/G5g==";
+      };
+      linux-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/8.0.19/aspnetcore-runtime-8.0.19-linux-x64.tar.gz";
+        hash = "sha512-lQP+hGJ3Fsud8CxkjjSXHG7E1EaG8hO8b2vXS8VP+0HvJy+9LIqj8KMJsgZkeWwS+cd7E3AV+EWBrCZa8vIWhw==";
+      };
+      linux-musl-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/8.0.19/aspnetcore-runtime-8.0.19-linux-musl-arm.tar.gz";
+        hash = "sha512-fOY8CoBCDB7T+ylYy0oj10/yXvzvCmeP93H4LDU5ySg/1txVQDoKtMlcuigGp24MjXhkvr6Y2JFP773u+XBJJg==";
+      };
+      linux-musl-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/8.0.19/aspnetcore-runtime-8.0.19-linux-musl-arm64.tar.gz";
+        hash = "sha512-TGVuirBIgvdMkfeTEXTwg7Ju2QR4vPyQmEsXg9T8pr6x0CHsBEafrmEOuwLfc/v6WK898ejVLL9eBoy/NBiNIQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/8.0.19/aspnetcore-runtime-8.0.19-linux-musl-x64.tar.gz";
+        hash = "sha512-7YmdUku5ok0MPK/e1tD0bsYghX89i0Oq8In+hgb6hsJehdksX+6aAW1Bp13XbDA+LtwtM5PA603DhsWuNjTCLw==";
+      };
+      osx-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/8.0.19/aspnetcore-runtime-8.0.19-osx-arm64.tar.gz";
+        hash = "sha512-Dd8cdJjFKLIJgmOz0wr67QtARqorQ9XHqDdAOh5VgzXBqViqhZtJjdKiU6851B8YHLJpqukc2N0QO2SgYJ+YQQ==";
+      };
+      osx-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/8.0.19/aspnetcore-runtime-8.0.19-osx-x64.tar.gz";
+        hash = "sha512-msIOtqYmFd+4LFZXwRWHtiHz5/DHxt0xEd8GFIIJLWPBy1T9Ka2w/kOljGPrLKitMi98cixuR7JLeDhf65PqRQ==";
+      };
+    };
+  };
+
+  runtime_8_0 = buildNetRuntime {
+    version = "8.0.19";
+    srcs = {
+      linux-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/8.0.19/dotnet-runtime-8.0.19-linux-arm.tar.gz";
+        hash = "sha512-sqsF9qKc/yuEQCEbxZGvCTD7Hp0IKxgLleYbfU4bP3n9KnKbKbqrcRSHgNksZGGOz4xWqM86ymIq+yn0h3Adgg==";
+      };
+      linux-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/8.0.19/dotnet-runtime-8.0.19-linux-arm64.tar.gz";
+        hash = "sha512-E/VgfaousPmg+2o2GT0oq8lFQgivVXPai8X+9cvrcLGH3q2valKz1G/cxZyFZ9t3wpN3XP12pD6B/5nEtCUFjA==";
+      };
+      linux-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/8.0.19/dotnet-runtime-8.0.19-linux-x64.tar.gz";
+        hash = "sha512-D2buVk/JqGuOrlQD9DGvWVZeYvXrWfblA3fnLFitJFUts7cuz9gkuFCkI0+u2yE5g7icxHk3L8Q2pVP7CGu5qA==";
+      };
+      linux-musl-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/8.0.19/dotnet-runtime-8.0.19-linux-musl-arm.tar.gz";
+        hash = "sha512-PVaVISyjZ0XjqelPUn0krVhdOL6hcfectHIl/wEEx8b4KBXDFpg+Er5UJquSsmB1XTtE3hRHxqsiVjJuhWFyEw==";
+      };
+      linux-musl-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/8.0.19/dotnet-runtime-8.0.19-linux-musl-arm64.tar.gz";
+        hash = "sha512-iOLYHKbsUtB/5xA3LQZPKjCJVzXHZNLZrcFI5OR//Iqjd2EDKZfvfTF8KevKvdqcoKmd0fpfF7nslrxtNKiGOw==";
+      };
+      linux-musl-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/8.0.19/dotnet-runtime-8.0.19-linux-musl-x64.tar.gz";
+        hash = "sha512-NvvF7er4ec5DBE4eEAAgfyKfLxK+5MNSETBHaYAJHIMqdBDc9fN3neITSYeu3C+j94R9v5oxPWJ/IJS/vNMqFg==";
+      };
+      osx-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/8.0.19/dotnet-runtime-8.0.19-osx-arm64.tar.gz";
+        hash = "sha512-FLRqUrgqF5zF0Sk/S8CWgFFHHw5is341Jaj3QR0pkP4Gds4OF/5QsrJIgA7rPRvZvYO+w6UntnDYJeGkxD6Pjg==";
+      };
+      osx-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/8.0.19/dotnet-runtime-8.0.19-osx-x64.tar.gz";
+        hash = "sha512-utNVjAqIbe35M+ZUKue0G3BhI26hRBcLOeD76bYVunbZ8GVt3Rub6J75MviU7enhtQMC7Qk+oNigDwSuYTZLyw==";
+      };
+    };
+  };
+
+  sdk_8_0_1xx = buildNetSdk {
+    version = "8.0.119";
+    srcs = {
+      linux-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/8.0.119/dotnet-sdk-8.0.119-linux-arm.tar.gz";
+        hash = "sha512-XlKdFdSfvXbJiMSL4zKr5ALd1UJClUJAwvHLYkZSd1kujMdjTxnNseQgBYLKd3ogu3Yc+PyYRV5aupzp440TjQ==";
+      };
+      linux-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/8.0.119/dotnet-sdk-8.0.119-linux-arm64.tar.gz";
+        hash = "sha512-y6QVS1UcGCsRhc34mlb/UrtGoTXzS99kGrE0DeqyPubQ8kwHDwt6WuIBBdcdwxURfyit4v+jLCJCvbLpyCUszQ==";
+      };
+      linux-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/8.0.119/dotnet-sdk-8.0.119-linux-x64.tar.gz";
+        hash = "sha512-L/7DOAoqwj6AHHx1B7OWL/0jKRGtBgJLdLl92stvRoBNj2MZ60x/x7Al9xZ3fUcRAhnK7rwwo7H+kiMGb/ioyg==";
+      };
+      linux-musl-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/8.0.119/dotnet-sdk-8.0.119-linux-musl-arm.tar.gz";
+        hash = "sha512-XVXCZxX9srBQJE4TZeW3FZ0gbLTsvgXUDxbjtYbVp/vbSQQSr3IXF77mHuF8FtcJyOUY3TywxRxtEcKQp2mgrg==";
+      };
+      linux-musl-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/8.0.119/dotnet-sdk-8.0.119-linux-musl-arm64.tar.gz";
+        hash = "sha512-JV5KFwlIKBYCHLwrn7cC3BG9nueksa6M3YnbV202M5moD2Fvftq2RXerNNwGf2BezyR2BuQX26TjxkjrtOppSQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/8.0.119/dotnet-sdk-8.0.119-linux-musl-x64.tar.gz";
+        hash = "sha512-HO040qC2vVYJdccMiHBotk4JyAUjlZFk/wXw2VaUqbe+c/jrAt7LknGDLpIEtEZkNOo+LIiqujufyshTgzbUzw==";
+      };
+      osx-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/8.0.119/dotnet-sdk-8.0.119-osx-arm64.tar.gz";
+        hash = "sha512-NNERmqe/mqzEJgaZOu8C0pD13B5snm2aTbCb9JIRe9HX4V1Qt7hp8AlUzUqpfol6HoXvRe9S79TtLoLdKAnpgA==";
+      };
+      osx-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/8.0.119/dotnet-sdk-8.0.119-osx-x64.tar.gz";
+        hash = "sha512-A9H6KOJDmrTSCoFRjdOWOSlS80A4AzXQ9i8JRWDmoiQx1Gn0UDd0CtuAfXwCT0KAcJ+XXgUUBrR2nfIlGoHd+A==";
+      };
+    };
+    inherit commonPackages hostPackages targetPackages;
+    runtime = runtime_8_0;
+    aspnetcore = aspnetcore_8_0;
+  };
+
+  sdk = sdk_8_0;
+
+  sdk_8_0 = sdk_8_0_1xx;
+}

pkgs/development/compilers/dotnet/8/default.nix

@@ -0,0 +1,11 @@
+{
+  callPackage,
+  dotnetCorePackages,
+}:
+callPackage ../dotnet.nix {
+  releaseManifestFile = ./release.json;
+  releaseInfoFile = ./release-info.json;
+  bootstrapSdkFile = ./bootstrap-sdk.nix;
+  depsFile = ./deps.json;
+  fallbackTargetPackages = dotnetCorePackages.sdk_8_0-bin.targetPackages;
+}

pkgs/development/compilers/dotnet/8/deps.json

@@ -0,0 +1,80 @@
+[
+  {
+    "hash": "sha256-K2tSVW4n4beRPzPu3rlVaBEMdGvWSv/3Q1fxaDh4Mjo=",
+    "pname": "Newtonsoft.Json",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/newtonsoft.json/13.0.1/newtonsoft.json.13.0.1.nupkg",
+    "version": "13.0.1"
+  },
+  {
+    "hash": "sha256-may/Wg+esmm1N14kQTG4ESMBi+GQKPp0ZrrBo/o6OXM=",
+    "pname": "System.Formats.Asn1",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.formats.asn1/8.0.1/system.formats.asn1.8.0.1.nupkg",
+    "version": "8.0.1"
+  },
+  {
+    "hash": "sha256-dQGC30JauIDWNWXMrSNOJncVa1umR1sijazYwUDdSIE=",
+    "pname": "System.Reflection.Metadata",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.reflection.metadata/8.0.0/system.reflection.metadata.8.0.0.nupkg",
+    "version": "8.0.0"
+  },
+  {
+    "hash": "sha256-yKxo54w5odWT6nPruUVsaX53oPRe+gKzGvLnnxtwP68=",
+    "pname": "System.Text.Json",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.text.json/8.0.5/system.text.json.8.0.5.nupkg",
+    "version": "8.0.5"
+  },
+  {
+    "hash": "sha256-yKxo54w5odWT6nPruUVsaX53oPRe+gKzGvLnnxtwP68=",
+    "pname": "System.Text.Json",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/system.text.json/8.0.5/system.text.json.8.0.5.nupkg",
+    "version": "8.0.5"
+  },
+  {
+    "pname": "runtime.linux-arm64.Microsoft.NETCore.ILAsm",
+    "sha256": "b97773aff2abf8d64309ee22aa298978175435a2a431f2c95c4d07ccd43a23fd",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.linux-arm64.microsoft.netcore.ilasm/8.0.19-servicing.25365.14/runtime.linux-arm64.microsoft.netcore.ilasm.8.0.19-servicing.25365.14.nupkg",
+    "version": "8.0.19-servicing.25365.14"
+  },
+  {
+    "pname": "runtime.linux-arm64.Microsoft.NETCore.ILDAsm",
+    "sha256": "ecd77edd965eb444eac6b19cd930524ee588259b35049fd611d5313338897ff3",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.linux-arm64.microsoft.netcore.ildasm/8.0.19-servicing.25365.14/runtime.linux-arm64.microsoft.netcore.ildasm.8.0.19-servicing.25365.14.nupkg",
+    "version": "8.0.19-servicing.25365.14"
+  },
+  {
+    "hash": "sha256-g0fUr4yUN+qcqsydiqdMkFT5nmuH5KKKC3XyrOXKQpg=",
+    "pname": "runtime.linux-x64.Microsoft.NETCore.ILAsm",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.linux-x64.microsoft.netcore.ilasm/8.0.19-servicing.25365.14/runtime.linux-x64.microsoft.netcore.ilasm.8.0.19-servicing.25365.14.nupkg",
+    "version": "8.0.19-servicing.25365.14"
+  },
+  {
+    "hash": "sha256-bf/f8L0OmzBW5KhrJFVurdtbewUGxcUbgbEgIZ6NLYw=",
+    "pname": "runtime.linux-x64.Microsoft.NETCore.ILDAsm",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.linux-x64.microsoft.netcore.ildasm/8.0.19-servicing.25365.14/runtime.linux-x64.microsoft.netcore.ildasm.8.0.19-servicing.25365.14.nupkg",
+    "version": "8.0.19-servicing.25365.14"
+  },
+  {
+    "pname": "runtime.osx-arm64.Microsoft.NETCore.ILAsm",
+    "sha256": "c02b0af5c5d1d0a608d25111d95279d0e880c33a96fd0757be192be9f7eb5023",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.osx-arm64.microsoft.netcore.ilasm/8.0.19-servicing.25365.14/runtime.osx-arm64.microsoft.netcore.ilasm.8.0.19-servicing.25365.14.nupkg",
+    "version": "8.0.19-servicing.25365.14"
+  },
+  {
+    "pname": "runtime.osx-arm64.Microsoft.NETCore.ILDAsm",
+    "sha256": "d9b48b8452e6451ebc121d6ea135085d8426575457b08745126f6e022709e29d",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.osx-arm64.microsoft.netcore.ildasm/8.0.19-servicing.25365.14/runtime.osx-arm64.microsoft.netcore.ildasm.8.0.19-servicing.25365.14.nupkg",
+    "version": "8.0.19-servicing.25365.14"
+  },
+  {
+    "pname": "runtime.osx-x64.Microsoft.NETCore.ILAsm",
+    "sha256": "17ad72cfd2b22fa3d7ad9bf032554c21df39515fb66126b4aeca6734e687f79e",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.osx-x64.microsoft.netcore.ilasm/8.0.19-servicing.25365.14/runtime.osx-x64.microsoft.netcore.ilasm.8.0.19-servicing.25365.14.nupkg",
+    "version": "8.0.19-servicing.25365.14"
+  },
+  {
+    "pname": "runtime.osx-x64.Microsoft.NETCore.ILDAsm",
+    "sha256": "7374baafd5248e2b6a720e669bc1e9f07feefd8d3ae9017e6249e8ea79a90a6e",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/a65e5cb4-26c0-410f-9457-06db3c5254be/nuget/v3/flat2/runtime.osx-x64.microsoft.netcore.ildasm/8.0.19-servicing.25365.14/runtime.osx-x64.microsoft.netcore.ildasm.8.0.19-servicing.25365.14.nupkg",
+    "version": "8.0.19-servicing.25365.14"
+  }
+]

pkgs/development/compilers/dotnet/8/release-info.json

@@ -0,0 +1,5 @@
+{
+  "tarballHash": "sha256-4mzLIWt2bYFqZQZqjMlm+WGnvxux1eorqUHEHsDs67Q=",
+  "artifactsUrl": "https://builds.dotnet.microsoft.com/source-built-artifacts/assets/Private.SourceBuilt.Artifacts.8.0.119-servicing.25373.1.centos.9-x64.tar.gz",
+  "artifactsHash": "sha256-pB2tVzeB/EAwXTNbzG42NT/3gnczxtaQ+oH0FvtHgnM="
+}

pkgs/development/compilers/dotnet/8/release.json

@@ -0,0 +1,10 @@
+{
+  "release": "8.0.20",
+  "channel": "8.0",
+  "tag": "v8.0.120",
+  "sdkVersion": "8.0.120",
+  "runtimeVersion": "8.0.20",
+  "aspNetCoreVersion": "8.0.20",
+  "sourceRepository": "https://github.com/dotnet/dotnet",
+  "sourceVersion": "6825a8d5c72c1893049c2c5ffa491b65cbcea7e0"
+}

pkgs/development/compilers/dotnet/9/bootstrap-sdk.nix

@@ -0,0 +1,528 @@
+{
+  buildAspNetCore,
+  buildNetRuntime,
+  buildNetSdk,
+  fetchNupkg,
+}:
+
+# v9.0 (active)
+
+let
+  commonPackages = [
+    (fetchNupkg {
+      pname = "Microsoft.AspNetCore.App.Ref";
+      version = "9.0.8";
+      hash = "sha512-HSxwnf37OGRcVt9qq6zwaPoqnve6MXpwjq/gzTagXAJTM3AgYE7gtAzFKUPj2/yYLAgdHEi2y+7N4e6LJXJAQQ==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NETCore.DotNetAppHost";
+      version = "9.0.8";
+      hash = "sha512-14cuFcWzlQUTtNwpeVNCP0q9bUfdm0lXFGd8fP47uulSBIJlcvUmucas1BpSmB9ofsVC+jcmkLr7EvK/l2zCXQ==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NETCore.App.Ref";
+      version = "9.0.8";
+      hash = "sha512-rXC+UlNcK0NDSKCc6NTc6KGlBSKXvu0hP/oamJ0+6mgETnlySbRimOOp9ZOipoXitRk7sXdWBQH7F4Jy1UEFyg==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.DotNet.ILCompiler";
+      version = "9.0.8";
+      hash = "sha512-LVju0J0eNHVvP8nQUmCiJIWTZrAo1TPoNRtMe4mB8WpqW+VzOHNkKNqycTCPxJ2ytN5DlQL055LtSLW7+lS/4Q==";
+    })
+    (fetchNupkg {
+      pname = "Microsoft.NET.ILLink.Tasks";
+      version = "9.0.8";
+      hash = "sha512-qa9R51SRJWc9SdEM3BGVEnV3AQm9rSQ6EjBELmcwE6mUymrLCSnHu3HcEh6BNtj3Jb1mk4i/mU1dWag/C+qdMg==";
+    })
+  ];
+
+  hostPackages = {
+    linux-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-arm";
+        version = "9.0.8";
+        hash = "sha512-U7dmRLkAb8vAO0UlHXtPHsljYS8XRZW2GnTc/3KCvtnePTQvVaOwAr7iLyY5buPykg9Pd88wwzBBOtF/97mlsw==";
+      })
+    ];
+    linux-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-arm64";
+        version = "9.0.8";
+        hash = "sha512-N4tnUp+0xdKb/m0tmHBic2YKlO3oWluKGtf5nd3eRZmtUdHQOCOjwCZzzSG1TW4MMIBbtc0ul21CeDd3xTghCA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm64.Microsoft.DotNet.ILCompiler";
+        version = "9.0.8";
+        hash = "sha512-01bVanORYWTIBcqg8SJfqVrWcadM/u9MYe6Y35fKjTm+S7nqmyXXxkJqsSW1nSiVTKLopIomBZU0vF6s6EHwXg==";
+      })
+    ];
+    linux-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-x64";
+        version = "9.0.8";
+        hash = "sha512-4JvBQlwuNpWip4n/jOMirgb+KTq40S1dHcq5/nBmojKRMARUU/lJiUqdH85NRamUE5iJocNsndWMLuqfJg9BaA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-x64.Microsoft.DotNet.ILCompiler";
+        version = "9.0.8";
+        hash = "sha512-rRu/lQKiSzP5a0Jo0Y+gD6dF26ZeRXkJWoRwxYGmj1NowU3DedL4tidTdFSVDJJ7p8jGLRhDB6x+MjpE05QL+g==";
+      })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm";
+        version = "9.0.8";
+        hash = "sha512-vWcLP1paVt0v4fwHJB0GYYybIhfMFCiD/hdg7Vfnvm1kkNOARP88U9xfSMhYN/EBxMzG2Q29kI6e6vTMrXrVNg==";
+      })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-arm64";
+        version = "9.0.8";
+        hash = "sha512-IkE1/clVa/ECX5w/hQy1Kt2BEMWjpmPhJJX/IDT6Igd7gckL4Funf31B7MJwGwmACF6uzGYSZHXM4GcyPYTyCw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm64.Microsoft.DotNet.ILCompiler";
+        version = "9.0.8";
+        hash = "sha512-RiKfoTAn5AeGNBuAANq0Raz91lSkTXFc5xFVNW7Ff7Gtv5unLAVvGfP/xwQVZtLHhIcvmyWo20mYf2uScdk12A==";
+      })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.linux-musl-x64";
+        version = "9.0.8";
+        hash = "sha512-dX1sfzQ+VMxakA/Q1g86LDpZdPAypT3GuYpd0HyzoFUoOMGS0KfQjBlG6Ujz6nGTrBR1627DB8o4UjrCtZO1Mg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-x64.Microsoft.DotNet.ILCompiler";
+        version = "9.0.8";
+        hash = "sha512-kOOuClCiRSu4qzUzBSnSQJiUtvZb6P0HB/005dDLB7hqVB0AtYRp7qu7qi0y5nYx/c6c0vdBqtyPMPkRx3NXGQ==";
+      })
+    ];
+    osx-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.osx-arm64";
+        version = "9.0.8";
+        hash = "sha512-RL39h0pyBnVYPshzvJOJtlbmdKvUvuWgf+tHBzl455jZqfwt7RsPf2WvROXCME0alrExZB6g3VSNbHhoFIo5CQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-arm64.Microsoft.DotNet.ILCompiler";
+        version = "9.0.8";
+        hash = "sha512-v12pAEBEbWm651O1lVlTZS1NyM/mEhORJ0JcVnEJQpS5u317/uDdqZ7LknIppwQJfqhF2rIg02jS3yElfg8O9Q==";
+      })
+    ];
+    osx-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.osx-x64";
+        version = "9.0.8";
+        hash = "sha512-GfVFJvhYUoJI4WbvOiAgMT4HS1+gMTizEXRuxlL6nmI7fVJNReIWOB3LsEBAaZOJbqBoGtciwVU7Oeu+nsOekQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-x64.Microsoft.DotNet.ILCompiler";
+        version = "9.0.8";
+        hash = "sha512-+XMW1cOzIwTSTcnam+tlZPa80BHlvugmxATXttjXY1u1DlJJXZCBHiE0cjCeO99k9VpwFr4g9MRHKgfJcNHKIA==";
+      })
+    ];
+    win-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.win-arm64";
+        version = "9.0.8";
+        hash = "sha512-tGARYv1U56BWPK0A3/2KmtYNPBSovSxIRVEP/7hh2d8kFbszy3RqzKaFNz4Anf3ZfNHGMrMK2A5DvqEIxR83eA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-arm64.Microsoft.DotNet.ILCompiler";
+        version = "9.0.8";
+        hash = "sha512-4slzmfzzj8K05cua+22dKz5OwNyYxEBXUzvosh/+jKmgEFpug74PPdTp2sgYliRUxUO/o1O3mWcXxMgp510k2w==";
+      })
+    ];
+    win-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.win-x64";
+        version = "9.0.8";
+        hash = "sha512-3VG/IV40RDsfc1F84fqE4e9t2MZG24pT29acsLpIeIt0K8GbfTFG9yPDK8/XXWqAqDSdVuVrLzQKHHFbN1hFVg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x64.Microsoft.DotNet.ILCompiler";
+        version = "9.0.8";
+        hash = "sha512-QIrPBAMJx0FBhFDMTwjwKm0Wp32egd3Zb6Fy454VkhWKq+bHZStSVVeLIfNnpemqZn5ULkmCQQWoOooAw21I7g==";
+      })
+    ];
+    win-x86 = [
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Crossgen2.win-x86";
+        version = "9.0.8";
+        hash = "sha512-kauELS7o6BPUFsLueozrv/dtUgY3HYlK8xxlsWkQNMILiTWhmkNoXyptjFAc8sCdthPTXryws5DFBg4A+kxmYQ==";
+      })
+    ];
+  };
+
+  targetPackages = {
+    linux-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-arm";
+        version = "9.0.8";
+        hash = "sha512-1C0R3FapqJo3Cu+DyMX0mwKVFTRtJnQNtQ0TOWEnT1N8lH/PRDsZH+tHal3U7/PkdWY9D1FmbsKQ7uxZNOmeKw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-arm";
+        version = "9.0.8";
+        hash = "sha512-4p6EKTtSGhY4WV3XbdNVsNnWl7JvZkzmCBJImCIqY4eB0kV8BpqbNCO0kopi7gNmNGWsp97yPI4D3HuFi+IQHg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-arm";
+        version = "9.0.8";
+        hash = "sha512-opZhwxdkU3wGOc42sLvsaoEfZ6cIzB0VfYlTowUeLqISP6Bw1YLE2x9y5IXjVHbRp6sKyIDQyrs45h4+MzLTMQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-5vJoOboU6uFIKZxF+oLVoCg7kuH+94YtC+nrO7l8YWdwba2oyWTPXoAfM6HnbzY/g5Omcc8oUNlKRZdwBuGBXg==";
+      })
+    ];
+    linux-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-arm64";
+        version = "9.0.8";
+        hash = "sha512-LxFcfH3yCeCTCu4YY0Rw4ZikgDqTD4TTZ19SZSqD69BDw74dKxcmCrQ9/A4d0DAFiqKEMMKTk3EVZ+Bqo/jVHw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-arm64";
+        version = "9.0.8";
+        hash = "sha512-tyRDrV53rTqdgEZNeWnLqOUpHuTdN0DwWuo726hpftJS0gqh+HpZpGazuzePUToD27O7gNx8Z6+eUbqUvpldKg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-arm64";
+        version = "9.0.8";
+        hash = "sha512-jH9WiOhUASzf/3XNOQGZtmkd4Zb+3qjhTB0qItNQO+HqJV8QZI/4XSrK6xEnoJS2J75N8vg/SDCTRi3BbR/qew==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-ldyC7aYLVx8PBpT9/SJw6Gi4pd6fEEMPCwxXpjUPtmhQVqjHKOtSeyt4mERDGlJBY5egNzHkF5Rc99yca20Y9w==";
+      })
+    ];
+    linux-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-x64";
+        version = "9.0.8";
+        hash = "sha512-kuP8TvuVRSUqTFW+Ui5IfVA8ewaRkerGRW/5ktUnViqtCPQsjkvxLxlWqt1SO4sRW57q9y+QZNDO2dHdNCTd7A==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-x64";
+        version = "9.0.8";
+        hash = "sha512-+Iz4IIEdJhFUKsbzFn12YR9lGs3O5XAuXw1e4M4wzzVyoix1J/O7JE/p6Ep/MxdWUrud89hledyBgbk2A7tLEA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-x64";
+        version = "9.0.8";
+        hash = "sha512-EKY7/AGlcUsgcMTm+0XJQtGZUH3MXQiIHaUsgK4UvugRzVAdqvwkSAs0un1mc4evvzTgWzMl9Yp8HapVWIMdpw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-pnIOiulipfx52mhy96M3v21YBsDYfzLJ21hr7tHCNaWtnBsr5dsnIfVNPUvaQQ2QJcadmrkoyhk18Dmb3QTmog==";
+      })
+    ];
+    linux-musl-arm = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm";
+        version = "9.0.8";
+        hash = "sha512-lzTfzT1Yd2o4KG8z+qu+CwJ1dNV2RhKOrypH6wIRHRd1ewTE3fLTOesq/OAhSJswIxjyG1g0a4K1kL98UfhKlA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-musl-arm";
+        version = "9.0.8";
+        hash = "sha512-v2Gg1viOsyHEuZT56c2P0zVUFpZGrYjdzXIsQejjAd6aRGu3Xl23sRob5cM49p4VOq1Ywv8sHAB1lhVwa7Mxjw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm";
+        version = "9.0.8";
+        hash = "sha512-jcMcr02ix+UM7wfSuSHGO/ZVbjDllhEQo0G6hPvL0n+8qQAu7p694JbFCVO+1h+wMOgudlFOBPLSb8ucTHb4Mw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-rephD4BBZWGzDM0nBn/IJCKyUaHhFFweXlZDQg7SzADACJDhr7pnAXr6WBDWBOZvtoScDO42W9SXBxebLlee0w==";
+      })
+    ];
+    linux-musl-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-arm64";
+        version = "9.0.8";
+        hash = "sha512-Fdc0fvuu9ufeF05mPezAlQGjNw48O0050itpfpc2xaPz6Tkmt4t4QS46iHKUlek3eosQo+TWgKr8+ydA2rTtiQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-musl-arm64";
+        version = "9.0.8";
+        hash = "sha512-IbAy/N9knqt52d8Jg0ZPlht8PLGlxFrkUFGLOu9q1B6wyNAxcr+SNcAuqIQndV2aiC1JX1LxF+Z/RtR/dllmMw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-musl-arm64";
+        version = "9.0.8";
+        hash = "sha512-eiuv/paMs3fiSFeGtP6EvmappnNAPl6oSWJJGPPcGCyjHKlvbvXXAGB4bo1gh08bDfyh42y9tzkFjj+N3eoJ8Q==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-n3582g9jXAzHDeBllHPjaihaGd8Q5ZMKgSh/2NpVB0SRw3Ie7jCHBloadFAqsz4CbMqBqz9bcwWJSs3UelF6Cg==";
+      })
+    ];
+    linux-musl-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.linux-musl-x64";
+        version = "9.0.8";
+        hash = "sha512-7Iu6w3otpfLf3PDvtus6k0DHYfyFiZ4/FrltO/3+7CPhYYNWtz69/CS7zMUbSebr47CMtGxDHa7sgwRhuQ0udg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.linux-musl-x64";
+        version = "9.0.8";
+        hash = "sha512-2MV4Mm2P0a7Xj33qe2DhxcUxORg4rOBx1MPrmFScypuzqwlcm7Ky6ValuVodGVAeziqxewG+TwEfQ+tlQtKTKw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.linux-musl-x64";
+        version = "9.0.8";
+        hash = "sha512-jx7ySFpxyeGIGu2e/RwWI5Qp0/Qi+7LLAnGa3p2ErCbEmx8cQpfzGijxKekjEhtOVIEFt3XDVUBaiShiFCAp7w==";
+      })
+      (fetchNupkg {
+        pname = "runtime.linux-musl-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-DAzBxlAn4kHG5UPmIIcNzLyVOFWmsSw3FBFE2k1gFBINRJQxsch/OYGeHJOvcV9AE1kCdOpwfvXkAuYsZ1yqJw==";
+      })
+    ];
+    osx-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.osx-arm64";
+        version = "9.0.8";
+        hash = "sha512-7/dik29myG9DpI57mqgQUZKBqUTch4gJPUVTsGwCrpX/+2fCRUMh6wTDZKVJigQmIEAOPDmjVjLsB/46QhCDdw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.osx-arm64";
+        version = "9.0.8";
+        hash = "sha512-bCH5hRqBpZXNuNO2xmhx4EmZtP6qvH7qlNP3neR9LhaRR2V6ttRwH2LOPZNaMiroNo1V4T+aDYsqP+4blJ7vFg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.osx-arm64";
+        version = "9.0.8";
+        hash = "sha512-VKdx5FBTl0DJSx3tXhSpEQmveT3plCbxvWmDiNmpZ1mroNunXT8F5HLfpnHBLfJ/AYoA/aR/rDDLK5521EjScg==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-Jzq382A89/24L3mRaWqD7SBzBO8Q3gFPksq5xnMrkt/kvTES68kMChvime8TE9Swq22vQNdmWc7Oleco/VsocA==";
+      })
+    ];
+    osx-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.osx-x64";
+        version = "9.0.8";
+        hash = "sha512-gsCIp/l+fBFkghgipU7AlJmbN9mBioZ0gTJ/71Ue3brd8oT+JTHljk7Byth43Wz/QHqvW6NtMfB/KMba+Ovcrw==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.osx-x64";
+        version = "9.0.8";
+        hash = "sha512-1bPBwHyTuD+bM2mIs/lDzPSbxUv3td2KvxqoslykADooEXMkEldhP4h6GRJabTygMKzpG36kaUbVhmY0Z3YzQg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.osx-x64";
+        version = "9.0.8";
+        hash = "sha512-iOBFiwX+SH3Sz6Re+xDVTUrdtNzD+A0w4CgmhKyvGEm+S2gXHKptcYTfuHPWxgXkewJfLFGb6SNjcdqpbC2ETA==";
+      })
+      (fetchNupkg {
+        pname = "runtime.osx-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-KZKJ7e4Mq8E06pMAtTnyjmk/SqNEEMLHcbESLJ7ggVedHcJA/elymIGepIZP9jSwQjtI1v7ggIc3g9C63QDrtA==";
+      })
+    ];
+    win-arm64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.win-arm64";
+        version = "9.0.8";
+        hash = "sha512-NJTDO+UX/6NpAORJ+AsL177tpbgCTAaSavaDKKTkz8wwdesjcT0OEMa6XveImmOA4KDQsD9dyPZk8CY+y/+6EQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.win-arm64";
+        version = "9.0.8";
+        hash = "sha512-LJ3kCcdyacCBeii37XDf8uSWGrkEa2rpwyCQRnQdPKDQKs3QemPqXBiodbUGe40jxsWeg/aTh68ux3E0w5A6ug==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.win-arm64";
+        version = "9.0.8";
+        hash = "sha512-r5eVgUvphRSxeAkmjQsbSQI7phyaFklVs4Mwu4Qgr4HAu+UkZI8UJi23jKbK8B5iUuqj+L2bE6/hNti1XIvQNw==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-arm64.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-KpD57JOPE5YykXteBFpIhQAs5TVrJKWxryEPpW9jdr0K73gGClquXUexYGjiHk++EPTr59aRKcUKQrNyZXOmDw==";
+      })
+    ];
+    win-x64 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.win-x64";
+        version = "9.0.8";
+        hash = "sha512-gXQpEX6W6CWyUpmX1zbRE4pGR3c0EJLbBqkXOpqiPpLc/qh6in+tC4MhGWesCNLOsZXf0nlFikBUouKeX4heUA==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.win-x64";
+        version = "9.0.8";
+        hash = "sha512-shIJcIsVRmlyuiBNu/OJ0cl3YS2g8LAUwN+r42Jin+HZYkZE5Esf3Zl6KNrBG4JdhZD32jNZ9JE/m0uB0PbLRQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.win-x64";
+        version = "9.0.8";
+        hash = "sha512-ubHRXN/19HpDTzlaXIAJUVOpfgOOnsPwIwxk+rlaO1nv2w74aa8dUQGtPeqNkpo87CSdwpc1uaDe79NLGeY0HQ==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x64.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-RFXToE31qPxev1Ei0hosMf8jN9U9hivDSiTWGFaBg8Bjyeai5YZ4JcYfNi3yNyaBKrra8sdPtcKMBHn3JtRnTw==";
+      })
+    ];
+    win-x86 = [
+      (fetchNupkg {
+        pname = "Microsoft.AspNetCore.App.Runtime.win-x86";
+        version = "9.0.8";
+        hash = "sha512-Hq2Jkbv1dN5A6hojoNpZYsWdHlmALRRZSAxWY6y/bYfwczY7xRXPcwDWcXg3TgURZ3tYDjLAZmKvmkxe8CGOWQ==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Host.win-x86";
+        version = "9.0.8";
+        hash = "sha512-iAKhXmVqwtB1oU09QaFgY1rHegt+GczpjlpmKibZCGjewULMevVnFaNTUGgnNKfnFziEy9Ou9khGyRjumrDbsg==";
+      })
+      (fetchNupkg {
+        pname = "Microsoft.NETCore.App.Runtime.win-x86";
+        version = "9.0.8";
+        hash = "sha512-JTcyKAl8lxnWoIptRAw9qdF1wfxKQb6JNs898g/HJQIOBQCuW6DkJy7TAn6QHhJPQ0o5KS4LtG/wCTs05IO3+g==";
+      })
+      (fetchNupkg {
+        pname = "runtime.win-x86.Microsoft.NETCore.DotNetAppHost";
+        version = "9.0.8";
+        hash = "sha512-SkW+QLlwQVY3G1yYd8ECVY22NtMo+gkGvnzOSQqsQ91e1Ihf8kGtAQ8mX8/NNmM4ekj7XuwsdGK6mt89HNoFXA==";
+      })
+    ];
+  };
+
+in
+rec {
+  release_9_0 = "9.0.8";
+
+  aspnetcore_9_0 = buildAspNetCore {
+    version = "9.0.8";
+    srcs = {
+      linux-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/9.0.8/aspnetcore-runtime-9.0.8-linux-arm.tar.gz";
+        hash = "sha512-qZREscunr0rNEtmtQSb+Ss3fLvDgK5md4LwYU3QuE27/sD7XrcKgpHBi0AUbMXkyCkf9PSOdD7hvl3W3PeQ9Gg==";
+      };
+      linux-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/9.0.8/aspnetcore-runtime-9.0.8-linux-arm64.tar.gz";
+        hash = "sha512-zx5y9LMnuTwaw/Le+cqDvuJ6QI5bWRP4TtlUz9bEY52hZk/j9OOSWIPbd+0p+lNkucqK83lvM8pzpMt0hOMmvA==";
+      };
+      linux-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/9.0.8/aspnetcore-runtime-9.0.8-linux-x64.tar.gz";
+        hash = "sha512-CK/fkk0A+HW0TMTv9otV+5tj5Mxo5rXN6HPaK86cW19BIOhptqHf3qSrEEqwrIeD7xV3tNMnWq6JmlPNiBMPHQ==";
+      };
+      linux-musl-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/9.0.8/aspnetcore-runtime-9.0.8-linux-musl-arm.tar.gz";
+        hash = "sha512-RND6DTb5z/mT9wie/TsrPg5g1AO8K1o5URa+fWtDqCRx4qu0TNFwJGStMCM3vD4M5J4kLwL6FKEUKI8PimYilg==";
+      };
+      linux-musl-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/9.0.8/aspnetcore-runtime-9.0.8-linux-musl-arm64.tar.gz";
+        hash = "sha512-5ExwXEbRT8tXVPF7o0bqKHb8G9tEv6A3K0jAmXkZmnaOuCdmuOfiK53AGnw4uFPvG1P4stxX3vFbPcJf0I6yVg==";
+      };
+      linux-musl-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/9.0.8/aspnetcore-runtime-9.0.8-linux-musl-x64.tar.gz";
+        hash = "sha512-5D3IU1sy+f0Xtrgc+7l1vkbwn3eTAkBC5i/htJnbZu6tbbESylH+/ZojxnbLbcsBkcWYXC9TQGmB9OFfC272Zw==";
+      };
+      osx-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/9.0.8/aspnetcore-runtime-9.0.8-osx-arm64.tar.gz";
+        hash = "sha512-T+od1lxCvVoGUOG+m2K8ygX0jKLI0bWX6VjGX5TfZZZmUHx+twPdnQbyStAHmI/pKvc2P+2z20lQK4pcVPmthA==";
+      };
+      osx-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/aspnetcore/Runtime/9.0.8/aspnetcore-runtime-9.0.8-osx-x64.tar.gz";
+        hash = "sha512-cOgD8+BEnqxWQ43hL4dx8yJgcpbuU+DmiWziEfXa/gg/XzP54sdsVAEsk/wblR4MFjDJdEd3fcRovvn7EZSfww==";
+      };
+    };
+  };
+
+  runtime_9_0 = buildNetRuntime {
+    version = "9.0.8";
+    srcs = {
+      linux-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.8/dotnet-runtime-9.0.8-linux-arm.tar.gz";
+        hash = "sha512-XitlwgOdZuHGyasekrvUh/zRvXphI8FwvqzbHOJGiNc0noSuizhr11i9JHK3NtGO3qg3DMY+tV+sCqs1ZYgP3g==";
+      };
+      linux-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.8/dotnet-runtime-9.0.8-linux-arm64.tar.gz";
+        hash = "sha512-MBXpX/DDc7jVlJHPHDIMgPTsdBjWNAC/ZQjU4l5xpH2yhUkVNIqxhuWKktWsLyD77BPWPfXF9gH/SvXynD2c0w==";
+      };
+      linux-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.8/dotnet-runtime-9.0.8-linux-x64.tar.gz";
+        hash = "sha512-92luoqMKErrQyPcyGsQoQ87TBxhNiUyUpkyFKJs88wk23zc/9YVDzpt3YFqAJD0fx3e8lZV1Y0qq2cqogPv4Zg==";
+      };
+      linux-musl-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.8/dotnet-runtime-9.0.8-linux-musl-arm.tar.gz";
+        hash = "sha512-sQh1B3IPZCmiSihUVMzVSokifIXcsb3wwjQkdyMJR8kc4/FmW+diYRNqk1yXPUvtjF0c7AiX+GsJMWuq7h27Qg==";
+      };
+      linux-musl-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.8/dotnet-runtime-9.0.8-linux-musl-arm64.tar.gz";
+        hash = "sha512-AYQXIV58CoKhnsfhGaQ4vKkYucRI84SyffuH+YGpiKwhTFdvKKrv7IV0WwBc/3C/0pm+Mb8k4xlVOKTpH6bv4w==";
+      };
+      linux-musl-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.8/dotnet-runtime-9.0.8-linux-musl-x64.tar.gz";
+        hash = "sha512-oAgYUGPY80Y15AMoMTrzHnuuI5yNokcmsf8gEuyTDDLvDcDWcpKuvE2FMNKyb6Rs/7M5PPFrzfZsEOqINFitcQ==";
+      };
+      osx-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.8/dotnet-runtime-9.0.8-osx-arm64.tar.gz";
+        hash = "sha512-+n7QPNWl4FVfZfjwEBx3Yua/2gBfpJWvoSZRjU1ByXNMZX/DWc+A+Qv2+/GGwmrwOBnbrdUlHpftTL0Ej8J7OA==";
+      };
+      osx-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Runtime/9.0.8/dotnet-runtime-9.0.8-osx-x64.tar.gz";
+        hash = "sha512-M5jxrKx2R+Jc0kdoBMWtJkyhjhUtDiKzLr2mvV13RMHpMqqQhq7NN5S4208vcl7SD/3UT/YV5ygaCsXdlQc7nw==";
+      };
+    };
+  };
+
+  sdk_9_0_1xx = buildNetSdk {
+    version = "9.0.109";
+    srcs = {
+      linux-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.109/dotnet-sdk-9.0.109-linux-arm.tar.gz";
+        hash = "sha512-QJEtXxu/WbBx0uHTHsHZq93b893GSzIz58fpFpawI+H6eglHJdOZW5MciAA4Ql7OvAXwE/dZYye/SWaSnpgBtQ==";
+      };
+      linux-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.109/dotnet-sdk-9.0.109-linux-arm64.tar.gz";
+        hash = "sha512-Kd/68u4iQCxgHD4cvvNoKbow/jLpdrMfJH32BaFF76KafiPfUJ7YH6mm0T8eVYFeKlkiA6p5wudniNkBpuGrWA==";
+      };
+      linux-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.109/dotnet-sdk-9.0.109-linux-x64.tar.gz";
+        hash = "sha512-zDhqjnAJhVpumjqKFT2htc5UwuC3t64wVEXunw1XNVGN/u8Nj/MqREeC4180oxZ1ck4EBTYAGnbJ3Bt1W1omBQ==";
+      };
+      linux-musl-arm = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.109/dotnet-sdk-9.0.109-linux-musl-arm.tar.gz";
+        hash = "sha512-62kBlt/TQmebHm0Mw/UAZ74dDypu+RFx/rcS5MSkkb7jgeNQBjgpDh5Z6TP3f1fMZL7ZLK1u6h62VnarikxmoQ==";
+      };
+      linux-musl-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.109/dotnet-sdk-9.0.109-linux-musl-arm64.tar.gz";
+        hash = "sha512-CZ+bh0Cjx1hBU8KWFg/Jb8y8GMfCRnjv9+ZCXWAsdw1TTE8ttWOTPNT+XJ6y1A99A6H2mu9em5RZDzYM9qFCgQ==";
+      };
+      linux-musl-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.109/dotnet-sdk-9.0.109-linux-musl-x64.tar.gz";
+        hash = "sha512-FonLs6wXs3SQOyFKFz8kFgByrlfMXRMH9bJgUbb/BAV3K2A7amx+8ZUvc3sYyfO5dvc1S4S4mra/Fb4g3QY2tg==";
+      };
+      osx-arm64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.109/dotnet-sdk-9.0.109-osx-arm64.tar.gz";
+        hash = "sha512-ri68P3dAq4gK9W4209Kh7lpU/BErb9zCUo8sjFmAjTZHbV+rXNqn0lgZsOSpARdF86nlxyaSzZMrMA62/YX1rw==";
+      };
+      osx-x64 = {
+        url = "https://builds.dotnet.microsoft.com/dotnet/Sdk/9.0.109/dotnet-sdk-9.0.109-osx-x64.tar.gz";
+        hash = "sha512-O3Lvl5RoYzAitNIi2jGnP45zjR6n1ENAghXecxGCTk8lycbdGTxEAUwmVZIoKTiVwWSlGTTzB+FT2SfnDLbztw==";
+      };
+    };
+    inherit commonPackages hostPackages targetPackages;
+    runtime = runtime_9_0;
+    aspnetcore = aspnetcore_9_0;
+  };
+
+  sdk = sdk_9_0;
+
+  sdk_9_0 = sdk_9_0_1xx;
+}

pkgs/development/compilers/dotnet/9/default.nix

@@ -0,0 +1,11 @@
+{
+  callPackage,
+  dotnetCorePackages,
+}:
+callPackage ../dotnet.nix {
+  releaseManifestFile = ./release.json;
+  releaseInfoFile = ./release-info.json;
+  bootstrapSdkFile = ./bootstrap-sdk.nix;
+  depsFile = ./deps.json;
+  fallbackTargetPackages = dotnetCorePackages.sdk_9_0-bin.targetPackages;
+}

pkgs/development/compilers/dotnet/9/deps.json

@@ -0,0 +1,50 @@
+[
+  {
+    "pname": "runtime.linux-arm64.Microsoft.NETCore.ILAsm",
+    "sha256": "dfde67692b77b9298c63d0748c02961409eaf9ec1f519b3709f40b74d6e4bce0",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/runtime.linux-arm64.microsoft.netcore.ilasm/9.0.8/runtime.linux-arm64.microsoft.netcore.ilasm.9.0.8.nupkg",
+    "version": "9.0.8"
+  },
+  {
+    "pname": "runtime.linux-arm64.Microsoft.NETCore.ILDAsm",
+    "sha256": "d58559760799329796108006ed50d2307340e99d910089132b45bb08d9f63746",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/runtime.linux-arm64.microsoft.netcore.ildasm/9.0.8/runtime.linux-arm64.microsoft.netcore.ildasm.9.0.8.nupkg",
+    "version": "9.0.8"
+  },
+  {
+    "hash": "sha256-L45+wVapWxxvfamjT3xTtJbYfIkUfi0JVptDp06DRUA=",
+    "pname": "runtime.linux-x64.Microsoft.NETCore.ILAsm",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/runtime.linux-x64.microsoft.netcore.ilasm/9.0.8/runtime.linux-x64.microsoft.netcore.ilasm.9.0.8.nupkg",
+    "version": "9.0.8"
+  },
+  {
+    "hash": "sha256-pC7+si0En60bPU1bqM+RxcaDlBUTCwmCgJOqgYdVO8I=",
+    "pname": "runtime.linux-x64.Microsoft.NETCore.ILDAsm",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/runtime.linux-x64.microsoft.netcore.ildasm/9.0.8/runtime.linux-x64.microsoft.netcore.ildasm.9.0.8.nupkg",
+    "version": "9.0.8"
+  },
+  {
+    "pname": "runtime.osx-arm64.Microsoft.NETCore.ILAsm",
+    "sha256": "fe448edf57d1782e08cfbbc85b4044f227bcd2c5148f5b784afaac22a3708901",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/runtime.osx-arm64.microsoft.netcore.ilasm/9.0.8/runtime.osx-arm64.microsoft.netcore.ilasm.9.0.8.nupkg",
+    "version": "9.0.8"
+  },
+  {
+    "pname": "runtime.osx-arm64.Microsoft.NETCore.ILDAsm",
+    "sha256": "a8c7fc434d9af9ab767ccaf3416046759c9d25c7ae5385096bf05ca4e4f354d9",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/runtime.osx-arm64.microsoft.netcore.ildasm/9.0.8/runtime.osx-arm64.microsoft.netcore.ildasm.9.0.8.nupkg",
+    "version": "9.0.8"
+  },
+  {
+    "pname": "runtime.osx-x64.Microsoft.NETCore.ILAsm",
+    "sha256": "448816bf6f7e1400d8ebe89ac1537dc796a8553b0ef2a2403c32e5afccdbc559",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/runtime.osx-x64.microsoft.netcore.ilasm/9.0.8/runtime.osx-x64.microsoft.netcore.ilasm.9.0.8.nupkg",
+    "version": "9.0.8"
+  },
+  {
+    "pname": "runtime.osx-x64.Microsoft.NETCore.ILDAsm",
+    "sha256": "161f30bfea6df634d6e80b4b93a62f598b2380e20cdb82df97f954f72f19532e",
+    "url": "https://pkgs.dev.azure.com/dnceng/9ee6d478-d288-47f7-aacc-f6e6d082ae6d/_packaging/45bacae2-5efb-47c8-91e5-8ec20c22b4f8/nuget/v3/flat2/runtime.osx-x64.microsoft.netcore.ildasm/9.0.8/runtime.osx-x64.microsoft.netcore.ildasm.9.0.8.nupkg",
+    "version": "9.0.8"
+  }
+]

pkgs/development/compilers/dotnet/9/release-info.json

@@ -0,0 +1,5 @@
+{
+  "tarballHash": "sha256-MQFwplcvl8bRQ3Ak60exusXgoWl3ZjHfBhdUJj3PYtY=",
+  "artifactsUrl": "https://builds.dotnet.microsoft.com/source-built-artifacts/assets/Private.SourceBuilt.Artifacts.9.0.109-servicing.25368.1.centos.9-x64.tar.gz",
+  "artifactsHash": "sha256-RoEaBJESjYehHRzrRPNmZjY9yI9WCNLhmqb/8EgSuqw="
+}

pkgs/development/compilers/dotnet/9/release.json

@@ -0,0 +1,10 @@
+{
+  "release": "9.0.9",
+  "channel": "9.0",
+  "tag": "v9.0.110",
+  "sdkVersion": "9.0.110",
+  "runtimeVersion": "9.0.9",
+  "aspNetCoreVersion": "9.0.9",
+  "sourceRepository": "https://github.com/dotnet/dotnet",
+  "sourceVersion": "999243871ad8799c178193bb2d384dfbcfd94ce6"
+}

pkgs/development/compilers/dotnet/UpdateNuGetConfigPackageSourcesMappings-don-t-add-em.patch

@@ -0,0 +1,30 @@
+From 93137ea040472f4042dd186427699ad249e7251b Mon Sep 17 00:00:00 2001
+From: David McFarland <corngood@gmail.com>
+Date: Sun, 22 Sep 2024 16:41:07 -0300
+Subject: [PATCH] UpdateNuGetConfigPackageSourcesMappings: don't add empty
+ mappings
+
+---
+ .../UpdateNuGetConfigPackageSourcesMappings.cs              | 6 +++++-
+ 1 file changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/eng/tools/tasks/Microsoft.DotNet.UnifiedBuild.Tasks/UpdateNuGetConfigPackageSourcesMappings.cs b/eng/tools/tasks/Microsoft.DotNet.UnifiedBuild.Tasks/UpdateNuGetConfigPackageSourcesMappings.cs
+index 3b188c1801..9b7050ef46 100644
+--- a/eng/tools/tasks/Microsoft.DotNet.UnifiedBuild.Tasks/UpdateNuGetConfigPackageSourcesMappings.cs
++++ b/eng/tools/tasks/Microsoft.DotNet.UnifiedBuild.Tasks/UpdateNuGetConfigPackageSourcesMappings.cs
+@@ -115,7 +115,11 @@ namespace Microsoft.DotNet.UnifiedBuild.Tasks
+                 // Skip sources with zero package patterns
+                 if (allSourcesPackages[packageSource]?.Count > 0)
+                 {
+-                    pkgSrcMappingClearElement.AddAfterSelf(GetPackageMappingsElementForSource(packageSource));
++                    var pkgSrc = GetPackageMappingsElementForSource(packageSource);
++                    if (pkgSrc.Elements().Any())
++                    {
++                        pkgSrcMappingClearElement.AddAfterSelf(pkgSrc);
++                    }
+                 }
+             }
+ 
+-- 
+2.46.0
+

pkgs/development/compilers/dotnet/build-dotnet.nix

@@ -0,0 +1,252 @@
+{
+  type,
+  version,
+  srcs,
+  commonPackages ? null,
+  hostPackages ? null,
+  targetPackages ? null,
+  runtime ? null,
+  aspnetcore ? null,
+}:
+
+assert builtins.elem type [
+  "aspnetcore"
+  "runtime"
+  "sdk"
+];
+assert
+  if type == "sdk" then
+    commonPackages != null
+    && hostPackages != null
+    && targetPackages != null
+    && runtime != null
+    && aspnetcore != null
+  else
+    true;
+
+{
+  lib,
+  stdenv,
+  fetchurl,
+  writeText,
+  autoPatchelfHook,
+  makeWrapper,
+  libunwind,
+  icu,
+  libuuid,
+  zlib,
+  libkrb5,
+  openssl,
+  curl,
+  lttng-ust_2_12,
+  testers,
+  runCommand,
+  writeShellScript,
+  mkNugetDeps,
+  callPackage,
+  systemToDotnetRid,
+  xmlstarlet,
+}:
+
+let
+  pname =
+    if type == "aspnetcore" then
+      "aspnetcore-runtime"
+    else if type == "runtime" then
+      "dotnet-runtime"
+    else
+      "dotnet-sdk";
+
+  descriptions = {
+    aspnetcore = "ASP.NET Core Runtime ${version}";
+    runtime = ".NET Runtime ${version}";
+    sdk = ".NET SDK ${version}";
+  };
+
+  mkWrapper = callPackage ./wrapper.nix { };
+
+  hostRid = systemToDotnetRid stdenv.hostPlatform.system;
+  targetRid = systemToDotnetRid stdenv.targetPlatform.system;
+
+  sigtool = callPackage ./sigtool.nix { };
+  signAppHost = callPackage ./sign-apphost.nix { };
+
+  hasILCompiler = lib.versionAtLeast version (if hostRid == "osx-arm64" then "8" else "7");
+
+  extraTargets = writeText "extra.targets" (
+    ''
+      <Project>
+    ''
+    + lib.optionalString hasILCompiler ''
+      <ItemGroup>
+        <CustomLinkerArg Include="-Wl,-rpath,'${
+          lib.makeLibraryPath [
+            icu
+            zlib
+            openssl
+          ]
+        }'" />
+      </ItemGroup>
+    ''
+    + lib.optionalString stdenv.hostPlatform.isDarwin ''
+      <Import Project="${signAppHost}" />
+    ''
+    + ''
+      </Project>
+    ''
+  );
+
+in
+mkWrapper type (
+  stdenv.mkDerivation (finalAttrs: {
+    inherit pname version;
+
+    # Some of these dependencies are `dlopen()`ed.
+    nativeBuildInputs = [
+      makeWrapper
+    ]
+    ++ lib.optional stdenv.hostPlatform.isLinux autoPatchelfHook
+    ++ lib.optionals (type == "sdk" && stdenv.hostPlatform.isDarwin) [
+      xmlstarlet
+      sigtool
+    ];
+
+    buildInputs = [
+      stdenv.cc.cc
+      zlib
+      icu
+      libkrb5
+      curl
+      xmlstarlet
+    ]
+    ++ lib.optional stdenv.hostPlatform.isLinux lttng-ust_2_12;
+
+    src = fetchurl (
+      srcs.${hostRid} or (throw "Missing source (url and hash) for host RID: ${hostRid}")
+    );
+
+    sourceRoot = ".";
+
+    postPatch =
+      if type == "sdk" then
+        (
+          ''
+            xmlstarlet ed \
+              --inplace \
+              -s //_:Project -t elem -n Import \
+              -i \$prev -t attr -n Project -v "${extraTargets}" \
+              sdk/*/Sdks/Microsoft.NET.Sdk/targets/Microsoft.NET.Sdk.targets
+          ''
+          + lib.optionalString (stdenv.hostPlatform.isDarwin && lib.versionOlder version "10") ''
+            codesign --remove-signature packs/Microsoft.NETCore.App.Host.osx-*/*/runtimes/osx-*/native/{apphost,singlefilehost}
+          ''
+        )
+      else
+        null;
+
+    dontPatchELF = true;
+    noDumpEnvVars = true;
+
+    installPhase = ''
+      runHook preInstall
+
+      mkdir -p $out/share/doc/$pname/$version
+      mv LICENSE.txt $out/share/doc/$pname/$version/
+      mv ThirdPartyNotices.txt $out/share/doc/$pname/$version/
+
+      mkdir -p $out/share/dotnet
+      cp -r ./ $out/share/dotnet
+
+      mkdir -p $out/bin
+      ln -s $out/share/dotnet/dotnet $out/bin/dotnet
+
+      runHook postInstall
+    '';
+
+    # Tell autoPatchelf about runtime dependencies.
+    # (postFixup phase is run before autoPatchelfHook.)
+    postFixup = lib.optionalString stdenv.hostPlatform.isLinux ''
+      patchelf \
+        --add-needed libicui18n.so \
+        --add-needed libicuuc.so \
+        $out/share/dotnet/shared/Microsoft.NETCore.App/*/libcoreclr.so \
+        $out/share/dotnet/shared/Microsoft.NETCore.App/*/*System.Globalization.Native.so \
+        $out/share/dotnet/packs/Microsoft.NETCore.App.Host.${hostRid}/*/runtimes/${hostRid}/native/*host
+      patchelf \
+        --add-needed libgssapi_krb5.so \
+        $out/share/dotnet/shared/Microsoft.NETCore.App/*/*System.Net.Security.Native.so \
+        $out/share/dotnet/packs/Microsoft.NETCore.App.Host.${hostRid}/*/runtimes/${hostRid}/native/*host
+      patchelf \
+        --add-needed libssl.so \
+        $out/share/dotnet/shared/Microsoft.NETCore.App/*/*System.Security.Cryptography.Native.OpenSsl.so \
+        $out/share/dotnet/packs/Microsoft.NETCore.App.Host.${hostRid}/*/runtimes/${hostRid}/native/*host
+    '';
+
+    # fixes: Could not load ICU data. UErrorCode: 2
+    propagatedSandboxProfile = lib.optionalString stdenv.hostPlatform.isDarwin ''
+      (allow file-read* (subpath "/usr/share/icu"))
+      (allow file-read* (subpath "/private/var/db/mds/system"))
+      (allow mach-lookup (global-name "com.apple.SecurityServer")
+                         (global-name "com.apple.system.opendirectoryd.membership"))
+    '';
+
+    passthru = {
+      inherit icu hasILCompiler;
+    }
+    // lib.optionalAttrs (type == "sdk") (
+      let
+        # force evaluation of the SDK package to ensure evaluation failures
+        # (e.g. due to vulnerabilities) propagate to the nuget packages
+        forceSDKEval = builtins.seq finalAttrs.finalPackage.drvPath;
+      in
+      {
+        packages = map forceSDKEval (
+          commonPackages ++ hostPackages.${hostRid} ++ targetPackages.${targetRid}
+        );
+        targetPackages = lib.mapAttrs (_: map forceSDKEval) targetPackages;
+        inherit runtime aspnetcore;
+
+        updateScript =
+          let
+            majorVersion = lib.concatStringsSep "." (lib.take 2 (lib.splitVersion version));
+          in
+          [
+            ./update.sh
+            majorVersion
+          ];
+      }
+    );
+
+    meta = with lib; {
+      description = builtins.getAttr type descriptions;
+      homepage = "https://dotnet.github.io/";
+      license = licenses.mit;
+      maintainers = with maintainers; [
+        kuznero
+        mdarocha
+        corngood
+      ];
+      mainProgram = "dotnet";
+      platforms = lib.filter (
+        platform:
+        let
+          e = builtins.tryEval (systemToDotnetRid platform);
+        in
+        e.success && srcs ? "${e.value}"
+      ) lib.platforms.all;
+      sourceProvenance = with lib.sourceTypes; [
+        binaryBytecode
+        binaryNativeCode
+      ];
+      knownVulnerabilities =
+        lib.optionals
+          (lib.elem (lib.head (lib.splitVersion version)) [
+            "6"
+            "7"
+          ])
+          [
+            "Dotnet SDK ${version} is EOL, please use 8.0 (LTS) or 9.0 (Current)"
+          ];
+    };
+  })
+)

pkgs/development/compilers/dotnet/bundler-fix-file-size-estimation-when-bundling-symli.patch

@@ -0,0 +1,47 @@
+From 8fa3570bf75c48bf68f42b74790bf8ba0f032a3f Mon Sep 17 00:00:00 2001
+From: David McFarland <corngood@gmail.com>
+Date: Thu, 14 Aug 2025 10:49:40 -0300
+Subject: [PATCH] bundler: fix file size estimation when bundling symlinks
+
+---
+ .../managed/Microsoft.NET.HostModel/Bundle/Bundler.cs  | 10 ++++++++--
+ 1 file changed, 8 insertions(+), 2 deletions(-)
+
+diff --git a/src/runtime/src/installer/managed/Microsoft.NET.HostModel/Bundle/Bundler.cs b/src/runtime/src/installer/managed/Microsoft.NET.HostModel/Bundle/Bundler.cs
+index a5e8b593484..39f39334251 100644
+--- a/src/runtime/src/installer/managed/Microsoft.NET.HostModel/Bundle/Bundler.cs
++++ b/src/runtime/src/installer/managed/Microsoft.NET.HostModel/Bundle/Bundler.cs
+@@ -284,6 +284,12 @@ public string GenerateBundle(IReadOnlyList<FileSpec> fileSpecs)
+                 throw new ArgumentException("Invalid input specification: Must specify the host binary");
+             }
+ 
++            static long GetFileLength(string path)
++            {
++                var info = new FileInfo(path);
++                return ((FileInfo?)info.ResolveLinkTarget(true) ?? info).Length;
++            }
++
+             (FileSpec Spec, FileType Type)[] relativePathToSpec = GetFilteredFileSpecs(fileSpecs);
+             long bundledFilesSize = 0;
+             // Conservatively estimate the size of bundled files.
+@@ -293,7 +299,7 @@ public string GenerateBundle(IReadOnlyList<FileSpec> fileSpecs)
+             // We will memory map a larger file than needed, but we'll take that trade-off.
+             foreach (var (spec, type) in relativePathToSpec)
+             {
+-                bundledFilesSize += new FileInfo(spec.SourcePath).Length;
++                bundledFilesSize += GetFileLength(spec.SourcePath);
+                 if (type == FileType.Assembly)
+                 {
+                     // Alignment could be as much as AssemblyAlignment - 1 bytes.
+@@ -314,7 +320,7 @@ public string GenerateBundle(IReadOnlyList<FileSpec> fileSpecs)
+             {
+                 Directory.CreateDirectory(destinationDirectory);
+             }
+-            var hostLength = new FileInfo(hostSource).Length;
++            var hostLength = GetFileLength(hostSource);
+             var bundleManifestLength = Manifest.GetManifestLength(BundleManifest.BundleMajorVersion, relativePathToSpec.Select(x => x.Spec.BundleRelativePath));
+             long bundleTotalSize = hostLength + bundledFilesSize + bundleManifestLength;
+             if (_target.IsOSX && _macosCodesign)
+-- 
+2.50.1
+

pkgs/development/compilers/dotnet/combine-deps.nix

@@ -0,0 +1,49 @@
+{
+  list,
+  baseRid,
+  otherRids,
+  pkgs ? import ../../../.. { },
+}:
+let
+  inherit (pkgs) writeText;
+
+  inherit (pkgs.lib)
+    concatMap
+    concatMapStringsSep
+    generators
+    importJSON
+    optionals
+    replaceStrings
+    sortOn
+    strings
+    unique
+    ;
+
+  packages = concatMap (file: importJSON file) list;
+
+  changePackageRid =
+    package: rid:
+    let
+      replace = replaceStrings [ ".${baseRid}" ] [ ".${rid}" ];
+    in
+    rec {
+      pname = replace package.pname;
+      inherit (package) version;
+      url = replace package.url;
+      sha256 = builtins.hashFile "sha256" (builtins.fetchurl url);
+    };
+
+  expandPackage =
+    package:
+    [ package ]
+    ++ optionals (strings.match ".*\\.${baseRid}(\\..*|$)" package.pname != null) (
+      map (changePackageRid package) otherRids
+    );
+
+  allPackages = sortOn (package: [
+    package.pname
+    package.version
+  ]) (concatMap expandPackage packages);
+
+in
+writeText "deps.json" (builtins.toJSON allPackages)

pkgs/development/compilers/dotnet/combine-packages.nix

@@ -0,0 +1,76 @@
+dotnetPackages:
+{
+  buildEnv,
+  makeWrapper,
+  lib,
+  symlinkJoin,
+  callPackage,
+}:
+# TODO: Rethink how we determine and/or get the CLI.
+#       Possible options raised in #187118:
+#         1. A separate argument for the CLI (as suggested by IvarWithoutBones
+#         2. Use the highest version SDK for the CLI (as suggested by GGG)
+#         3. Something else?
+let
+  cli = builtins.head dotnetPackages;
+  mkWrapper = callPackage ./wrapper.nix { };
+in
+assert lib.assertMsg ((builtins.length dotnetPackages) > 0) ''
+  You must include at least one package, e.g
+        `with dotnetCorePackages; combinePackages [
+            sdk_9_0 aspnetcore_8_0
+         ];`'';
+mkWrapper "sdk" (
+  (buildEnv {
+    name = "dotnet-combined";
+    paths = dotnetPackages;
+    pathsToLink = map (x: "/share/dotnet/${x}") [
+      "host"
+      "metadata"
+      "packs"
+      "sdk"
+      "sdk-manifests"
+      "shared"
+      "templates"
+    ];
+    ignoreCollisions = true;
+    nativeBuildInputs = [ makeWrapper ];
+    postBuild = ''
+      mkdir -p "$out"/share/dotnet
+      cp "${cli}"/share/dotnet/dotnet $out/share/dotnet
+      cp -R "${cli}"/nix-support "$out"/
+      mkdir "$out"/bin
+      ln -s "$out"/share/dotnet/dotnet "$out"/bin/dotnet
+    ''
+    + lib.optionalString (cli ? man) ''
+      ln -s ${cli.man} $man
+    '';
+    passthru = {
+      pname = "dotnet";
+      version = "combined";
+      inherit (cli) icu;
+
+      versions = lib.catAttrs "version" dotnetPackages;
+      packages = lib.concatLists (lib.catAttrs "packages" dotnetPackages);
+      targetPackages = lib.zipAttrsWith (_: lib.concatLists) (
+        lib.catAttrs "targetPackages" dotnetPackages
+      );
+    };
+
+    meta = {
+      description = "${cli.meta.description or "dotnet"} (combined)";
+      inherit (cli.meta)
+        homepage
+        license
+        mainProgram
+        maintainers
+        platforms
+        ;
+    };
+  }).overrideAttrs
+    {
+      propagatedSandboxProfile = toString (
+        lib.unique (lib.concatLists (lib.catAttrs "__propagatedSandboxProfile" dotnetPackages))
+      );
+    }
+)

pkgs/development/compilers/dotnet/completions/dotnet.bash

@@ -0,0 +1,13 @@
+# bash parameter completion for the dotnet CLI
+
+function _dotnet_bash_complete()
+{
+    local cur="${COMP_WORDS[COMP_CWORD]}" IFS=$'\n' # On Windows you may need to use use IFS=$'\r\n'
+    local candidates
+
+    read -d '' -ra candidates < <(dotnet complete --position "${COMP_POINT}" "${COMP_LINE}" 2>/dev/null)
+
+    read -d '' -ra COMPREPLY < <(compgen -W "${candidates[*]:-}" -- "$cur")
+}
+
+complete -f -F _dotnet_bash_complete dotnet

pkgs/development/compilers/dotnet/completions/dotnet.fish

@@ -0,0 +1 @@
+complete -f -c dotnet -a "(dotnet complete (commandline -cp))"

pkgs/development/compilers/dotnet/completions/dotnet.zsh

@@ -0,0 +1,18 @@
+# zsh parameter completion for the dotnet CLI
+
+_dotnet_zsh_complete()
+{
+  local completions=("$(dotnet complete "$words")")
+
+  # If the completion list is empty, just continue with filename selection
+  if [ -z "$completions" ]
+  then
+    _arguments '*::arguments: _normal'
+    return
+  fi
+
+  # This is not a variable assignment, don't remove spaces!
+  _values = "${(ps:\n:)completions}"
+}
+
+compdef _dotnet_zsh_complete dotnet

pkgs/development/compilers/dotnet/default.nix

@@ -0,0 +1,186 @@
+/*
+  How to combine packages for use in development:
+  dotnetCombined = with dotnetCorePackages; combinePackages [ sdk_9_0 aspnetcore_8_0 ];
+
+  Hashes and urls are retrieved from:
+  https://dotnet.microsoft.com/download/dotnet
+*/
+{
+  lib,
+  config,
+  recurseIntoAttrs,
+  generateSplicesForMkScope,
+  makeScopeWithSplicing',
+  writeScriptBin,
+}:
+
+let
+  pkgs = makeScopeWithSplicing' {
+    otherSplices = generateSplicesForMkScope "dotnetCorePackages";
+    f = (
+      self:
+      let
+        callPackage = self.callPackage;
+
+        fetchNupkg = callPackage ../../../build-support/dotnet/fetch-nupkg { };
+
+        buildDotnet = attrs: callPackage (import ./build-dotnet.nix attrs) { };
+        buildDotnetSdk =
+          version:
+          import version {
+            inherit fetchNupkg;
+            buildAspNetCore = attrs: buildDotnet (attrs // { type = "aspnetcore"; });
+            buildNetRuntime = attrs: buildDotnet (attrs // { type = "runtime"; });
+            buildNetSdk = attrs: buildDotnet (attrs // { type = "sdk"; });
+          };
+
+        ## Files in versions/ are generated automatically by update.sh ##
+        dotnet-bin = lib.mergeAttrsList (
+          map buildDotnetSdk [
+            ./versions/6.0.nix
+            ./versions/7.0.nix
+            ./versions/8.0.nix
+            ./versions/9.0.nix
+            ./versions/10.0.nix
+          ]
+        );
+
+        runtimeIdentifierMap = {
+          "x86_64-linux" = "linux-x64";
+          "aarch64-linux" = "linux-arm64";
+          "x86_64-darwin" = "osx-x64";
+          "aarch64-darwin" = "osx-arm64";
+          "x86_64-windows" = "win-x64";
+          "i686-windows" = "win-x86";
+        };
+
+      in
+      lib.optionalAttrs config.allowAliases (
+        {
+          # EOL
+          sdk_2_1 = throw "Dotnet SDK 2.1 is EOL, please use 8.0 (LTS) or 9.0 (Current)";
+          sdk_2_2 = throw "Dotnet SDK 2.2 is EOL, please use 8.0 (LTS) or 9.0 (Current)";
+          sdk_3_0 = throw "Dotnet SDK 3.0 is EOL, please use 8.0 (LTS) or 9.0 (Current)";
+          sdk_3_1 = throw "Dotnet SDK 3.1 is EOL, please use 8.0 (LTS) or 9.0 (Current)";
+          sdk_5_0 = throw "Dotnet SDK 5.0 is EOL, please use 8.0 (LTS) or 9.0 (Current)";
+        }
+        // dotnet-bin
+      )
+      // lib.mapAttrs' (k: v: lib.nameValuePair "${k}-bin" v) dotnet-bin
+      // {
+        inherit callPackage fetchNupkg buildDotnetSdk;
+
+        generate-dotnet-sdk = writeScriptBin "generate-dotnet-sdk" (
+          # Don't include current nixpkgs in the exposed version. We want to make the script runnable without nixpkgs repo.
+          builtins.replaceStrings [ " -I nixpkgs=./." ] [ "" ] (builtins.readFile ./update.sh)
+        );
+
+        # Convert a "stdenv.hostPlatform.system" to a dotnet RID
+        systemToDotnetRid =
+          system: runtimeIdentifierMap.${system} or (throw "unsupported platform ${system}");
+
+        combinePackages = attrs: callPackage (import ./combine-packages.nix attrs) { };
+
+        patchNupkgs = callPackage ./patch-nupkgs.nix { };
+        nugetPackageHook = callPackage ./nuget-package-hook.nix { };
+        autoPatchcilHook = callPackage ../../../build-support/dotnet/auto-patchcil-hook { };
+
+        buildDotnetModule = callPackage ../../../build-support/dotnet/build-dotnet-module { };
+        buildDotnetGlobalTool = callPackage ../../../build-support/dotnet/build-dotnet-global-tool { };
+
+        mkNugetSource = callPackage ../../../build-support/dotnet/make-nuget-source { };
+        mkNugetDeps = callPackage ../../../build-support/dotnet/make-nuget-deps { };
+        addNuGetDeps = callPackage ../../../build-support/dotnet/add-nuget-deps { };
+
+        dotnet_8 = recurseIntoAttrs (callPackage ./8 { });
+        dotnet_9 = recurseIntoAttrs (callPackage ./9 { });
+        dotnet_10 = recurseIntoAttrs (callPackage ./10 { });
+      }
+    );
+  };
+
+  # combine an SDK with the runtime/packages from a base SDK
+  combineSdk =
+    base: overlay:
+    if (overlay.runtime.version != base.runtime.version) then
+      throw "combineSdk: unable to combine ${overlay.name} with ${base.name} because runtime versions don't match (${overlay.runtime.version} != ${base.runtime.version})"
+    else
+      pkgs.callPackage ./wrapper.nix { } "sdk" (
+        (pkgs.combinePackages [
+          base.runtime
+          base.aspnetcore
+          (overlay.overrideAttrs (old: {
+            passthru = old.passthru // {
+              inherit (base)
+                packages
+                targetPackages
+                ;
+            };
+          }))
+        ]).unwrapped.overrideAttrs
+          (old: {
+            name = overlay.unwrapped.name;
+            # resolve symlinks so DOTNET_ROOT is self-contained
+            postBuild = ''
+              mv "$out"/share/dotnet{,~}
+              cp -Lr "$out"/share/dotnet{~,}
+              rm -r "$out"/share/dotnet~
+            ''
+            + old.postBuild;
+            passthru =
+              old.passthru
+              // (
+                let
+                  # if only overlay has a working ILCompiler, use it
+                  hostRid = pkgs.systemToDotnetRid base.stdenv.hostPlatform.system;
+                  hasILCompiler = base.hasILCompiler || overlay.hasILCompiler;
+                  packageName = "runtime.${hostRid}.Microsoft.DotNet.ILCompiler";
+                  packages =
+                    if !base.hasILCompiler && overlay.hasILCompiler then
+                      lib.filter (x: x.pname != packageName) base.packages
+                      ++ lib.filter (x: x.pname == packageName) overlay.packages
+                    else
+                      base.packages;
+                in
+                {
+                  inherit hasILCompiler packages;
+                  inherit (base)
+                    targetPackages
+                    runtime
+                    aspnetcore
+                    ;
+                  inherit (overlay.unwrapped)
+                    pname
+                    version
+                    ;
+                }
+              );
+          })
+      );
+
+in
+pkgs
+// rec {
+  # use binary SDK here to avoid downgrading feature band
+  sdk_8_0_1xx = if !pkgs.dotnet_8.vmr.meta.broken then pkgs.dotnet_8.sdk else pkgs.sdk_8_0_1xx-bin;
+  sdk_9_0_1xx = if !pkgs.dotnet_9.vmr.meta.broken then pkgs.dotnet_9.sdk else pkgs.sdk_9_0_1xx-bin;
+  sdk_10_0_1xx =
+    if !pkgs.dotnet_10.vmr.meta.broken then pkgs.dotnet_10.sdk else pkgs.sdk_10_0_1xx-bin;
+  # source-built SDK only exists for _1xx feature band
+  # https://github.com/dotnet/source-build/issues/3667
+  sdk_8_0_3xx = combineSdk sdk_8_0_1xx pkgs.sdk_8_0_3xx-bin;
+  sdk_8_0_4xx = combineSdk sdk_8_0_1xx pkgs.sdk_8_0_4xx-bin;
+  sdk_9_0_3xx = combineSdk sdk_9_0_1xx pkgs.sdk_9_0_3xx-bin;
+  sdk_8_0 = sdk_8_0_4xx;
+  sdk_9_0 = sdk_9_0_3xx;
+  sdk_10_0 = sdk_10_0_1xx;
+  sdk_8_0-source = sdk_8_0_1xx;
+  sdk_9_0-source = sdk_9_0_1xx;
+  sdk_10_0-source = sdk_10_0_1xx;
+  runtime_8_0 = sdk_8_0.runtime;
+  runtime_9_0 = sdk_9_0.runtime;
+  runtime_10_0 = sdk_10_0.runtime;
+  aspnetcore_8_0 = sdk_8_0.aspnetcore;
+  aspnetcore_9_0 = sdk_9_0.aspnetcore;
+  aspnetcore_10_0 = sdk_10_0.aspnetcore;
+}

pkgs/development/compilers/dotnet/dotnet-sdk-setup-hook.sh

@@ -0,0 +1,209 @@
+# shellcheck shell=bash disable=SC2154
+export MSBUILDALWAYSOVERWRITEREADONLYFILES=1
+export MSBUILDTERMINALLOGGER=false
+
+declare -Ag _nugetInputs
+
+addNugetInputs() {
+    if [[ -d $1/share/nuget ]]; then
+        _nugetInputs[$1]=1
+    fi
+}
+
+addEnvHooks "$targetOffset" addNugetInputs
+
+_linkPackages() {
+    local -r src="$1"
+    local -r dest="$2"
+    local dir
+    local x
+
+    (
+        shopt -s nullglob
+        for x in "$src"/*/*; do
+            dir=$dest/$(basename "$(dirname "$x")")
+            mkdir -p "$dir"
+            ln -s "$x" "$dir"/
+        done
+    )
+}
+
+configureNuget() {
+    runHook preConfigureNuGet
+
+    local nugetTemp x
+
+    nugetTemp="$(mktemp -dt nuget.XXXXXX)"
+    # trailing slash required here:
+    # Microsoft.Managed.Core.targets(236,5): error : SourceRoot paths are required to end with a slash or backslash: '/build/.nuget-temp/packages'
+    # also e.g. from avalonia:
+    # <EmbeddedResource Include="$(NuGetPackageRoot)sourcelink/1.1.0/tools/pdbstr.exe" />
+    export NUGET_PACKAGES=$nugetTemp/packages/
+    export NUGET_FALLBACK_PACKAGES=$nugetTemp/fallback/
+    nugetSource=$nugetTemp/source
+    mkdir -p "${NUGET_PACKAGES%/}" "${NUGET_FALLBACK_PACKAGES%/}" "$nugetSource"
+
+    for x in "${!_nugetInputs[@]}"; do
+        if [[ -d $x/share/nuget/packages ]]; then
+            _linkPackages "$x/share/nuget/packages" "${NUGET_FALLBACK_PACKAGES%/}"
+        fi
+
+        if [[ -d $x/share/nuget/source ]]; then
+            _linkPackages "$x/share/nuget/source" "$nugetSource"
+        fi
+    done
+
+    if [[ -f .config/dotnet-tools.json
+        || -f dotnet-tools.json ]]; then
+        : ${linkNugetPackages=1}
+    fi
+
+    if [[ -z ${keepNugetConfig-} && -f paket.dependencies ]]; then
+        sed -i "s:source .*:source $nugetSource:" paket.dependencies
+        sed -i "s:remote\:.*:remote\: $nugetSource:" paket.lock
+
+        : ${linkNuGetPackagesAndSources=1}
+    fi
+
+    if [[ -n ${linkNuGetPackagesAndSources-} ]]; then
+       for x in "${!_nugetInputs[@]}"; do
+           if [[ -d $x/share/nuget/source ]]; then
+               @lndir@/bin/lndir -silent "$x/share/nuget/packages" "${NUGET_PACKAGES%/}"
+               @lndir@/bin/lndir -silent "$x/share/nuget/source" "${NUGET_PACKAGES%/}"
+           fi
+       done
+    elif [[ -n ${linkNugetPackages-} ]]; then
+        for x in "${!_nugetInputs[@]}"; do
+            if [[ -d $x/share/nuget/packages ]]; then
+                _linkPackages "$x/share/nuget/packages" "${NUGET_PACKAGES%/}"
+            fi
+        done
+    fi
+
+    # create a root nuget.config if one doesn't exist
+    local rootConfig
+    rootConfig=$(find . -maxdepth 1 -iname nuget.config -print -quit)
+    if [[ -z $rootConfig ]]; then
+        dotnet new nugetconfig
+        rootConfig=nuget.config
+    fi
+
+    (
+        shopt -s nullglob
+
+        local -a xmlConfigArgs=() xmlRootConfigArgs=()
+
+        local -ra xmlSourceConfigArgs=(
+            -s /configuration -t elem -n packageSources
+            -d '/configuration/packageSources[position() != 1]'
+            -s /configuration/packageSources -t elem -n __new
+            -i /configuration/packageSources/__new -t attr -n key -v _nix
+            -i /configuration/packageSources/__new -t attr -n value -v "$nugetSource"
+            -r /configuration/packageSources/__new -v add)
+
+        if [[ -n ${keepNugetConfig-} ]] &&
+            ! @xmlstarlet@/bin/xmlstarlet select -t -i "/configuration/packageSources/clear" -nl "$rootConfig" &&
+            ! @xmlstarlet@/bin/xmlstarlet select -t -i "/configuration/packageSources/add[@value='https://api.nuget.org/v3/index.json' or @key='nuget.org']" -nl "$rootConfig"; then
+            dotnet nuget add source https://api.nuget.org/v3/index.json --name nuget.org --configfile "$rootConfig"
+        fi
+
+        if [[ -z ${keepNugetConfig-} ]]; then
+            xmlConfigArgs+=(-d '//configuration/*')
+            xmlRootConfigArgs+=("${xmlSourceConfigArgs[@]}")
+        else
+            if [[ -n ${mapNuGetDependencies-} ]]; then
+                xmlConfigArgs+=(
+                    -s /configuration -t elem -n __tmp
+                    # If there's no packageSourceMapping, we need to add * patterns for
+                    # all the sources, else they won't be used.
+                    -u \$prev -x ../packageSources/add
+                    -d '/configuration/__tmp/add/@*[name() != "key"]'
+                    -r /configuration/__tmp/add -v packageSource
+                    -s /configuration/__tmp/packageSource -t elem -n package
+                    -i \$prev -t attr -n pattern -v \*
+                    -r /configuration/__tmp -v packageSourceMapping
+                    -d '/configuration/packageSourceMapping[position() != 1]'
+                    "${xmlSourceConfigArgs[@]}"
+                    # add package source mappings from all existing patterns to _nix
+                    # this ensures _nix is always considered
+                    -s /configuration/packageSourceMapping -t elem -n packageSource
+                    -u \$prev -x ../packageSource/package
+                    -i \$prev -t attr -n key -v _nix)
+
+                cd "$nugetSource"
+                local id
+                for id in *; do
+                    id=${id,,}
+                    xmlConfigArgs+=(
+                        # unmap any fully-qualified patterns that exist, so they
+                        # can't be used, using a horrific method for
+                        # case-insensitivity in xpath1
+                        -d "/configuration/packageSourceMapping/packageSource/package[translate(@pattern, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz') = ${id@Q}]"
+                        -s '/configuration/packageSourceMapping/packageSource[@key="_nix"]' -t elem -n package
+                        -i \$prev -t attr -n pattern -v "$id")
+                done
+                cd - > /dev/null
+            else
+                xmlConfigArgs+=(
+                    "${xmlSourceConfigArgs[@]}"
+                    # add package source mappings from all existing patterns to _nix
+                    # this ensures _nix is always considered
+                    -s /configuration/packageSourceMapping -t elem -n packageSource
+                    -u \$prev -x '../packageSource/package'
+                    -i \$prev -t attr -n key -v _nix
+                    # delete empty _nix mapping
+                    -d '/configuration/packageSourceMapping/packageSource[@key="_nix" and not(*)]')
+            fi
+        fi
+
+        # try to stop the global config from having any effect
+        if [[ -z ${keepNugetConfig-} || -z ${allowGlobalNuGetConfig-} ]]; then
+            local -ar configSections=(
+                config
+                bindingRedirects
+                packageRestore
+                solution
+                packageSources
+                auditSources
+                apikeys
+                disabledPackageSources
+                activePackageSource
+                fallbackPackageFolders
+                packageSourceMapping
+                packageManagement)
+
+            for section in "${configSections[@]}"; do
+                xmlRootConfigArgs+=(
+                    -s /configuration -t elem -n "$section"
+                    # hacky way of ensuring we use existing sections when they exist
+                    -d "/configuration/$section[position() != 1]"
+                    # hacky way of adding to the start of a possibly empty element
+                    -s "/configuration/$section" -t elem -n __unused
+                    -i "/configuration/$section/*[1]" -t elem -n clear
+                    -d "/configuration/$section/__unused"
+                    # delete consecutive clears
+                    # these actually cause nuget tools to fail in some cases
+                    -d "/configuration/$section/clear[position() = 2 and name() = \"clear\"]")
+            done
+        fi
+
+        find . \( -iname nuget.config \) -print0 | while IFS= read -rd "" config; do
+            local dir isRoot=
+
+            dir=$(dirname "$config")
+            [[ $dir != . ]] || isRoot=1
+
+            @xmlstarlet@/bin/xmlstarlet \
+                ed --inplace \
+                "${xmlConfigArgs[@]}" \
+                ${isRoot:+"${xmlRootConfigArgs[@]}"} \
+                "$config"
+        done
+    )
+
+    runHook postConfigureNuGet
+}
+
+if [[ -z ${dontConfigureNuget-} ]]; then
+    appendToVar preConfigurePhases configureNuget
+fi

pkgs/development/compilers/dotnet/dotnet-setup-hook.sh

@@ -0,0 +1,8 @@
+if [ ! -w "$HOME" ]; then
+    export HOME=$(mktemp -d) # Dotnet expects a writable home directory for its configuration files
+fi
+
+export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1 # Dont try to expand NuGetFallbackFolder to disk
+export DOTNET_NOLOGO=1 # Disables the welcome message
+export DOTNET_CLI_TELEMETRY_OPTOUT=1
+export DOTNET_SKIP_WORKLOAD_INTEGRITY_CHECK=1 # Skip integrity check on first run, which fails due to read-only directory

pkgs/development/compilers/dotnet/dotnet.nix

@@ -0,0 +1,67 @@
+{
+  stdenvNoCC,
+  callPackage,
+  lib,
+  fetchurl,
+  releaseManifestFile,
+  releaseInfoFile,
+  bootstrapSdkFile,
+  allowPrerelease ? false,
+  depsFile,
+  fallbackTargetPackages,
+  pkgsBuildHost,
+  buildDotnetSdk,
+}:
+
+let
+  inherit (lib.importJSON releaseInfoFile)
+    tarballHash
+    artifactsUrl
+    artifactsHash
+    bootstrapSdk
+    ;
+
+  pkgs = callPackage ./stage1.nix {
+    inherit
+      releaseManifestFile
+      tarballHash
+      depsFile
+      fallbackTargetPackages
+      ;
+    bootstrapSdk = (buildDotnetSdk bootstrapSdkFile).sdk.unwrapped.overrideAttrs (old: {
+      passthru = old.passthru or { } // {
+        artifacts = stdenvNoCC.mkDerivation {
+          name = lib.nameFromURL artifactsUrl ".tar.gz";
+
+          src = fetchurl {
+            url = artifactsUrl;
+            hash = artifactsHash;
+          };
+
+          sourceRoot = ".";
+
+          installPhase = ''
+            mkdir -p $out
+            cp -r * $out/
+          '';
+        };
+      };
+    });
+  };
+
+in
+pkgs
+// {
+  vmr = pkgs.vmr.overrideAttrs (old: {
+    passthru = old.passthru // {
+      updateScript = pkgsBuildHost.callPackage ./update.nix {
+        inherit
+          releaseManifestFile
+          releaseInfoFile
+          bootstrapSdkFile
+          allowPrerelease
+          ;
+      };
+    };
+  });
+}

pkgs/development/compilers/dotnet/fix-aspnetcore-portable-build.patch

@@ -0,0 +1,25 @@
+From ebc2540f8d0aba2e5ec2f0d5f5889100475ad93e Mon Sep 17 00:00:00 2001
+From: David McFarland <corngood@gmail.com>
+Date: Mon, 1 Jan 2024 12:45:41 -0400
+Subject: [PATCH] fix aspnetcore portable build
+
+https://github.com/dotnet/installer/pull/15163#issuecomment-1873396096
+---
+ repo-projects/aspnetcore.proj | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/repo-projects/aspnetcore.proj b/repo-projects/aspnetcore.proj
+index e3f4b1664a..947532add9 100644
+--- a/repo-projects/aspnetcore.proj
++++ b/repo-projects/aspnetcore.proj
+@@ -8,6 +8,7 @@
+     <OverrideTargetRid Condition="'$(TargetOS)' == 'Windows_NT'">win-$(Platform)</OverrideTargetRid>
+     <_portableRidOverridden Condition="'$(TargetRid)' != '$(OverrideTargetRid)'">true</_portableRidOverridden>
+     <_portableRidOverridden Condition="'$(TargetRid)' == '$(OverrideTargetRid)'">false</_portableRidOverridden>
++    <_portableRidOverridden Condition="'$(PortableBuild)' != ''">$(PortableBuild)</_portableRidOverridden>
+ 
+     <!-- StandardSourceBuildArgs include -publish which is not supported by the aspnetcore build script. -->
+     <BuildCommandArgs>$(StandardSourceBuildArgs.Replace('--publish', ''))</BuildCommandArgs>
+-- 
+2.40.1
+