diff --git a/.gitignore b/.gitignore
index e783c2953..69b5279db 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+/build-*
 ##### TUP GITIGNORE #####
 ##### Lines below automatically generated by Tup.
 ##### Do not edit.
diff --git a/ports/chuck/Tupfile b/ports/chuck/Tupfile
new file mode 100644
index 000000000..ab79e9b81
--- /dev/null
+++ b/ports/chuck/Tupfile
@@ -0,0 +1,7 @@
+include_rules
+
+: |> $(NIX_BUILD) .. --out-link port \
+	--attr source --attr include |> port-source port-include {port}
+
+: port-source |> cp %f/%d.pc %o \
+	|> $(PKG_CONFIG_DIR)/%d.pc $(GENODE_DIR)/<pkg-config>
diff --git a/ports/chuck/default.nix b/ports/chuck/default.nix
new file mode 100644
index 000000000..496472b51
--- /dev/null
+++ b/ports/chuck/default.nix
@@ -0,0 +1,14 @@
+{ preparePort, chuck }:
+
+preparePort rec {
+  inherit (chuck) name version src;
+  outputs = [ "source" ];
+  
+  sourceRoot = "${name}/src";
+
+  installPhase =
+    ''
+      mkdir -p $source
+      cp -r core host scripts $source
+    '';
+}
diff --git a/ports/default.nix b/ports/default.nix
new file mode 100644
index 000000000..74e2901bf
--- /dev/null
+++ b/ports/default.nix
@@ -0,0 +1,23 @@
+{ tool ? import ../tool { } }:
+
+let
+  importPort = path:
+    let f = (import path);
+    in f (builtins.intersectAttrs (builtins.functionArgs f) (tool.nixpkgs // tool) );
+
+  hasSuffixNix = tool.hasSuffix ".nix";
+  dir = builtins.readDir ../ports;
+in
+builtins.listToAttrs (
+  builtins.filter
+    (x: x != null)
+    (map
+      (name:
+         if (builtins.getAttr name dir) != "directory" then null else
+           { inherit name;
+             value = importPort (../ports + "/${name}");
+           }
+      )
+      (builtins.attrNames dir)
+    )
+)
diff --git a/ports/rtaudio/Tupfile b/ports/rtaudio/Tupfile
new file mode 100644
index 000000000..ab79e9b81
--- /dev/null
+++ b/ports/rtaudio/Tupfile
@@ -0,0 +1,7 @@
+include_rules
+
+: |> $(NIX_BUILD) .. --out-link port \
+	--attr source --attr include |> port-source port-include {port}
+
+: port-source |> cp %f/%d.pc %o \
+	|> $(PKG_CONFIG_DIR)/%d.pc $(GENODE_DIR)/<pkg-config>
diff --git a/ports/rtaudio/default.nix b/ports/rtaudio/default.nix
new file mode 100644
index 000000000..cc8987a1b
--- /dev/null
+++ b/ports/rtaudio/default.nix
@@ -0,0 +1,25 @@
+{ preparePort, rtaudio }:
+
+preparePort rec {
+  inherit (rtaudio) name version src;
+  outputs = [ "source" "include" ];
+  buildPhase =
+    ''
+      mkdir $source $include
+      sed \
+        -e "s|^includedir.*|include=$include|" \
+        -e 's/@PACKAGE_VERSION@/${version}/' \
+        -e 's/@req@/stdcxx/' \
+        -e 's/^Libs:.*/Libs: -l:rtaudio.lib.so/' \
+        -e '/pthread/d' \
+        -e 's/@api@/-D__GENODE_AUDIO__/' \
+        -e '/@/d' \
+        -e '/prefix/d' \
+        < rtaudio.pc.in > $source/rtaudio.pc
+    '';
+  installPhase =
+    ''
+      cp -rv RtAudio.cpp rtaudio_c.cpp include $source
+      cp RtAudio.h rtaudio_c.h $include
+    '';
+}
diff --git a/tool/default.nix b/tool/default.nix
new file mode 100644
index 000000000..fa1b53a3f
--- /dev/null
+++ b/tool/default.nix
@@ -0,0 +1,477 @@
+/*
+ * \brief  Tools and utility functions
+ * \author Emery Hemingway
+ * \date   2014-09-30
+ */
+
+{ nixpkgs ? import <nixpkgs> { } }:
+
+with builtins;
+
+rec {
+  inherit nixpkgs;
+  inherit (nixpkgs) fetchurl;
+
+  ##
+  # Add a prefix to a list of strings.
+  addPrefix = prefix: map (s: prefix+s);
+
+  ##
+  # Determine if any of the following libs are shared.
+  anyShared = libs:
+    let h = head libs; in
+    if libs == [] then false else
+    if h.shared or false then true else anyShared (tail libs);
+
+  ##
+  # Drop a suffix from the end of a string.
+  dropSuffix = suf: str:
+    let
+      strL = stringLength str;
+      sufL = stringLength suf;
+    in
+    if lessThan strL sufL || substring (sub strL sufL) strL str != suf
+    then abort "${str} does not have suffix ${suf}"
+    else substring 0 (sub strL sufL) str;
+
+  ##
+  # Generate a list of file paths from a directory and
+  # filenames.
+  fromDir = dir: map (s: dir+("/"+s));
+
+  ##
+  # Utility functions for gathering sources.
+  fromGlob =
+  dir: glob:
+  let
+    dirName = dir.name or baseNameOf (toString dir);
+  in
+  import (shellDerivation {
+    name = "${dirName}-glob.nix";
+    script = ./from-glob.sh;
+    #PATH="${nixpkgs.coreutils}/bin";
+    inherit dir glob;
+  });
+
+  fromPath = path: [ [ path (baseNameOf (toString path)) ] ];
+  fromPaths = paths: map (p: [ p (baseNameOf (toString p)) ]) paths;
+
+  ##
+  # Filter out libs that are not derivations
+  filterFakeLibs = libs: filter (lib: hasAttr "shared" lib) libs;
+
+  ##
+  # Test if a string ends in '.h'.
+  hasDotH = s: substring (sub (stringLength s) 2) 2 s == ".h";
+  hasDotHH = s: substring (sub (stringLength s) 3) 3 s == ".hh";
+  hasDotHPP = s: substring (sub (stringLength s) 4) 4 s == ".hpp";
+
+  ##
+  # Filter out everything but *.h on a path.
+  # Prevents files that exist alongside headers from changing header path hash.
+  filterHeaders = dir: filterSource
+    (path: type: hasDotH path || hasDotHH path || hasDotHPP path || type == "directory")
+    dir;
+
+  ##
+  # Find a filename in a search path.
+  findFile = fn: searchPath:
+    if searchPath == [] then []
+    else
+      let
+        sp = head searchPath;
+        fn' = sp + "/${fn}";
+      in
+      if builtins.typeOf fn' != "path" then [] else
+      if pathExists fn' then
+        [ { key = fn'; relative = fn; } ]
+      else findFile fn (tail searchPath);
+
+  findIncludes = main: path:
+    map (x: [ x.key x.relative ]) (genericClosure {
+      startSet = [ { key = main; relative = baseNameOf (toString main); } ];
+      operator =
+        { key, ... }:
+        let
+          includes = import (includesOf key);
+          includesFound =
+            nixpkgs.lib.concatMap
+              (fn: findFile fn ([ (dirOf main) ] ++ path))
+              includes;
+        in includesFound;
+    });
+
+  ##
+  # Recursively find libraries.
+  findLibraries = libs:
+    let
+      list = map (lib: { key = lib.name; inherit lib; });
+    in
+    map (x: x.lib) (genericClosure {
+      startSet = list libs;
+      operator = { key, lib }: list lib.libs or [];
+    });
+
+  ##
+  # Recursively find libraries to link.
+  findLinkLibraries = libs:
+    let
+      list = libs: map
+        (lib: { key = lib.name; inherit lib; })
+        (filter (lib: hasAttr "drvPath" lib) libs);
+    in
+    map (x: x.lib) (genericClosure {
+      startSet = list libs;
+      operator =
+        { key, lib }:
+        if lib.shared then []
+        else list lib.libs or [];
+      });
+
+  findLocalIncludes = main: path:
+    let path' = [ (dirOf main) ] ++ path; in
+    map (x: [ x.key x.relative ]) (genericClosure {
+      startSet = [ { key = main; relative = baseNameOf (toString main); } ];
+      operator =
+        { key, ... }:
+        let
+          includes = import (localIncludesOf key);
+          includesFound =
+            nixpkgs.lib.concatMap
+              (fn: findFile fn path')
+              includes;
+        in includesFound;
+    });
+
+  ##
+  # Recursively find shared libraries.
+  findRuntimeLibraries = libs:
+    let
+      filter = libs: builtins.filter (lib: lib.shared) libs;
+      list = libs:
+        map (lib: { key = lib.name; inherit lib; }) libs;
+    in
+  filter (map (x: x.lib) (genericClosure {
+    startSet = list libs;
+    operator =
+      { key, lib }:
+      list ([lib ] ++ lib.libs);
+  }));
+
+  ##
+  # Determine if a string has the given suffix.
+  hasSuffix = suf: str:
+    let
+      strL = stringLength str;
+      sufL = stringLength suf;
+    in
+    if lessThan strL sufL then false else
+      substring (sub strL sufL) strL str == suf;
+
+  includesOf = file:
+    import (derivation {
+      name =
+        if typeOf file == "path"
+        then "${baseNameOf (toString file)}-includes"
+        else "includes";
+      system = currentSystem;
+      preferLocalBuild = true;
+      builder = "${nixpkgs.perl}/bin/perl";
+      args = [ ./find-includes.pl ];
+      inherit file;
+    });
+
+  ##
+  # Create a bootable ISO.
+  iso =
+  { name, contents, kernel, kernelArgs }:
+  shellDerivation {
+    name = "${name}.iso";
+    script = ./iso.sh;
+    PATH="${nixpkgs.coreutils}/bin:${nixpkgs.cdrkit}/bin:${nixpkgs.binutils}/bin";
+    inherit kernel kernelArgs;
+    inherit (nixpkgs) syslinux cdrkit;
+    sources = map (x: x.source) contents;
+    targets = map (x: x.target) contents;
+  };
+
+  ##
+  # Generate a contents list of runtime libraries for a package.
+  # This will go away as tool.runtime matures.
+  libContents = contents: builtins.concatLists (map (
+    content:
+      map (source: { target = "/"; inherit source; }) content.source.runtime.libs or []
+  ) contents);
+
+  localIncludesOf = main: derivation {
+    name =
+      if typeOf main == "path"
+      then "${baseNameOf (toString main)}-local-includes"
+      else "local-includes";
+    system = currentSystem;
+    preferLocalBuild = true;
+    builder = "${nixpkgs.perl}/bin/perl";
+    args = [ ./find-local-includes.pl ];
+    inherit main;
+  };
+
+  ##
+  # Merge an attr between two sets.
+  mergeAttr =
+  name: s1: s2:
+  let
+    a1 = getAttr name s1;
+    a2 = getAttr name s2;
+    type1 = typeOf a1;
+    type2 = typeOf a2;
+  in
+  if type1 == "null" then a2 else if type2 == "null" then a1 else
+  if type1 != type2 then abort "cannot merge ${name}s of type ${type1} and ${type2}" else
+  if type1 == "set" then mergeSet a1 a2 else
+  if type1 == "list" then a1 ++ a2 else
+  if type1 == "string" then "${a1} ${a2}" else
+  #if type1 == "int" then add a1 a2 else
+  abort "cannot merge ${type1} ${name} ${toString a1} ${toString a2}";
+
+  ##
+  # Merge two sets together.
+  mergeSet = s1: s2:
+    s1 // s2 // (listToAttrs (map
+      (name: { inherit name; value = mergeAttr name s1 s2; })
+      (attrNames (intersectAttrs s1 s2))
+    ));
+
+  ##
+  # Merge a list of sets.
+  mergeSets =
+  sets:
+  if sets == [] then {} else
+    mergeSet (head sets) (mergeSets (tail sets));
+
+  newDir =
+  name: contents:
+  derivation {
+    inherit name contents;
+    system = builtins.currentSystem;
+    preferLocalBuild = true;
+    builder = shell;
+    PATH="${nixpkgs.coreutils}/bin";
+    args = [ "-e" "-c" ''
+      mkdir -p $out ; \
+      for i in $contents; do cp -Hr $i $out; done
+    '' ];
+  };
+
+  ##
+  # Generate a list of paths from a path and a shell glob.
+  pathsFromGlob = dir: glob:
+    let path = toString dir; in
+    import (derivation {
+      name = "${baseNameOf path}-glob.nix";
+      args = [ "-e" "-O" "nullglob" ./path-from-glob.sh ];
+      inherit dir glob path;
+      preferLocalBuild = true;
+    });
+
+  preparePort = import ./prepare-port { inherit nixpkgs; };
+
+  # Concatenate the named attr found in pkgs.
+  propagate = attrName: pkgs:
+    let
+      pkg = head pkgs;
+    in
+    if pkgs == [] then [] else
+    ( if hasAttr attrName pkg
+      then getAttr attrName pkg
+      else []
+    ) ++
+    (propagate attrName (tail pkgs));
+
+
+  ##
+  # Replace substring a with substring b in string s.
+  replaceInString =
+  a: b: s:
+  let
+    al = stringLength a;
+    bl = stringLength b;
+    sl = stringLength s;
+  in
+  if al == 0 then s else
+  if sl == 0 then "" else
+  if ((substring 0 al s) == a) then
+    b+(replaceInString a b (substring al sl s))
+  else
+    (substring 0 1 s) + (replaceInString a b (substring 1 sl s));
+
+  shell = nixpkgs.bash + "/bin/sh";
+
+  # Save some typing when creating derivation that use our shell.
+  shellDerivation = { script, ... } @ args:
+    derivation ( (removeAttrs args [ "script" ]) //
+      { system = builtins.currentSystem;
+        builder = shell;
+        args = [ "-e" script ];
+      }
+    );
+
+  singleton = x: [x];
+
+  # Bootability is not assured, so its really system image.
+  systemImage = import ./system-image { inherit nixpkgs; };
+  bootImage = systemImage; # get rid of this
+
+
+  wildcard =
+  path: glob:
+  let
+    relativePaths = import (shellDerivation {
+      name = "files.nix";
+      PATH="${nixpkgs.coreutils}/bin";
+      script = ./wildcard.sh;
+      inherit path glob;
+
+    });
+  in
+  map (rp: (path+"/${rp}")) relativePaths;
+
+  # Appends string context from another string
+  addContextFrom = a: b: substring 0 0 a + b;
+
+  # Compares strings not requiring context equality
+  # Obviously, a workaround but works on all Nix versions
+  eqStrings = a: b: addContextFrom b a == addContextFrom a b;
+
+
+  ##
+  # Cut a string with a separator and produces a list of strings which were
+  # separated by this separator. e.g.,
+  # `splitString "." "foo.bar.baz"' returns ["foo" "bar" "baz"].
+  # From nixpkgs.
+  splitString = _sep: _s:
+    let
+      sep = addContextFrom _s _sep;
+      s = addContextFrom _sep _s;
+      sepLen = stringLength sep;
+      sLen = stringLength s;
+      lastSearch = sLen - sepLen;
+      startWithSep = startAt:
+        substring startAt sepLen s == sep;
+
+      recurse = index: startAt:
+        let cutUntil = i: [(substring startAt (i - startAt) s)]; in
+        if index < lastSearch then
+          if startWithSep index then
+            let restartAt = index + sepLen; in
+            cutUntil index ++ recurse restartAt restartAt
+          else
+            recurse (index + 1) startAt
+        else
+          cutUntil sLen;
+    in
+      recurse 0 0;
+  ##
+  # What I thought builtins.match would do.
+  matchPattern = pat: str:
+    concatLists (
+      map
+        ( l:
+          let m = match pat l; in
+          if m == null then [] else m
+        )
+        (splitString "\n" str)
+    );
+
+  ##
+  # Generate a set of local ("") and system (<>)
+  # preprocessor include directives from a file.
+  relativeIncludes = file:
+    let
+      matches = pattern: lines:
+        concatLists (filter (x: x != null) (map (match pattern) lines));
+      lines = splitString "\n" (readFile file);
+    in
+    { local  = matches ''.*#include\s*"([^>]*)".*'' lines;
+      system = matches ''.*#include\s*<([^>]*)>.*'' lines;
+    };
+
+  ##
+  # Find a file in a set of directories.
+  findFile' = key: dirs:
+    if substring 0 1 key == "!" then builtins.trace "found a !key" key else
+    if dirs == [] then null else
+    let abs = (builtins.head dirs) +"/${key}"; in
+    if builtins.pathExists abs then abs
+    else findFile' key (builtins.tail dirs);
+
+  ##
+  # Generate a set of relative to absolute include mappings from a file.
+  # This set includes a mapping from the orginal file basename to its
+  # absolute path.
+  #
+  # The genericClosure primative applies an operation to a list of sets that
+  # contain the attribute 'key'. This operation returns a similar list of sets,
+  # and genericClosure appends elements of that list that contain a key
+  # that does not already exist in the previous set. All sets returned by this
+  # operation contain a function to resolve the relative path at 'key' into an
+  # absolute one at 'abs', and a function to parse the absolute path at 'abs'
+  # into a list of relative includes at 'inc'. GenericClosure discards any set
+  # with a relative path at 'key' that it has already been seen, and thus due
+  # to lazy evaulation, no relative path is resolved or parsed twice.
+  #
+  # A ! is prepended to the files of the initial set, to differentiate them from
+  # files with unsolved locations and to satisfy the requirement that strings
+  # not directly reference store paths in findFile'
+  includesOfFiles = files: searchPath:
+    let
+      concat = sets:
+        if sets == [] then {} else
+        let x = head sets; in
+        (if x.abs == null || substring 0 1 x.key == "!" then {} else { "${x.key}" = x.abs; }) // concat (tail sets);
+    in
+    concat (genericClosure {
+      # Can the startSet really be filled with elements sharing a key?
+      startSet = map (abs: { key = "!${abs}"; inherit abs; inc = includesOf abs; }) files;
+      operator =
+        { key, abs, inc }: if abs == null then [] else let abs' = abs; in
+          (map 
+            (key: rec { inherit key; abs = (findFile' key searchPath); inc = includesOf abs; })
+            inc.system)
+          ++
+          (map
+            (key: rec { inherit key; abs = (findFile' key (if typeOf abs' == "path" then searchPath ++ [ (dirOf abs') ] else searchPath)); inc = relativeIncludes abs; })
+            inc.local);
+    });
+
+  ##
+  # Load expressions from a directory path and apply func.
+  loadExpressions = func: path:
+    let
+      dirSet  = builtins.readDir path;
+      default =
+        if builtins.hasAttr "default.nix" dirSet
+        then func (import (path + "/default.nix"))
+        else {};
+    in
+    default // (builtins.listToAttrs (builtins.filter (x: x != {}) (map
+      (name:
+        let
+          type = builtins.getAttr name dirSet;
+          more = loadExpressions func (path + "/${name}");
+        in
+        if type == "directory"
+        then { inherit name; value = more; }
+        else
+        if
+          (type == "regular" || type == "symlink") &&
+          (hasSuffix ".nix" name)
+        then
+          { name = dropSuffix ".nix" name;
+            value = func (import (path+"/${name}"));
+          }
+        else { }
+      )
+      (builtins.attrNames dirSet)
+    )));
+
+}
diff --git a/tool/prepare-port/builder.sh b/tool/prepare-port/builder.sh
new file mode 100644
index 000000000..3c9255d04
--- /dev/null
+++ b/tool/prepare-port/builder.sh
@@ -0,0 +1,10 @@
+export PATH=
+for i in $initialPath; do
+    if [ "$i" = / ]; then i=; fi
+    PATH=$PATH${PATH:+:}$i/bin
+done
+
+mkdir $out
+
+sed -e "s^@initialPath@^$initialPath^g" \
+    < $setup > $out/setup
diff --git a/tool/prepare-port/default-builder.sh b/tool/prepare-port/default-builder.sh
new file mode 100644
index 000000000..0f81f60c3
--- /dev/null
+++ b/tool/prepare-port/default-builder.sh
@@ -0,0 +1,2 @@
+source $preparePort/setup
+genericBuild
diff --git a/tool/prepare-port/default.nix b/tool/prepare-port/default.nix
new file mode 100644
index 000000000..5c6ca4488
--- /dev/null
+++ b/tool/prepare-port/default.nix
@@ -0,0 +1,39 @@
+{ nixpkgs }:
+let
+  shell = nixpkgs.bash + "/bin/sh";
+
+   initialPath =
+    [ nixpkgs.coreutils
+      nixpkgs.findutils
+      nixpkgs.diffutils
+      nixpkgs.gawk
+      nixpkgs.gnugrep
+      nixpkgs.gnused
+      nixpkgs.gnutar
+      nixpkgs.patch
+      nixpkgs.gzip
+      nixpkgs.bzip2
+      nixpkgs.xz
+    ];
+in
+{ name
+, outputs ? [ "out" ]
+, preferLocalBuild ? true
+, ... } @ attrs:
+derivation (attrs // {
+  inherit name outputs initialPath;
+
+  preparePort = derivation {
+    name = "prepare-port";
+    system = builtins.currentSystem;
+    builder = shell;
+    args = [ "-e" ./builder.sh ];
+    setup = ./setup.sh;
+    inherit initialPath;
+  };
+
+  system = builtins.currentSystem;
+
+  builder = attrs.realBuilder or shell;
+  args = attrs.args or [ "-e" (attrs.builder or ./default-builder.sh) ];
+})
diff --git a/tool/prepare-port/setup.sh b/tool/prepare-port/setup.sh
new file mode 100644
index 000000000..b055e826b
--- /dev/null
+++ b/tool/prepare-port/setup.sh
@@ -0,0 +1,1221 @@
+set -eu
+set -o pipefail
+
+if (( "${NIX_DEBUG:-0}" >= 6 )); then
+    set -x
+fi
+
+: ${outputs:=out}
+
+
+######################################################################
+# Hook handling.
+
+
+# Run all hooks with the specified name in the order in which they
+# were added, stopping if any fails (returns a non-zero exit
+# code). The hooks for <hookName> are the shell function or variable
+# <hookName>, and the values of the shell array ‘<hookName>Hooks’.
+runHook() {
+    local oldOpts="$(shopt -po nounset)"
+    set -u # May be called from elsewhere, so do `set -u`.
+
+    local hookName="$1"
+    shift
+    local hooksSlice="${hookName%Hook}Hooks[@]"
+
+    local hook
+    # Hack around old bash being bad and thinking empty arrays are
+    # undefined.
+    for hook in "_callImplicitHook 0 $hookName" ${!hooksSlice+"${!hooksSlice}"}; do
+        _eval "$hook" "$@"
+        set -u # To balance `_eval`
+    done
+
+    eval "${oldOpts}"
+    return 0
+}
+
+
+# Run all hooks with the specified name, until one succeeds (returns a
+# zero exit code). If none succeed, return a non-zero exit code.
+runOneHook() {
+    local oldOpts="$(shopt -po nounset)"
+    set -u # May be called from elsewhere, so do `set -u`.
+
+    local hookName="$1"
+    shift
+    local hooksSlice="${hookName%Hook}Hooks[@]"
+
+    local hook ret=1
+    # Hack around old bash like above
+    for hook in "_callImplicitHook 1 $hookName" ${!hooksSlice+"${!hooksSlice}"}; do
+        if _eval "$hook" "$@"; then
+            ret=0
+            break
+        fi
+        set -u # To balance `_eval`
+    done
+
+    eval "${oldOpts}"
+    return "$ret"
+}
+
+
+# Run the named hook, either by calling the function with that name or
+# by evaluating the variable with that name. This allows convenient
+# setting of hooks both from Nix expressions (as attributes /
+# environment variables) and from shell scripts (as functions). If you
+# want to allow multiple hooks, use runHook instead.
+_callImplicitHook() {
+    set -u
+    local def="$1"
+    local hookName="$2"
+    case "$(type -t "$hookName")" in
+        (function|alias|builtin)
+            set +u
+            "$hookName";;
+        (file)
+            set +u
+            source "$hookName";;
+        (keyword) :;;
+        (*) if [ -z "${!hookName:-}" ]; then
+                return "$def";
+            else
+                set +u
+                eval "${!hookName}"
+            fi;;
+    esac
+    # `_eval` expects hook to need nounset disable and leave it
+    # disabled anyways, so Ok to to delegate. The alternative of a
+    # return trap is no good because it would affect nested returns.
+}
+
+
+# A function wrapper around ‘eval’ that ensures that ‘return’ inside
+# hooks exits the hook, not the caller. Also will only pass args if
+# command can take them
+_eval() {
+    if [ "$(type -t "$1")" = function ]; then
+        set +u
+        "$@" # including args
+    else
+        set +u
+        eval "$1"
+    fi
+    # `run*Hook` reenables `set -u`
+}
+
+
+######################################################################
+# Logging.
+
+# Obsolete.
+stopNest() { true; }
+header() { echo "$1"; }
+closeNest() { true; }
+
+# Prints a command such that all word splits are unambiguous. We need
+# to split the command in three parts because the middle format string
+# will be, and must be, repeated for each argument. The first argument
+# goes before the ':' and is just for convenience.
+echoCmd() {
+    printf "%s:" "$1"
+    shift
+    printf ' %q' "$@"
+    echo
+}
+
+
+######################################################################
+# Error handling.
+
+exitHandler() {
+    exitCode="$?"
+    set +e
+
+    if [ -n "${showBuildStats:-}" ]; then
+        times > "$NIX_BUILD_TOP/.times"
+        local -a times=($(cat "$NIX_BUILD_TOP/.times"))
+        # Print the following statistics:
+        # - user time for the shell
+        # - system time for the shell
+        # - user time for all child processes
+        # - system time for all child processes
+        echo "build time elapsed: " "${times[@]}"
+    fi
+
+    if (( "$exitCode" != 0 )); then
+        runHook failureHook
+
+        # If the builder had a non-zero exit code and
+        # $succeedOnFailure is set, create the file
+        # ‘$out/nix-support/failed’ to signal failure, and exit
+        # normally.  Otherwise, return the original exit code.
+        if [ -n "${succeedOnFailure:-}" ]; then
+            echo "build failed with exit code $exitCode (ignored)"
+            mkdir -p "$out/nix-support"
+            printf "%s" "$exitCode" > "$out/nix-support/failed"
+            exit 0
+        fi
+
+    else
+        runHook exitHook
+    fi
+
+    exit "$exitCode"
+}
+
+trap "exitHandler" EXIT
+
+
+######################################################################
+# Helper functions.
+
+
+addToSearchPathWithCustomDelimiter() {
+    local delimiter="$1"
+    local varName="$2"
+    local dir="$3"
+    if [ -d "$dir" ]; then
+        export "${varName}=${!varName:+${!varName}${delimiter}}${dir}"
+    fi
+}
+
+addToSearchPath() {
+    addToSearchPathWithCustomDelimiter ":" "$@"
+}
+
+# Add $1/lib* into rpaths.
+# The function is used in multiple-outputs.sh hook,
+# so it is defined here but tried after the hook.
+_addRpathPrefix() {
+    if [ "${NIX_NO_SELF_RPATH:-0}" != 1 ]; then
+        export NIX_LDFLAGS="-rpath $1/lib $NIX_LDFLAGS"
+        if [ -n "${NIX_LIB64_IN_SELF_RPATH:-}" ]; then
+            export NIX_LDFLAGS="-rpath $1/lib64 $NIX_LDFLAGS"
+        fi
+        if [ -n "${NIX_LIB32_IN_SELF_RPATH:-}" ]; then
+            export NIX_LDFLAGS="-rpath $1/lib32 $NIX_LDFLAGS"
+        fi
+    fi
+}
+
+# Return success if the specified file is an ELF object.
+isELF() {
+    local fn="$1"
+    local fd
+    local magic
+    exec {fd}< "$fn"
+    read -r -n 4 -u "$fd" magic
+    exec {fd}<&-
+    if [ "$magic" = $'\177ELF' ]; then return 0; else return 1; fi
+}
+
+# Return success if the specified file is a script (i.e. starts with
+# "#!").
+isScript() {
+    local fn="$1"
+    local fd
+    local magic
+    exec {fd}< "$fn"
+    read -r -n 2 -u "$fd" magic
+    exec {fd}<&-
+    if [[ "$magic" =~ \#! ]]; then return 0; else return 1; fi
+}
+
+# printf unfortunately will print a trailing newline regardless
+printLines() {
+    (( "$#" > 0 )) || return 0
+    printf '%s\n' "$@"
+}
+
+printWords() {
+    (( "$#" > 0 )) || return 0
+    printf '%s ' "$@"
+}
+
+######################################################################
+# Initialisation.
+
+
+# Set a fallback default value for SOURCE_DATE_EPOCH, used by some
+# build tools to provide a deterministic substitute for the "current"
+# time. Note that 1 = 1970-01-01 00:00:01. We don't use 0 because it
+# confuses some applications.
+export SOURCE_DATE_EPOCH
+: ${SOURCE_DATE_EPOCH:=1}
+
+
+# Wildcard expansions that don't match should expand to an empty list.
+# This ensures that, for instance, "for i in *; do ...; done" does the
+# right thing.
+shopt -s nullglob
+
+
+# Set up the initial path.
+PATH=
+HOST_PATH=
+for i in $initialPath; do
+    if [ "$i" = / ]; then i=; fi
+    addToSearchPath PATH "$i/bin"
+
+    # For backward compatibility, we add initial path to HOST_PATH so
+    # it can be used in auto patch-shebangs. Unfortunately this will
+    # not work with cross compilation.
+    if [ -z "${strictDeps-}" ]; then
+        addToSearchPath HOST_PATH "$i/bin"
+    fi
+done
+
+if (( "${NIX_DEBUG:-0}" >= 1 )); then
+    echo "initial path: $PATH"
+fi
+
+
+# Check that the pre-hook initialised SHELL.
+if [ -z "${SHELL:-}" ]; then echo "SHELL not set"; exit 1; fi
+BASH="$SHELL"
+export CONFIG_SHELL="$SHELL"
+
+
+# Execute the pre-hook.
+if [ -z "${shell:-}" ]; then export shell="$SHELL"; fi
+runHook preHook
+
+
+# Allow the caller to augment buildInputs (it's not always possible to
+# do this before the call to setup.sh, since the PATH is empty at that
+# point; here we have a basic Unix environment).
+runHook addInputsHook
+
+
+# Package accumulators
+
+# shellcheck disable=SC2034
+declare -a pkgsBuildBuild pkgsBuildHost pkgsBuildTarget
+declare -a pkgsHostHost pkgsHostTarget
+declare -a pkgsTargetTarget
+
+declare -ra pkgBuildAccumVars=(pkgsBuildBuild pkgsBuildHost pkgsBuildTarget)
+declare -ra pkgHostAccumVars=(pkgsHostHost pkgsHostTarget)
+declare -ra pkgTargetAccumVars=(pkgsTargetTarget)
+
+declare -ra pkgAccumVarVars=(pkgBuildAccumVars pkgHostAccumVars pkgTargetAccumVars)
+
+
+# Hooks
+
+declare -a envBuildBuildHooks envBuildHostHooks envBuildTargetHooks
+declare -a envHostHostHooks envHostTargetHooks
+declare -a envTargetTargetHooks
+
+declare -ra pkgBuildHookVars=(envBuildBuildHook envBuildHostHook envBuildTargetHook)
+declare -ra pkgHostHookVars=(envHostHostHook envHostTargetHook)
+declare -ra pkgTargetHookVars=(envTargetTargetHook)
+
+declare -ra pkgHookVarVars=(pkgBuildHookVars pkgHostHookVars pkgTargetHookVars)
+
+# Add env hooks for all sorts of deps with the specified host offset.
+addEnvHooks() {
+    local depHostOffset="$1"
+    shift
+    local pkgHookVarsSlice="${pkgHookVarVars[$depHostOffset + 1]}[@]"
+    local pkgHookVar
+    for pkgHookVar in "${!pkgHookVarsSlice}"; do
+        eval "${pkgHookVar}s"'+=("$@")'
+    done
+}
+
+
+# Propagated dep files
+
+declare -ra propagatedBuildDepFiles=(
+    propagated-build-build-deps
+    propagated-native-build-inputs # Legacy name for back-compat
+    propagated-build-target-deps
+)
+declare -ra propagatedHostDepFiles=(
+    propagated-host-host-deps
+    propagated-build-inputs # Legacy name for back-compat
+)
+declare -ra propagatedTargetDepFiles=(
+    propagated-target-target-deps
+)
+declare -ra propagatedDepFilesVars=(
+    propagatedBuildDepFiles
+    propagatedHostDepFiles
+    propagatedTargetDepFiles
+)
+
+# Platform offsets: build = -1, host = 0, target = 1
+declare -ra allPlatOffsets=(-1 0 1)
+
+
+# Mutually-recursively find all build inputs. See the dependency section of the
+# stdenv chapter of the Nixpkgs manual for the specification this algorithm
+# implements.
+findInputs() {
+    local -r pkg="$1"
+    local -ri hostOffset="$2"
+    local -ri targetOffset="$3"
+
+    # Sanity check
+    (( "$hostOffset" <= "$targetOffset" )) || exit -1
+
+    local varVar="${pkgAccumVarVars[$hostOffset + 1]}"
+    local varRef="$varVar[\$targetOffset - \$hostOffset]"
+    local var="${!varRef}"
+    unset -v varVar varRef
+
+    # TODO(@Ericson2314): Restore using associative array once Darwin
+    # nix-shell doesn't use impure bash. This should replace the O(n)
+    # case with an O(1) hash map lookup, assuming bash is implemented
+    # well :D.
+    local varSlice="$var[*]"
+    # ${..-} to hack around old bash empty array problem
+    case "${!varSlice-}" in
+        *" $pkg "*) return 0 ;;
+    esac
+    unset -v varSlice
+
+    eval "$var"'+=("$pkg")'
+
+    if ! [ -e "$pkg" ]; then
+        echo "build input $pkg does not exist" >&2
+        exit 1
+    fi
+
+    # The current package's host and target offset together
+    # provide a <=-preserving homomorphism from the relative
+    # offsets to current offset
+    function mapOffset() {
+        local -ri inputOffset="$1"
+        if (( "$inputOffset" <= 0 )); then
+            local -ri outputOffset="$inputOffset + $hostOffset"
+        else
+            local -ri outputOffset="$inputOffset - 1 + $targetOffset"
+        fi
+        echo "$outputOffset"
+    }
+
+    # Host offset relative to that of the package whose immediate
+    # dependencies we are currently exploring.
+    local -i relHostOffset
+    for relHostOffset in "${allPlatOffsets[@]}"; do
+        # `+ 1` so we start at 0 for valid index
+        local files="${propagatedDepFilesVars[$relHostOffset + 1]}"
+
+        # Host offset relative to the package currently being
+        # built---as absolute an offset as will be used.
+        local -i hostOffsetNext
+        hostOffsetNext="$(mapOffset relHostOffset)"
+
+        # Ensure we're in bounds relative to the package currently
+        # being built.
+        [[ "${allPlatOffsets[*]}" = *"$hostOffsetNext"*  ]] || continue
+
+        # Target offset relative to the *host* offset of the package
+        # whose immediate dependencies we are currently exploring.
+        local -i relTargetOffset
+        for relTargetOffset in "${allPlatOffsets[@]}"; do
+            (( "$relHostOffset" <= "$relTargetOffset" )) || continue
+
+            local fileRef="${files}[$relTargetOffset - $relHostOffset]"
+            local file="${!fileRef}"
+            unset -v fileRef
+
+            # Target offset relative to the package currently being
+            # built.
+            local -i targetOffsetNext
+            targetOffsetNext="$(mapOffset relTargetOffset)"
+
+            # Once again, ensure we're in bounds relative to the
+            # package currently being built.
+            [[ "${allPlatOffsets[*]}" = *"$targetOffsetNext"* ]] || continue
+
+            [[ -f "$pkg/nix-support/$file" ]] || continue
+
+            local pkgNext
+            for pkgNext in $(< "$pkg/nix-support/$file"); do
+                findInputs "$pkgNext" "$hostOffsetNext" "$targetOffsetNext"
+            done
+        done
+    done
+}
+
+# Make sure all are at least defined as empty
+: ${depsBuildBuild=} ${depsBuildBuildPropagated=}
+: ${nativeBuildInputs=} ${propagatedNativeBuildInputs=} ${defaultNativeBuildInputs=}
+: ${depsBuildTarget=} ${depsBuildTargetPropagated=}
+: ${depsHostHost=} ${depsHostHostPropagated=}
+: ${buildInputs=} ${propagatedBuildInputs=} ${defaultBuildInputs=}
+: ${depsTargetTarget=} ${depsTargetTargetPropagated=}
+
+for pkg in $depsBuildBuild $depsBuildBuildPropagated; do
+    findInputs "$pkg" -1 -1
+done
+for pkg in $nativeBuildInputs $propagatedNativeBuildInputs; do
+    findInputs "$pkg" -1  0
+done
+for pkg in $depsBuildTarget $depsBuildTargetPropagated; do
+    findInputs "$pkg" -1  1
+done
+for pkg in $depsHostHost $depsHostHostPropagated; do
+    findInputs "$pkg"  0  0
+done
+for pkg in $buildInputs $propagatedBuildInputs ; do
+    findInputs "$pkg"  0  1
+done
+for pkg in $depsTargetTarget $depsTargetTargetPropagated; do
+    findInputs "$pkg"  1  1
+done
+# Default inputs must be processed last
+for pkg in $defaultNativeBuildInputs; do
+    findInputs "$pkg" -1  0
+done
+for pkg in $defaultBuildInputs; do
+    findInputs "$pkg"  0  1
+done
+
+# Add package to the future PATH and run setup hooks
+activatePackage() {
+    local pkg="$1"
+    local -ri hostOffset="$2"
+    local -ri targetOffset="$3"
+
+    # Sanity check
+    (( "$hostOffset" <= "$targetOffset" )) || exit -1
+
+    if [ -f "$pkg" ]; then
+        local oldOpts="$(shopt -po nounset)"
+        set +u
+        source "$pkg"
+        eval "$oldOpts"
+    fi
+
+    # Only dependencies whose host platform is guaranteed to match the
+    # build platform are included here. That would be `depsBuild*`,
+    # and legacy `nativeBuildInputs`, in general. If we aren't cross
+    # compiling, however, everything can be put on the PATH. To ease
+    # the transition, we do include everything in thatcase.
+    #
+    # TODO(@Ericson2314): Don't special-case native compilation
+    if [[ ( -z "${strictDeps-}" ||  "$hostOffset" -le -1 ) && -d "$pkg/bin" ]]; then
+        addToSearchPath _PATH "$pkg/bin"
+    fi
+
+    if [[ "$hostOffset" -eq 0 && -d "$pkg/bin" ]]; then
+        addToSearchPath _HOST_PATH "$pkg/bin"
+    fi
+
+    if [[ -f "$pkg/nix-support/setup-hook" ]]; then
+        local oldOpts="$(shopt -po nounset)"
+        set +u
+        source "$pkg/nix-support/setup-hook"
+        eval "$oldOpts"
+    fi
+}
+
+_activatePkgs() {
+    local -i hostOffset targetOffset
+    local pkg
+
+    for hostOffset in "${allPlatOffsets[@]}"; do
+        local pkgsVar="${pkgAccumVarVars[$hostOffset + 1]}"
+        for targetOffset in "${allPlatOffsets[@]}"; do
+            (( "$hostOffset" <= "$targetOffset" )) || continue
+            local pkgsRef="${pkgsVar}[$targetOffset - $hostOffset]"
+            local pkgsSlice="${!pkgsRef}[@]"
+            for pkg in ${!pkgsSlice+"${!pkgsSlice}"}; do
+                activatePackage "$pkg" "$hostOffset" "$targetOffset"
+            done
+        done
+    done
+}
+
+# Run the package setup hooks and build _PATH
+_activatePkgs
+
+# Set the relevant environment variables to point to the build inputs
+# found above.
+#
+# These `depOffset`s, beyond indexing the arrays, also tell the env
+# hook what sort of dependency (ignoring propagatedness) is being
+# passed to the env hook. In a real language, we'd append a closure
+# with this information to the relevant env hook array, but bash
+# doesn't have closures, so it's easier to just pass this in.
+_addToEnv() {
+    local -i depHostOffset depTargetOffset
+    local pkg
+
+    for depHostOffset in "${allPlatOffsets[@]}"; do
+        local hookVar="${pkgHookVarVars[$depHostOffset + 1]}"
+        local pkgsVar="${pkgAccumVarVars[$depHostOffset + 1]}"
+        for depTargetOffset in "${allPlatOffsets[@]}"; do
+            (( "$depHostOffset" <= "$depTargetOffset" )) || continue
+            local hookRef="${hookVar}[$depTargetOffset - $depHostOffset]"
+            if [[ -z "${strictDeps-}" ]]; then
+
+                # Keep track of which packages we have visited before.
+                local visitedPkgs=""
+
+                # Apply environment hooks to all packages during native
+                # compilation to ease the transition.
+                #
+                # TODO(@Ericson2314): Don't special-case native compilation
+                for pkg in \
+                    ${pkgsBuildBuild+"${pkgsBuildBuild[@]}"} \
+                    ${pkgsBuildHost+"${pkgsBuildHost[@]}"} \
+                    ${pkgsBuildTarget+"${pkgsBuildTarget[@]}"} \
+                    ${pkgsHostHost+"${pkgsHostHost[@]}"} \
+                    ${pkgsHostTarget+"${pkgsHostTarget[@]}"} \
+                    ${pkgsTargetTarget+"${pkgsTargetTarget[@]}"}
+                do
+                    if [[ "$visitedPkgs" = *"$pkg"* ]]; then
+                        continue
+                    fi
+                    runHook "${!hookRef}" "$pkg"
+                    visitedPkgs+=" $pkg"
+                done
+            else
+                local pkgsRef="${pkgsVar}[$depTargetOffset - $depHostOffset]"
+                local pkgsSlice="${!pkgsRef}[@]"
+                for pkg in ${!pkgsSlice+"${!pkgsSlice}"}; do
+                    runHook "${!hookRef}" "$pkg"
+                done
+            fi
+        done
+    done
+}
+
+# Run the package-specific hooks set by the setup-hook scripts.
+_addToEnv
+
+
+# Set the TZ (timezone) environment variable, otherwise commands like
+# `date' will complain (e.g., `Tue Mar 9 10:01:47 Local time zone must
+# be set--see zic manual page 2004').
+export TZ=UTC
+
+
+if [ "${useTempPrefix:-}" = 1 ]; then
+    prefix="$NIX_BUILD_TOP/tmp_prefix";
+fi
+
+
+PATH="${_PATH-}${_PATH:+${PATH:+:}}$PATH"
+HOST_PATH="${_HOST_PATH-}${_HOST_PATH:+${HOST_PATH:+:}}$HOST_PATH"
+if (( "${NIX_DEBUG:-0}" >= 1 )); then
+    echo "final path: $PATH"
+    echo "final host path: $HOST_PATH"
+fi
+
+unset _PATH
+unset _HOST_PATH
+
+
+# Make GNU Make produce nested output.
+export NIX_INDENT_MAKE=1
+
+
+# Normalize the NIX_BUILD_CORES variable. The value might be 0, which
+# means that we're supposed to try and auto-detect the number of
+# available CPU cores at run-time.
+
+if [ -z "${NIX_BUILD_CORES:-}" ]; then
+  NIX_BUILD_CORES="1"
+elif [ "$NIX_BUILD_CORES" -le 0 ]; then
+  NIX_BUILD_CORES=$(nproc 2>/dev/null || true)
+  if expr >/dev/null 2>&1 "$NIX_BUILD_CORES" : "^[0-9][0-9]*$"; then
+    :
+  else
+    NIX_BUILD_CORES="1"
+  fi
+fi
+export NIX_BUILD_CORES
+
+
+# Prevent SSL libraries from using certificates in /etc/ssl, unless set explicitly.
+# Leave it in impure shells for convenience.
+if [ -z "${NIX_SSL_CERT_FILE:-}" ] && [ "${IN_NIX_SHELL:-}" != "impure" ]; then
+  export NIX_SSL_CERT_FILE=/no-cert-file.crt
+fi
+# Another variant left for compatibility.
+if [ -z "${SSL_CERT_FILE:-}" ] && [ "${IN_NIX_SHELL:-}" != "impure" ]; then
+  export SSL_CERT_FILE=/no-cert-file.crt
+fi
+
+
+######################################################################
+# Textual substitution functions.
+
+
+substituteStream() {
+    local var=$1
+    local description=$2
+    shift 2
+
+    while (( "$#" )); do
+        case "$1" in
+            --replace)
+                pattern="$2"
+                replacement="$3"
+                shift 3
+                local savedvar
+                savedvar="${!var}"
+                eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}'
+                if [ "$pattern" != "$replacement" ]; then
+                    if [ "${!var}" == "$savedvar" ]; then
+                        echo "substituteStream(): WARNING: pattern '$pattern' doesn't match anything in $description" >&2
+                    fi
+                fi
+                ;;
+
+            --subst-var)
+                local varName="$2"
+                shift 2
+                # check if the used nix attribute name is a valid bash name
+                if ! [[ "$varName" =~ ^[a-zA-Z_][a-zA-Z0-9_]*$ ]]; then
+                    echo "substituteStream(): ERROR: substitution variables must be valid Bash names, \"$varName\" isn't." >&2
+                    return 1
+                fi
+                if [ -z ${!varName+x} ]; then
+                    echo "substituteStream(): ERROR: variable \$$varName is unset" >&2
+                    return 1
+                fi
+                pattern="@$varName@"
+                replacement="${!varName}"
+                eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}'
+                ;;
+
+            --subst-var-by)
+                pattern="@$2@"
+                replacement="$3"
+                eval "$var"'=${'"$var"'//"$pattern"/"$replacement"}'
+                shift 3
+                ;;
+
+            *)
+                echo "substituteStream(): ERROR: Invalid command line argument: $1" >&2
+                return 1
+                ;;
+        esac
+    done
+
+    printf "%s" "${!var}"
+}
+
+consumeEntire() {
+    # read returns non-0 on EOF, so we want read to fail
+    if IFS='' read -r -N 0 $1; then
+        echo "consumeEntire(): ERROR: Input null bytes, won't process" >&2
+        return 1
+    fi
+}
+
+substitute() {
+    local input="$1"
+    local output="$2"
+    shift 2
+
+    if [ ! -f "$input" ]; then
+        echo "substitute(): ERROR: file '$input' does not exist" >&2
+        return 1
+    fi
+
+    local content
+    consumeEntire content < "$input"
+
+    if [ -e "$output" ]; then chmod +w "$output"; fi
+    substituteStream content "file '$input'" "$@" > "$output"
+}
+
+substituteInPlace() {
+    local fileName="$1"
+    shift
+    substitute "$fileName" "$fileName" "$@"
+}
+
+_allFlags() {
+    for varName in $(awk 'BEGIN { for (v in ENVIRON) if (v ~ /^[a-z][a-zA-Z0-9_]*$/) print v }'); do
+        if (( "${NIX_DEBUG:-0}" >= 1 )); then
+            printf "@%s@ -> %q\n" "${varName}" "${!varName}"
+        fi
+        args+=("--subst-var" "$varName")
+    done
+}
+
+substituteAllStream() {
+    local -a args=()
+    _allFlags
+
+    substituteStream "$1" "$2" "${args[@]}"
+}
+
+# Substitute all environment variables that start with a lowercase character and
+# are valid Bash names.
+substituteAll() {
+    local input="$1"
+    local output="$2"
+
+    local -a args=()
+    _allFlags
+
+    substitute "$input" "$output" "${args[@]}"
+}
+
+
+substituteAllInPlace() {
+    local fileName="$1"
+    shift
+    substituteAll "$fileName" "$fileName" "$@"
+}
+
+
+######################################################################
+# What follows is the generic builder.
+
+
+# This function is useful for debugging broken Nix builds.  It dumps
+# all environment variables to a file `env-vars' in the build
+# directory.  If the build fails and the `-K' option is used, you can
+# then go to the build directory and source in `env-vars' to reproduce
+# the environment used for building.
+dumpVars() {
+    if [ "${noDumpEnvVars:-0}" != 1 ]; then
+        export > "$NIX_BUILD_TOP/env-vars" || true
+    fi
+}
+
+
+# Utility function: echo the base name of the given path, with the
+# prefix `HASH-' removed, if present.
+stripHash() {
+    local strippedName
+    # On separate line for `set -e`
+    strippedName="$(basename "$1")"
+    if echo "$strippedName" | grep -q '^[a-z0-9]\{32\}-'; then
+        echo "$strippedName" | cut -c34-
+    else
+        echo "$strippedName"
+    fi
+}
+
+
+unpackCmdHooks+=(_defaultUnpack)
+_defaultUnpack() {
+    local fn="$1"
+
+    if [ -d "$fn" ]; then
+
+        # We can't preserve hardlinks because they may have been
+        # introduced by store optimization, which might break things
+        # in the build.
+        cp -pr --reflink=auto -- "$fn" "$(stripHash "$fn")"
+
+    else
+
+        case "$fn" in
+            *.tar.xz | *.tar.lzma | *.txz)
+                # Don't rely on tar knowing about .xz.
+                xz -d < "$fn" | tar xf - ${tarFlags}
+                ;;
+            *.tar | *.tar.* | *.tgz | *.tbz2 | *.tbz)
+                # GNU tar can automatically select the decompression method
+                # (info "(tar) gzip").
+                tar xf "$fn" ${tarFlags}
+                ;;
+            *)
+                return 1
+                ;;
+        esac
+
+    fi
+}
+
+
+unpackFile() {
+    curSrc="$1"
+    header "unpacking source archive $curSrc" 3
+    if ! runOneHook unpackCmd "$curSrc"; then
+        echo "do not know how to unpack source archive $curSrc"
+        exit 1
+    fi
+}
+
+
+unpackPhase() {
+    runHook preUnpack
+
+    if [ -z "${srcs:-}" ]; then
+        if [ -z "${src:-}" ]; then
+            # shellcheck disable=SC2016
+            echo 'variable $src or $srcs should point to the source'
+            exit 1
+        fi
+        srcs="$src"
+    fi
+
+    # To determine the source directory created by unpacking the
+    # source archives, we record the contents of the current
+    # directory, then look below which directory got added.  Yeah,
+    # it's rather hacky.
+    local dirsBefore=""
+    for i in *; do
+        if [ -d "$i" ]; then
+            dirsBefore="$dirsBefore $i "
+        fi
+    done
+
+    # Unpack all source archives.
+    for i in $srcs; do
+        unpackFile "$i"
+    done
+
+    # Find the source directory.
+
+    # set to empty if unset
+    : ${sourceRoot=}
+
+    if [ -n "${setSourceRoot:-}" ]; then
+        runOneHook setSourceRoot
+    elif [ -z "$sourceRoot" ]; then
+        for i in *; do
+            if [ -d "$i" ]; then
+                case $dirsBefore in
+                    *\ $i\ *)
+                        ;;
+                    *)
+                        if [ -n "$sourceRoot" ]; then
+                            echo "unpacker produced multiple directories"
+                            exit 1
+                        fi
+                        sourceRoot="$i"
+                        ;;
+                esac
+            fi
+        done
+    fi
+
+    if [ -z "$sourceRoot" ]; then
+        echo "unpacker appears to have produced no directories"
+        exit 1
+    fi
+
+    echo "source root is $sourceRoot"
+
+    # By default, add write permission to the sources.  This is often
+    # necessary when sources have been copied from other store
+    # locations.
+    if [ "${dontMakeSourcesWritable:-0}" != 1 ]; then
+        chmod -R u+w -- "$sourceRoot"
+    fi
+
+    runHook postUnpack
+}
+
+
+patchPhase() {
+    runHook prePatch
+
+    for i in ${patches:-}; do
+        header "applying patch $i" 3
+        local uncompress=cat
+        case "$i" in
+            *.gz)
+                uncompress="gzip -d"
+                ;;
+            *.bz2)
+                uncompress="bzip2 -d"
+                ;;
+            *.xz)
+                uncompress="xz -d"
+                ;;
+            *.lzma)
+                uncompress="lzma -d"
+                ;;
+        esac
+        # "2>&1" is a hack to make patch fail if the decompressor fails (nonexistent patch, etc.)
+        # shellcheck disable=SC2086
+        $uncompress < "$i" 2>&1 | patch ${patchFlags:--p1}
+    done
+
+    runHook postPatch
+}
+
+
+fixLibtool() {
+    sed -i -e 's^eval sys_lib_.*search_path=.*^^' "$1"
+}
+
+
+buildPhase() {
+    runHook preBuild
+    runHook postBuild
+}
+
+
+checkPhase() {
+    runHook preCheck
+
+    if [[ -z "${foundMakefile:-}" ]]; then
+        echo "no Makefile or custom buildPhase, doing nothing"
+        runHook postCheck
+        return
+    fi
+
+    if [[ -z "${checkTarget:-}" ]]; then
+        #TODO(@oxij): should flagsArray influence make -n?
+        if make -n ${makefile:+-f $makefile} check >/dev/null 2>&1; then
+            checkTarget=check
+        elif make -n ${makefile:+-f $makefile} test >/dev/null 2>&1; then
+            checkTarget=test
+        fi
+    fi
+
+    if [[ -z "${checkTarget:-}" ]]; then
+        echo "no check/test target in ${makefile:-Makefile}, doing nothing"
+    else
+        # Old bash empty array hack
+        # shellcheck disable=SC2086
+        local flagsArray=(
+            ${enableParallelChecking:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}}
+            SHELL=$SHELL
+            $makeFlags ${makeFlagsArray+"${makeFlagsArray[@]}"}
+            ${checkFlags:-VERBOSE=y} ${checkFlagsArray+"${checkFlagsArray[@]}"}
+            ${checkTarget}
+        )
+
+        echoCmd 'check flags' "${flagsArray[@]}"
+        make ${makefile:+-f $makefile} "${flagsArray[@]}"
+
+        unset flagsArray
+    fi
+
+    runHook postCheck
+}
+
+
+installPhase() {
+    runHook preInstall
+
+    if [ -n "$prefix" ]; then
+        mkdir -p "$prefix"
+    fi
+
+    cp -r ./* "$prefix"
+
+    runHook postInstall
+}
+
+
+# The fixup phase performs generic, package-independent stuff, like
+# stripping binaries, running patchelf and setting
+# propagated-build-inputs.
+fixupPhase() {
+    # Make sure everything is writable so "strip" et al. work.
+    local output
+    for output in $outputs; do
+        if [ -e "${!output}" ]; then chmod -R u+w "${!output}"; fi
+    done
+
+    runHook preFixup
+
+    # Apply fixup to each output.
+    local output
+    for output in $outputs; do
+        prefix="${!output}" runHook fixupOutput
+    done
+
+
+    # Propagate dependencies & setup hook into the development output.
+    declare -ra flatVars=(
+        # Build
+        depsBuildBuildPropagated
+        propagatedNativeBuildInputs
+        depsBuildTargetPropagated
+        # Host
+        depsHostHostPropagated
+        propagatedBuildInputs
+        # Target
+        depsTargetTargetPropagated
+    )
+    declare -ra flatFiles=(
+        "${propagatedBuildDepFiles[@]}"
+        "${propagatedHostDepFiles[@]}"
+        "${propagatedTargetDepFiles[@]}"
+    )
+
+    local propagatedInputsIndex
+    for propagatedInputsIndex in "${!flatVars[@]}"; do
+        local propagatedInputsSlice="${flatVars[$propagatedInputsIndex]}[@]"
+        local propagatedInputsFile="${flatFiles[$propagatedInputsIndex]}"
+
+        [[ "${!propagatedInputsSlice}" ]] || continue
+
+        mkdir -p "${!outputDev}/nix-support"
+        # shellcheck disable=SC2086
+        printWords ${!propagatedInputsSlice} > "${!outputDev}/nix-support/$propagatedInputsFile"
+    done
+
+
+    if [ -n "${setupHook:-}" ]; then
+        mkdir -p "${!outputDev}/nix-support"
+        substituteAll "$setupHook" "${!outputDev}/nix-support/setup-hook"
+    fi
+
+    # TODO(@Ericson2314): Remove after https://github.com/NixOS/nixpkgs/pull/31414
+    if [ -n "${setupHooks:-}" ]; then
+        mkdir -p "${!outputDev}/nix-support"
+        local hook
+        for hook in $setupHooks; do
+            local content
+            consumeEntire content < "$hook"
+            substituteAllStream content "file '$hook'" >> "${!outputDev}/nix-support/setup-hook"
+            unset -v content
+        done
+        unset -v hook
+    fi
+
+    # Propagate user-env packages into the output with binaries, TODO?
+
+    if [ -n "${propagatedUserEnvPkgs:-}" ]; then
+        mkdir -p "${!outputBin}/nix-support"
+        # shellcheck disable=SC2086
+        printWords $propagatedUserEnvPkgs > "${!outputBin}/nix-support/propagated-user-env-packages"
+    fi
+
+    runHook postFixup
+}
+
+
+installCheckPhase() {
+    runHook preInstallCheck
+
+    if [[ -z "${foundMakefile:-}" ]]; then
+        echo "no Makefile or custom buildPhase, doing nothing"
+    #TODO(@oxij): should flagsArray influence make -n?
+    elif [[ -z "${installCheckTarget:-}" ]] \
+       && ! make -n ${makefile:+-f $makefile} ${installCheckTarget:-installcheck} >/dev/null 2>&1; then
+        echo "no installcheck target in ${makefile:-Makefile}, doing nothing"
+    else
+        # Old bash empty array hack
+        # shellcheck disable=SC2086
+        local flagsArray=(
+            ${enableParallelChecking:+-j${NIX_BUILD_CORES} -l${NIX_BUILD_CORES}}
+            SHELL=$SHELL
+            $makeFlags ${makeFlagsArray+"${makeFlagsArray[@]}"}
+            $installCheckFlags ${installCheckFlagsArray+"${installCheckFlagsArray[@]}"}
+            ${installCheckTarget:-installcheck}
+        )
+
+        echoCmd 'installcheck flags' "${flagsArray[@]}"
+        make ${makefile:+-f $makefile} "${flagsArray[@]}"
+        unset flagsArray
+    fi
+
+    runHook postInstallCheck
+}
+
+
+distPhase() {
+    runHook preDist
+
+    # Old bash empty array hack
+    # shellcheck disable=SC2086
+    local flagsArray=(
+        $distFlags ${distFlagsArray+"${distFlagsArray[@]}"} ${distTarget:-dist}
+    )
+
+    echo 'dist flags: %q' "${flagsArray[@]}"
+    make ${makefile:+-f $makefile} "${flagsArray[@]}"
+
+    if [ "${dontCopyDist:-0}" != 1 ]; then
+        mkdir -p "$out/tarballs"
+
+        # Note: don't quote $tarballs, since we explicitly permit
+        # wildcards in there.
+        # shellcheck disable=SC2086
+        cp -pvd ${tarballs:-*.tar.gz} "$out/tarballs"
+    fi
+
+    runHook postDist
+}
+
+
+showPhaseHeader() {
+    local phase="$1"
+    case "$phase" in
+        unpackPhase) header "unpacking sources";;
+        patchPhase) header "patching sources";;
+        configurePhase) header "configuring";;
+        buildPhase) header "building";;
+        checkPhase) header "running tests";;
+        installPhase) header "installing";;
+        fixupPhase) header "post-installation fixup";;
+        installCheckPhase) header "running install tests";;
+        *) header "$phase";;
+    esac
+}
+
+
+genericBuild() {
+    header "preparing $out"
+
+    if [ -f "${buildCommandPath:-}" ]; then
+        local oldOpts="$(shopt -po nounset)"
+        set +u
+        source "$buildCommandPath"
+        eval "$oldOpts"
+        return
+    fi
+    if [ -n "${buildCommand:-}" ]; then
+        local oldOpts="$(shopt -po nounset)"
+        set +u
+        eval "$buildCommand"
+        eval "$oldOpts"
+        return
+    fi
+
+    if [ -z "$phases" ]; then
+        phases="unpackPhase patchPhase buildPhase installPhase"
+    fi
+
+
+    for curPhase in $phases; do
+        if [[ -n $NIX_LOG_FD ]]; then
+            echo "@nix { \"action\": \"setPhase\", \"phase\": \"$curPhase\" }" >&$NIX_LOG_FD
+        fi
+
+        showPhaseHeader "$curPhase"
+        dumpVars
+
+        # Evaluate the variable named $curPhase if it exists, otherwise the
+        # function named $curPhase.
+        local oldOpts="$(shopt -po nounset)"
+        set +u
+        eval "${!curPhase:-$curPhase}"
+        eval "$oldOpts"
+
+        if [ "$curPhase" = unpackPhase ]; then
+            cd "${sourceRoot:-.}"
+        fi
+    done
+}
+
+
+# Execute the post-hooks.
+runHook postHook
+
+
+# Execute the global user hook (defined through the Nixpkgs
+# configuration option ‘stdenv.userHook’).  This can be used to set
+# global compiler optimisation flags, for instance.
+runHook userHook
+
+
+dumpVars
+
+# Disable nounset for nix-shell.
+set +u