Merge branch 'nixpkgs-update' into master

146 files changed, 9151 insertions, 12058 deletions

diff --git a/doc/Makefile b/doc/Makefile
index 49f361ebb60..1d3a0e7ccbd 100644
--- a/doc/Makefile
+++ b/doc/Makefile
@@ -1,4 +1,15 @@
-MD_TARGETS=$(addsuffix .xml, $(basename $(shell find . -type f -regex '.*\.md$$')))
+MD_TARGETS=$(addsuffix .xml, $(basename $(shell find . -type f -regex '.*\.md$$' -not -name README.md)))
+
+PANDOC ?= pandoc
+
+pandoc_media_dir = media
+# NOTE: Keep in sync with NixOS manual (/nixos/doc/manual/md-to-db.sh).
+# TODO: Remove raw-attribute when we can get rid of DocBook altogether.
+pandoc_commonmark_enabled_extensions = +attributes+fenced_divs+footnotes+bracketed_spans+definition_lists+pipe_tables+raw_attribute
+pandoc_flags = --extract-media=$(pandoc_media_dir) \
+	--lua-filter=$(PANDOC_LUA_FILTERS_DIR)/diagram-generator.lua \
+	--lua-filter=labelless-link-is-xref.lua \
+	-f commonmark$(pandoc_commonmark_enabled_extensions)+smart
 
 .PHONY: all
 all: validate format out/html/index.html out/epub/manual.epub
@@ -22,7 +33,7 @@ fix-misc-xml:
 .PHONY: clean
 clean:
 	rm -f ${MD_TARGETS} doc-support/result .version manual-full.xml functions/library/locations.xml functions/library/generated
-	rm -rf ./out/ ./highlightjs
+	rm -rf ./out/ ./highlightjs ./media
 
 .PHONY: validate
 validate: manual-full.xml doc-support/result
@@ -39,6 +50,7 @@ out/html/index.html: doc-support/result manual-full.xml style.css highlightjs
 	mkdir -p out/html/highlightjs/
 	cp -r highlightjs out/html/
 
+	cp -r $(pandoc_media_dir) out/html/
 	cp ./overrides.css out/html/
 	cp ./style.css out/html/style.css
 
@@ -53,6 +65,7 @@ out/epub/manual.epub: manual-full.xml
 		doc-support/result/epub.xsl \
 		./manual-full.xml
 
+	cp -r $(pandoc_media_dir) out/epub/scratch/OEBPS
 	cp ./overrides.css out/epub/scratch/OEBPS
 	cp ./style.css out/epub/scratch/OEBPS
 	mkdir -p out/epub/scratch/OEBPS/images/callouts/
@@ -87,24 +100,12 @@ functions/library/generated: doc-support/result
 	ln -rfs ./doc-support/result/function-docs functions/library/generated
 
 %.section.xml: %.section.md
-	pandoc $^ -w docbook \
-		-f markdown+smart \
-	  | sed -e 's|<ulink url=|<link xlink:href=|' \
-	      -e 's|</ulink>|</link>|' \
-	      -e 's|<sect. id=|<section xml:id=|' \
-	      -e 's|</sect[0-9]>|</section>|' \
-	      -e '1s| id=| xml:id=|' \
-	      -e '1s|\(<[^ ]* \)|\1xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" |' \
-	| cat  > $@
+	$(PANDOC) $^ -t docbook \
+		$(pandoc_flags) \
+		-o $@
 
 %.chapter.xml: %.chapter.md
-	pandoc $^ -w docbook \
+	$(PANDOC) $^ -t docbook \
 		--top-level-division=chapter \
-		-f markdown+smart \
-	  | sed -e 's|<ulink url=|<link xlink:href=|' \
-	      -e 's|</ulink>|</link>|' \
-	      -e 's|<sect. id=|<section xml:id=|' \
-	      -e 's|</sect[0-9]>|</section>|' \
-	      -e '1s| id=| xml:id=|' \
-	      -e '1s|\(<[^ ]* \)|\1|' \
-	| cat  > $@
+		$(pandoc_flags) \
+		-o $@
diff --git a/doc/README.md b/doc/README.md
new file mode 100644
index 00000000000..5395d7ca8f6
--- /dev/null
+++ b/doc/README.md
@@ -0,0 +1,12 @@
+
+# Nixpkgs/doc
+
+This directory houses the sources files for the Nixpkgs manual.
+
+You can find the [rendered documentation for Nixpkgs `unstable` on nixos.org](https://nixos.org/manual/nixpkgs/unstable/).
+
+[Docs for Nixpkgs stable](https://nixos.org/manual/nixpkgs/stable/) are also available.
+
+If you want to contribute to the documentation, [here's how to do it](https://nixos.org/manual/nixpkgs/unstable/#chap-contributing).
+
+If you're only getting started with Nix, go to [nixos.org/learn](https://nixos.org/learn).
diff --git a/doc/builders/fetchers.chapter.md b/doc/builders/fetchers.chapter.md
new file mode 100644
index 00000000000..30d06534485
--- /dev/null
+++ b/doc/builders/fetchers.chapter.md
@@ -0,0 +1,77 @@
+# Fetchers {#chap-pkgs-fetchers}
+
+When using Nix, you will frequently need to download source code and other files from the internet. Nixpkgs comes with a few helper functions that allow you to fetch fixed-output derivations in a structured way.
+
+The two fetcher primitives are `fetchurl` and `fetchzip`. Both of these have two required arguments, a URL and a hash. The hash is typically `sha256`, although many more hash algorithms are supported. Nixpkgs contributors are currently recommended to use `sha256`. This hash will be used by Nix to identify your source. A typical usage of fetchurl is provided below.
+
+```nix
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation {
+  name = "hello";
+  src = fetchurl {
+    url = "http://www.example.org/hello.tar.gz";
+    sha256 = "1111111111111111111111111111111111111111111111111111";
+  };
+}
+```
+
+The main difference between `fetchurl` and `fetchzip` is in how they store the contents. `fetchurl` will store the unaltered contents of the URL within the Nix store. `fetchzip` on the other hand will decompress the archive for you, making files and directories directly accessible in the future. `fetchzip` can only be used with archives. Despite the name, `fetchzip` is not limited to .zip files and can also be used with any tarball.
+
+`fetchpatch` works very similarly to `fetchurl` with the same arguments expected. It expects patch files as a source and performs normalization on them before computing the checksum. For example it will remove comments or other unstable parts that are sometimes added by version control systems and can change over time.
+
+Other fetcher functions allow you to add source code directly from a VCS such as subversion or git. These are mostly straightforward nambes based on the name of the command used with the VCS system. Because they give you a working repository, they act most like `fetchzip`.
+
+## `fetchsvn` {#fetchsvn}
+
+Used with Subversion. Expects `url` to a Subversion directory, `rev`, and `sha256`.
+
+## `fetchgit` {#fetchgit}
+
+Used with Git. Expects `url` to a Git repo, `rev`, and `sha256`. `rev` in this case can be full the git commit id (SHA1 hash) or a tag name like `refs/tags/v1.0`.
+
+Additionally the following optional arguments can be given: `fetchSubmodules = true` makes `fetchgit` also fetch the submodules of a repository. If `deepClone` is set to true, the entire repository is cloned as opposing to just creating a shallow clone. `deepClone = true` also implies `leaveDotGit = true` which means that the `.git` directory of the clone won't be removed after checkout.
+
+## `fetchfossil` {#fetchfossil}
+
+Used with Fossil. Expects `url` to a Fossil archive, `rev`, and `sha256`.
+
+## `fetchcvs` {#fetchcvs}
+
+Used with CVS. Expects `cvsRoot`, `tag`, and `sha256`.
+
+## `fetchhg` {#fetchhg}
+
+Used with Mercurial. Expects `url`, `rev`, and `sha256`.
+
+A number of fetcher functions wrap part of `fetchurl` and `fetchzip`. They are mainly convenience functions intended for commonly used destinations of source code in Nixpkgs. These wrapper fetchers are listed below.
+
+## `fetchFromGitHub` {#fetchfromgithub}
+
+`fetchFromGitHub` expects four arguments. `owner` is a string corresponding to the GitHub user or organization that controls this repository. `repo` corresponds to the name of the software repository. These are located at the top of every GitHub HTML page as `owner`/`repo`. `rev` corresponds to the Git commit hash or tag (e.g `v1.0`) that will be downloaded from Git. Finally, `sha256` corresponds to the hash of the extracted directory. Again, other hash algorithms are also available but `sha256` is currently preferred.
+
+`fetchFromGitHub` uses `fetchzip` to download the source archive generated by GitHub for the specified revision. If `leaveDotGit`, `deepClone` or `fetchSubmodules` are set to `true`, `fetchFromGitHub` will use `fetchgit` instead. Refer to its section for documentation of these options.
+
+## `fetchFromGitLab` {#fetchfromgitlab}
+
+This is used with GitLab repositories. The arguments expected are very similar to fetchFromGitHub above.
+
+## `fetchFromGitiles` {#fetchfromgitiles}
+
+This is used with Gitiles repositories. The arguments expected are similar to fetchgit.
+
+## `fetchFromBitbucket` {#fetchfrombitbucket}
+
+This is used with BitBucket repositories. The arguments expected are very similar to fetchFromGitHub above.
+
+## `fetchFromSavannah` {#fetchfromsavannah}
+
+This is used with Savannah repositories. The arguments expected are very similar to fetchFromGitHub above.
+
+## `fetchFromRepoOrCz` {#fetchfromrepoorcz}
+
+This is used with repo.or.cz repositories. The arguments expected are very similar to fetchFromGitHub above.
+
+## `fetchFromSourcehut` {#fetchfromsourcehut}
+
+This is used with sourcehut repositories. The arguments expected are very similar to fetchFromGitHub above. Don't forget the tilde (~) in front of the user name!
diff --git a/doc/builders/fetchers.xml b/doc/builders/fetchers.xml
deleted file mode 100644
index f07c310dcdf..00000000000
--- a/doc/builders/fetchers.xml
+++ /dev/null
@@ -1,150 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="chap-pkgs-fetchers">
- <title>Fetchers</title>
- <para>
-  When using Nix, you will frequently need to download source code and other files from the internet. Nixpkgs comes with a few helper functions that allow you to fetch fixed-output derivations in a structured way.
- </para>
- <para>
-  The two fetcher primitives are <function>fetchurl</function> and <function>fetchzip</function>. Both of these have two required arguments, a URL and a hash. The hash is typically <literal>sha256</literal>, although many more hash algorithms are supported. Nixpkgs contributors are currently recommended to use <literal>sha256</literal>. This hash will be used by Nix to identify your source. A typical usage of fetchurl is provided below.
- </para>
-<programlisting><![CDATA[
-{ stdenv, fetchurl }:
-
-stdenv.mkDerivation {
-  name = "hello";
-  src = fetchurl {
-    url = "http://www.example.org/hello.tar.gz";
-    sha256 = "1111111111111111111111111111111111111111111111111111";
-  };
-}
-]]></programlisting>
- <para>
-  The main difference between <function>fetchurl</function> and <function>fetchzip</function> is in how they store the contents. <function>fetchurl</function> will store the unaltered contents of the URL within the Nix store. <function>fetchzip</function> on the other hand will decompress the archive for you, making files and directories directly accessible in the future. <function>fetchzip</function> can only be used with archives. Despite the name, <function>fetchzip</function> is not limited to .zip files and can also be used with any tarball.
- </para>
- <para>
-  <function>fetchpatch</function> works very similarly to <function>fetchurl</function> with the same arguments expected. It expects patch files as a source and and performs normalization on them before computing the checksum. For example it will remove comments or other unstable parts that are sometimes added by version control systems and can change over time.
- </para>
- <para>
-  Other fetcher functions allow you to add source code directly from a VCS such as subversion or git. These are mostly straightforward names based on the name of the command used with the VCS system. Because they give you a working repository, they act most like <function>fetchzip</function>.
- </para>
- <variablelist>
-  <varlistentry>
-   <term>
-    <literal>fetchsvn</literal>
-   </term>
-   <listitem>
-    <para>
-     Used with Subversion. Expects <literal>url</literal> to a Subversion directory, <literal>rev</literal>, and <literal>sha256</literal>.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>fetchgit</literal>
-   </term>
-   <listitem>
-    <para>
-     Used with Git. Expects <literal>url</literal> to a Git repo, <literal>rev</literal>, and <literal>sha256</literal>. <literal>rev</literal> in this case can be full the git commit id (SHA1 hash) or a tag name like <literal>refs/tags/v1.0</literal>.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>fetchfossil</literal>
-   </term>
-   <listitem>
-    <para>
-     Used with Fossil. Expects <literal>url</literal> to a Fossil archive, <literal>rev</literal>, and <literal>sha256</literal>.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>fetchcvs</literal>
-   </term>
-   <listitem>
-    <para>
-     Used with CVS. Expects <literal>cvsRoot</literal>, <literal>tag</literal>, and <literal>sha256</literal>.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>fetchhg</literal>
-   </term>
-   <listitem>
-    <para>
-     Used with Mercurial. Expects <literal>url</literal>, <literal>rev</literal>, and <literal>sha256</literal>.
-    </para>
-   </listitem>
-  </varlistentry>
- </variablelist>
- <para>
-  A number of fetcher functions wrap part of <function>fetchurl</function> and <function>fetchzip</function>. They are mainly convenience functions intended for commonly used destinations of source code in Nixpkgs. These wrapper fetchers are listed below.
- </para>
- <variablelist>
-  <varlistentry>
-   <term>
-    <literal>fetchFromGitHub</literal>
-   </term>
-   <listitem>
-    <para>
-     <function>fetchFromGitHub</function> expects four arguments. <literal>owner</literal> is a string corresponding to the GitHub user or organization that controls this repository. <literal>repo</literal> corresponds to the name of the software repository. These are located at the top of every GitHub HTML page as <literal>owner</literal>/<literal>repo</literal>. <literal>rev</literal> corresponds to the Git commit hash or tag (e.g <literal>v1.0</literal>) that will be downloaded from Git. Finally, <literal>sha256</literal> corresponds to the hash of the extracted directory. Again, other hash algorithms are also available but <literal>sha256</literal> is currently preferred.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>fetchFromGitLab</literal>
-   </term>
-   <listitem>
-    <para>
-     This is used with GitLab repositories. The arguments expected are very similar to fetchFromGitHub above.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>fetchFromGitiles</literal>
-   </term>
-   <listitem>
-    <para>
-     This is used with Gitiles repositories. The arguments expected
-     are similar to fetchgit.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>fetchFromBitbucket</literal>
-   </term>
-   <listitem>
-    <para>
-     This is used with BitBucket repositories. The arguments expected are very similar to fetchFromGitHub above.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>fetchFromSavannah</literal>
-   </term>
-   <listitem>
-    <para>
-     This is used with Savannah repositories. The arguments expected are very similar to fetchFromGitHub above.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>fetchFromRepoOrCz</literal>
-   </term>
-   <listitem>
-    <para>
-     This is used with repo.or.cz repositories. The arguments expected are very similar to fetchFromGitHub above.
-    </para>
-   </listitem>
-  </varlistentry>
- </variablelist>
-</chapter>
diff --git a/doc/builders/images.xml b/doc/builders/images.xml
index 5e042a8ada8..cd10d69a96d 100644
--- a/doc/builders/images.xml
+++ b/doc/builders/images.xml
@@ -5,8 +5,8 @@
  <para>
   This chapter describes tools for creating various types of images.
  </para>
- <xi:include href="images/appimagetools.xml" />
- <xi:include href="images/dockertools.xml" />
- <xi:include href="images/ocitools.xml" />
- <xi:include href="images/snaptools.xml" />
+ <xi:include href="images/appimagetools.section.xml" />
+ <xi:include href="images/dockertools.section.xml" />
+ <xi:include href="images/ocitools.section.xml" />
+ <xi:include href="images/snaptools.section.xml" />
 </chapter>
diff --git a/doc/builders/images/appimagetools.section.md b/doc/builders/images/appimagetools.section.md
new file mode 100644
index 00000000000..67e63dc5f61
--- /dev/null
+++ b/doc/builders/images/appimagetools.section.md
@@ -0,0 +1,48 @@
+# pkgs.appimageTools {#sec-pkgs-appimageTools}
+
+`pkgs.appimageTools` is a set of functions for extracting and wrapping [AppImage](https://appimage.org/) files. They are meant to be used if traditional packaging from source is infeasible, or it would take too long. To quickly run an AppImage file, `pkgs.appimage-run` can be used as well.
+
+::: {.warning}
+The `appimageTools` API is unstable and may be subject to backwards-incompatible changes in the future.
+:::
+
+## AppImage formats {#ssec-pkgs-appimageTools-formats}
+
+There are different formats for AppImages, see [the specification](https://github.com/AppImage/AppImageSpec/blob/74ad9ca2f94bf864a4a0dac1f369dd4f00bd1c28/draft.md#image-format) for details.
+
+- Type 1 images are ISO 9660 files that are also ELF executables.
+- Type 2 images are ELF executables with an appended filesystem.
+
+They can be told apart with `file -k`:
+
+```ShellSession
+$ file -k type1.AppImage
+type1.AppImage: ELF 64-bit LSB executable, x86-64, version 1 (SYSV) ISO 9660 CD-ROM filesystem data 'AppImage' (Lepton 3.x), scale 0-0,
+spot sensor temperature 0.000000, unit celsius, color scheme 0, calibration: offset 0.000000, slope 0.000000, dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.18, BuildID[sha1]=d629f6099d2344ad82818172add1d38c5e11bc6d, stripped\012- data
+
+$ file -k type2.AppImage
+type2.AppImage: ELF 64-bit LSB executable, x86-64, version 1 (SYSV) (Lepton 3.x), scale 232-60668, spot sensor temperature -4.187500, color scheme 15, show scale bar, calibration: offset -0.000000, slope 0.000000 (Lepton 2.x), scale 4111-45000, spot sensor temperature 412442.250000, color scheme 3, minimum point enabled, calibration: offset -75402534979642766821519867692934234112.000000, slope 5815371847733706829839455140374904832.000000, dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.18, BuildID[sha1]=79dcc4e55a61c293c5e19edbd8d65b202842579f, stripped\012- data
+```
+
+Note how the type 1 AppImage is described as an `ISO 9660 CD-ROM filesystem`, and the type 2 AppImage is not.
+
+## Wrapping {#ssec-pkgs-appimageTools-wrapping}
+
+Depending on the type of AppImage you're wrapping, you'll have to use `wrapType1` or `wrapType2`.
+
+```nix
+appimageTools.wrapType2 { # or wrapType1
+  name = "patchwork";
+  src = fetchurl {
+    url = "https://github.com/ssbc/patchwork/releases/download/v3.11.4/Patchwork-3.11.4-linux-x86_64.AppImage";
+    sha256 = "1blsprpkvm0ws9b96gb36f0rbf8f5jgmw4x6dsb1kswr4ysf591s";
+  };
+  extraPkgs = pkgs: with pkgs; [ ];
+}
+```
+
+- `name` specifies the name of the resulting image.
+- `src` specifies the AppImage file to extract.
+- `extraPkgs` allows you to pass a function to include additional packages inside the FHS environment your AppImage is going to run in. There are a few ways to learn which dependencies an application needs:
+  - Looking through the extracted AppImage files, reading its scripts and running `patchelf` and `ldd` on its executables. This can also be done in `appimage-run`, by setting `APPIMAGE_DEBUG_EXEC=bash`.
+  - Running `strace -vfefile` on the wrapped executable, looking for libraries that can't be found.
diff --git a/doc/builders/images/appimagetools.xml b/doc/builders/images/appimagetools.xml
deleted file mode 100644
index 45c5619abd9..00000000000
--- a/doc/builders/images/appimagetools.xml
+++ /dev/null
@@ -1,102 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-pkgs-appimageTools">
- <title>pkgs.appimageTools</title>
-
- <para>
-  <varname>pkgs.appimageTools</varname> is a set of functions for extracting and wrapping <link xlink:href="https://appimage.org/">AppImage</link> files. They are meant to be used if traditional packaging from source is infeasible, or it would take too long. To quickly run an AppImage file, <literal>pkgs.appimage-run</literal> can be used as well.
- </para>
-
- <warning>
-  <para>
-   The <varname>appimageTools</varname> API is unstable and may be subject to backwards-incompatible changes in the future.
-  </para>
- </warning>
-
- <section xml:id="ssec-pkgs-appimageTools-formats">
-  <title>AppImage formats</title>
-
-  <para>
-   There are different formats for AppImages, see <link xlink:href="https://github.com/AppImage/AppImageSpec/blob/74ad9ca2f94bf864a4a0dac1f369dd4f00bd1c28/draft.md#image-format">the specification</link> for details.
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Type 1 images are ISO 9660 files that are also ELF executables.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Type 2 images are ELF executables with an appended filesystem.
-    </para>
-   </listitem>
-  </itemizedlist>
-
-  <para>
-   They can be told apart with <command>file -k</command>:
-  </para>
-
-<screen>
-<prompt>$ </prompt>file -k type1.AppImage
-type1.AppImage: ELF 64-bit LSB executable, x86-64, version 1 (SYSV) ISO 9660 CD-ROM filesystem data 'AppImage' (Lepton 3.x), scale 0-0,
-spot sensor temperature 0.000000, unit celsius, color scheme 0, calibration: offset 0.000000, slope 0.000000, dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.18, BuildID[sha1]=d629f6099d2344ad82818172add1d38c5e11bc6d, stripped\012- data
-
-<prompt>$ </prompt>file -k type2.AppImage
-type2.AppImage: ELF 64-bit LSB executable, x86-64, version 1 (SYSV) (Lepton 3.x), scale 232-60668, spot sensor temperature -4.187500, color scheme 15, show scale bar, calibration: offset -0.000000, slope 0.000000 (Lepton 2.x), scale 4111-45000, spot sensor temperature 412442.250000, color scheme 3, minimum point enabled, calibration: offset -75402534979642766821519867692934234112.000000, slope 5815371847733706829839455140374904832.000000, dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.18, BuildID[sha1]=79dcc4e55a61c293c5e19edbd8d65b202842579f, stripped\012- data
-</screen>
-
-  <para>
-   Note how the type 1 AppImage is described as an <literal>ISO 9660 CD-ROM filesystem</literal>, and the type 2 AppImage is not.
-  </para>
- </section>
-
- <section xml:id="ssec-pkgs-appimageTools-wrapping">
-  <title>Wrapping</title>
-
-  <para>
-   Depending on the type of AppImage you're wrapping, you'll have to use <varname>wrapType1</varname> or <varname>wrapType2</varname>.
-  </para>
-
-<programlisting>
-appimageTools.wrapType2 { # or wrapType1
-  name = "patchwork"; <co xml:id='ex-appimageTools-wrapping-1' />
-  src = fetchurl { <co xml:id='ex-appimageTools-wrapping-2' />
-    url = "https://github.com/ssbc/patchwork/releases/download/v3.11.4/Patchwork-3.11.4-linux-x86_64.AppImage";
-    sha256 =  "1blsprpkvm0ws9b96gb36f0rbf8f5jgmw4x6dsb1kswr4ysf591s";
-  };
-  extraPkgs = pkgs: with pkgs; [ ]; <co xml:id='ex-appimageTools-wrapping-3' />
-}</programlisting>
-
-  <calloutlist>
-   <callout arearefs='ex-appimageTools-wrapping-1'>
-    <para>
-     <varname>name</varname> specifies the name of the resulting image.
-    </para>
-   </callout>
-   <callout arearefs='ex-appimageTools-wrapping-2'>
-    <para>
-     <varname>src</varname> specifies the AppImage file to extract.
-    </para>
-   </callout>
-   <callout arearefs='ex-appimageTools-wrapping-3'>
-    <para>
-     <varname>extraPkgs</varname> allows you to pass a function to include additional packages inside the FHS environment your AppImage is going to run in. There are a few ways to learn which dependencies an application needs:
-     <itemizedlist>
-      <listitem>
-       <para>
-        Looking through the extracted AppImage files, reading its scripts and running <command>patchelf</command> and <command>ldd</command> on its executables. This can also be done in <command>appimage-run</command>, by setting <command>APPIMAGE_DEBUG_EXEC=bash</command>.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        Running <command>strace -vfefile</command> on the wrapped executable, looking for libraries that can't be found.
-       </para>
-      </listitem>
-     </itemizedlist>
-    </para>
-   </callout>
-  </calloutlist>
- </section>
-</section>
diff --git a/doc/builders/images/dockertools.section.md b/doc/builders/images/dockertools.section.md
new file mode 100644
index 00000000000..bfe1d17a606
--- /dev/null
+++ b/doc/builders/images/dockertools.section.md
@@ -0,0 +1,308 @@
+# pkgs.dockerTools {#sec-pkgs-dockerTools}
+
+`pkgs.dockerTools` is a set of functions for creating and manipulating Docker images according to the [Docker Image Specification v1.2.0](https://github.com/moby/moby/blob/master/image/spec/v1.2.md#docker-image-specification-v120). Docker itself is not used to perform any of the operations done by these functions.
+
+## buildImage {#ssec-pkgs-dockerTools-buildImage}
+
+This function is analogous to the `docker build` command, in that it can be used to build a Docker-compatible repository tarball containing a single image with one or multiple layers. As such, the result is suitable for being loaded in Docker with `docker load`.
+
+The parameters of `buildImage` with relative example values are described below:
+
+[]{#ex-dockerTools-buildImage}
+[]{#ex-dockerTools-buildImage-runAsRoot}
+
+```nix
+buildImage {
+  name = "redis";
+  tag = "latest";
+
+  fromImage = someBaseImage;
+  fromImageName = null;
+  fromImageTag = "latest";
+
+  contents = pkgs.redis;
+  runAsRoot = ''
+    #!${pkgs.runtimeShell}
+    mkdir -p /data
+  '';
+
+  config = {
+    Cmd = [ "/bin/redis-server" ];
+    WorkingDir = "/data";
+    Volumes = { "/data" = { }; };
+  };
+}
+```
+
+The above example will build a Docker image `redis/latest` from the given base image. Loading and running this image in Docker results in `redis-server` being started automatically.
+
+- `name` specifies the name of the resulting image. This is the only required argument for `buildImage`.
+
+- `tag` specifies the tag of the resulting image. By default it's `null`, which indicates that the nix output hash will be used as tag.
+
+- `fromImage` is the repository tarball containing the base image. It must be a valid Docker image, such as exported by `docker save`. By default it's `null`, which can be seen as equivalent to `FROM scratch` of a `Dockerfile`.
+
+- `fromImageName` can be used to further specify the base image within the repository, in case it contains multiple images. By default it's `null`, in which case `buildImage` will peek the first image available in the repository.
+
+- `fromImageTag` can be used to further specify the tag of the base image within the repository, in case an image contains multiple tags. By default it's `null`, in which case `buildImage` will peek the first tag available for the base image.
+
+- `contents` is a derivation that will be copied in the new layer of the resulting image. This can be similarly seen as `ADD contents/ /` in a `Dockerfile`. By default it's `null`.
+
+- `runAsRoot` is a bash script that will run as root in an environment that overlays the existing layers of the base image with the new resulting layer, including the previously copied `contents` derivation. This can be similarly seen as `RUN ...` in a `Dockerfile`.
+
+> **_NOTE:_** Using this parameter requires the `kvm` device to be available.
+
+- `config` is used to specify the configuration of the containers that will be started off the built image in Docker. The available options are listed in the [Docker Image Specification v1.2.0](https://github.com/moby/moby/blob/master/image/spec/v1.2.md#image-json-field-descriptions).
+
+After the new layer has been created, its closure (to which `contents`, `config` and `runAsRoot` contribute) will be copied in the layer itself. Only new dependencies that are not already in the existing layers will be copied.
+
+At the end of the process, only one new single layer will be produced and added to the resulting image.
+
+The resulting repository will only list the single image `image/tag`. In the case of [the `buildImage` example](#ex-dockerTools-buildImage) it would be `redis/latest`.
+
+It is possible to inspect the arguments with which an image was built using its `buildArgs` attribute.
+
+> **_NOTE:_** If you see errors similar to `getProtocolByName: does not exist (no such protocol name: tcp)` you may need to add `pkgs.iana-etc` to `contents`.
+
+> **_NOTE:_** If you see errors similar to `Error_Protocol ("certificate has unknown CA",True,UnknownCa)` you may need to add `pkgs.cacert` to `contents`.
+
+By default `buildImage` will use a static date of one second past the UNIX Epoch. This allows `buildImage` to produce binary reproducible images. When listing images with `docker images`, the newly created images will be listed like this:
+
+```ShellSession
+$ docker images
+REPOSITORY   TAG      IMAGE ID       CREATED        SIZE
+hello        latest   08c791c7846e   48 years ago   25.2MB
+```
+
+You can break binary reproducibility but have a sorted, meaningful `CREATED` column by setting `created` to `now`.
+
+```nix
+pkgs.dockerTools.buildImage {
+  name = "hello";
+  tag = "latest";
+  created = "now";
+  contents = pkgs.hello;
+
+  config.Cmd = [ "/bin/hello" ];
+}
+```
+
+and now the Docker CLI will display a reasonable date and sort the images as expected:
+
+```ShellSession
+$ docker images
+REPOSITORY   TAG      IMAGE ID       CREATED              SIZE
+hello        latest   de2bf4786de6   About a minute ago   25.2MB
+```
+
+however, the produced images will not be binary reproducible.
+
+## buildLayeredImage {#ssec-pkgs-dockerTools-buildLayeredImage}
+
+Create a Docker image with many of the store paths being on their own layer to improve sharing between images. The image is realized into the Nix store as a gzipped tarball. Depending on the intended usage, many users might prefer to use `streamLayeredImage` instead, which this function uses internally.
+
+`name`
+
+: The name of the resulting image.
+
+`tag` _optional_
+
+: Tag of the generated image.
+
+    *Default:* the output path's hash
+
+`fromImage` _optional_
+
+: The repository tarball containing the base image. It must be a valid Docker image, such as one exported by `docker save`.
+
+    *Default:* `null`, which can be seen as equivalent to `FROM scratch` of a `Dockerfile`.
+
+`contents` _optional_
+
+: Top level paths in the container. Either a single derivation, or a list of derivations.
+
+    *Default:* `[]`
+
+`config` _optional_
+
+: Run-time configuration of the container. A full list of the options are available at in the [ Docker Image Specification v1.2.0 ](https://github.com/moby/moby/blob/master/image/spec/v1.2.md#image-json-field-descriptions).
+
+    *Default:* `{}`
+
+`created` _optional_
+
+: Date and time the layers were created. Follows the same `now` exception supported by `buildImage`.
+
+    *Default:* `1970-01-01T00:00:01Z`
+
+`maxLayers` _optional_
+
+: Maximum number of layers to create.
+
+    *Default:* `100`
+
+    *Maximum:* `125`
+
+`extraCommands` _optional_
+
+: Shell commands to run while building the final layer, without access to most of the layer contents. Changes to this layer are "on top" of all the other layers, so can create additional directories and files.
+
+`fakeRootCommands` _optional_
+
+: Shell commands to run while creating the archive for the final layer in a fakeroot environment. Unlike `extraCommands`, you can run `chown` to change the owners of the files in the archive, changing fakeroot's state instead of the real filesystem. The latter would require privileges that the build user does not have. Static binaries do not interact with the fakeroot environment. By default all files in the archive will be owned by root.
+
+### Behavior of `contents` in the final image {#dockerTools-buildLayeredImage-arg-contents}
+
+Each path directly listed in `contents` will have a symlink in the root of the image.
+
+For example:
+
+```nix
+pkgs.dockerTools.buildLayeredImage {
+  name = "hello";
+  contents = [ pkgs.hello ];
+}
+```
+
+will create symlinks for all the paths in the `hello` package:
+
+```ShellSession
+/bin/hello -> /nix/store/h1zb1padqbbb7jicsvkmrym3r6snphxg-hello-2.10/bin/hello
+/share/info/hello.info -> /nix/store/h1zb1padqbbb7jicsvkmrym3r6snphxg-hello-2.10/share/info/hello.info
+/share/locale/bg/LC_MESSAGES/hello.mo -> /nix/store/h1zb1padqbbb7jicsvkmrym3r6snphxg-hello-2.10/share/locale/bg/LC_MESSAGES/hello.mo
+```
+
+### Automatic inclusion of `config` references {#dockerTools-buildLayeredImage-arg-config}
+
+The closure of `config` is automatically included in the closure of the final image.
+
+This allows you to make very simple Docker images with very little code. This container will start up and run `hello`:
+
+```nix
+pkgs.dockerTools.buildLayeredImage {
+  name = "hello";
+  config.Cmd = [ "${pkgs.hello}/bin/hello" ];
+}
+```
+
+### Adjusting `maxLayers` {#dockerTools-buildLayeredImage-arg-maxLayers}
+
+Increasing the `maxLayers` increases the number of layers which have a chance to be shared between different images.
+
+Modern Docker installations support up to 128 layers, however older versions support as few as 42.
+
+If the produced image will not be extended by other Docker builds, it is safe to set `maxLayers` to `128`. However it will be impossible to extend the image further.
+
+The first (`maxLayers-2`) most "popular" paths will have their own individual layers, then layer \#`maxLayers-1` will contain all the remaining "unpopular" paths, and finally layer \#`maxLayers` will contain the Image configuration.
+
+Docker's Layers are not inherently ordered, they are content-addressable and are not explicitly layered until they are composed in to an Image.
+
+## streamLayeredImage {#ssec-pkgs-dockerTools-streamLayeredImage}
+
+Builds a script which, when run, will stream an uncompressed tarball of a Docker image to stdout. The arguments to this function are as for `buildLayeredImage`. This method of constructing an image does not realize the image into the Nix store, so it saves on IO and disk/cache space, particularly with large images.
+
+The image produced by running the output script can be piped directly into `docker load`, to load it into the local docker daemon:
+
+```ShellSession
+$(nix-build) | docker load
+```
+
+Alternatively, the image be piped via `gzip` into `skopeo`, e.g. to copy it into a registry:
+
+```ShellSession
+$(nix-build) | gzip --fast | skopeo copy docker-archive:/dev/stdin docker://some_docker_registry/myimage:tag
+```
+
+## pullImage {#ssec-pkgs-dockerTools-fetchFromRegistry}
+
+This function is analogous to the `docker pull` command, in that it can be used to pull a Docker image from a Docker registry. By default [Docker Hub](https://hub.docker.com/) is used to pull images.
+
+Its parameters are described in the example below:
+
+```nix
+pullImage {
+  imageName = "nixos/nix";
+  imageDigest =
+    "sha256:20d9485b25ecfd89204e843a962c1bd70e9cc6858d65d7f5fadc340246e2116b";
+  finalImageName = "nix";
+  finalImageTag = "1.11";
+  sha256 = "0mqjy3zq2v6rrhizgb9nvhczl87lcfphq9601wcprdika2jz7qh8";
+  os = "linux";
+  arch = "x86_64";
+}
+```
+
+- `imageName` specifies the name of the image to be downloaded, which can also include the registry namespace (e.g. `nixos`). This argument is required.
+
+- `imageDigest` specifies the digest of the image to be downloaded. This argument is required.
+
+- `finalImageName`, if specified, this is the name of the image to be created. Note it is never used to fetch the image since we prefer to rely on the immutable digest ID. By default it's equal to `imageName`.
+
+- `finalImageTag`, if specified, this is the tag of the image to be created. Note it is never used to fetch the image since we prefer to rely on the immutable digest ID. By default it's `latest`.
+
+- `sha256` is the checksum of the whole fetched image. This argument is required.
+
+- `os`, if specified, is the operating system of the fetched image. By default it's `linux`.
+
+- `arch`, if specified, is the cpu architecture of the fetched image. By default it's `x86_64`.
+
+`nix-prefetch-docker` command can be used to get required image parameters:
+
+```ShellSession
+$ nix run nixpkgs.nix-prefetch-docker -c nix-prefetch-docker --image-name mysql --image-tag 5
+```
+
+Since a given `imageName` may transparently refer to a manifest list of images which support multiple architectures and/or operating systems, you can supply the `--os` and `--arch` arguments to specify exactly which image you want. By default it will match the OS and architecture of the host the command is run on.
+
+```ShellSession
+$ nix-prefetch-docker --image-name mysql --image-tag 5 --arch x86_64 --os linux
+```
+
+Desired image name and tag can be set using `--final-image-name` and `--final-image-tag` arguments:
+
+```ShellSession
+$ nix-prefetch-docker --image-name mysql --image-tag 5 --final-image-name eu.gcr.io/my-project/mysql --final-image-tag prod
+```
+
+## exportImage {#ssec-pkgs-dockerTools-exportImage}
+
+This function is analogous to the `docker export` command, in that it can be used to flatten a Docker image that contains multiple layers. It is in fact the result of the merge of all the layers of the image. As such, the result is suitable for being imported in Docker with `docker import`.
+
+> **_NOTE:_** Using this function requires the `kvm` device to be available.
+
+The parameters of `exportImage` are the following:
+
+```nix
+exportImage {
+  fromImage = someLayeredImage;
+  fromImageName = null;
+  fromImageTag = null;
+
+  name = someLayeredImage.name;
+}
+```
+
+The parameters relative to the base image have the same synopsis as described in [buildImage](#ssec-pkgs-dockerTools-buildImage), except that `fromImage` is the only required argument in this case.
+
+The `name` argument is the name of the derivation output, which defaults to `fromImage.name`.
+
+## shadowSetup {#ssec-pkgs-dockerTools-shadowSetup}
+
+This constant string is a helper for setting up the base files for managing users and groups, only if such files don't exist already. It is suitable for being used in a [`buildImage` `runAsRoot`](#ex-dockerTools-buildImage-runAsRoot) script for cases like in the example below:
+
+```nix
+buildImage {
+  name = "shadow-basic";
+
+  runAsRoot = ''
+    #!${pkgs.runtimeShell}
+    ${shadowSetup}
+    groupadd -r redis
+    useradd -r -g redis redis
+    mkdir /data
+    chown redis:redis /data
+  '';
+}
+```
+
+Creating base files like `/etc/passwd` or `/etc/login.defs` is necessary for shadow-utils to manipulate users and groups.
diff --git a/doc/builders/images/dockertools.xml b/doc/builders/images/dockertools.xml
deleted file mode 100644
index 126698d0a9e..00000000000
--- a/doc/builders/images/dockertools.xml
+++ /dev/null
@@ -1,499 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-pkgs-dockerTools">
- <title>pkgs.dockerTools</title>
-
- <para>
-  <varname>pkgs.dockerTools</varname> is a set of functions for creating and manipulating Docker images according to the <link xlink:href="https://github.com/moby/moby/blob/master/image/spec/v1.2.md#docker-image-specification-v120"> Docker Image Specification v1.2.0 </link>. Docker itself is not used to perform any of the operations done by these functions.
- </para>
-
- <section xml:id="ssec-pkgs-dockerTools-buildImage">
-  <title>buildImage</title>
-
-  <para>
-   This function is analogous to the <command>docker build</command> command, in that it can be used to build a Docker-compatible repository tarball containing a single image with one or multiple layers. As such, the result is suitable for being loaded in Docker with <command>docker load</command>.
-  </para>
-
-  <para>
-   The parameters of <varname>buildImage</varname> with relative example values are described below:
-  </para>
-
-  <example xml:id='ex-dockerTools-buildImage'>
-   <title>Docker build</title>
-<programlisting>
-buildImage {
-  name = "redis"; <co xml:id='ex-dockerTools-buildImage-1' />
-  tag = "latest"; <co xml:id='ex-dockerTools-buildImage-2' />
-
-  fromImage = someBaseImage; <co xml:id='ex-dockerTools-buildImage-3' />
-  fromImageName = null; <co xml:id='ex-dockerTools-buildImage-4' />
-  fromImageTag = "latest"; <co xml:id='ex-dockerTools-buildImage-5' />
-
-  contents = pkgs.redis; <co xml:id='ex-dockerTools-buildImage-6' />
-  runAsRoot = '' <co xml:id='ex-dockerTools-buildImage-runAsRoot' />
-    #!${pkgs.runtimeShell}
-    mkdir -p /data
-  '';
-
-  config = { <co xml:id='ex-dockerTools-buildImage-8' />
-    Cmd = [ "/bin/redis-server" ];
-    WorkingDir = "/data";
-    Volumes = {
-      "/data" = {};
-    };
-  };
-}
-</programlisting>
-  </example>
-
-  <para>
-   The above example will build a Docker image <literal>redis/latest</literal> from the given base image. Loading and running this image in Docker results in <literal>redis-server</literal> being started automatically.
-  </para>
-
-  <calloutlist>
-   <callout arearefs='ex-dockerTools-buildImage-1'>
-    <para>
-     <varname>name</varname> specifies the name of the resulting image. This is the only required argument for <varname>buildImage</varname>.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-buildImage-2'>
-    <para>
-     <varname>tag</varname> specifies the tag of the resulting image. By default it's <literal>null</literal>, which indicates that the nix output hash will be used as tag.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-buildImage-3'>
-    <para>
-     <varname>fromImage</varname> is the repository tarball containing the base image. It must be a valid Docker image, such as exported by <command>docker save</command>. By default it's <literal>null</literal>, which can be seen as equivalent to <literal>FROM scratch</literal> of a <filename>Dockerfile</filename>.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-buildImage-4'>
-    <para>
-     <varname>fromImageName</varname> can be used to further specify the base image within the repository, in case it contains multiple images. By default it's <literal>null</literal>, in which case <varname>buildImage</varname> will peek the first image available in the repository.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-buildImage-5'>
-    <para>
-     <varname>fromImageTag</varname> can be used to further specify the tag of the base image within the repository, in case an image contains multiple tags. By default it's <literal>null</literal>, in which case <varname>buildImage</varname> will peek the first tag available for the base image.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-buildImage-6'>
-    <para>
-     <varname>contents</varname> is a derivation that will be copied in the new layer of the resulting image. This can be similarly seen as <command>ADD contents/ /</command> in a <filename>Dockerfile</filename>. By default it's <literal>null</literal>.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-buildImage-runAsRoot'>
-    <para>
-     <varname>runAsRoot</varname> is a bash script that will run as root in an environment that overlays the existing layers of the base image with the new resulting layer, including the previously copied <varname>contents</varname> derivation. This can be similarly seen as <command>RUN ...</command> in a <filename>Dockerfile</filename>.
-     <note>
-      <para>
-       Using this parameter requires the <literal>kvm</literal> device to be available.
-      </para>
-     </note>
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-buildImage-8'>
-    <para>
-     <varname>config</varname> is used to specify the configuration of the containers that will be started off the built image in Docker. The available options are listed in the <link xlink:href="https://github.com/moby/moby/blob/master/image/spec/v1.2.md#image-json-field-descriptions"> Docker Image Specification v1.2.0 </link>.
-    </para>
-   </callout>
-  </calloutlist>
-
-  <para>
-   After the new layer has been created, its closure (to which <varname>contents</varname>, <varname>config</varname> and <varname>runAsRoot</varname> contribute) will be copied in the layer itself. Only new dependencies that are not already in the existing layers will be copied.
-  </para>
-
-  <para>
-   At the end of the process, only one new single layer will be produced and added to the resulting image.
-  </para>
-
-  <para>
-   The resulting repository will only list the single image <varname>image/tag</varname>. In the case of <xref linkend='ex-dockerTools-buildImage'/> it would be <varname>redis/latest</varname>.
-  </para>
-
-  <para>
-   It is possible to inspect the arguments with which an image was built using its <varname>buildArgs</varname> attribute.
-  </para>
-
-  <note>
-   <para>
-    If you see errors similar to <literal>getProtocolByName: does not exist (no such protocol name: tcp)</literal> you may need to add <literal>pkgs.iana-etc</literal> to <varname>contents</varname>.
-   </para>
-  </note>
-
-  <note>
-   <para>
-    If you see errors similar to <literal>Error_Protocol ("certificate has unknown CA",True,UnknownCa)</literal> you may need to add <literal>pkgs.cacert</literal> to <varname>contents</varname>.
-   </para>
-  </note>
-
-  <example xml:id="example-pkgs-dockerTools-buildImage-creation-date">
-   <title>Impurely Defining a Docker Layer's Creation Date</title>
-   <para>
-    By default <function>buildImage</function> will use a static date of one second past the UNIX Epoch. This allows <function>buildImage</function> to produce binary reproducible images. When listing images with <command>docker images</command>, the newly created images will be listed like this:
-   </para>
-<screen><![CDATA[
-$ docker images
-REPOSITORY   TAG      IMAGE ID       CREATED        SIZE
-hello        latest   08c791c7846e   48 years ago   25.2MB
-]]></screen>
-   <para>
-    You can break binary reproducibility but have a sorted, meaningful <literal>CREATED</literal> column by setting <literal>created</literal> to <literal>now</literal>.
-   </para>
-<programlisting><![CDATA[
-pkgs.dockerTools.buildImage {
-  name = "hello";
-  tag = "latest";
-  created = "now";
-  contents = pkgs.hello;
-
-  config.Cmd = [ "/bin/hello" ];
-}
-]]></programlisting>
-   <para>
-    and now the Docker CLI will display a reasonable date and sort the images as expected:
-<screen><![CDATA[
-$ docker images
-REPOSITORY   TAG      IMAGE ID       CREATED              SIZE
-hello        latest   de2bf4786de6   About a minute ago   25.2MB
-]]></screen>
-    however, the produced images will not be binary reproducible.
-   </para>
-  </example>
- </section>
-
- <section xml:id="ssec-pkgs-dockerTools-buildLayeredImage">
-  <title>buildLayeredImage</title>
-
-  <para>
-   Create a Docker image with many of the store paths being on their own layer to improve sharing between images. The image is realized into the Nix store as a gzipped tarball. Depending on the intended usage, many users might prefer to use <function>streamLayeredImage</function> instead, which this function uses internally.
-  </para>
-
-  <variablelist>
-   <varlistentry>
-    <term>
-     <varname>name</varname>
-    </term>
-    <listitem>
-     <para>
-      The name of the resulting image.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>tag</varname> <emphasis>optional</emphasis>
-    </term>
-    <listitem>
-     <para>
-      Tag of the generated image.
-     </para>
-     <para>
-      <emphasis>Default:</emphasis> the output path's hash
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>contents</varname> <emphasis>optional</emphasis>
-    </term>
-    <listitem>
-     <para>
-      Top level paths in the container. Either a single derivation, or a list of derivations.
-     </para>
-     <para>
-      <emphasis>Default:</emphasis> <literal>[]</literal>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>config</varname> <emphasis>optional</emphasis>
-    </term>
-    <listitem>
-     <para>
-      Run-time configuration of the container. A full list of the options are available at in the <link xlink:href="https://github.com/moby/moby/blob/master/image/spec/v1.2.md#image-json-field-descriptions"> Docker Image Specification v1.2.0 </link>.
-     </para>
-     <para>
-      <emphasis>Default:</emphasis> <literal>{}</literal>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>created</varname> <emphasis>optional</emphasis>
-    </term>
-    <listitem>
-     <para>
-      Date and time the layers were created. Follows the same <literal>now</literal> exception supported by <literal>buildImage</literal>.
-     </para>
-     <para>
-      <emphasis>Default:</emphasis> <literal>1970-01-01T00:00:01Z</literal>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>maxLayers</varname> <emphasis>optional</emphasis>
-    </term>
-    <listitem>
-     <para>
-      Maximum number of layers to create.
-     </para>
-     <para>
-      <emphasis>Default:</emphasis> <literal>100</literal>
-     </para>
-     <para>
-      <emphasis>Maximum:</emphasis> <literal>125</literal>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>extraCommands</varname> <emphasis>optional</emphasis>
-    </term>
-    <listitem>
-     <para>
-      Shell commands to run while building the final layer, without access to most of the layer contents. Changes to this layer are "on top" of all the other layers, so can create additional directories and files.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
-
-  <section xml:id="dockerTools-buildLayeredImage-arg-contents">
-   <title>Behavior of <varname>contents</varname> in the final image</title>
-
-   <para>
-    Each path directly listed in <varname>contents</varname> will have a symlink in the root of the image.
-   </para>
-
-   <para>
-    For example:
-<programlisting><![CDATA[
-pkgs.dockerTools.buildLayeredImage {
-  name = "hello";
-  contents = [ pkgs.hello ];
-}
-]]></programlisting>
-    will create symlinks for all the paths in the <literal>hello</literal> package:
-<screen><![CDATA[
-/bin/hello -> /nix/store/h1zb1padqbbb7jicsvkmrym3r6snphxg-hello-2.10/bin/hello
-/share/info/hello.info -> /nix/store/h1zb1padqbbb7jicsvkmrym3r6snphxg-hello-2.10/share/info/hello.info
-/share/locale/bg/LC_MESSAGES/hello.mo -> /nix/store/h1zb1padqbbb7jicsvkmrym3r6snphxg-hello-2.10/share/locale/bg/LC_MESSAGES/hello.mo
-]]></screen>
-   </para>
-  </section>
-
-  <section xml:id="dockerTools-buildLayeredImage-arg-config">
-   <title>Automatic inclusion of <varname>config</varname> references</title>
-
-   <para>
-    The closure of <varname>config</varname> is automatically included in the closure of the final image.
-   </para>
-
-   <para>
-    This allows you to make very simple Docker images with very little code. This container will start up and run <command>hello</command>:
-<programlisting><![CDATA[
-pkgs.dockerTools.buildLayeredImage {
-  name = "hello";
-  config.Cmd = [ "${pkgs.hello}/bin/hello" ];
-}
-]]></programlisting>
-   </para>
-  </section>
-
-  <section xml:id="dockerTools-buildLayeredImage-arg-maxLayers">
-   <title>Adjusting <varname>maxLayers</varname></title>
-
-   <para>
-    Increasing the <varname>maxLayers</varname> increases the number of layers which have a chance to be shared between different images.
-   </para>
-
-   <para>
-    Modern Docker installations support up to 128 layers, however older versions support as few as 42.
-   </para>
-
-   <para>
-    If the produced image will not be extended by other Docker builds, it is safe to set <varname>maxLayers</varname> to <literal>128</literal>. However it will be impossible to extend the image further.
-   </para>
-
-   <para>
-    The first (<literal>maxLayers-2</literal>) most "popular" paths will have their own individual layers, then layer #<literal>maxLayers-1</literal> will contain all the remaining "unpopular" paths, and finally layer #<literal>maxLayers</literal> will contain the Image configuration.
-   </para>
-
-   <para>
-    Docker's Layers are not inherently ordered, they are content-addressable and are not explicitly layered until they are composed in to an Image.
-   </para>
-  </section>
- </section>
-
- <section xml:id="ssec-pkgs-dockerTools-streamLayeredImage">
-  <title>streamLayeredImage</title>
-
-  <para>
-   Builds a script which, when run, will stream an uncompressed tarball of a Docker image to stdout. The arguments to this function are as for <function>buildLayeredImage</function>. This method of constructing an image does not realize the image into the Nix store, so it saves on IO and disk/cache space, particularly with large images.
-  </para>
-
-  <para>
-    The image produced by running the output script can be piped directly into <command>docker load</command>, to load it into the local docker daemon:
-    <screen><![CDATA[
-$(nix-build) | docker load
-    ]]></screen>
-  </para>
-  <para>
-    Alternatively, the image be piped via <command>gzip</command> into <command>skopeo</command>, e.g. to copy it into a registry:
-    <screen><![CDATA[
-$(nix-build) | gzip --fast | skopeo copy docker-archive:/dev/stdin docker://some_docker_registry/myimage:tag
-    ]]></screen>
-  </para>
- </section>
-
- <section xml:id="ssec-pkgs-dockerTools-fetchFromRegistry">
-  <title>pullImage</title>
-
-  <para>
-   This function is analogous to the <command>docker pull</command> command, in that it can be used to pull a Docker image from a Docker registry. By default <link xlink:href="https://hub.docker.com/">Docker Hub</link> is used to pull images.
-  </para>
-
-  <para>
-   Its parameters are described in the example below:
-  </para>
-
-  <example xml:id='ex-dockerTools-pullImage'>
-   <title>Docker pull</title>
-<programlisting>
-pullImage {
-  imageName = "nixos/nix"; <co xml:id='ex-dockerTools-pullImage-1' />
-  imageDigest = "sha256:20d9485b25ecfd89204e843a962c1bd70e9cc6858d65d7f5fadc340246e2116b"; <co xml:id='ex-dockerTools-pullImage-2' />
-  finalImageName = "nix"; <co xml:id='ex-dockerTools-pullImage-3' />
-  finalImageTag = "1.11";  <co xml:id='ex-dockerTools-pullImage-4' />
-  sha256 = "0mqjy3zq2v6rrhizgb9nvhczl87lcfphq9601wcprdika2jz7qh8"; <co xml:id='ex-dockerTools-pullImage-5' />
-  os = "linux"; <co xml:id='ex-dockerTools-pullImage-6' />
-  arch = "x86_64"; <co xml:id='ex-dockerTools-pullImage-7' />
-}
-</programlisting>
-  </example>
-
-  <calloutlist>
-   <callout arearefs='ex-dockerTools-pullImage-1'>
-    <para>
-     <varname>imageName</varname> specifies the name of the image to be downloaded, which can also include the registry namespace (e.g. <literal>nixos</literal>). This argument is required.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-pullImage-2'>
-    <para>
-     <varname>imageDigest</varname> specifies the digest of the image to be downloaded. This argument is required.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-pullImage-3'>
-    <para>
-     <varname>finalImageName</varname>, if specified, this is the name of the image to be created. Note it is never used to fetch the image since we prefer to rely on the immutable digest ID. By default it's equal to <varname>imageName</varname>.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-pullImage-4'>
-    <para>
-     <varname>finalImageTag</varname>, if specified, this is the tag of the image to be created. Note it is never used to fetch the image since we prefer to rely on the immutable digest ID. By default it's <literal>latest</literal>.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-pullImage-5'>
-    <para>
-     <varname>sha256</varname> is the checksum of the whole fetched image. This argument is required.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-pullImage-6'>
-    <para>
-     <varname>os</varname>, if specified, is the operating system of the fetched image. By default it's <literal>linux</literal>.
-    </para>
-   </callout>
-   <callout arearefs='ex-dockerTools-pullImage-7'>
-    <para>
-     <varname>arch</varname>, if specified, is the cpu architecture of the fetched image. By default it's <literal>x86_64</literal>.
-    </para>
-   </callout>
-  </calloutlist>
-
-  <para>
-   <literal>nix-prefetch-docker</literal> command can be used to get required image parameters:
-<screen>
-<prompt>$ </prompt>nix run nixpkgs.nix-prefetch-docker -c nix-prefetch-docker --image-name mysql --image-tag 5
-</screen>
-   Since a given <varname>imageName</varname> may transparently refer to a manifest list of images which support multiple architectures and/or operating systems, you can supply the <option>--os</option> and <option>--arch</option> arguments to specify exactly which image you want. By default it will match the OS and architecture of the host the command is run on.
-<screen>
-<prompt>$ </prompt>nix-prefetch-docker --image-name mysql --image-tag 5 --arch x86_64 --os linux
-</screen>
-   Desired image name and tag can be set using <option>--final-image-name</option> and <option>--final-image-tag</option> arguments:
-<screen>
-<prompt>$ </prompt>nix-prefetch-docker --image-name mysql --image-tag 5 --final-image-name eu.gcr.io/my-project/mysql --final-image-tag prod
-</screen>
-  </para>
- </section>
-
- <section xml:id="ssec-pkgs-dockerTools-exportImage">
-  <title>exportImage</title>
-
-  <para>
-   This function is analogous to the <command>docker export</command> command, in that it can be used to flatten a Docker image that contains multiple layers. It is in fact the result of the merge of all the layers of the image. As such, the result is suitable for being imported in Docker with <command>docker import</command>.
-  </para>
-
-  <note>
-   <para>
-    Using this function requires the <literal>kvm</literal> device to be available.
-   </para>
-  </note>
-
-  <para>
-   The parameters of <varname>exportImage</varname> are the following:
-  </para>
-
-  <example xml:id='ex-dockerTools-exportImage'>
-   <title>Docker export</title>
-<programlisting>
-exportImage {
-  fromImage = someLayeredImage;
-  fromImageName = null;
-  fromImageTag = null;
-
-  name = someLayeredImage.name;
-}
-</programlisting>
-  </example>
-
-  <para>
-   The parameters relative to the base image have the same synopsis as described in <xref linkend='ssec-pkgs-dockerTools-buildImage'/>, except that <varname>fromImage</varname> is the only required argument in this case.
-  </para>
-
-  <para>
-   The <varname>name</varname> argument is the name of the derivation output, which defaults to <varname>fromImage.name</varname>.
-  </para>
- </section>
-
- <section xml:id="ssec-pkgs-dockerTools-shadowSetup">
-  <title>shadowSetup</title>
-
-  <para>
-   This constant string is a helper for setting up the base files for managing users and groups, only if such files don't exist already. It is suitable for being used in a <varname>runAsRoot</varname> <xref linkend='ex-dockerTools-buildImage-runAsRoot'/> script for cases like in the example below:
-  </para>
-
-  <example xml:id='ex-dockerTools-shadowSetup'>
-   <title>Shadow base files</title>
-<programlisting>
-buildImage {
-  name = "shadow-basic";
-
-  runAsRoot = ''
-    #!${pkgs.runtimeShell}
-    ${shadowSetup}
-    groupadd -r redis
-    useradd -r -g redis redis
-    mkdir /data
-    chown redis:redis /data
-  '';
-}
-</programlisting>
-  </example>
-
-  <para>
-   Creating base files like <literal>/etc/passwd</literal> or <literal>/etc/login.defs</literal> is necessary for shadow-utils to manipulate users and groups.
-  </para>
- </section>
-</section>
diff --git a/doc/builders/images/ocitools.section.md b/doc/builders/images/ocitools.section.md
new file mode 100644
index 00000000000..d3dee57ebac
--- /dev/null
+++ b/doc/builders/images/ocitools.section.md
@@ -0,0 +1,37 @@
+# pkgs.ociTools {#sec-pkgs-ociTools}
+
+`pkgs.ociTools` is a set of functions for creating containers according to the [OCI container specification v1.0.0](https://github.com/opencontainers/runtime-spec). Beyond that it makes no assumptions about the container runner you choose to use to run the created container.
+
+## buildContainer {#ssec-pkgs-ociTools-buildContainer}
+
+This function creates a simple OCI container that runs a single command inside of it. An OCI container consists of a `config.json` and a rootfs directory.The nix store of the container will contain all referenced dependencies of the given command.
+
+The parameters of `buildContainer` with an example value are described below:
+
+```nix
+buildContainer {
+  args = [
+    (with pkgs;
+      writeScript "run.sh" ''
+        #!${bash}/bin/bash
+        exec ${bash}/bin/bash
+      '').outPath
+  ];
+
+  mounts = {
+    "/data" = {
+      type = "none";
+      source = "/var/lib/mydata";
+      options = [ "bind" ];
+    };
+  };
+
+  readonly = false;
+}
+```
+
+- `args` specifies a set of arguments to run inside the container. This is the only required argument for `buildContainer`. All referenced packages inside the derivation will be made available inside the container
+
+- `mounts` specifies additional mount points chosen by the user. By default only a minimal set of necessary filesystems are mounted into the container (e.g procfs, cgroupfs)
+
+- `readonly` makes the container\'s rootfs read-only if it is set to true. The default value is false `false`.
diff --git a/doc/builders/images/ocitools.xml b/doc/builders/images/ocitools.xml
deleted file mode 100644
index e8cd3472f54..00000000000
--- a/doc/builders/images/ocitools.xml
+++ /dev/null
@@ -1,62 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-pkgs-ociTools">
- <title>pkgs.ociTools</title>
-
- <para>
-  <varname>pkgs.ociTools</varname> is a set of functions for creating containers according to the <link xlink:href="https://github.com/opencontainers/runtime-spec">OCI container specification v1.0.0</link>. Beyond that it makes no assumptions about the container runner you choose to use to run the created container.
- </para>
-
- <section xml:id="ssec-pkgs-ociTools-buildContainer">
-  <title>buildContainer</title>
-
-  <para>
-   This function creates a simple OCI container that runs a single command inside of it. An OCI container consists of a <varname>config.json</varname> and a rootfs directory.The nix store of the container will contain all referenced dependencies of the given command.
-  </para>
-
-  <para>
-   The parameters of <varname>buildContainer</varname> with an example value are described below:
-  </para>
-
-  <example xml:id='ex-ociTools-buildContainer'>
-   <title>Build Container</title>
-<programlisting>
-buildContainer {
-  args = [ (with pkgs; writeScript "run.sh" ''
-    #!${bash}/bin/bash
-    exec ${bash}/bin/bash
-  '').outPath ]; <co xml:id='ex-ociTools-buildContainer-1' />
-
-  mounts = {
-    "/data" = {
-      type = "none";
-      source = "/var/lib/mydata";
-      options = [ "bind" ];
-    };
-  };<co xml:id='ex-ociTools-buildContainer-2' />
-
-  readonly = false; <co xml:id='ex-ociTools-buildContainer-3' />
-}
-
-    </programlisting>
-   <calloutlist>
-    <callout arearefs='ex-ociTools-buildContainer-1'>
-     <para>
-      <varname>args</varname> specifies a set of arguments to run inside the container. This is the only required argument for <varname>buildContainer</varname>. All referenced packages inside the derivation will be made available inside the container
-     </para>
-    </callout>
-    <callout arearefs='ex-ociTools-buildContainer-2'>
-     <para>
-      <varname>mounts</varname> specifies additional mount points chosen by the user. By default only a minimal set of necessary filesystems are mounted into the container (e.g procfs, cgroupfs)
-     </para>
-    </callout>
-    <callout arearefs='ex-ociTools-buildContainer-3'>
-     <para>
-      <varname>readonly</varname> makes the container's rootfs read-only if it is set to true. The default value is false <literal>false</literal>.
-     </para>
-    </callout>
-   </calloutlist>
-  </example>
- </section>
-</section>
diff --git a/doc/builders/images/snap/example-firefox.nix b/doc/builders/images/snap/example-firefox.nix
deleted file mode 100644
index d58c98a65a2..00000000000
--- a/doc/builders/images/snap/example-firefox.nix
+++ /dev/null
@@ -1,28 +0,0 @@
-let
-  inherit (import <nixpkgs> { }) snapTools firefox;
-in snapTools.makeSnap {
-  meta = {
-    name = "nix-example-firefox";
-    summary = firefox.meta.description;
-    architectures = [ "amd64" ];
-    apps.nix-example-firefox = {
-      command = "${firefox}/bin/firefox";
-      plugs = [
-        "pulseaudio"
-        "camera"
-        "browser-support"
-        "avahi-observe"
-        "cups-control"
-        "desktop"
-        "desktop-legacy"
-        "gsettings"
-        "home"
-        "network"
-        "mount-observe"
-        "removable-media"
-        "x11"
-      ];
-    };
-    confinement = "strict";
-  };
-}
diff --git a/doc/builders/images/snap/example-hello.nix b/doc/builders/images/snap/example-hello.nix
deleted file mode 100644
index 123da80c547..00000000000
--- a/doc/builders/images/snap/example-hello.nix
+++ /dev/null
@@ -1,12 +0,0 @@
-let
-  inherit (import <nixpkgs> { }) snapTools hello;
-in snapTools.makeSnap {
-  meta = {
-    name = "hello";
-    summary = hello.meta.description;
-    description = hello.meta.longDescription;
-    architectures = [ "amd64" ];
-    confinement = "strict";
-    apps.hello.command = "${hello}/bin/hello";
-  };
-}
diff --git a/doc/builders/images/snaptools.section.md b/doc/builders/images/snaptools.section.md
new file mode 100644
index 00000000000..5f710d2de7f
--- /dev/null
+++ b/doc/builders/images/snaptools.section.md
@@ -0,0 +1,71 @@
+# pkgs.snapTools {#sec-pkgs-snapTools}
+
+`pkgs.snapTools` is a set of functions for creating Snapcraft images. Snap and Snapcraft is not used to perform these operations.
+
+## The makeSnap Function {#ssec-pkgs-snapTools-makeSnap-signature}
+
+`makeSnap` takes a single named argument, `meta`. This argument mirrors [the upstream `snap.yaml` format](https://docs.snapcraft.io/snap-format) exactly.
+
+The `base` should not be specified, as `makeSnap` will force set it.
+
+Currently, `makeSnap` does not support creating GUI stubs.
+
+## Build a Hello World Snap {#ssec-pkgs-snapTools-build-a-snap-hello}
+
+The following expression packages GNU Hello as a Snapcraft snap.
+
+``` {#ex-snapTools-buildSnap-hello .nix}
+let
+  inherit (import <nixpkgs> { }) snapTools hello;
+in snapTools.makeSnap {
+  meta = {
+    name = "hello";
+    summary = hello.meta.description;
+    description = hello.meta.longDescription;
+    architectures = [ "amd64" ];
+    confinement = "strict";
+    apps.hello.command = "${hello}/bin/hello";
+  };
+}
+```
+
+`nix-build` this expression and install it with `snap install ./result --dangerous`. `hello` will now be the Snapcraft version of the package.
+
+## Build a Graphical Snap {#ssec-pkgs-snapTools-build-a-snap-firefox}
+
+Graphical programs require many more integrations with the host. This example uses Firefox as an example, because it is one of the most complicated programs we could package.
+
+``` {#ex-snapTools-buildSnap-firefox .nix}
+let
+  inherit (import <nixpkgs> { }) snapTools firefox;
+in snapTools.makeSnap {
+  meta = {
+    name = "nix-example-firefox";
+    summary = firefox.meta.description;
+    architectures = [ "amd64" ];
+    apps.nix-example-firefox = {
+      command = "${firefox}/bin/firefox";
+      plugs = [
+        "pulseaudio"
+        "camera"
+        "browser-support"
+        "avahi-observe"
+        "cups-control"
+        "desktop"
+        "desktop-legacy"
+        "gsettings"
+        "home"
+        "network"
+        "mount-observe"
+        "removable-media"
+        "x11"
+      ];
+    };
+    confinement = "strict";
+  };
+}
+```
+
+`nix-build` this expression and install it with `snap install ./result --dangerous`. `nix-example-firefox` will now be the Snapcraft version of the Firefox package.
+
+The specific meaning behind plugs can be looked up in the [Snapcraft interface documentation](https://docs.snapcraft.io/supported-interfaces).
diff --git a/doc/builders/images/snaptools.xml b/doc/builders/images/snaptools.xml
deleted file mode 100644
index 422fcfa37d8..00000000000
--- a/doc/builders/images/snaptools.xml
+++ /dev/null
@@ -1,59 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-pkgs-snapTools">
- <title>pkgs.snapTools</title>
-
- <para>
-  <varname>pkgs.snapTools</varname> is a set of functions for creating Snapcraft images. Snap and Snapcraft is not used to perform these operations.
- </para>
-
- <section xml:id="ssec-pkgs-snapTools-makeSnap-signature">
-  <title>The makeSnap Function</title>
-
-  <para>
-   <function>makeSnap</function> takes a single named argument, <parameter>meta</parameter>. This argument mirrors <link xlink:href="https://docs.snapcraft.io/snap-format">the upstream <filename>snap.yaml</filename> format</link> exactly.
-  </para>
-
-  <para>
-   The <parameter>base</parameter> should not be be specified, as <function>makeSnap</function> will force set it.
-  </para>
-
-  <para>
-   Currently, <function>makeSnap</function> does not support creating GUI stubs.
-  </para>
- </section>
-
- <section xml:id="ssec-pkgs-snapTools-build-a-snap-hello">
-  <title>Build a Hello World Snap</title>
-
-  <example xml:id="ex-snapTools-buildSnap-hello">
-   <title>Making a Hello World Snap</title>
-   <para>
-    The following expression packages GNU Hello as a Snapcraft snap.
-   </para>
-<programlisting><xi:include href="./snap/example-hello.nix" parse="text" /></programlisting>
-   <para>
-    <command>nix-build</command> this expression and install it with <command>snap install ./result --dangerous</command>. <command>hello</command> will now be the Snapcraft version of the package.
-   </para>
-  </example>
- </section>
-
- <section xml:id="ssec-pkgs-snapTools-build-a-snap-firefox">
-  <title>Build a Hello World Snap</title>
-
-  <example xml:id="ex-snapTools-buildSnap-firefox">
-   <title>Making a Graphical Snap</title>
-   <para>
-    Graphical programs require many more integrations with the host. This example uses Firefox as an example, because it is one of the most complicated programs we could package.
-   </para>
-<programlisting><xi:include href="./snap/example-firefox.nix" parse="text" /></programlisting>
-   <para>
-    <command>nix-build</command> this expression and install it with <command>snap install ./result --dangerous</command>. <command>nix-example-firefox</command> will now be the Snapcraft version of the Firefox package.
-   </para>
-   <para>
-    The specific meaning behind plugs can be looked up in the <link xlink:href="https://docs.snapcraft.io/supported-interfaces">Snapcraft interface documentation</link>.
-   </para>
-  </example>
- </section>
-</section>
diff --git a/doc/builders/packages/cataclysm-dda.section.md b/doc/builders/packages/cataclysm-dda.section.md
index ae2ee56a010..bfeacb47fef 100644
--- a/doc/builders/packages/cataclysm-dda.section.md
+++ b/doc/builders/packages/cataclysm-dda.section.md
@@ -1,6 +1,6 @@
-# Cataclysm: Dark Days Ahead
+# Cataclysm: Dark Days Ahead {#cataclysm-dark-days-ahead}
 
-## How to install Cataclysm DDA
+## How to install Cataclysm DDA {#how-to-install-cataclysm-dda}
 
 To install the latest stable release of Cataclysm DDA to your profile, execute
 `nix-env -f "<nixpkgs>" -iA cataclysm-dda`. For the curses build (build
@@ -34,7 +34,42 @@ cataclysm-dda.override {
 }
 ```
 
-## Customizing with mods
+## Important note for overriding packages {#important-note-for-overriding-packages}
+
+After applying `overrideAttrs`, you need to fix `passthru.pkgs` and
+`passthru.withMods` attributes either manually or by using `attachPkgs`:
+
+```nix
+let
+  # You enabled parallel building.
+  myCDDA = cataclysm-dda-git.overrideAttrs (_: {
+    enableParallelBuilding = true;
+  });
+
+  # Unfortunately, this refers to the package before overriding and
+  # parallel building is still disabled.
+  badExample = myCDDA.withMods (_: []);
+
+  inherit (cataclysmDDA) attachPkgs pkgs wrapCDDA;
+
+  # You can fix it by hand
+  goodExample1 = myCDDA.overrideAttrs (old: {
+    passthru = old.passthru // {
+      pkgs = pkgs.override { build = goodExample1; };
+      withMods = wrapCDDA goodExample1;
+    };
+  });
+
+  # or by using a helper function `attachPkgs`.
+  goodExample2 = attachPkgs pkgs myCDDA;
+in
+
+# badExample                     # parallel building disabled
+# goodExample1.withMods (_: [])  # parallel building enabled
+goodExample2.withMods (_: [])    # parallel building enabled
+```
+
+## Customizing with mods {#customizing-with-mods}
 
 To install Cataclysm DDA with mods of your choice, you can use `withMods`
 attribute:
diff --git a/doc/builders/packages/citrix.section.md b/doc/builders/packages/citrix.section.md
new file mode 100644
index 00000000000..b25ecb0bdef
--- /dev/null
+++ b/doc/builders/packages/citrix.section.md
@@ -0,0 +1,32 @@
+# Citrix Workspace {#sec-citrix}
+
+The [Citrix Workspace App](https://www.citrix.com/products/workspace-app/) is a remote desktop viewer which provides access to [XenDesktop](https://www.citrix.com/products/xenapp-xendesktop/) installations.
+
+## Basic usage {#sec-citrix-base}
+
+The tarball archive needs to be downloaded manually as the license agreements of the vendor for [Citrix Workspace](https://www.citrix.de/downloads/workspace-app/linux/workspace-app-for-linux-latest.html) needs to be accepted first. Then run `nix-prefetch-url file://$PWD/linuxx64-$version.tar.gz`. With the archive available in the store the package can be built and installed with Nix.
+
+## Citrix Selfservice {#sec-citrix-selfservice}
+
+The [selfservice](https://support.citrix.com/article/CTX200337) is an application managing Citrix desktops and applications. Please note that this feature only works with at least citrix_workspace_20_06_0 and later versions.
+
+In order to set this up, you first have to [download the `.cr` file from the Netscaler Gateway](https://its.uiowa.edu/support/article/102186). After that you can configure the `selfservice` like this:
+
+```ShellSession
+$ storebrowse -C ~/Downloads/receiverconfig.cr
+$ selfservice
+```
+
+## Custom certificates {#sec-citrix-custom-certs}
+
+The `Citrix Workspace App` in `nixpkgs` trusts several certificates [from the Mozilla database](https://curl.haxx.se/docs/caextract.html) by default. However several companies using Citrix might require their own corporate certificate. On distros with imperative packaging these certs can be stored easily in [`$ICAROOT`](https://developer-docs.citrix.com/projects/receiver-for-linux-command-reference/en/13.7/), however this directory is a store path in `nixpkgs`. In order to work around this issue the package provides a simple mechanism to add custom certificates without rebuilding the entire package using `symlinkJoin`:
+
+```nix
+with import <nixpkgs> { config.allowUnfree = true; };
+let
+  extraCerts = [
+    ./custom-cert-1.pem
+    ./custom-cert-2.pem # ...
+  ];
+in citrix_workspace.override { inherit extraCerts; }
+```
diff --git a/doc/builders/packages/citrix.xml b/doc/builders/packages/citrix.xml
deleted file mode 100644
index 16f1bc6f8f2..00000000000
--- a/doc/builders/packages/citrix.xml
+++ /dev/null
@@ -1,46 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-citrix">
- <title>Citrix Workspace</title>
-
- <para>
-  The <link xlink:href="https://www.citrix.com/products/workspace-app/">Citrix Workspace App</link> is a remote desktop viewer which provides access to <link xlink:href="https://www.citrix.com/products/xenapp-xendesktop/">XenDesktop</link> installations.
- </para>
-
- <section xml:id="sec-citrix-base">
-  <title>Basic usage</title>
-
-  <para>
-   The tarball archive needs to be downloaded manually as the license agreements of the vendor for <link xlink:href="https://www.citrix.de/downloads/workspace-app/linux/workspace-app-for-linux-latest.html">Citrix Workspace</link> needs to be accepted first. Then run <command>nix-prefetch-url file://$PWD/linuxx64-$version.tar.gz</command>. With the archive available in the store the package can be built and installed with Nix.
-  </para>
- </section>
-
- <section xml:id="sec-citrix-selfservice">
-  <title>Citrix Selfservice</title>
-  <para>
-   The <link xlink:href="https://support.citrix.com/article/CTX200337">selfservice</link> is an application managing Citrix desktops and applications. Please note that this feature only works with at least <package>citrix_workspace_20_06_0</package> and later versions.
-  </para>
-  <para>
-   In order to set this up, you first have to <link xlink:href="https://its.uiowa.edu/support/article/102186">download the <literal>.cr</literal> file from the Netscaler Gateway</link>. After that you can configure the <command>selfservice</command> like this:
-   <screen>
-    <prompt>$ </prompt>storebrowse -C ~/Downloads/receiverconfig.cr
-    <prompt>$ </prompt>selfservice
-   </screen>
-  </para>
- </section>
-
- <section xml:id="sec-citrix-custom-certs">
-  <title>Custom certificates</title>
-
-  <para>
-   The <literal>Citrix Workspace App</literal> in <literal>nixpkgs</literal> trusts several certificates <link xlink:href="https://curl.haxx.se/docs/caextract.html">from the Mozilla database</link> by default. However several companies using Citrix might require their own corporate certificate. On distros with imperative packaging these certs can be stored easily in <link xlink:href="https://developer-docs.citrix.com/projects/receiver-for-linux-command-reference/en/13.7/"><literal>$ICAROOT</literal></link>, however this directory is a store path in <literal>nixpkgs</literal>. In order to work around this issue the package provides a simple mechanism to add custom certificates without rebuilding the entire package using <literal>symlinkJoin</literal>:
-<programlisting>
-<![CDATA[with import <nixpkgs> { config.allowUnfree = true; };
-let extraCerts = [ ./custom-cert-1.pem ./custom-cert-2.pem /* ... */ ]; in
-citrix_workspace.override {
-  inherit extraCerts;
-}]]>
-</programlisting>
-  </para>
- </section>
-</section>
diff --git a/doc/builders/packages/dlib.section.md b/doc/builders/packages/dlib.section.md
new file mode 100644
index 00000000000..8f0aa861018
--- /dev/null
+++ b/doc/builders/packages/dlib.section.md
@@ -0,0 +1,13 @@
+# DLib {#dlib}
+
+[DLib](http://dlib.net/) is a modern, C++-based toolkit which provides several machine learning algorithms.
+
+## Compiling without AVX support {#compiling-without-avx-support}
+
+Especially older CPUs don\'t support [AVX](https://en.wikipedia.org/wiki/Advanced_Vector_Extensions) (Advanced Vector Extensions) instructions that are used by DLib to optimize their algorithms.
+
+On the affected hardware errors like `Illegal instruction` will occur. In those cases AVX support needs to be disabled:
+
+```nix
+self: super: { dlib = super.dlib.override { avxSupport = false; }; }
+```
diff --git a/doc/builders/packages/dlib.xml b/doc/builders/packages/dlib.xml
deleted file mode 100644
index 5f768dd51b6..00000000000
--- a/doc/builders/packages/dlib.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="dlib">
- <title>DLib</title>
-
- <para>
-  <link xlink:href="http://dlib.net/">DLib</link> is a modern, C++-based toolkit which provides several machine learning algorithms.
- </para>
-
- <section xml:id="compiling-without-avx-support">
-  <title>Compiling without AVX support</title>
-
-  <para>
-   Especially older CPUs don't support <link xlink:href="https://en.wikipedia.org/wiki/Advanced_Vector_Extensions">AVX</link> (<abbrev>Advanced Vector Extensions</abbrev>) instructions that are used by DLib to optimize their algorithms.
-  </para>
-
-  <para>
-   On the affected hardware errors like <literal>Illegal instruction</literal> will occur. In those cases AVX support needs to be disabled:
-<programlisting>self: super: {
-  dlib = super.dlib.override { avxSupport = false; };
-}</programlisting>
-  </para>
- </section>
-</section>
diff --git a/doc/builders/packages/eclipse.section.md b/doc/builders/packages/eclipse.section.md
new file mode 100644
index 00000000000..faabb188450
--- /dev/null
+++ b/doc/builders/packages/eclipse.section.md
@@ -0,0 +1,64 @@
+# Eclipse {#sec-eclipse}
+
+The Nix expressions related to the Eclipse platform and IDE are in [`pkgs/applications/editors/eclipse`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/eclipse).
+
+Nixpkgs provides a number of packages that will install Eclipse in its various forms. These range from the bare-bones Eclipse Platform to the more fully featured Eclipse SDK or Scala-IDE packages and multiple version are often available. It is possible to list available Eclipse packages by issuing the command:
+
+```ShellSession
+$ nix-env -f '<nixpkgs>' -qaP -A eclipses --description
+```
+
+Once an Eclipse variant is installed it can be run using the `eclipse` command, as expected. From within Eclipse it is then possible to install plugins in the usual manner by either manually specifying an Eclipse update site or by installing the Marketplace Client plugin and using it to discover and install other plugins. This installation method provides an Eclipse installation that closely resemble a manually installed Eclipse.
+
+If you prefer to install plugins in a more declarative manner then Nixpkgs also offer a number of Eclipse plugins that can be installed in an _Eclipse environment_. This type of environment is created using the function `eclipseWithPlugins` found inside the `nixpkgs.eclipses` attribute set. This function takes as argument `{ eclipse, plugins ? [], jvmArgs ? [] }` where `eclipse` is a one of the Eclipse packages described above, `plugins` is a list of plugin derivations, and `jvmArgs` is a list of arguments given to the JVM running the Eclipse. For example, say you wish to install the latest Eclipse Platform with the popular Eclipse Color Theme plugin and also allow Eclipse to use more RAM. You could then add
+
+```nix
+packageOverrides = pkgs: {
+  myEclipse = with pkgs.eclipses; eclipseWithPlugins {
+    eclipse = eclipse-platform;
+    jvmArgs = [ "-Xmx2048m" ];
+    plugins = [ plugins.color-theme ];
+  };
+}
+```
+
+to your Nixpkgs configuration (`~/.config/nixpkgs/config.nix`) and install it by running `nix-env -f '<nixpkgs>' -iA myEclipse` and afterward run Eclipse as usual. It is possible to find out which plugins are available for installation using `eclipseWithPlugins` by running
+
+```ShellSession
+$ nix-env -f '<nixpkgs>' -qaP -A eclipses.plugins --description
+```
+
+If there is a need to install plugins that are not available in Nixpkgs then it may be possible to define these plugins outside Nixpkgs using the `buildEclipseUpdateSite` and `buildEclipsePlugin` functions found in the `nixpkgs.eclipses.plugins` attribute set. Use the `buildEclipseUpdateSite` function to install a plugin distributed as an Eclipse update site. This function takes `{ name, src }` as argument where `src` indicates the Eclipse update site archive. All Eclipse features and plugins within the downloaded update site will be installed. When an update site archive is not available then the `buildEclipsePlugin` function can be used to install a plugin that consists of a pair of feature and plugin JARs. This function takes an argument `{ name, srcFeature, srcPlugin }` where `srcFeature` and `srcPlugin` are the feature and plugin JARs, respectively.
+
+Expanding the previous example with two plugins using the above functions we have
+
+```nix
+packageOverrides = pkgs: {
+  myEclipse = with pkgs.eclipses; eclipseWithPlugins {
+    eclipse = eclipse-platform;
+    jvmArgs = [ "-Xmx2048m" ];
+    plugins = [
+      plugins.color-theme
+      (plugins.buildEclipsePlugin {
+        name = "myplugin1-1.0";
+        srcFeature = fetchurl {
+          url = "http://…/features/myplugin1.jar";
+          sha256 = "123…";
+        };
+        srcPlugin = fetchurl {
+          url = "http://…/plugins/myplugin1.jar";
+          sha256 = "123…";
+        };
+      });
+      (plugins.buildEclipseUpdateSite {
+        name = "myplugin2-1.0";
+        src = fetchurl {
+          stripRoot = false;
+          url = "http://…/myplugin2.zip";
+          sha256 = "123…";
+        };
+      });
+    ];
+  };
+}
+```
diff --git a/doc/builders/packages/eclipse.xml b/doc/builders/packages/eclipse.xml
deleted file mode 100644
index fc5094ed8f3..00000000000
--- a/doc/builders/packages/eclipse.xml
+++ /dev/null
@@ -1,72 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-eclipse">
- <title>Eclipse</title>
-
- <para>
-  The Nix expressions related to the Eclipse platform and IDE are in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/eclipse"><filename>pkgs/applications/editors/eclipse</filename></link>.
- </para>
-
- <para>
-  Nixpkgs provides a number of packages that will install Eclipse in its various forms. These range from the bare-bones Eclipse Platform to the more fully featured Eclipse SDK or Scala-IDE packages and multiple version are often available. It is possible to list available Eclipse packages by issuing the command:
-<screen>
-<prompt>$ </prompt>nix-env -f '&lt;nixpkgs&gt;' -qaP -A eclipses --description
-</screen>
-  Once an Eclipse variant is installed it can be run using the <command>eclipse</command> command, as expected. From within Eclipse it is then possible to install plugins in the usual manner by either manually specifying an Eclipse update site or by installing the Marketplace Client plugin and using it to discover and install other plugins. This installation method provides an Eclipse installation that closely resemble a manually installed Eclipse.
- </para>
-
- <para>
-  If you prefer to install plugins in a more declarative manner then Nixpkgs also offer a number of Eclipse plugins that can be installed in an <emphasis>Eclipse environment</emphasis>. This type of environment is created using the function <varname>eclipseWithPlugins</varname> found inside the <varname>nixpkgs.eclipses</varname> attribute set. This function takes as argument <literal>{ eclipse, plugins ? [], jvmArgs ? [] }</literal> where <varname>eclipse</varname> is a one of the Eclipse packages described above, <varname>plugins</varname> is a list of plugin derivations, and <varname>jvmArgs</varname> is a list of arguments given to the JVM running the Eclipse. For example, say you wish to install the latest Eclipse Platform with the popular Eclipse Color Theme plugin and also allow Eclipse to use more RAM. You could then add
-<screen>
-packageOverrides = pkgs: {
-  myEclipse = with pkgs.eclipses; eclipseWithPlugins {
-    eclipse = eclipse-platform;
-    jvmArgs = [ "-Xmx2048m" ];
-    plugins = [ plugins.color-theme ];
-  };
-}
-</screen>
-  to your Nixpkgs configuration (<filename>~/.config/nixpkgs/config.nix</filename>) and install it by running <command>nix-env -f '&lt;nixpkgs&gt;' -iA myEclipse</command> and afterward run Eclipse as usual. It is possible to find out which plugins are available for installation using <varname>eclipseWithPlugins</varname> by running
-<screen>
-<prompt>$ </prompt>nix-env -f '&lt;nixpkgs&gt;' -qaP -A eclipses.plugins --description
-</screen>
- </para>
-
- <para>
-  If there is a need to install plugins that are not available in Nixpkgs then it may be possible to define these plugins outside Nixpkgs using the <varname>buildEclipseUpdateSite</varname> and <varname>buildEclipsePlugin</varname> functions found in the <varname>nixpkgs.eclipses.plugins</varname> attribute set. Use the <varname>buildEclipseUpdateSite</varname> function to install a plugin distributed as an Eclipse update site. This function takes <literal>{ name, src }</literal> as argument where <literal>src</literal> indicates the Eclipse update site archive. All Eclipse features and plugins within the downloaded update site will be installed. When an update site archive is not available then the <varname>buildEclipsePlugin</varname> function can be used to install a plugin that consists of a pair of feature and plugin JARs. This function takes an argument <literal>{ name, srcFeature, srcPlugin }</literal> where <literal>srcFeature</literal> and <literal>srcPlugin</literal> are the feature and plugin JARs, respectively.
- </para>
-
- <para>
-  Expanding the previous example with two plugins using the above functions we have
-<screen>
-packageOverrides = pkgs: {
-  myEclipse = with pkgs.eclipses; eclipseWithPlugins {
-    eclipse = eclipse-platform;
-    jvmArgs = [ "-Xmx2048m" ];
-    plugins = [
-      plugins.color-theme
-      (plugins.buildEclipsePlugin {
-        name = "myplugin1-1.0";
-        srcFeature = fetchurl {
-          url = "http://…/features/myplugin1.jar";
-          sha256 = "123…";
-        };
-        srcPlugin = fetchurl {
-          url = "http://…/plugins/myplugin1.jar";
-          sha256 = "123…";
-        };
-      });
-      (plugins.buildEclipseUpdateSite {
-        name = "myplugin2-1.0";
-        src = fetchurl {
-          stripRoot = false;
-          url = "http://…/myplugin2.zip";
-          sha256 = "123…";
-        };
-      });
-    ];
-  };
-}
-</screen>
- </para>
-</section>
diff --git a/doc/builders/packages/elm.section.md b/doc/builders/packages/elm.section.md
new file mode 100644
index 00000000000..ae223c802da
--- /dev/null
+++ b/doc/builders/packages/elm.section.md
@@ -0,0 +1,11 @@
+# Elm {#sec-elm}
+
+To start a development environment do
+
+```ShellSession
+nix-shell -p elmPackages.elm elmPackages.elm-format
+```
+
+To update the Elm compiler, see `nixpkgs/pkgs/development/compilers/elm/README.md`.
+
+To package Elm applications, [read about elm2nix](https://github.com/hercules-ci/elm2nix#elm2nix).
diff --git a/doc/builders/packages/elm.xml b/doc/builders/packages/elm.xml
deleted file mode 100644
index a067f6c7c70..00000000000
--- a/doc/builders/packages/elm.xml
+++ /dev/null
@@ -1,17 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-elm">
- <title>Elm</title>
-
- <para>
-  To start a development environment do <command>nix-shell -p elmPackages.elm elmPackages.elm-format</command>
- </para>
-
- <para>
-  To update Elm compiler, see <filename>nixpkgs/pkgs/development/compilers/elm/README.md</filename>.
- </para>
-
- <para>
-  To package Elm applications, <link xlink:href="https://github.com/hercules-ci/elm2nix#elm2nix">read about elm2nix</link>.
- </para>
-</section>
diff --git a/doc/builders/packages/emacs.section.md b/doc/builders/packages/emacs.section.md
new file mode 100644
index 00000000000..93a819bc79b
--- /dev/null
+++ b/doc/builders/packages/emacs.section.md
@@ -0,0 +1,119 @@
+# Emacs {#sec-emacs}
+
+## Configuring Emacs {#sec-emacs-config}
+
+The Emacs package comes with some extra helpers to make it easier to configure. `emacs.pkgs.withPackages` allows you to manage packages from ELPA. This means that you will not have to install that packages from within Emacs. For instance, if you wanted to use `company` `counsel`, `flycheck`, `ivy`, `magit`, `projectile`, and `use-package` you could use this as a `~/.config/nixpkgs/config.nix` override:
+
+```nix
+{
+  packageOverrides = pkgs: with pkgs; {
+    myEmacs = emacs.pkgs.withPackages (epkgs: (with epkgs.melpaStablePackages; [
+      company
+      counsel
+      flycheck
+      ivy
+      magit
+      projectile
+      use-package
+    ]));
+  }
+}
+```
+
+You can install it like any other packages via `nix-env -iA myEmacs`. However, this will only install those packages. It will not `configure` them for us. To do this, we need to provide a configuration file. Luckily, it is possible to do this from within Nix! By modifying the above example, we can make Emacs load a custom config file. The key is to create a package that provide a `default.el` file in `/share/emacs/site-start/`. Emacs knows to load this file automatically when it starts.
+
+```nix
+{
+  packageOverrides = pkgs: with pkgs; rec {
+    myEmacsConfig = writeText "default.el" ''
+      ;; initialize package
+
+      (require 'package)
+      (package-initialize 'noactivate)
+      (eval-when-compile
+        (require 'use-package))
+
+      ;; load some packages
+
+      (use-package company
+        :bind ("<C-tab>" . company-complete)
+        :diminish company-mode
+        :commands (company-mode global-company-mode)
+        :defer 1
+        :config
+        (global-company-mode))
+
+      (use-package counsel
+        :commands (counsel-descbinds)
+        :bind (([remap execute-extended-command] . counsel-M-x)
+               ("C-x C-f" . counsel-find-file)
+               ("C-c g" . counsel-git)
+               ("C-c j" . counsel-git-grep)
+               ("C-c k" . counsel-ag)
+               ("C-x l" . counsel-locate)
+               ("M-y" . counsel-yank-pop)))
+
+      (use-package flycheck
+        :defer 2
+        :config (global-flycheck-mode))
+
+      (use-package ivy
+        :defer 1
+        :bind (("C-c C-r" . ivy-resume)
+               ("C-x C-b" . ivy-switch-buffer)
+               :map ivy-minibuffer-map
+               ("C-j" . ivy-call))
+        :diminish ivy-mode
+        :commands ivy-mode
+        :config
+        (ivy-mode 1))
+
+      (use-package magit
+        :defer
+        :if (executable-find "git")
+        :bind (("C-x g" . magit-status)
+               ("C-x G" . magit-dispatch-popup))
+        :init
+        (setq magit-completing-read-function 'ivy-completing-read))
+
+      (use-package projectile
+        :commands projectile-mode
+        :bind-keymap ("C-c p" . projectile-command-map)
+        :defer 5
+        :config
+        (projectile-global-mode))
+    '';
+
+    myEmacs = emacs.pkgs.withPackages (epkgs: (with epkgs.melpaStablePackages; [
+      (runCommand "default.el" {} ''
+         mkdir -p $out/share/emacs/site-lisp
+         cp ${myEmacsConfig} $out/share/emacs/site-lisp/default.el
+       '')
+      company
+      counsel
+      flycheck
+      ivy
+      magit
+      projectile
+      use-package
+    ]));
+  };
+}
+```
+
+This provides a fairly full Emacs start file. It will load in addition to the user's presonal config. You can always disable it by passing `-q` to the Emacs command.
+
+Sometimes `emacs.pkgs.withPackages` is not enough, as this package set has some priorities imposed on packages (with the lowest priority assigned to Melpa Unstable, and the highest for packages manually defined in `pkgs/top-level/emacs-packages.nix`). But you can't control this priorities when some package is installed as a dependency. You can override it on per-package-basis, providing all the required dependencies manually - but it's tedious and there is always a possibility that an unwanted dependency will sneak in through some other package. To completely override such a package you can use `overrideScope'`.
+
+```nix
+overrides = self: super: rec {
+  haskell-mode = self.melpaPackages.haskell-mode;
+  ...
+};
+((emacsPackagesFor emacs).overrideScope' overrides).emacs.pkgs.withPackages
+  (p: with p; [
+    # here both these package will use haskell-mode of our own choice
+    ghc-mod
+    dante
+  ])
+```
diff --git a/doc/builders/packages/emacs.xml b/doc/builders/packages/emacs.xml
deleted file mode 100644
index 9cce7c40863..00000000000
--- a/doc/builders/packages/emacs.xml
+++ /dev/null
@@ -1,131 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-emacs">
- <title>Emacs</title>
-
- <section xml:id="sec-emacs-config">
-  <title>Configuring Emacs</title>
-
-  <para>
-   The Emacs package comes with some extra helpers to make it easier to configure. <varname>emacsWithPackages</varname> allows you to manage packages from ELPA. This means that you will not have to install that packages from within Emacs. For instance, if you wanted to use <literal>company</literal>, <literal>counsel</literal>, <literal>flycheck</literal>, <literal>ivy</literal>, <literal>magit</literal>, <literal>projectile</literal>, and <literal>use-package</literal> you could use this as a <filename>~/.config/nixpkgs/config.nix</filename> override:
-  </para>
-
-<screen>
-{
-  packageOverrides = pkgs: with pkgs; {
-    myEmacs = emacsWithPackages (epkgs: (with epkgs.melpaStablePackages; [
-      company
-      counsel
-      flycheck
-      ivy
-      magit
-      projectile
-      use-package
-    ]));
-  }
-}
-</screen>
-
-  <para>
-   You can install it like any other packages via <command>nix-env -iA myEmacs</command>. However, this will only install those packages. It will not <literal>configure</literal> them for us. To do this, we need to provide a configuration file. Luckily, it is possible to do this from within Nix! By modifying the above example, we can make Emacs load a custom config file. The key is to create a package that provide a <filename>default.el</filename> file in <filename>/share/emacs/site-start/</filename>. Emacs knows to load this file automatically when it starts.
-  </para>
-
-<screen>
-{
-  packageOverrides = pkgs: with pkgs; rec {
-    myEmacsConfig = writeText "default.el" ''
-;; initialize package
-
-(require 'package)
-(package-initialize 'noactivate)
-(eval-when-compile
-  (require 'use-package))
-
-;; load some packages
-
-(use-package company
-  :bind ("&lt;C-tab&gt;" . company-complete)
-  :diminish company-mode
-  :commands (company-mode global-company-mode)
-  :defer 1
-  :config
-  (global-company-mode))
-
-(use-package counsel
-  :commands (counsel-descbinds)
-  :bind (([remap execute-extended-command] . counsel-M-x)
-         ("C-x C-f" . counsel-find-file)
-         ("C-c g" . counsel-git)
-         ("C-c j" . counsel-git-grep)
-         ("C-c k" . counsel-ag)
-         ("C-x l" . counsel-locate)
-         ("M-y" . counsel-yank-pop)))
-
-(use-package flycheck
-  :defer 2
-  :config (global-flycheck-mode))
-
-(use-package ivy
-  :defer 1
-  :bind (("C-c C-r" . ivy-resume)
-         ("C-x C-b" . ivy-switch-buffer)
-         :map ivy-minibuffer-map
-         ("C-j" . ivy-call))
-  :diminish ivy-mode
-  :commands ivy-mode
-  :config
-  (ivy-mode 1))
-
-(use-package magit
-  :defer
-  :if (executable-find "git")
-  :bind (("C-x g" . magit-status)
-         ("C-x G" . magit-dispatch-popup))
-  :init
-  (setq magit-completing-read-function 'ivy-completing-read))
-
-(use-package projectile
-  :commands projectile-mode
-  :bind-keymap ("C-c p" . projectile-command-map)
-  :defer 5
-  :config
-  (projectile-global-mode))
-    '';
-    myEmacs = emacsWithPackages (epkgs: (with epkgs.melpaStablePackages; [
-      (runCommand "default.el" {} ''
-mkdir -p $out/share/emacs/site-lisp
-cp ${myEmacsConfig} $out/share/emacs/site-lisp/default.el
-'')
-      company
-      counsel
-      flycheck
-      ivy
-      magit
-      projectile
-      use-package
-    ]));
-  };
-}
-</screen>
-
-  <para>
-   This provides a fairly full Emacs start file. It will load in addition to the user's presonal config. You can always disable it by passing <command>-q</command> to the Emacs command.
-  </para>
-
-  <para>
-   Sometimes <varname>emacsWithPackages</varname> is not enough, as this package set has some priorities imposed on packages (with the lowest priority assigned to Melpa Unstable, and the highest for packages manually defined in <filename>pkgs/top-level/emacs-packages.nix</filename>). But you can't control this priorities when some package is installed as a dependency. You can override it on per-package-basis, providing all the required dependencies manually - but it's tedious and there is always a possibility that an unwanted dependency will sneak in through some other package. To completely override such a package you can use <varname>overrideScope'</varname>.
-  </para>
-
-<screen>
-overrides = self: super: rec {
-  haskell-mode = self.melpaPackages.haskell-mode;
-  ...
-};
-((emacsPackagesGen emacs).overrideScope' overrides).emacsWithPackages (p: with p; [
-  # here both these package will use haskell-mode of our own choice
-  ghc-mod
-  dante
-])
-</screen>
- </section>
-</section>
diff --git a/doc/builders/packages/firefox.section.md b/doc/builders/packages/firefox.section.md
new file mode 100644
index 00000000000..b7c430db232
--- /dev/null
+++ b/doc/builders/packages/firefox.section.md
@@ -0,0 +1,49 @@
+# Firefox {#sec-firefox}
+
+## Build wrapped Firefox with extensions and policies {#build-wrapped-firefox-with-extensions-and-policies}
+
+The `wrapFirefox` function allows to pass policies, preferences and extension that are available to firefox. With the help of `fetchFirefoxAddon` this allows build a firefox version that already comes with addons pre-installed:
+
+```nix
+{
+  myFirefox = wrapFirefox firefox-unwrapped {
+    nixExtensions = [
+      (fetchFirefoxAddon {
+        name = "ublock"; # Has to be unique!
+        url = "https://addons.mozilla.org/firefox/downloads/file/3679754/ublock_origin-1.31.0-an+fx.xpi";
+        sha256 = "1h768ljlh3pi23l27qp961v1hd0nbj2vasgy11bmcrlqp40zgvnr";
+      })
+    ];
+
+    extraPolicies = {
+      CaptivePortal = false;
+      DisableFirefoxStudies = true;
+      DisablePocket = true;
+      DisableTelemetry = true;
+      DisableFirefoxAccounts = true;
+      FirefoxHome = {
+        Pocket = false;
+        Snippets = false;
+      };
+       UserMessaging = {
+         ExtensionRecommendations = false;
+         SkipOnboarding = true;
+       };
+    };
+
+    extraPrefs = ''
+      // Show more ssl cert infos
+      lockPref("security.identityblock.show_extended_validation", true);
+    '';
+  };
+}
+```
+
+If `nixExtensions != null` then all manually installed addons will be uninstalled from your browser profile.
+To view available enterprise policies visit [enterprise policies](https://github.com/mozilla/policy-templates#enterprisepoliciesenabled)
+or type into the Firefox url bar: `about:policies#documentation`.
+Nix installed addons do not have a valid signature, which is why signature verification is disabled. This does not compromise security because downloaded addons are checksumed and manual addons can't be installed. Also make sure that the `name` field of fetchFirefoxAddon is unique. If you remove an addon from the nixExtensions array, rebuild and start Firefox the removed addon will be completly removed with all of its settings.
+
+## Troubleshooting {#sec-firefox-troubleshooting}
+If addons do not appear installed although they have been defined in your nix configuration file reset the local addon state of your Firefox profile by clicking `help -> restart with addons disabled -> restart -> refresh firefox`. This can happen if you switch from manual addon mode to nix addon mode and then back to manual mode and then again to nix addon mode.
+
diff --git a/doc/builders/packages/fish.section.md b/doc/builders/packages/fish.section.md
new file mode 100644
index 00000000000..3086bd68348
--- /dev/null
+++ b/doc/builders/packages/fish.section.md
@@ -0,0 +1,50 @@
+# Fish {#sec-fish}
+
+Fish is a "smart and user-friendly command line shell" with support for plugins.
+
+
+## Vendor Fish scripts {#sec-fish-vendor}
+
+Any package may ship its own Fish completions, configuration snippets, and
+functions. Those should be installed to
+`$out/share/fish/vendor_{completions,conf,functions}.d` respectively.
+
+When the `programs.fish.enable` and
+`programs.fish.vendor.{completions,config,functions}.enable` options from the
+NixOS Fish module are set to true, those paths are symlinked in the current
+system environment and automatically loaded by Fish.
+
+
+## Packaging Fish plugins {#sec-fish-plugins-pkg}
+
+While packages providing standalone executables belong to the top level,
+packages which have the sole purpose of extending Fish belong to the
+`fishPlugins` scope and should be registered in
+`pkgs/shells/fish/plugins/default.nix`.
+
+The `buildFishPlugin` utility function can be used to automatically copy Fish
+scripts from `$src/{completions,conf,conf.d,functions}` to the standard vendor
+installation paths. It also sets up the test environment so that the optional
+`checkPhase` is executed in a Fish shell with other already packaged plugins
+and package-local Fish functions specified in `checkPlugins` and
+`checkFunctionDirs` respectively.
+
+See `pkgs/shells/fish/plugins/pure.nix` for an example of Fish plugin package
+using `buildFishPlugin` and running unit tests with the `fishtape` test runner.
+
+
+## Fish wrapper {#sec-fish-wrapper}
+
+The `wrapFish` package is a wrapper around Fish which can be used to create
+Fish shells initialised with some plugins as well as completions, configuration
+snippets and functions sourced from the given paths. This provides a convenient
+way to test Fish plugins and scripts without having to alter the environment.
+
+```nix
+wrapFish {
+  pluginPkgs = with fishPlugins; [ pure foreign-env ];
+  completionDirs = [];
+  functionDirs = [];
+  confDirs = [ "/path/to/some/fish/init/dir/" ];
+}
+```
diff --git a/doc/builders/packages/fuse.section.md b/doc/builders/packages/fuse.section.md
new file mode 100644
index 00000000000..eb0023fcbc3
--- /dev/null
+++ b/doc/builders/packages/fuse.section.md
@@ -0,0 +1,45 @@
+# FUSE {#sec-fuse}
+
+Some packages rely on
+[FUSE](https://www.kernel.org/doc/html/latest/filesystems/fuse.html) to provide
+support for additional filesystems not supported by the kernel.
+
+In general, FUSE software are primarily developed for Linux but many of them can
+also run on macOS. Nixpkgs supports FUSE packages on macOS, but it requires
+[macFUSE](https://osxfuse.github.io) to be installed outside of Nix. macFUSE
+currently isn't packaged in Nixpkgs mainly because it includes a kernel
+extension, which isn't supported by Nix outside of NixOS.
+
+If a package fails to run on macOS with an error message similar to the
+following, it's a likely sign that you need to have macFUSE installed.
+
+    dyld: Library not loaded: /usr/local/lib/libfuse.2.dylib
+    Referenced from: /nix/store/w8bi72bssv0bnxhwfw3xr1mvn7myf37x-sshfs-fuse-2.10/bin/sshfs
+    Reason: image not found
+    [1]    92299 abort      /nix/store/w8bi72bssv0bnxhwfw3xr1mvn7myf37x-sshfs-fuse-2.10/bin/sshfs
+
+Package maintainers may often encounter the following error when building FUSE
+packages on macOS:
+
+    checking for fuse.h... no
+    configure: error: No fuse.h found.
+
+This happens on autoconf based projects that uses `AC_CHECK_HEADERS` or
+`AC_CHECK_LIBS` to detect libfuse, and will occur even when the `fuse` package
+is included in `buildInputs`. It happens because libfuse headers throw an error
+on macOS if the `FUSE_USE_VERSION` macro is undefined. Many proejcts do define
+`FUSE_USE_VERSION`, but only inside C source files. This results in the above
+error at configure time because the configure script would attempt to compile
+sample FUSE programs without defining `FUSE_USE_VERSION`.
+
+There are two possible solutions for this problem in Nixpkgs:
+
+1. Pass `FUSE_USE_VERSION` to the configure script by adding
+   `CFLAGS=-DFUSE_USE_VERSION=25` in `configureFlags`. The actual value would
+   have to match the definition used in the upstream source code.
+2. Remove `AC_CHECK_HEADERS` / `AC_CHECK_LIBS` for libfuse.
+
+However, a better solution might be to fix the build script upstream to use
+`PKG_CHECK_MODULES` instead. This approach wouldn't suffer from the problem that
+`AC_CHECK_HEADERS`/`AC_CHECK_LIBS` has at the price of introducing a dependency
+on pkg-config.
diff --git a/doc/builders/packages/ibus.section.md b/doc/builders/packages/ibus.section.md
new file mode 100644
index 00000000000..2ce85467bb8
--- /dev/null
+++ b/doc/builders/packages/ibus.section.md
@@ -0,0 +1,38 @@
+# ibus-engines.typing-booster {#sec-ibus-typing-booster}
+
+This package is an ibus-based completion method to speed up typing.
+
+## Activating the engine {#sec-ibus-typing-booster-activate}
+
+IBus needs to be configured accordingly to activate `typing-booster`. The configuration depends on the desktop manager in use. For detailed instructions, please refer to the [upstream docs](https://mike-fabian.github.io/ibus-typing-booster/documentation.html).
+
+On NixOS you need to explicitly enable `ibus` with given engines before customizing your desktop to use `typing-booster`. This can be achieved using the `ibus` module:
+
+```nix
+{ pkgs, ... }: {
+  i18n.inputMethod = {
+    enabled = "ibus";
+    ibus.engines = with pkgs.ibus-engines; [ typing-booster ];
+  };
+}
+```
+
+## Using custom hunspell dictionaries {#sec-ibus-typing-booster-customize-hunspell}
+
+The IBus engine is based on `hunspell` to support completion in many languages. By default the dictionaries `de-de`, `en-us`, `fr-moderne` `es-es`, `it-it`, `sv-se` and `sv-fi` are in use. To add another dictionary, the package can be overridden like this:
+
+```nix
+ibus-engines.typing-booster.override { langs = [ "de-at" "en-gb" ]; }
+```
+
+_Note: each language passed to `langs` must be an attribute name in `pkgs.hunspellDicts`._
+
+## Built-in emoji picker {#sec-ibus-typing-booster-emoji-picker}
+
+The `ibus-engines.typing-booster` package contains a program named `emoji-picker`. To display all emojis correctly, a special font such as `noto-fonts-emoji` is needed:
+
+On NixOS it can be installed using the following expression:
+
+```nix
+{ pkgs, ... }: { fonts.fonts = with pkgs; [ noto-fonts-emoji ]; }
+```
diff --git a/doc/builders/packages/ibus.xml b/doc/builders/packages/ibus.xml
deleted file mode 100644
index 2ed37903a27..00000000000
--- a/doc/builders/packages/ibus.xml
+++ /dev/null
@@ -1,57 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-ibus-typing-booster">
- <title>ibus-engines.typing-booster</title>
-
- <para>
-  This package is an ibus-based completion method to speed up typing.
- </para>
-
- <section xml:id="sec-ibus-typing-booster-activate">
-  <title>Activating the engine</title>
-
-  <para>
-   IBus needs to be configured accordingly to activate <literal>typing-booster</literal>. The configuration depends on the desktop manager in use. For detailed instructions, please refer to the <link xlink:href="https://mike-fabian.github.io/ibus-typing-booster/documentation.html">upstream docs</link>.
-  </para>
-
-  <para>
-   On NixOS you need to explicitly enable <literal>ibus</literal> with given engines before customizing your desktop to use <literal>typing-booster</literal>. This can be achieved using the <literal>ibus</literal> module:
-<programlisting>{ pkgs, ... }: {
-  i18n.inputMethod = {
-    enabled = "ibus";
-    ibus.engines = with pkgs.ibus-engines; [ typing-booster ];
-  };
-}</programlisting>
-  </para>
- </section>
-
- <section xml:id="sec-ibus-typing-booster-customize-hunspell">
-  <title>Using custom hunspell dictionaries</title>
-
-  <para>
-   The IBus engine is based on <literal>hunspell</literal> to support completion in many languages. By default the dictionaries <literal>de-de</literal>, <literal>en-us</literal>, <literal>fr-moderne</literal> <literal>es-es</literal>, <literal>it-it</literal>, <literal>sv-se</literal> and <literal>sv-fi</literal> are in use. To add another dictionary, the package can be overridden like this:
-<programlisting>ibus-engines.typing-booster.override {
-  langs = [ "de-at" "en-gb" ];
-}</programlisting>
-  </para>
-
-  <para>
-   <emphasis>Note: each language passed to <literal>langs</literal> must be an attribute name in <literal>pkgs.hunspellDicts</literal>.</emphasis>
-  </para>
- </section>
-
- <section xml:id="sec-ibus-typing-booster-emoji-picker">
-  <title>Built-in emoji picker</title>
-
-  <para>
-   The <literal>ibus-engines.typing-booster</literal> package contains a program named <literal>emoji-picker</literal>. To display all emojis correctly, a special font such as <literal>noto-fonts-emoji</literal> is needed:
-  </para>
-
-  <para>
-   On NixOS it can be installed using the following expression:
-<programlisting>{ pkgs, ... }: {
-  fonts.fonts = with pkgs; [ noto-fonts-emoji ];
-}</programlisting>
-  </para>
- </section>
-</section>
diff --git a/doc/builders/packages/index.xml b/doc/builders/packages/index.xml
index e20b0c689a8..f5b05b0bbcc 100644
--- a/doc/builders/packages/index.xml
+++ b/doc/builders/packages/index.xml
@@ -5,21 +5,24 @@
  <para>
   This chapter contains information about how to use and maintain the Nix expressions for a number of specific packages, such as the Linux kernel or X.org.
  </para>
- <xi:include href="citrix.xml" />
- <xi:include href="dlib.xml" />
- <xi:include href="eclipse.xml" />
- <xi:include href="elm.xml" />
- <xi:include href="emacs.xml" />
- <xi:include href="ibus.xml" />
- <xi:include href="kakoune.xml" />
- <xi:include href="linux.xml" />
- <xi:include href="locales.xml" />
- <xi:include href="nginx.xml" />
- <xi:include href="opengl.xml" />
- <xi:include href="shell-helpers.xml" />
- <xi:include href="steam.xml" />
+ <xi:include href="citrix.section.xml" />
+ <xi:include href="dlib.section.xml" />
+ <xi:include href="eclipse.section.xml" />
+ <xi:include href="elm.section.xml" />
+ <xi:include href="emacs.section.xml" />
+ <xi:include href="firefox.section.xml" />
+ <xi:include href="fish.section.xml" />
+ <xi:include href="fuse.section.xml" />
+ <xi:include href="ibus.section.xml" />
+ <xi:include href="kakoune.section.xml" />
+ <xi:include href="linux.section.xml" />
+ <xi:include href="locales.section.xml" />
+ <xi:include href="nginx.section.xml" />
+ <xi:include href="opengl.section.xml" />
+ <xi:include href="shell-helpers.section.xml" />
+ <xi:include href="steam.section.xml" />
  <xi:include href="cataclysm-dda.section.xml" />
- <xi:include href="urxvt.xml" />
- <xi:include href="weechat.xml" />
- <xi:include href="xorg.xml" />
+ <xi:include href="urxvt.section.xml" />
+ <xi:include href="weechat.section.xml" />
+ <xi:include href="xorg.section.xml" />
 </chapter>
diff --git a/doc/builders/packages/kakoune.section.md b/doc/builders/packages/kakoune.section.md
new file mode 100644
index 00000000000..8e054777a75
--- /dev/null
+++ b/doc/builders/packages/kakoune.section.md
@@ -0,0 +1,9 @@
+# Kakoune {#sec-kakoune}
+
+Kakoune can be built to autoload plugins:
+
+```nix
+(kakoune.override {
+  plugins = with pkgs.kakounePlugins; [ parinfer-rust ];
+})
+```
diff --git a/doc/builders/packages/kakoune.xml b/doc/builders/packages/kakoune.xml
deleted file mode 100644
index 728d40dacc9..00000000000
--- a/doc/builders/packages/kakoune.xml
+++ /dev/null
@@ -1,14 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-kakoune">
- <title>Kakoune</title>
-
- <para>
-  Kakoune can be built to autoload plugins:
-<programlisting>(kakoune.override {
-  configure = {
-    plugins = with pkgs.kakounePlugins; [ parinfer-rust ];
-  };
-})</programlisting>
- </para>
-</section>
diff --git a/doc/builders/packages/linux.section.md b/doc/builders/packages/linux.section.md
new file mode 100644
index 00000000000..1b8d6eda749
--- /dev/null
+++ b/doc/builders/packages/linux.section.md
@@ -0,0 +1,41 @@
+# Linux kernel {#sec-linux-kernel}
+
+The Nix expressions to build the Linux kernel are in [`pkgs/os-specific/linux/kernel`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/os-specific/linux/kernel).
+
+The function that builds the kernel has an argument `kernelPatches` which should be a list of `{name, patch, extraConfig}` attribute sets, where `name` is the name of the patch (which is included in the kernel’s `meta.description` attribute), `patch` is the patch itself (possibly compressed), and `extraConfig` (optional) is a string specifying extra options to be concatenated to the kernel configuration file (`.config`).
+
+The kernel derivation exports an attribute `features` specifying whether optional functionality is or isn’t enabled. This is used in NixOS to implement kernel-specific behaviour. For instance, if the kernel has the `iwlwifi` feature (i.e. has built-in support for Intel wireless chipsets), then NixOS doesn’t have to build the external `iwlwifi` package:
+
+```nix
+modulesTree = [kernel]
+  ++ pkgs.lib.optional (!kernel.features ? iwlwifi) kernelPackages.iwlwifi
+  ++ ...;
+```
+
+How to add a new (major) version of the Linux kernel to Nixpkgs:
+
+1.  Copy the old Nix expression (e.g. `linux-2.6.21.nix`) to the new one (e.g. `linux-2.6.22.nix`) and update it.
+
+2.  Add the new kernel to `all-packages.nix` (e.g., create an attribute `kernel_2_6_22`).
+
+3.  Now we’re going to update the kernel configuration. First unpack the kernel. Then for each supported platform (`i686`, `x86_64`, `uml`) do the following:
+
+    1.  Make an copy from the old config (e.g. `config-2.6.21-i686-smp`) to the new one (e.g. `config-2.6.22-i686-smp`).
+
+    2.  Copy the config file for this platform (e.g. `config-2.6.22-i686-smp`) to `.config` in the kernel source tree.
+
+    3.  Run `make oldconfig ARCH={i386,x86_64,um}` and answer all questions. (For the uml configuration, also add `SHELL=bash`.) Make sure to keep the configuration consistent between platforms (i.e. don’t enable some feature on `i686` and disable it on `x86_64`).
+
+    4.  If needed you can also run `make menuconfig`:
+
+        ```ShellSession
+        $ nix-env -i ncurses
+        $ export NIX_CFLAGS_LINK=-lncurses
+        $ make menuconfig ARCH=arch
+        ```
+
+    5.  Copy `.config` over the new config file (e.g. `config-2.6.22-i686-smp`).
+
+4.  Test building the kernel: `nix-build -A kernel_2_6_22`. If it compiles, ship it! For extra credit, try booting NixOS with it.
+
+5.  It may be that the new kernel requires updating the external kernel modules and kernel-dependent packages listed in the `linuxPackagesFor` function in `all-packages.nix` (such as the NVIDIA drivers, AUFS, etc.). If the updated packages aren’t backwards compatible with older kernels, you may need to keep the older versions around.
diff --git a/doc/builders/packages/linux.xml b/doc/builders/packages/linux.xml
deleted file mode 100644
index 72d0e21493b..00000000000
--- a/doc/builders/packages/linux.xml
+++ /dev/null
@@ -1,85 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-linux-kernel">
- <title>Linux kernel</title>
-
- <para>
-  The Nix expressions to build the Linux kernel are in <link
-xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/os-specific/linux/kernel"><filename>pkgs/os-specific/linux/kernel</filename></link>.
- </para>
-
- <para>
-  The function that builds the kernel has an argument <varname>kernelPatches</varname> which should be a list of <literal>{name, patch, extraConfig}</literal> attribute sets, where <varname>name</varname> is the name of the patch (which is included in the kernel’s <varname>meta.description</varname> attribute), <varname>patch</varname> is the patch itself (possibly compressed), and <varname>extraConfig</varname> (optional) is a string specifying extra options to be concatenated to the kernel configuration file (<filename>.config</filename>).
- </para>
-
- <para>
-  The kernel derivation exports an attribute <varname>features</varname> specifying whether optional functionality is or isn’t enabled. This is used in NixOS to implement kernel-specific behaviour. For instance, if the kernel has the <varname>iwlwifi</varname> feature (i.e. has built-in support for Intel wireless chipsets), then NixOS doesn’t have to build the external <varname>iwlwifi</varname> package:
-<programlisting>
-modulesTree = [kernel]
-  ++ pkgs.lib.optional (!kernel.features ? iwlwifi) kernelPackages.iwlwifi
-  ++ ...;
-</programlisting>
- </para>
-
- <para>
-  How to add a new (major) version of the Linux kernel to Nixpkgs:
-  <orderedlist>
-   <listitem>
-    <para>
-     Copy the old Nix expression (e.g. <filename>linux-2.6.21.nix</filename>) to the new one (e.g. <filename>linux-2.6.22.nix</filename>) and update it.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Add the new kernel to <filename>all-packages.nix</filename> (e.g., create an attribute <varname>kernel_2_6_22</varname>).
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Now we’re going to update the kernel configuration. First unpack the kernel. Then for each supported platform (<literal>i686</literal>, <literal>x86_64</literal>, <literal>uml</literal>) do the following:
-     <orderedlist>
-      <listitem>
-       <para>
-        Make an copy from the old config (e.g. <filename>config-2.6.21-i686-smp</filename>) to the new one (e.g. <filename>config-2.6.22-i686-smp</filename>).
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        Copy the config file for this platform (e.g. <filename>config-2.6.22-i686-smp</filename>) to <filename>.config</filename> in the kernel source tree.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        Run <literal>make oldconfig ARCH=<replaceable>{i386,x86_64,um}</replaceable></literal> and answer all questions. (For the uml configuration, also add <literal>SHELL=bash</literal>.) Make sure to keep the configuration consistent between platforms (i.e. don’t enable some feature on <literal>i686</literal> and disable it on <literal>x86_64</literal>).
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        If needed you can also run <literal>make menuconfig</literal>:
-<screen>
-<prompt>$ </prompt>nix-env -i ncurses
-<prompt>$ </prompt>export NIX_CFLAGS_LINK=-lncurses
-<prompt>$ </prompt>make menuconfig ARCH=<replaceable>arch</replaceable></screen>
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        Copy <filename>.config</filename> over the new config file (e.g. <filename>config-2.6.22-i686-smp</filename>).
-       </para>
-      </listitem>
-     </orderedlist>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Test building the kernel: <literal>nix-build -A kernel_2_6_22</literal>. If it compiles, ship it! For extra credit, try booting NixOS with it.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     It may be that the new kernel requires updating the external kernel modules and kernel-dependent packages listed in the <varname>linuxPackagesFor</varname> function in <filename>all-packages.nix</filename> (such as the NVIDIA drivers, AUFS, etc.). If the updated packages aren’t backwards compatible with older kernels, you may need to keep the older versions around.
-    </para>
-   </listitem>
-  </orderedlist>
- </para>
-</section>
diff --git a/doc/builders/packages/locales.section.md b/doc/builders/packages/locales.section.md
new file mode 100644
index 00000000000..e5a03700481
--- /dev/null
+++ b/doc/builders/packages/locales.section.md
@@ -0,0 +1,5 @@
+# Locales {#locales}
+
+To allow simultaneous use of packages linked against different versions of `glibc` with different locale archive formats Nixpkgs patches `glibc` to rely on `LOCALE_ARCHIVE` environment variable.
+
+On non-NixOS distributions this variable is obviously not set. This can cause regressions in language support or even crashes in some Nixpkgs-provided programs. The simplest way to mitigate this problem is exporting the `LOCALE_ARCHIVE` variable pointing to `${glibcLocales}/lib/locale/locale-archive`. The drawback (and the reason this is not the default) is the relatively large (a hundred MiB) size of the full set of locales. It is possible to build a custom set of locales by overriding parameters `allLocales` and `locales` of the package.
diff --git a/doc/builders/packages/locales.xml b/doc/builders/packages/locales.xml
deleted file mode 100644
index 44fdef034e7..00000000000
--- a/doc/builders/packages/locales.xml
+++ /dev/null
@@ -1,13 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="locales">
- <title>Locales</title>
-
- <para>
-  To allow simultaneous use of packages linked against different versions of <literal>glibc</literal> with different locale archive formats Nixpkgs patches <literal>glibc</literal> to rely on <literal>LOCALE_ARCHIVE</literal> environment variable.
- </para>
-
- <para>
-  On non-NixOS distributions this variable is obviously not set. This can cause regressions in language support or even crashes in some Nixpkgs-provided programs. The simplest way to mitigate this problem is exporting the <literal>LOCALE_ARCHIVE</literal> variable pointing to <literal>${glibcLocales}/lib/locale/locale-archive</literal>. The drawback (and the reason this is not the default) is the relatively large (a hundred MiB) size of the full set of locales. It is possible to build a custom set of locales by overriding parameters <literal>allLocales</literal> and <literal>locales</literal> of the package.
- </para>
-</section>
diff --git a/doc/builders/packages/nginx.section.md b/doc/builders/packages/nginx.section.md
new file mode 100644
index 00000000000..154c21f9b36
--- /dev/null
+++ b/doc/builders/packages/nginx.section.md
@@ -0,0 +1,11 @@
+# Nginx {#sec-nginx}
+
+[Nginx](https://nginx.org) is a reverse proxy and lightweight webserver.
+
+## ETags on static files served from the Nix store {#sec-nginx-etag}
+
+HTTP has a couple different mechanisms for caching to prevent clients from having to download the same content repeatedly if a resource has not changed since the last time it was requested. When nginx is used as a server for static files, it implements the caching mechanism based on the [`Last-Modified`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Last-Modified) response header automatically; unfortunately, it works by using filesystem timestamps to determine the value of the `Last-Modified` header. This doesn't give the desired behavior when the file is in the Nix store, because all file timestamps are set to 0 (for reasons related to build reproducibility).
+
+Fortunately, HTTP supports an alternative (and more effective) caching mechanism: the [`ETag`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag) response header. The value of the `ETag` header specifies some identifier for the particular content that the server is sending (e.g. a hash). When a client makes a second request for the same resource, it sends that value back in an `If-None-Match` header. If the ETag value is unchanged, then the server does not need to resend the content.
+
+As of NixOS 19.09, the nginx package in Nixpkgs is patched such that when nginx serves a file out of `/nix/store`, the hash in the store path is used as the `ETag` header in the HTTP response, thus providing proper caching functionality. This happens automatically; you do not need to do modify any configuration to get this behavior.
diff --git a/doc/builders/packages/nginx.xml b/doc/builders/packages/nginx.xml
deleted file mode 100644
index 65854ba0236..00000000000
--- a/doc/builders/packages/nginx.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-nginx">
- <title>Nginx</title>
-
- <para>
-  <link xlink:href="https://nginx.org/">Nginx</link> is a reverse proxy and lightweight webserver.
- </para>
-
- <section xml:id="sec-nginx-etag">
-  <title>ETags on static files served from the Nix store</title>
-
-  <para>
-   HTTP has a couple different mechanisms for caching to prevent clients from having to download the same content repeatedly if a resource has not changed since the last time it was requested. When nginx is used as a server for static files, it implements the caching mechanism based on the <link xlink:href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Last-Modified"><literal>Last-Modified</literal></link> response header automatically; unfortunately, it works by using filesystem timestamps to determine the value of the <literal>Last-Modified</literal> header. This doesn't give the desired behavior when the file is in the Nix store, because all file timestamps are set to 0 (for reasons related to build reproducibility).
-  </para>
-
-  <para>
-   Fortunately, HTTP supports an alternative (and more effective) caching mechanism: the <link xlink:href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag"><literal>ETag</literal></link> response header. The value of the <literal>ETag</literal> header specifies some identifier for the particular content that the server is sending (e.g. a hash). When a client makes a second request for the same resource, it sends that value back in an <literal>If-None-Match</literal> header. If the ETag value is unchanged, then the server does not need to resend the content.
-  </para>
-
-  <para>
-   As of NixOS 19.09, the nginx package in Nixpkgs is patched such that when nginx serves a file out of <filename>/nix/store</filename>, the hash in the store path is used as the <literal>ETag</literal> header in the HTTP response, thus providing proper caching functionality. This happens automatically; you do not need to do modify any configuration to get this behavior.
-  </para>
- </section>
-</section>
diff --git a/doc/builders/packages/opengl.section.md b/doc/builders/packages/opengl.section.md
new file mode 100644
index 00000000000..ee7f3af98cf
--- /dev/null
+++ b/doc/builders/packages/opengl.section.md
@@ -0,0 +1,15 @@
+# OpenGL {#sec-opengl}
+
+OpenGL support varies depending on which hardware is used and which drivers are available and loaded.
+
+Broadly, we support both GL vendors: Mesa and NVIDIA.
+
+## NixOS Desktop {#nixos-desktop}
+
+The NixOS desktop or other non-headless configurations are the primary target for OpenGL libraries and applications. The current solution for discovering which drivers are available is based on [libglvnd](https://gitlab.freedesktop.org/glvnd/libglvnd). `libglvnd` performs "vendor-neutral dispatch", trying a variety of techniques to find the system's GL implementation. In practice, this will be either via standard GLX for X11 users or EGL for Wayland users, and supporting either NVIDIA or Mesa extensions.
+
+## Nix on GNU/Linux {#nix-on-gnulinux}
+
+If you are using a non-NixOS GNU/Linux/X11 desktop with free software video drivers, consider launching OpenGL-dependent programs from Nixpkgs with Nixpkgs versions of `libglvnd` and `mesa.drivers` in `LD_LIBRARY_PATH`. For Mesa drivers, the Linux kernel version doesn't have to match nixpkgs.
+
+For proprietary video drivers you might have luck with also adding the corresponding video driver package.
diff --git a/doc/builders/packages/opengl.xml b/doc/builders/packages/opengl.xml
deleted file mode 100644
index 5f4433a2884..00000000000
--- a/doc/builders/packages/opengl.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-opengl">
- <title>OpenGL</title>
-
- <para>
-  Packages that use OpenGL have NixOS desktop as their primary target. The current solution for loading the GPU-specific drivers is based on <literal>libglvnd</literal> and looks for the driver implementation in <literal>LD_LIBRARY_PATH</literal>. If you are using a non-NixOS GNU/Linux/X11 desktop with free software video drivers, consider launching OpenGL-dependent programs from Nixpkgs with Nixpkgs versions of <literal>libglvnd</literal> and <literal>mesa_drivers</literal> in <literal>LD_LIBRARY_PATH</literal>. For proprietary video drivers you might have luck with also adding the corresponding video driver package.
- </para>
-</section>
diff --git a/doc/builders/packages/shell-helpers.section.md b/doc/builders/packages/shell-helpers.section.md
new file mode 100644
index 00000000000..57b8619c500
--- /dev/null
+++ b/doc/builders/packages/shell-helpers.section.md
@@ -0,0 +1,12 @@
+# Interactive shell helpers {#sec-shell-helpers}
+
+Some packages provide the shell integration to be more useful. But unlike other systems, nix doesn't have a standard `share` directory location. This is why a bunch `PACKAGE-share` scripts are shipped that print the location of the corresponding shared folder. Current list of such packages is as following:
+
+- `fzf` : `fzf-share`
+
+E.g. `fzf` can then used in the `.bashrc` like this:
+
+```bash
+source "$(fzf-share)/completion.bash"
+source "$(fzf-share)/key-bindings.bash"
+```
diff --git a/doc/builders/packages/shell-helpers.xml b/doc/builders/packages/shell-helpers.xml
deleted file mode 100644
index cb70d527d67..00000000000
--- a/doc/builders/packages/shell-helpers.xml
+++ /dev/null
@@ -1,25 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-shell-helpers">
- <title>Interactive shell helpers</title>
-
- <para>
-  Some packages provide the shell integration to be more useful. But unlike other systems, nix doesn't have a standard share directory location. This is why a bunch <command>PACKAGE-share</command> scripts are shipped that print the location of the corresponding shared folder. Current list of such packages is as following:
-  <itemizedlist>
-   <listitem>
-    <para>
-     <literal>autojump</literal>: <command>autojump-share</command>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     <literal>fzf</literal>: <command>fzf-share</command>
-    </para>
-   </listitem>
-  </itemizedlist>
-  E.g. <literal>autojump</literal> can then used in the .bashrc like this:
-<screen>
-  source "$(autojump-share)/autojump.bash"
-</screen>
- </para>
-</section>
diff --git a/doc/builders/packages/steam.section.md b/doc/builders/packages/steam.section.md
new file mode 100644
index 00000000000..0cfc1a2c245
--- /dev/null
+++ b/doc/builders/packages/steam.section.md
@@ -0,0 +1,63 @@
+# Steam {#sec-steam}
+
+## Steam in Nix {#sec-steam-nix}
+
+Steam is distributed as a `.deb` file, for now only as an i686 package (the amd64 package only has documentation). When unpacked, it has a script called `steam` that in Ubuntu (their target distro) would go to `/usr/bin`. When run for the first time, this script copies some files to the user's home, which include another script that is the ultimate responsible for launching the steam binary, which is also in \$HOME.
+
+Nix problems and constraints:
+
+- We don't have `/bin/bash` and many scripts point there. Similarly for `/usr/bin/python`.
+- We don't have the dynamic loader in `/lib`.
+- The `steam.sh` script in \$HOME can not be patched, as it is checked and rewritten by steam.
+- The steam binary cannot be patched, it's also checked.
+
+The current approach to deploy Steam in NixOS is composing a FHS-compatible chroot environment, as documented [here](http://sandervanderburg.blogspot.nl/2013/09/composing-fhs-compatible-chroot.html). This allows us to have binaries in the expected paths without disrupting the system, and to avoid patching them to work in a non FHS environment.
+
+## How to play {#sec-steam-play}
+
+Use `programs.steam.enable = true;` if you want to add steam to systemPackages and also enable a few workarrounds aswell as Steam controller support or other Steam supported controllers such as the DualShock 4 or Nintendo Switch Pr.
+
+## Troubleshooting {#sec-steam-troub}
+
+- **Steam fails to start. What do I do?**
+
+  Try to run
+
+  ```ShellSession
+  strace steam
+  ```
+
+  to see what is causing steam to fail.
+
+- **Using the FOSS Radeon or nouveau (nvidia) drivers**
+
+  - The `newStdcpp` parameter was removed since NixOS 17.09 and should not be needed anymore.
+  - Steam ships statically linked with a version of libcrypto that conflics with the one dynamically loaded by radeonsi_dri.so. If you get the error
+
+    ```
+    steam.sh: line 713: 7842 Segmentation fault (core dumped)
+    ```
+
+    have a look at [this pull request](https://github.com/NixOS/nixpkgs/pull/20269).
+
+- **Java**
+
+  1. There is no java in steam chrootenv by default. If you get a message like
+
+    ```
+    /home/foo/.local/share/Steam/SteamApps/common/towns/towns.sh: line 1: java: command not found
+    ```
+
+    you need to add
+
+    ```nix
+    steam.override { withJava = true; };
+    ```
+
+## steam-run {#sec-steam-run}
+
+The FHS-compatible chroot used for Steam can also be used to run other Linux games that expect a FHS environment. To use it, install the `steam-run-native` package and run the game with
+
+```
+steam-run ./foo
+```
diff --git a/doc/builders/packages/steam.xml b/doc/builders/packages/steam.xml
deleted file mode 100644
index 59673328bac..00000000000
--- a/doc/builders/packages/steam.xml
+++ /dev/null
@@ -1,125 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-steam">
- <title>Steam</title>
-
- <section xml:id="sec-steam-nix">
-  <title>Steam in Nix</title>
-
-  <para>
-   Steam is distributed as a <filename>.deb</filename> file, for now only as an i686 package (the amd64 package only has documentation). When unpacked, it has a script called <filename>steam</filename> that in Ubuntu (their target distro) would go to <filename>/usr/bin </filename>. When run for the first time, this script copies some files to the user's home, which include another script that is the ultimate responsible for launching the steam binary, which is also in $HOME.
-  </para>
-
-  <para>
-   Nix problems and constraints:
-   <itemizedlist>
-    <listitem>
-     <para>
-      We don't have <filename>/bin/bash</filename> and many scripts point there. Similarly for <filename>/usr/bin/python</filename> .
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      We don't have the dynamic loader in <filename>/lib </filename>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      The <filename>steam.sh</filename> script in $HOME can not be patched, as it is checked and rewritten by steam.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      The steam binary cannot be patched, it's also checked.
-     </para>
-    </listitem>
-   </itemizedlist>
-  </para>
-
-  <para>
-   The current approach to deploy Steam in NixOS is composing a FHS-compatible chroot environment, as documented <link xlink:href="http://sandervanderburg.blogspot.nl/2013/09/composing-fhs-compatible-chroot.html">here</link>. This allows us to have binaries in the expected paths without disrupting the system, and to avoid patching them to work in a non FHS environment.
-  </para>
- </section>
-
- <section xml:id="sec-steam-play">
-  <title>How to play</title>
-
-  <para>
-   Use <programlisting>programs.steam.enable = true;</programlisting> if you want to add steam to systemPackages and also enable a few workarrounds aswell as Steam controller support or other Steam supported controllers such as the DualShock 4 or Nintendo Switch Pr.
-  </para>
- </section>
-
- <section xml:id="sec-steam-troub">
-  <title>Troubleshooting</title>
-
-  <para>
-   <variablelist>
-    <varlistentry>
-     <term>
-      Steam fails to start. What do I do?
-     </term>
-     <listitem>
-      <para>
-       Try to run
-<programlisting>strace steam</programlisting>
-       to see what is causing steam to fail.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      Using the FOSS Radeon or nouveau (nvidia) drivers
-     </term>
-     <listitem>
-      <itemizedlist>
-       <listitem>
-        <para>
-         The <literal>newStdcpp</literal> parameter was removed since NixOS 17.09 and should not be needed anymore.
-        </para>
-       </listitem>
-       <listitem>
-        <para>
-         Steam ships statically linked with a version of libcrypto that conflics with the one dynamically loaded by radeonsi_dri.so. If you get the error
-<programlisting>steam.sh: line 713: 7842 Segmentation fault (core dumped)</programlisting>
-         have a look at <link xlink:href="https://github.com/NixOS/nixpkgs/pull/20269">this pull request</link>.
-        </para>
-       </listitem>
-      </itemizedlist>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      Java
-     </term>
-     <listitem>
-      <orderedlist>
-       <listitem>
-        <para>
-         There is no java in steam chrootenv by default. If you get a message like
-<programlisting>/home/foo/.local/share/Steam/SteamApps/common/towns/towns.sh: line 1: java: command not found</programlisting>
-         You need to add
-<programlisting> steam.override { withJava = true; };</programlisting>
-         to your configuration.
-        </para>
-       </listitem>
-      </orderedlist>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </para>
- </section>
-
- <section xml:id="sec-steam-run">
-  <title>steam-run</title>
-
-  <para>
-   The FHS-compatible chroot used for steam can also be used to run other linux games that expect a FHS environment. To do it, add
-<programlisting>pkgs.(steam.override {
-          nativeOnly = true;
-          newStdcpp = true;
-        }).run</programlisting>
-   to your configuration, rebuild, and run the game with
-<programlisting>steam-run ./foo</programlisting>
-  </para>
- </section>
-</section>
diff --git a/doc/builders/packages/urxvt.section.md b/doc/builders/packages/urxvt.section.md
new file mode 100644
index 00000000000..2d1196d9227
--- /dev/null
+++ b/doc/builders/packages/urxvt.section.md
@@ -0,0 +1,71 @@
+# Urxvt {#sec-urxvt}
+
+Urxvt, also known as rxvt-unicode, is a highly customizable terminal emulator.
+
+## Configuring urxvt {#sec-urxvt-conf}
+
+In `nixpkgs`, urxvt is provided by the package `rxvt-unicode`. It can be configured to include your choice of plugins, reducing its closure size from the default configuration which includes all available plugins. To make use of this functionality, use an overlay or directly install an expression that overrides its configuration, such as
+
+```nix
+rxvt-unicode.override {
+  configure = { availablePlugins, ... }: {
+    plugins = with availablePlugins; [ perls resize-font vtwheel ];
+  };
+}
+```
+
+If the `configure` function returns an attrset without the `plugins` attribute, `availablePlugins` will be used automatically.
+
+In order to add plugins but also keep all default plugins installed, it is possible to use the following method:
+
+```nix
+rxvt-unicode.override {
+  configure = { availablePlugins, ... }: {
+    plugins = (builtins.attrValues availablePlugins) ++ [ custom-plugin ];
+  };
+}
+```
+
+To get a list of all the plugins available, open the Nix REPL and run
+
+```ShellSession
+$ nix repl
+:l <nixpkgs>
+map (p: p.name) pkgs.rxvt-unicode.plugins
+```
+
+Alternatively, if your shell is bash or zsh and have completion enabled, simply type `nixpkgs.rxvt-unicode.plugins.<tab>`.
+
+In addition to `plugins` the options `extraDeps` and `perlDeps` can be used to install extra packages. `extraDeps` can be used, for example, to provide `xsel` (a clipboard manager) to the clipboard plugin, without installing it globally:
+
+```nix
+rxvt-unicode.override {
+  configure = { availablePlugins, ... }: {
+    pluginsDeps = [ xsel ];
+  };
+}
+```
+
+`perlDeps` is a handy way to provide Perl packages to your custom plugins (in `$HOME/.urxvt/ext`). For example, if you need `AnyEvent` you can do:
+
+```nix
+rxvt-unicode.override {
+  configure = { availablePlugins, ... }: {
+    perlDeps = with perlPackages; [ AnyEvent ];
+  };
+}
+```
+
+## Packaging urxvt plugins {#sec-urxvt-pkg}
+
+Urxvt plugins resides in `pkgs/applications/misc/rxvt-unicode-plugins`. To add a new plugin create an expression in a subdirectory and add the package to the set in `pkgs/applications/misc/rxvt-unicode-plugins/default.nix`.
+
+A plugin can be any kind of derivation, the only requirement is that it should always install perl scripts in `$out/lib/urxvt/perl`. Look for existing plugins for examples.
+
+If the plugin is itself a perl package that needs to be imported from other plugins or scripts, add the following passthrough:
+
+```nix
+passthru.perlPackages = [ "self" ];
+```
+
+This will make the urxvt wrapper pick up the dependency and set up the perl path accordingly.
diff --git a/doc/builders/packages/urxvt.xml b/doc/builders/packages/urxvt.xml
deleted file mode 100644
index 135cc82a0b5..00000000000
--- a/doc/builders/packages/urxvt.xml
+++ /dev/null
@@ -1,101 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-urxvt">
- <title>Urxvt</title>
-
- <para>
-  Urxvt, also known as rxvt-unicode, is a highly customizable terminal emulator.
- </para>
-
- <section xml:id="sec-urxvt-conf">
-
-  <title>Configuring urxvt</title>
-
-  <para>
-   In <literal>nixpkgs</literal>, urxvt is provided by the package
-   <literal>rxvt-unicode</literal>. It can be configured to include your choice
-   of plugins, reducing its closure size from the default configuration which
-   includes all available plugins. To make use of this functionality, use an
-   overlay or directly install an expression that overrides its configuration,
-   such as
-   <programlisting>rxvt-unicode.override { configure = { availablePlugins, ... }: {
-    plugins = with availablePlugins; [ perls resize-font vtwheel ];
-  }
-}</programlisting>
-   If the <literal>configure</literal> function returns an attrset without the
-   <literal>plugins</literal> attribute, <literal>availablePlugins</literal>
-   will be used automatically.
-  </para>
-
-  <para>
-   In order to add plugins but also keep all default plugins installed, it is
-   possible to use the following method:
-   <programlisting>rxvt-unicode.override { configure = { availablePlugins, ... }: {
-     plugins = (builtins.attrValues availablePlugins) ++ [ custom-plugin ];
-   };
-}</programlisting>
-  </para>
-
-  <para>
-   To get a list of all the plugins available, open the Nix REPL and run
-   <programlisting>$ nix repl
-:l &lt;nixpkgs&gt;
-map (p: p.name) pkgs.rxvt-unicode.plugins
-   </programlisting>
-   Alternatively, if your shell is bash or zsh and have completion enabled,
-   simply type <literal>nixpkgs.rxvt-unicode.plugins.&lt;tab&gt;</literal>.
-  </para>
-
-  <para>
-    In addition to <literal>plugins</literal> the options
-    <literal>extraDeps</literal> and <literal>perlDeps</literal> can be used
-    to install extra packages.
-    <literal>extraDeps</literal> can be used, for example, to provide
-    <literal>xsel</literal> (a clipboard manager) to the clipboard plugin,
-    without installing it globally:
-    <programlisting>rxvt-unicode.override { configure = { availablePlugins, ... }: {
-     pluginsDeps = [ xsel ];
-   }
-}</programlisting>
-
-    <literal>perlDeps</literal> is a handy way to provide Perl packages to
-    your custom plugins (in <literal>$HOME/.urxvt/ext</literal>). For example,
-    if you need <literal>AnyEvent</literal> you can do:
-    <programlisting>rxvt-unicode.override { configure = { availablePlugins, ... }: {
-     perlDeps = with perlPackages; [ AnyEvent ];
-   }
-}</programlisting>
-  </para>
-
- </section>
-
- <section xml:id="sec-urxvt-pkg">
-
-  <title>Packaging urxvt plugins</title>
-
-  <para>
-   Urxvt plugins resides in
-   <literal>pkgs/applications/misc/rxvt-unicode-plugins</literal>.
-   To add a new plugin create an expression in a subdirectory and add the
-   package to the set in
-   <literal>pkgs/applications/misc/rxvt-unicode-plugins/default.nix</literal>.
-  </para>
-
-  <para>
-   A plugin can be any kind of derivation, the only requirement is that it
-   should always install perl scripts in <literal>$out/lib/urxvt/perl</literal>.
-   Look for existing plugins for examples.
-  </para>
-
-  <para>
-   If the plugin is itself a perl package that needs to be imported from
-   other plugins or scripts, add the following passthrough:
-   <programlisting>passthru.perlPackages = [ "self" ];
-</programlisting>
-   This will make the urxvt wrapper pick up the dependency and set up the perl
-   path accordingly.
-  </para>
-
- </section>
-
-</section>
diff --git a/doc/builders/packages/weechat.section.md b/doc/builders/packages/weechat.section.md
new file mode 100644
index 00000000000..e4e956b908e
--- /dev/null
+++ b/doc/builders/packages/weechat.section.md
@@ -0,0 +1,85 @@
+# Weechat {#sec-weechat}
+
+Weechat can be configured to include your choice of plugins, reducing its closure size from the default configuration which includes all available plugins. To make use of this functionality, install an expression that overrides its configuration such as
+
+```nix
+weechat.override {configure = {availablePlugins, ...}: {
+    plugins = with availablePlugins; [ python perl ];
+  }
+}
+```
+
+If the `configure` function returns an attrset without the `plugins` attribute, `availablePlugins` will be used automatically.
+
+The plugins currently available are `python`, `perl`, `ruby`, `guile`, `tcl` and `lua`.
+
+The python and perl plugins allows the addition of extra libraries. For instance, the `inotify.py` script in `weechat-scripts` requires D-Bus or libnotify, and the `fish.py` script requires `pycrypto`. To use these scripts, use the plugin's `withPackages` attribute:
+
+```nix
+weechat.override { configure = {availablePlugins, ...}: {
+    plugins = with availablePlugins; [
+            (python.withPackages (ps: with ps; [ pycrypto python-dbus ]))
+        ];
+    };
+}
+```
+
+In order to also keep all default plugins installed, it is possible to use the following method:
+
+```nix
+weechat.override { configure = { availablePlugins, ... }: {
+  plugins = builtins.attrValues (availablePlugins // {
+    python = availablePlugins.python.withPackages (ps: with ps; [ pycrypto python-dbus ]);
+  });
+}; }
+```
+
+WeeChat allows to set defaults on startup using the `--run-command`. The `configure` method can be used to pass commands to the program:
+
+```nix
+weechat.override {
+  configure = { availablePlugins, ... }: {
+    init = ''
+      /set foo bar
+      /server add libera irc.libera.chat
+    '';
+  };
+}
+```
+
+Further values can be added to the list of commands when running `weechat --run-command "your-commands"`.
+
+Additionally it's possible to specify scripts to be loaded when starting `weechat`. These will be loaded before the commands from `init`:
+
+```nix
+weechat.override {
+  configure = { availablePlugins, ... }: {
+    scripts = with pkgs.weechatScripts; [
+      weechat-xmpp weechat-matrix-bridge wee-slack
+    ];
+    init = ''
+      /set plugins.var.python.jabber.key "val"
+    '':
+  };
+}
+```
+
+In `nixpkgs` there's a subpackage which contains derivations for WeeChat scripts. Such derivations expect a `passthru.scripts` attribute which contains a list of all scripts inside the store path. Furthermore all scripts have to live in `$out/share`. An exemplary derivation looks like this:
+
+```nix
+{ stdenv, fetchurl }:
+
+stdenv.mkDerivation {
+  name = "exemplary-weechat-script";
+  src = fetchurl {
+    url = "https://scripts.tld/your-scripts.tar.gz";
+    sha256 = "...";
+  };
+  passthru.scripts = [ "foo.py" "bar.lua" ];
+  installPhase = ''
+    mkdir $out/share
+    cp foo.py $out/share
+    cp bar.lua $out/share
+  '';
+}
+```
diff --git a/doc/builders/packages/weechat.xml b/doc/builders/packages/weechat.xml
deleted file mode 100644
index a110d3f491c..00000000000
--- a/doc/builders/packages/weechat.xml
+++ /dev/null
@@ -1,85 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-weechat">
- <title>Weechat</title>
-
- <para>
-  Weechat can be configured to include your choice of plugins, reducing its closure size from the default configuration which includes all available plugins. To make use of this functionality, install an expression that overrides its configuration such as
-<programlisting>weechat.override {configure = {availablePlugins, ...}: {
-    plugins = with availablePlugins; [ python perl ];
-  }
-}</programlisting>
-  If the <literal>configure</literal> function returns an attrset without the <literal>plugins</literal> attribute, <literal>availablePlugins</literal> will be used automatically.
- </para>
-
- <para>
-  The plugins currently available are <literal>python</literal>, <literal>perl</literal>, <literal>ruby</literal>, <literal>guile</literal>, <literal>tcl</literal> and <literal>lua</literal>.
- </para>
-
- <para>
-  The python and perl plugins allows the addition of extra libraries. For instance, the <literal>inotify.py</literal> script in weechat-scripts requires D-Bus or libnotify, and the <literal>fish.py</literal> script requires pycrypto. To use these scripts, use the plugin's <literal>withPackages</literal> attribute:
-<programlisting>weechat.override { configure = {availablePlugins, ...}: {
-    plugins = with availablePlugins; [
-            (python.withPackages (ps: with ps; [ pycrypto python-dbus ]))
-        ];
-    };
-}
-</programlisting>
- </para>
-
- <para>
-  In order to also keep all default plugins installed, it is possible to use the following method:
-<programlisting>weechat.override { configure = { availablePlugins, ... }: {
-  plugins = builtins.attrValues (availablePlugins // {
-    python = availablePlugins.python.withPackages (ps: with ps; [ pycrypto python-dbus ]);
-  });
-}; }
-</programlisting>
- </para>
-
- <para>
-  WeeChat allows to set defaults on startup using the <literal>--run-command</literal>. The <literal>configure</literal> method can be used to pass commands to the program:
-<programlisting>weechat.override {
-  configure = { availablePlugins, ... }: {
-    init = ''
-      /set foo bar
-      /server add freenode chat.freenode.org
-    '';
-  };
-}</programlisting>
-  Further values can be added to the list of commands when running <literal>weechat --run-command "your-commands"</literal>.
- </para>
-
- <para>
-  Additionally it's possible to specify scripts to be loaded when starting <literal>weechat</literal>. These will be loaded before the commands from <literal>init</literal>:
-<programlisting>weechat.override {
-  configure = { availablePlugins, ... }: {
-    scripts = with pkgs.weechatScripts; [
-      weechat-xmpp weechat-matrix-bridge wee-slack
-    ];
-    init = ''
-      /set plugins.var.python.jabber.key "val"
-    '':
-  };
-}</programlisting>
- </para>
-
- <para>
-  In <literal>nixpkgs</literal> there's a subpackage which contains derivations for WeeChat scripts. Such derivations expect a <literal>passthru.scripts</literal> attribute which contains a list of all scripts inside the store path. Furthermore all scripts have to live in <literal>$out/share</literal>. An exemplary derivation looks like this:
-<programlisting>{ stdenv, fetchurl }:
-
-stdenv.mkDerivation {
-  name = "exemplary-weechat-script";
-  src = fetchurl {
-    url = "https://scripts.tld/your-scripts.tar.gz";
-    sha256 = "...";
-  };
-  passthru.scripts = [ "foo.py" "bar.lua" ];
-  installPhase = ''
-    mkdir $out/share
-    cp foo.py $out/share
-    cp bar.lua $out/share
-  '';
-}</programlisting>
- </para>
-</section>
diff --git a/doc/builders/packages/xorg.section.md b/doc/builders/packages/xorg.section.md
new file mode 100644
index 00000000000..ae885f92346
--- /dev/null
+++ b/doc/builders/packages/xorg.section.md
@@ -0,0 +1,34 @@
+# X.org {#sec-xorg}
+
+The Nix expressions for the X.org packages reside in `pkgs/servers/x11/xorg/default.nix`. This file is automatically generated from lists of tarballs in an X.org release. As such it should not be modified directly; rather, you should modify the lists, the generator script or the file `pkgs/servers/x11/xorg/overrides.nix`, in which you can override or add to the derivations produced by the generator.
+
+## Katamari Tarballs {#katamari-tarballs}
+
+X.org upstream releases used to include [katamari](https://en.wiktionary.org/wiki/%E3%81%8B%E3%81%9F%E3%81%BE%E3%82%8A) releases, which included a holistic recommended version for each tarball, up until 7.7. To create a list of tarballs in a katamari release:
+
+```ShellSession
+export release="X11R7.7"
+export url="mirror://xorg/$release/src/everything/"
+cat $(PRINT_PATH=1 nix-prefetch-url $url | tail -n 1) \
+  | perl -e 'while (<>) { if (/(href|HREF)="([^"]*.bz2)"/) { print "$ENV{'url'}$2\n"; }; }' \
+  | sort > "tarballs-$release.list"
+```
+
+## Individual Tarballs {#individual-tarballs}
+
+The upstream release process for [X11R7.8](https://x.org/wiki/Releases/7.8/) does not include a planned katamari. Instead, each component of X.org is released as its own tarball. We maintain `pkgs/servers/x11/xorg/tarballs.list` as a list of tarballs for each individual package. This list includes X.org core libraries and protocol descriptions, extra newer X11 interface libraries, like `xorg.libxcb`, and classic utilities which are largely unused but still available if needed, like `xorg.imake`.
+
+## Generating Nix Expressions {#generating-nix-expressions}
+
+The generator is invoked as follows:
+
+```ShellSession
+cd pkgs/servers/x11/xorg
+<tarballs.list perl ./generate-expr-from-tarballs.pl
+```
+
+For each of the tarballs in the `.list` files, the script downloads it, unpacks it, and searches its `configure.ac` and `*.pc.in` files for dependencies. This information is used to generate `default.nix`. The generator caches downloaded tarballs between runs. Pay close attention to the `NOT FOUND: $NAME` messages at the end of the run, since they may indicate missing dependencies. (Some might be optional dependencies, however.)
+
+## Overriding the Generator {#overriding-the-generator}
+
+If the expression for a package requires derivation attributes that the generator cannot figure out automatically (say, `patches` or a `postInstall` hook), you should modify `pkgs/servers/x11/xorg/overrides.nix`.
diff --git a/doc/builders/packages/xorg.xml b/doc/builders/packages/xorg.xml
deleted file mode 100644
index ebf4930cc09..00000000000
--- a/doc/builders/packages/xorg.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-xorg">
- <title>X.org</title>
-
- <para>
-  The Nix expressions for the X.org packages reside in <filename>pkgs/servers/x11/xorg/default.nix</filename>. This file is automatically generated from lists of tarballs in an X.org release. As such it should not be modified directly; rather, you should modify the lists, the generator script or the file <filename>pkgs/servers/x11/xorg/overrides.nix</filename>, in which you can override or add to the derivations produced by the generator.
- </para>
-
- <para>
-  The generator is invoked as follows:
-<screen>
-<prompt>$ </prompt>cd pkgs/servers/x11/xorg
-<prompt>$ </prompt>cat tarballs-7.5.list extra.list old.list \
-  | perl ./generate-expr-from-tarballs.pl
-</screen>
-  For each of the tarballs in the <filename>.list</filename> files, the script downloads it, unpacks it, and searches its <filename>configure.ac</filename> and <filename>*.pc.in</filename> files for dependencies. This information is used to generate <filename>default.nix</filename>. The generator caches downloaded tarballs between runs. Pay close attention to the <literal>NOT FOUND: <replaceable>name</replaceable></literal> messages at the end of the run, since they may indicate missing dependencies. (Some might be optional dependencies, however.)
- </para>
-
- <para>
-  A file like <filename>tarballs-7.5.list</filename> contains all tarballs in a X.org release. It can be generated like this:
-<screen>
-<prompt>$ </prompt>export i="mirror://xorg/X11R7.4/src/everything/"
-<prompt>$ </prompt>cat $(PRINT_PATH=1 nix-prefetch-url $i | tail -n 1) \
-  | perl -e 'while (&lt;>) { if (/(href|HREF)="([^"]*.bz2)"/) { print "$ENV{'i'}$2\n"; }; }' \
-  | sort > tarballs-7.4.list
-</screen>
-  <filename>extra.list</filename> contains libraries that aren’t part of X.org proper, but are closely related to it, such as <literal>libxcb</literal>. <filename>old.list</filename> contains some packages that were removed from X.org, but are still needed by some people or by other packages (such as <varname>imake</varname>).
- </para>
-
- <para>
-  If the expression for a package requires derivation attributes that the generator cannot figure out automatically (say, <varname>patches</varname> or a <varname>postInstall</varname> hook), you should modify <filename>pkgs/servers/x11/xorg/overrides.nix</filename>.
- </para>
-</section>
diff --git a/doc/builders/special.xml b/doc/builders/special.xml
index 15fdba9a041..8902ce5c813 100644
--- a/doc/builders/special.xml
+++ b/doc/builders/special.xml
@@ -5,6 +5,6 @@
  <para>
   This chapter describes several special builders.
  </para>
- <xi:include href="special/fhs-environments.xml" />
- <xi:include href="special/mkshell.xml" />
+ <xi:include href="special/fhs-environments.section.xml" />
+ <xi:include href="special/mkshell.section.xml" />
 </chapter>
diff --git a/doc/builders/special/fhs-environments.section.md b/doc/builders/special/fhs-environments.section.md
new file mode 100644
index 00000000000..43dc99b7c18
--- /dev/null
+++ b/doc/builders/special/fhs-environments.section.md
@@ -0,0 +1,47 @@
+# buildFHSUserEnv {#sec-fhs-environments}
+
+`buildFHSUserEnv` provides a way to build and run FHS-compatible lightweight sandboxes. It creates an isolated root with bound `/nix/store`, so its footprint in terms of disk space needed is quite small. This allows one to run software which is hard or unfeasible to patch for NixOS -- 3rd-party source trees with FHS assumptions, games distributed as tarballs, software with integrity checking and/or external self-updated binaries. It uses Linux namespaces feature to create temporary lightweight environments which are destroyed after all child processes exit, without root user rights requirement. Accepted arguments are:
+
+- `name`
+        Environment name.
+- `targetPkgs`
+        Packages to be installed for the main host's architecture (i.e. x86_64 on x86_64 installations). Along with libraries binaries are also installed.
+- `multiPkgs`
+        Packages to be installed for all architectures supported by a host (i.e. i686 and x86_64 on x86_64 installations). Only libraries are installed by default.
+- `extraBuildCommands`
+        Additional commands to be executed for finalizing the directory structure.
+- `extraBuildCommandsMulti`
+        Like `extraBuildCommands`, but executed only on multilib architectures.
+- `extraOutputsToInstall`
+        Additional derivation outputs to be linked for both target and multi-architecture packages.
+- `extraInstallCommands`
+        Additional commands to be executed for finalizing the derivation with runner script.
+- `runScript`
+        A command that would be executed inside the sandbox and passed all the command line arguments. It defaults to `bash`.
+- `profile`
+        Optional script for `/etc/profile` within the sandbox.
+
+One can create a simple environment using a `shell.nix` like that:
+
+```nix
+{ pkgs ? import <nixpkgs> {} }:
+
+(pkgs.buildFHSUserEnv {
+  name = "simple-x11-env";
+  targetPkgs = pkgs: (with pkgs;
+    [ udev
+      alsa-lib
+    ]) ++ (with pkgs.xorg;
+    [ libX11
+      libXcursor
+      libXrandr
+    ]);
+  multiPkgs = pkgs: (with pkgs;
+    [ udev
+      alsa-lib
+    ]);
+  runScript = "bash";
+}).env
+```
+
+Running `nix-shell` would then drop you into a shell with these libraries and binaries available. You can use this to run closed-source applications which expect FHS structure without hassles: simply change `runScript` to the application path, e.g. `./bin/start.sh` -- relative paths are supported.
diff --git a/doc/builders/special/fhs-environments.xml b/doc/builders/special/fhs-environments.xml
deleted file mode 100644
index e7b81e97a23..00000000000
--- a/doc/builders/special/fhs-environments.xml
+++ /dev/null
@@ -1,122 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-fhs-environments">
- <title>buildFHSUserEnv</title>
-
- <para>
-  <function>buildFHSUserEnv</function> provides a way to build and run FHS-compatible lightweight sandboxes. It creates an isolated root with bound <filename>/nix/store</filename>, so its footprint in terms of disk space needed is quite small. This allows one to run software which is hard or unfeasible to patch for NixOS -- 3rd-party source trees with FHS assumptions, games distributed as tarballs, software with integrity checking and/or external self-updated binaries. It uses Linux namespaces feature to create temporary lightweight environments which are destroyed after all child processes exit, without root user rights requirement. Accepted arguments are:
- </para>
-
- <variablelist>
-  <varlistentry>
-   <term>
-    <literal>name</literal>
-   </term>
-   <listitem>
-    <para>
-     Environment name.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>targetPkgs</literal>
-   </term>
-   <listitem>
-    <para>
-     Packages to be installed for the main host's architecture (i.e. x86_64 on x86_64 installations). Along with libraries binaries are also installed.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>multiPkgs</literal>
-   </term>
-   <listitem>
-    <para>
-     Packages to be installed for all architectures supported by a host (i.e. i686 and x86_64 on x86_64 installations). Only libraries are installed by default.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>extraBuildCommands</literal>
-   </term>
-   <listitem>
-    <para>
-     Additional commands to be executed for finalizing the directory structure.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>extraBuildCommandsMulti</literal>
-   </term>
-   <listitem>
-    <para>
-     Like <literal>extraBuildCommands</literal>, but executed only on multilib architectures.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>extraOutputsToInstall</literal>
-   </term>
-   <listitem>
-    <para>
-     Additional derivation outputs to be linked for both target and multi-architecture packages.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>extraInstallCommands</literal>
-   </term>
-   <listitem>
-    <para>
-     Additional commands to be executed for finalizing the derivation with runner script.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry>
-   <term>
-    <literal>runScript</literal>
-   </term>
-   <listitem>
-    <para>
-     A command that would be executed inside the sandbox and passed all the command line arguments. It defaults to <literal>bash</literal>.
-    </para>
-   </listitem>
-  </varlistentry>
- </variablelist>
-
- <para>
-  One can create a simple environment using a <literal>shell.nix</literal> like that:
- </para>
-
-<programlisting><![CDATA[
-{ pkgs ? import <nixpkgs> {} }:
-
-(pkgs.buildFHSUserEnv {
-  name = "simple-x11-env";
-  targetPkgs = pkgs: (with pkgs;
-    [ udev
-      alsaLib
-    ]) ++ (with pkgs.xorg;
-    [ libX11
-      libXcursor
-      libXrandr
-    ]);
-  multiPkgs = pkgs: (with pkgs;
-    [ udev
-      alsaLib
-    ]);
-  runScript = "bash";
-}).env
-]]></programlisting>
-
- <para>
-  Running <literal>nix-shell</literal> would then drop you into a shell with these libraries and binaries available. You can use this to run closed-source applications which expect FHS structure without hassles: simply change <literal>runScript</literal> to the application path, e.g. <filename>./bin/start.sh</filename> -- relative paths are supported.
- </para>
-</section>
diff --git a/doc/builders/special/mkshell.section.md b/doc/builders/special/mkshell.section.md
new file mode 100644
index 00000000000..8a62c50e17d
--- /dev/null
+++ b/doc/builders/special/mkshell.section.md
@@ -0,0 +1,17 @@
+# pkgs.mkShell {#sec-pkgs-mkShell}
+
+`pkgs.mkShell` is a special kind of derivation that is only useful when using
+it combined with `nix-shell`. It will in fact fail to instantiate when invoked
+with `nix-build`.
+
+## Usage {#sec-pkgs-mkShell-usage}
+
+```nix
+{ pkgs ? import <nixpkgs> {} }:
+pkgs.mkShell {
+  # specify which packages to add to the shell environment
+  packages = [ pkgs.gnumake ];
+  # add all the dependencies, of the given packages, to the shell environment
+  inputsFrom = with pkgs; [ hello gnutar ];
+}
+```
diff --git a/doc/builders/special/mkshell.xml b/doc/builders/special/mkshell.xml
deleted file mode 100644
index cef65d06b88..00000000000
--- a/doc/builders/special/mkshell.xml
+++ /dev/null
@@ -1,24 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-pkgs-mkShell">
- <title>pkgs.mkShell</title>
-
- <para>
-  <function>pkgs.mkShell</function> is a special kind of derivation that is only useful when using it combined with <command>nix-shell</command>. It will in fact fail to instantiate when invoked with <command>nix-build</command>.
- </para>
-
- <section xml:id="sec-pkgs-mkShell-usage">
-  <title>Usage</title>
-
-<programlisting><![CDATA[
-{ pkgs ? import <nixpkgs> {} }:
-pkgs.mkShell {
-  # this will make all the build inputs from hello and gnutar
-  # available to the shell environment
-  inputsFrom = with pkgs; [ hello gnutar ];
-  buildInputs = [ pkgs.gnumake ];
-}
-]]></programlisting>
- </section>
-</section>
diff --git a/doc/builders/trivial-builders.chapter.md b/doc/builders/trivial-builders.chapter.md
new file mode 100644
index 00000000000..46620e1b459
--- /dev/null
+++ b/doc/builders/trivial-builders.chapter.md
@@ -0,0 +1,99 @@
+# Trivial builders {#chap-trivial-builders}
+
+Nixpkgs provides a couple of functions that help with building derivations. The most important one, `stdenv.mkDerivation`, has already been documented above. The following functions wrap `stdenv.mkDerivation`, making it easier to use in certain cases.
+
+## `runCommand` {#trivial-builder-runCommand}
+
+This takes three arguments, `name`, `env`, and `buildCommand`. `name` is just the name that Nix will append to the store path in the same way that `stdenv.mkDerivation` uses its `name` attribute. `env` is an attribute set specifying environment variables that will be set for this derivation. These attributes are then passed to the wrapped `stdenv.mkDerivation`. `buildCommand` specifies the commands that will be run to create this derivation. Note that you will need to create `$out` for Nix to register the command as successful.
+
+An example of using `runCommand` is provided below.
+
+```nix
+(import <nixpkgs> {}).runCommand "my-example" {} ''
+  echo My example command is running
+
+  mkdir $out
+
+  echo I can write data to the Nix store > $out/message
+
+  echo I can also run basic commands like:
+
+  echo ls
+  ls
+
+  echo whoami
+  whoami
+
+  echo date
+  date
+''
+```
+
+## `runCommandCC` {#trivial-builder-runCommandCC}
+
+This works just like `runCommand`. The only difference is that it also provides a C compiler in `buildCommand`'s environment. To minimize your dependencies, you should only use this if you are sure you will need a C compiler as part of running your command.
+
+## `runCommandLocal` {#trivial-builder-runCommandLocal}
+
+Variant of `runCommand` that forces the derivation to be built locally, it is not substituted. This is intended for very cheap commands (<1s execution time). It saves on the network roundrip and can speed up a build.
+
+::: {.note}
+This sets [`allowSubstitutes` to `false`](https://nixos.org/nix/manual/#adv-attr-allowSubstitutes), so only use `runCommandLocal` if you are certain the user will always have a builder for the `system` of the derivation. This should be true for most trivial use cases (e.g. just copying some files to a different location or adding symlinks), because there the `system` is usually the same as `builtins.currentSystem`.
+:::
+
+## `writeTextFile`, `writeText`, `writeTextDir`, `writeScript`, `writeScriptBin` {#trivial-builder-writeText}
+
+These functions write `text` to the Nix store. This is useful for creating scripts from Nix expressions. `writeTextFile` takes an attribute set and expects two arguments, `name` and `text`. `name` corresponds to the name used in the Nix store path. `text` will be the contents of the file. You can also set `executable` to true to make this file have the executable bit set.
+
+Many more commands wrap `writeTextFile` including `writeText`, `writeTextDir`, `writeScript`, and `writeScriptBin`. These are convenience functions over `writeTextFile`.
+
+## `symlinkJoin` {#trivial-builder-symlinkJoin}
+
+This can be used to put many derivations into the same directory structure. It works by creating a new derivation and adding symlinks to each of the paths listed. It expects two arguments, `name`, and `paths`. `name` is the name used in the Nix store path for the created derivation. `paths` is a list of paths that will be symlinked. These paths can be to Nix store derivations or any other subdirectory contained within.
+
+## `writeReferencesToFile` {#trivial-builder-writeReferencesToFile}
+
+Writes the closure of transitive dependencies to a file.
+
+This produces the equivalent of `nix-store -q --requisites`.
+
+For example,
+
+```nix
+writeReferencesToFile (writeScriptBin "hi" ''${hello}/bin/hello'')
+```
+
+produces an output path `/nix/store/<hash>-runtime-deps` containing
+
+```nix
+/nix/store/<hash>-hello-2.10
+/nix/store/<hash>-hi
+/nix/store/<hash>-libidn2-2.3.0
+/nix/store/<hash>-libunistring-0.9.10
+/nix/store/<hash>-glibc-2.32-40
+```
+
+You can see that this includes `hi`, the original input path,
+`hello`, which is a direct reference, but also
+the other paths that are indirectly required to run `hello`.
+
+## `writeDirectReferencesToFile` {#trivial-builder-writeDirectReferencesToFile}
+
+Writes the set of references to the output file, that is, their immediate dependencies.
+
+This produces the equivalent of `nix-store -q --references`.
+
+For example,
+
+```nix
+writeDirectReferencesToFile (writeScriptBin "hi" ''${hello}/bin/hello'')
+```
+
+produces an output path `/nix/store/<hash>-runtime-references` containing
+
+```nix
+/nix/store/<hash>-hello-2.10
+```
+
+but none of `hello`'s dependencies, because those are not referenced directly
+by `hi`'s output.
diff --git a/doc/builders/trivial-builders.xml b/doc/builders/trivial-builders.xml
deleted file mode 100644
index 94948c57b91..00000000000
--- a/doc/builders/trivial-builders.xml
+++ /dev/null
@@ -1,90 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="chap-trivial-builders">
- <title>Trivial builders</title>
- <para>
-  Nixpkgs provides a couple of functions that help with building derivations. The most important one, <function>stdenv.mkDerivation</function>, has already been documented above. The following functions wrap <function>stdenv.mkDerivation</function>, making it easier to use in certain cases.
- </para>
- <variablelist>
-  <varlistentry xml:id="trivial-builder-runCommand">
-   <term>
-    <literal>runCommand</literal>
-   </term>
-   <listitem>
-    <para>
-     This takes three arguments, <literal>name</literal>, <literal>env</literal>, and <literal>buildCommand</literal>. <literal>name</literal> is just the name that Nix will append to the store path in the same way that <literal>stdenv.mkDerivation</literal> uses its <literal>name</literal> attribute. <literal>env</literal> is an attribute set specifying environment variables that will be set for this derivation. These attributes are then passed to the wrapped <literal>stdenv.mkDerivation</literal>. <literal>buildCommand</literal> specifies the commands that will be run to create this derivation. Note that you will need to create <literal>$out</literal> for Nix to register the command as successful.
-    </para>
-    <para>
-     An example of using <literal>runCommand</literal> is provided below.
-    </para>
-<programlisting>
-(import &lt;nixpkgs&gt; {}).runCommand "my-example" {} ''
-  echo My example command is running
-
-  mkdir $out
-
-  echo I can write data to the Nix store > $out/message
-
-  echo I can also run basic commands like:
-
-  echo ls
-  ls
-
-  echo whoami
-  whoami
-
-  echo date
-  date
-''
-</programlisting>
-   </listitem>
-  </varlistentry>
-  <varlistentry xml:id="trivial-builder-runCommandCC">
-   <term>
-    <literal>runCommandCC</literal>
-   </term>
-   <listitem>
-    <para>
-     This works just like <literal>runCommand</literal>. The only difference is that it also provides a C compiler in <literal>buildCommand</literal>’s environment. To minimize your dependencies, you should only use this if you are sure you will need a C compiler as part of running your command.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry xml:id="trivial-builder-runCommandLocal">
-   <term>
-    <literal>runCommandLocal</literal>
-   </term>
-   <listitem>
-    <para>
-     Variant of <literal>runCommand</literal> that forces the derivation to be built locally, it is not substituted. This is intended for very cheap commands (&lt;1s execution time). It saves on the network roundrip and can speed up a build.
-    </para>
-    <note><para>
-      This sets <link xlink:href="https://nixos.org/nix/manual/#adv-attr-allowSubstitutes"><literal>allowSubstitutes</literal> to <literal>false</literal></link>, so only use <literal>runCommandLocal</literal> if you are certain the user will always have a builder for the <literal>system</literal> of the derivation. This should be true for most trivial use cases (e.g. just copying some files to a different location or adding symlinks), because there the <literal>system</literal> is usually the same as <literal>builtins.currentSystem</literal>.
-    </para></note>
-   </listitem>
-  </varlistentry>
-  <varlistentry xml:id="trivial-builder-writeText">
-   <term>
-    <literal>writeTextFile</literal>, <literal>writeText</literal>, <literal>writeTextDir</literal>, <literal>writeScript</literal>, <literal>writeScriptBin</literal>
-   </term>
-   <listitem>
-    <para>
-     These functions write <literal>text</literal> to the Nix store. This is useful for creating scripts from Nix expressions. <literal>writeTextFile</literal> takes an attribute set and expects two arguments, <literal>name</literal> and <literal>text</literal>. <literal>name</literal> corresponds to the name used in the Nix store path. <literal>text</literal> will be the contents of the file. You can also set <literal>executable</literal> to true to make this file have the executable bit set.
-    </para>
-    <para>
-     Many more commands wrap <literal>writeTextFile</literal> including <literal>writeText</literal>, <literal>writeTextDir</literal>, <literal>writeScript</literal>, and <literal>writeScriptBin</literal>. These are convenience functions over <literal>writeTextFile</literal>.
-    </para>
-   </listitem>
-  </varlistentry>
-  <varlistentry xml:id="trivial-builder-symlinkJoin">
-   <term>
-    <literal>symlinkJoin</literal>
-   </term>
-   <listitem>
-    <para>
-     This can be used to put many derivations into the same directory structure. It works by creating a new derivation and adding symlinks to each of the paths listed. It expects two arguments, <literal>name</literal>, and <literal>paths</literal>. <literal>name</literal> is the name used in the Nix store path for the created derivation. <literal>paths</literal> is a list of paths that will be symlinked. These paths can be to Nix store derivations or any other subdirectory contained within.
-    </para>
-   </listitem>
-  </varlistentry>
- </variablelist>
-</chapter>
diff --git a/doc/contributing/coding-conventions.chapter.md b/doc/contributing/coding-conventions.chapter.md
new file mode 100644
index 00000000000..e42ba512b98
--- /dev/null
+++ b/doc/contributing/coding-conventions.chapter.md
@@ -0,0 +1,604 @@
+# Coding conventions {#chap-conventions}
+
+## Syntax {#sec-syntax}
+
+- Use 2 spaces of indentation per indentation level in Nix expressions, 4 spaces in shell scripts.
+
+- Do not use tab characters, i.e. configure your editor to use soft tabs. For instance, use `(setq-default indent-tabs-mode nil)` in Emacs. Everybody has different tab settings so it’s asking for trouble.
+
+- Use `lowerCamelCase` for variable names, not `UpperCamelCase`. Note, this rule does not apply to package attribute names, which instead follow the rules in [](#sec-package-naming).
+
+- Function calls with attribute set arguments are written as
+
+  ```nix
+  foo {
+    arg = ...;
+  }
+  ```
+
+  not
+
+  ```nix
+  foo
+  {
+    arg = ...;
+  }
+  ```
+
+  Also fine is
+
+  ```nix
+  foo { arg = ...; }
+  ```
+
+  if it's a short call.
+
+- In attribute sets or lists that span multiple lines, the attribute names or list elements should be aligned:
+
+  ```nix
+  # A long list.
+  list = [
+    elem1
+    elem2
+    elem3
+  ];
+
+  # A long attribute set.
+  attrs = {
+    attr1 = short_expr;
+    attr2 =
+      if true then big_expr else big_expr;
+  };
+
+  # Combined
+  listOfAttrs = [
+    {
+      attr1 = 3;
+      attr2 = "fff";
+    }
+    {
+      attr1 = 5;
+      attr2 = "ggg";
+    }
+  ];
+  ```
+
+- Short lists or attribute sets can be written on one line:
+
+  ```nix
+  # A short list.
+  list = [ elem1 elem2 elem3 ];
+
+  # A short set.
+  attrs = { x = 1280; y = 1024; };
+  ```
+
+- Breaking in the middle of a function argument can give hard-to-read code, like
+
+  ```nix
+  someFunction { x = 1280;
+    y = 1024; } otherArg
+    yetAnotherArg
+  ```
+
+  (especially if the argument is very large, spanning multiple lines).
+
+  Better:
+
+  ```nix
+  someFunction
+    { x = 1280; y = 1024; }
+    otherArg
+    yetAnotherArg
+  ```
+
+  or
+
+  ```nix
+  let res = { x = 1280; y = 1024; };
+  in someFunction res otherArg yetAnotherArg
+  ```
+
+- The bodies of functions, asserts, and withs are not indented to prevent a lot of superfluous indentation levels, i.e.
+
+  ```nix
+  { arg1, arg2 }:
+  assert system == "i686-linux";
+  stdenv.mkDerivation { ...
+  ```
+
+  not
+
+  ```nix
+  { arg1, arg2 }:
+    assert system == "i686-linux";
+      stdenv.mkDerivation { ...
+  ```
+
+- Function formal arguments are written as:
+
+  ```nix
+  { arg1, arg2, arg3 }:
+  ```
+
+  but if they don't fit on one line they're written as:
+
+  ```nix
+  { arg1, arg2, arg3
+  , arg4, ...
+  , # Some comment...
+    argN
+  }:
+  ```
+
+- Functions should list their expected arguments as precisely as possible. That is, write
+
+  ```nix
+  { stdenv, fetchurl, perl }: ...
+  ```
+
+  instead of
+
+  ```nix
+  args: with args; ...
+  ```
+
+  or
+
+  ```nix
+  { stdenv, fetchurl, perl, ... }: ...
+  ```
+
+  For functions that are truly generic in the number of arguments (such as wrappers around `mkDerivation`) that have some required arguments, you should write them using an `@`-pattern:
+
+  ```nix
+  { stdenv, doCoverageAnalysis ? false, ... } @ args:
+
+  stdenv.mkDerivation (args // {
+    ... if doCoverageAnalysis then "bla" else "" ...
+  })
+  ```
+
+  instead of
+
+  ```nix
+  args:
+
+  args.stdenv.mkDerivation (args // {
+    ... if args ? doCoverageAnalysis && args.doCoverageAnalysis then "bla" else "" ...
+  })
+  ```
+
+- Unnecessary string conversions should be avoided. Do
+
+  ```nix
+  rev = version;
+  ```
+
+  instead of
+
+  ```nix
+  rev = "${version}";
+  ```
+
+- Arguments should be listed in the order they are used, with the exception of `lib`, which always goes first.
+
+## Package naming {#sec-package-naming}
+
+The key words _must_, _must not_, _required_, _shall_, _shall not_, _should_, _should not_, _recommended_, _may_, and _optional_ in this section are to be interpreted as described in [RFC 2119](https://tools.ietf.org/html/rfc2119). Only _emphasized_ words are to be interpreted in this way.
+
+In Nixpkgs, there are generally three different names associated with a package:
+
+- The `name` attribute of the derivation (excluding the version part). This is what most users see, in particular when using `nix-env`.
+
+- The variable name used for the instantiated package in `all-packages.nix`, and when passing it as a dependency to other functions. Typically this is called the _package attribute name_. This is what Nix expression authors see. It can also be used when installing using `nix-env -iA`.
+
+- The filename for (the directory containing) the Nix expression.
+
+Most of the time, these are the same. For instance, the package `e2fsprogs` has a `name` attribute `"e2fsprogs-version"`, is bound to the variable name `e2fsprogs` in `all-packages.nix`, and the Nix expression is in `pkgs/os-specific/linux/e2fsprogs/default.nix`.
+
+There are a few naming guidelines:
+
+- The `name` attribute _should_ be identical to the upstream package name.
+
+- The `name` attribute _must not_ contain uppercase letters — e.g., `"mplayer-1.0rc2"` instead of `"MPlayer-1.0rc2"`.
+
+- The version part of the `name` attribute _must_ start with a digit (following a dash) — e.g., `"hello-0.3.1rc2"`.
+
+- If a package is not a release but a commit from a repository, then the version part of the name _must_ be the date of that (fetched) commit. The date _must_ be in `"YYYY-MM-DD"` format. Also append `"unstable"` to the name - e.g., `"pkgname-unstable-2014-09-23"`.
+
+- Dashes in the package name _should_ be preserved in new variable names, rather than converted to underscores or camel cased — e.g., `http-parser` instead of `http_parser` or `httpParser`. The hyphenated style is preferred in all three package names.
+
+- If there are multiple versions of a package, this _should_ be reflected in the variable names in `all-packages.nix`, e.g. `json-c-0-9` and `json-c-0-11`. If there is an obvious “default” version, make an attribute like `json-c = json-c-0-9;`. See also [](#sec-versioning)
+
+## File naming and organisation {#sec-organisation}
+
+Names of files and directories should be in lowercase, with dashes between words — not in camel case. For instance, it should be `all-packages.nix`, not `allPackages.nix` or `AllPackages.nix`.
+
+### Hierarchy {#sec-hierarchy}
+
+Each package should be stored in its own directory somewhere in the `pkgs/` tree, i.e. in `pkgs/category/subcategory/.../pkgname`. Below are some rules for picking the right category for a package. Many packages fall under several categories; what matters is the _primary_ purpose of a package. For example, the `libxml2` package builds both a library and some tools; but it’s a library foremost, so it goes under `pkgs/development/libraries`.
+
+When in doubt, consider refactoring the `pkgs/` tree, e.g. creating new categories or splitting up an existing category.
+
+**If it’s used to support _software development_:**
+
+- **If it’s a _library_ used by other packages:**
+
+  - `development/libraries` (e.g. `libxml2`)
+
+- **If it’s a _compiler_:**
+
+  - `development/compilers` (e.g. `gcc`)
+
+- **If it’s an _interpreter_:**
+
+  - `development/interpreters` (e.g. `guile`)
+
+- **If it’s a (set of) development _tool(s)_:**
+
+  - **If it’s a _parser generator_ (including lexers):**
+
+    - `development/tools/parsing` (e.g. `bison`, `flex`)
+
+  - **If it’s a _build manager_:**
+
+    - `development/tools/build-managers` (e.g. `gnumake`)
+
+  - **Else:**
+
+    - `development/tools/misc` (e.g. `binutils`)
+
+- **Else:**
+
+  - `development/misc`
+
+**If it’s a (set of) _tool(s)_:**
+
+(A tool is a relatively small program, especially one intended to be used non-interactively.)
+
+- **If it’s for _networking_:**
+
+  - `tools/networking` (e.g. `wget`)
+
+- **If it’s for _text processing_:**
+
+  - `tools/text` (e.g. `diffutils`)
+
+- **If it’s a _system utility_, i.e., something related or essential to the operation of a system:**
+
+  - `tools/system` (e.g. `cron`)
+
+- **If it’s an _archiver_ (which may include a compression function):**
+
+  - `tools/archivers` (e.g. `zip`, `tar`)
+
+- **If it’s a _compression_ program:**
+
+  - `tools/compression` (e.g. `gzip`, `bzip2`)
+
+- **If it’s a _security_-related program:**
+
+  - `tools/security` (e.g. `nmap`, `gnupg`)
+
+- **Else:**
+
+  - `tools/misc`
+
+**If it’s a _shell_:**
+
+- `shells` (e.g. `bash`)
+
+**If it’s a _server_:**
+
+- **If it’s a web server:**
+
+  - `servers/http` (e.g. `apache-httpd`)
+
+- **If it’s an implementation of the X Windowing System:**
+
+  - `servers/x11` (e.g. `xorg` — this includes the client libraries and programs)
+
+- **Else:**
+
+  - `servers/misc`
+
+**If it’s a _desktop environment_:**
+
+- `desktops` (e.g. `kde`, `gnome`, `enlightenment`)
+
+**If it’s a _window manager_:**
+
+- `applications/window-managers` (e.g. `awesome`, `stumpwm`)
+
+**If it’s an _application_:**
+
+A (typically large) program with a distinct user interface, primarily used interactively.
+
+- **If it’s a _version management system_:**
+
+  - `applications/version-management` (e.g. `subversion`)
+
+- **If it’s a _terminal emulator_:**
+
+  - `applications/terminal-emulators` (e.g. `alacritty` or `rxvt` or `termite`)
+
+- **If it’s for _video playback / editing_:**
+
+  - `applications/video` (e.g. `vlc`)
+
+- **If it’s for _graphics viewing / editing_:**
+
+  - `applications/graphics` (e.g. `gimp`)
+
+- **If it’s for _networking_:**
+
+  - **If it’s a _mailreader_:**
+
+    - `applications/networking/mailreaders` (e.g. `thunderbird`)
+
+  - **If it’s a _newsreader_:**
+
+    - `applications/networking/newsreaders` (e.g. `pan`)
+
+  - **If it’s a _web browser_:**
+
+    - `applications/networking/browsers` (e.g. `firefox`)
+
+  - **Else:**
+
+    - `applications/networking/misc`
+
+- **Else:**
+
+  - `applications/misc`
+
+**If it’s _data_ (i.e., does not have a straight-forward executable semantics):**
+
+- **If it’s a _font_:**
+
+  - `data/fonts`
+
+- **If it’s an _icon theme_:**
+
+  - `data/icons`
+
+- **If it’s related to _SGML/XML processing_:**
+
+  - **If it’s an _XML DTD_:**
+
+    - `data/sgml+xml/schemas/xml-dtd` (e.g. `docbook`)
+
+  - **If it’s an _XSLT stylesheet_:**
+
+    (Okay, these are executable...)
+
+    - `data/sgml+xml/stylesheets/xslt` (e.g. `docbook-xsl`)
+
+- **If it’s a _theme_ for a _desktop environment_, a _window manager_ or a _display manager_:**
+
+  - `data/themes`
+
+**If it’s a _game_:**
+
+- `games`
+
+**Else:**
+
+- `misc`
+
+### Versioning {#sec-versioning}
+
+Because every version of a package in Nixpkgs creates a potential maintenance burden, old versions of a package should not be kept unless there is a good reason to do so. For instance, Nixpkgs contains several versions of GCC because other packages don’t build with the latest version of GCC. Other examples are having both the latest stable and latest pre-release version of a package, or to keep several major releases of an application that differ significantly in functionality.
+
+If there is only one version of a package, its Nix expression should be named `e2fsprogs/default.nix`. If there are multiple versions, this should be reflected in the filename, e.g. `e2fsprogs/1.41.8.nix` and `e2fsprogs/1.41.9.nix`. The version in the filename should leave out unnecessary detail. For instance, if we keep the latest Firefox 2.0.x and 3.5.x versions in Nixpkgs, they should be named `firefox/2.0.nix` and `firefox/3.5.nix`, respectively (which, at a given point, might contain versions `2.0.0.20` and `3.5.4`). If a version requires many auxiliary files, you can use a subdirectory for each version, e.g. `firefox/2.0/default.nix` and `firefox/3.5/default.nix`.
+
+All versions of a package _must_ be included in `all-packages.nix` to make sure that they evaluate correctly.
+
+## Fetching Sources {#sec-sources}
+
+There are multiple ways to fetch a package source in nixpkgs. The general guideline is that you should package reproducible sources with a high degree of availability. Right now there is only one fetcher which has mirroring support and that is `fetchurl`. Note that you should also prefer protocols which have a corresponding proxy environment variable.
+
+You can find many source fetch helpers in `pkgs/build-support/fetch*`.
+
+In the file `pkgs/top-level/all-packages.nix` you can find fetch helpers, these have names on the form `fetchFrom*`. The intention of these are to provide snapshot fetches but using the same api as some of the version controlled fetchers from `pkgs/build-support/`. As an example going from bad to good:
+
+- Bad: Uses `git://` which won't be proxied.
+
+  ```nix
+  src = fetchgit {
+    url = "git://github.com/NixOS/nix.git";
+    rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
+    sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";
+  }
+  ```
+
+- Better: This is ok, but an archive fetch will still be faster.
+
+  ```nix
+  src = fetchgit {
+    url = "https://github.com/NixOS/nix.git";
+    rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
+    sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";
+  }
+  ```
+
+- Best: Fetches a snapshot archive and you get the rev you want.
+
+  ```nix
+  src = fetchFromGitHub {
+    owner = "NixOS";
+    repo = "nix";
+    rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
+    sha256 = "1i2yxndxb6yc9l6c99pypbd92lfq5aac4klq7y2v93c9qvx2cgpc";
+  }
+  ```
+
+  Find the value to put as `sha256` by running `nix run -f '<nixpkgs>' nix-prefetch-github -c nix-prefetch-github --rev 1f795f9f44607cc5bec70d1300150bfefcef2aae NixOS nix` or `nix-prefetch-url --unpack https://github.com/NixOS/nix/archive/1f795f9f44607cc5bec70d1300150bfefcef2aae.tar.gz`.
+
+## Obtaining source hash {#sec-source-hashes}
+
+Preferred source hash type is sha256. There are several ways to get it.
+
+1. Prefetch URL (with `nix-prefetch-XXX URL`, where `XXX` is one of `url`, `git`, `hg`, `cvs`, `bzr`, `svn`). Hash is printed to stdout.
+
+2. Prefetch by package source (with `nix-prefetch-url '<nixpkgs>' -A PACKAGE.src`, where `PACKAGE` is package attribute name). Hash is printed to stdout.
+
+    This works well when you've upgraded existing package version and want to find out new hash, but is useless if package can't be accessed by attribute or package has multiple sources (`.srcs`, architecture-dependent sources, etc).
+
+3. Upstream provided hash: use it when upstream provides `sha256` or `sha512` (when upstream provides `md5`, don't use it, compute `sha256` instead).
+
+    A little nuance is that `nix-prefetch-*` tools produce hash encoded with `base32`, but upstream usually provides hexadecimal (`base16`) encoding. Fetchers understand both formats. Nixpkgs does not standardize on any one format.
+
+    You can convert between formats with nix-hash, for example:
+
+    ```ShellSession
+    $ nix-hash --type sha256 --to-base32 HASH
+    ```
+
+4. Extracting hash from local source tarball can be done with `sha256sum`. Use `nix-prefetch-url file:///path/to/tarball` if you want base32 hash.
+
+5. Fake hash: set fake hash in package expression, perform build and extract correct hash from error Nix prints.
+
+    For package updates it is enough to change one symbol to make hash fake. For new packages, you can use `lib.fakeSha256`, `lib.fakeSha512` or any other fake hash.
+
+    This is last resort method when reconstructing source URL is non-trivial and `nix-prefetch-url -A` isn’t applicable (for example, [one of `kodi` dependencies](https://github.com/NixOS/nixpkgs/blob/d2ab091dd308b99e4912b805a5eb088dd536adb9/pkgs/applications/video/kodi/default.nix#L73)). The easiest way then would be replace hash with a fake one and rebuild. Nix build will fail and error message will contain desired hash.
+
+::: {.warning}
+This method has security problems. Check below for details.
+:::
+
+### Obtaining hashes securely {#sec-source-hashes-security}
+
+Let's say Man-in-the-Middle (MITM) sits close to your network. Then instead of fetching source you can fetch malware, and instead of source hash you get hash of malware. Here are security considerations for this scenario:
+
+- `http://` URLs are not secure to prefetch hash from;
+
+- hashes from upstream (in method 3) should be obtained via secure protocol;
+
+- `https://` URLs are secure in methods 1, 2, 3;
+
+- `https://` URLs are not secure in method 5. When obtaining hashes with fake hash method, TLS checks are disabled. So refetch source hash from several different networks to exclude MITM scenario. Alternatively, use fake hash method to make Nix error, but instead of extracting hash from error, extract `https://` URL and prefetch it with method 1.
+
+## Patches {#sec-patches}
+
+Patches available online should be retrieved using `fetchpatch`.
+
+```nix
+patches = [
+  (fetchpatch {
+    name = "fix-check-for-using-shared-freetype-lib.patch";
+    url = "http://git.ghostscript.com/?p=ghostpdl.git;a=patch;h=8f5d285";
+    sha256 = "1f0k043rng7f0rfl9hhb89qzvvksqmkrikmm38p61yfx51l325xr";
+  })
+];
+```
+
+Otherwise, you can add a `.patch` file to the `nixpkgs` repository. In the interest of keeping our maintenance burden to a minimum, only patches that are unique to `nixpkgs` should be added in this way.
+
+```nix
+patches = [ ./0001-changes.patch ];
+```
+
+If you do need to do create this sort of patch file, one way to do so is with git:
+
+1. Move to the root directory of the source code you're patching.
+
+    ```ShellSession
+    $ cd the/program/source
+    ```
+
+2. If a git repository is not already present, create one and stage all of the source files.
+
+    ```ShellSession
+    $ git init
+    $ git add .
+    ```
+
+3. Edit some files to make whatever changes need to be included in the patch.
+
+4. Use git to create a diff, and pipe the output to a patch file:
+
+    ```ShellSession
+    $ git diff > nixpkgs/pkgs/the/package/0001-changes.patch
+    ```
+
+If a patch is available online but does not cleanly apply, it can be modified in some fixed ways by using additional optional arguments for `fetchpatch`:
+
+- `stripLen`: Remove the first `stripLen` components of pathnames in the patch.
+- `extraPrefix`: Prefix pathnames by this string.
+- `excludes`: Exclude files matching this pattern.
+- `includes`: Include only files matching this pattern.
+- `revert`: Revert the patch.
+
+Note that because the checksum is computed after applying these effects, using or modifying these arguments will have no effect unless the `sha256` argument is changed as well.
+
+## Package tests {#sec-package-tests}
+
+Tests are important to ensure quality and make reviews and automatic updates easy.
+
+Nix package tests are a lightweight alternative to [NixOS module tests](https://nixos.org/manual/nixos/stable/#sec-nixos-tests). They can be used to create simple integration tests for packages while the module tests are used to test services or programs with a graphical user interface on a NixOS VM. Unittests that are included in the source code of a package should be executed in the `checkPhase`.
+
+### Writing package tests {#ssec-package-tests-writing}
+
+This is an example using the `phoronix-test-suite` package with the current best practices.
+
+Add the tests in `passthru.tests` to the package definition like this:
+
+```nix
+{ stdenv, lib, fetchurl, callPackage }:
+
+stdenv.mkDerivation {
+  …
+
+  passthru.tests = {
+    simple-execution = callPackage ./tests.nix { };
+  };
+
+  meta = { … };
+}
+```
+
+Create `tests.nix` in the package directory:
+
+```nix
+{ runCommand, phoronix-test-suite }:
+
+let
+  inherit (phoronix-test-suite) pname version;
+in
+
+runCommand "${pname}-tests" { meta.timeout = 3; }
+  ''
+    # automatic initial setup to prevent interactive questions
+    ${phoronix-test-suite}/bin/phoronix-test-suite enterprise-setup >/dev/null
+    # get version of installed program and compare with package version
+    if [[ `${phoronix-test-suite}/bin/phoronix-test-suite version` != *"${version}"*  ]]; then
+      echo "Error: program version does not match package version"
+      exit 1
+    fi
+    # run dummy command
+    ${phoronix-test-suite}/bin/phoronix-test-suite dummy_module.dummy-command >/dev/null
+    # needed for Nix to register the command as successful
+    touch $out
+  ''
+```
+
+### Running package tests {#ssec-package-tests-running}
+
+You can run these tests with:
+
+```ShellSession
+$ cd path/to/nixpkgs
+$ nix-build -A phoronix-test-suite.tests
+```
+
+### Examples of package tests {#ssec-package-tests-examples}
+
+Here are examples of package tests:
+
+- [Jasmin compile test](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/compilers/jasmin/test-assemble-hello-world/default.nix)
+- [Lobster compile test](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/compilers/lobster/test-can-run-hello-world.nix)
+- [Spacy annotation test](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/python-modules/spacy/annotation-test/default.nix)
+- [Libtorch test](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/libraries/science/math/libtorch/test/default.nix)
+- [Multiple tests for nanopb](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/libraries/nanopb/default.nix)
diff --git a/doc/contributing/coding-conventions.xml b/doc/contributing/coding-conventions.xml
deleted file mode 100644
index fcb6501f615..00000000000
--- a/doc/contributing/coding-conventions.xml
+++ /dev/null
@@ -1,924 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-conventions">
- <title>Coding conventions</title>
- <section xml:id="sec-syntax">
-  <title>Syntax</title>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Use 2 spaces of indentation per indentation level in Nix expressions, 4 spaces in shell scripts.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Do not use tab characters, i.e. configure your editor to use soft tabs. For instance, use <literal>(setq-default indent-tabs-mode nil)</literal> in Emacs. Everybody has different tab settings so it’s asking for trouble.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Use <literal>lowerCamelCase</literal> for variable names, not <literal>UpperCamelCase</literal>. Note, this rule does not apply to package attribute names, which instead follow the rules in <xref linkend="sec-package-naming"/>.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Function calls with attribute set arguments are written as
-<programlisting>
-foo {
-  arg = ...;
-}
-</programlisting>
-     not
-<programlisting>
-foo
-{
-  arg = ...;
-}
-</programlisting>
-     Also fine is
-<programlisting>
-foo { arg = ...; }
-</programlisting>
-     if it's a short call.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     In attribute sets or lists that span multiple lines, the attribute names or list elements should be aligned:
-<programlisting>
-# A long list.
-list = [
-  elem1
-  elem2
-  elem3
-];
-
-# A long attribute set.
-attrs = {
-  attr1 = short_expr;
-  attr2 =
-    if true then big_expr else big_expr;
-};
-
-# Combined
-listOfAttrs = [
-  {
-    attr1 = 3;
-    attr2 = "fff";
-  }
-  {
-    attr1 = 5;
-    attr2 = "ggg";
-  }
-];
-</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Short lists or attribute sets can be written on one line:
-<programlisting>
-# A short list.
-list = [ elem1 elem2 elem3 ];
-
-# A short set.
-attrs = { x = 1280; y = 1024; };
-</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Breaking in the middle of a function argument can give hard-to-read code, like
-<programlisting>
-someFunction { x = 1280;
-  y = 1024; } otherArg
-  yetAnotherArg
-</programlisting>
-     (especially if the argument is very large, spanning multiple lines).
-    </para>
-    <para>
-     Better:
-<programlisting>
-someFunction
-  { x = 1280; y = 1024; }
-  otherArg
-  yetAnotherArg
-</programlisting>
-     or
-<programlisting>
-let res = { x = 1280; y = 1024; };
-in someFunction res otherArg yetAnotherArg
-</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     The bodies of functions, asserts, and withs are not indented to prevent a lot of superfluous indentation levels, i.e.
-<programlisting>
-{ arg1, arg2 }:
-assert system == "i686-linux";
-stdenv.mkDerivation { ...
-</programlisting>
-     not
-<programlisting>
-{ arg1, arg2 }:
-  assert system == "i686-linux";
-    stdenv.mkDerivation { ...
-</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Function formal arguments are written as:
-<programlisting>
-{ arg1, arg2, arg3 }:
-</programlisting>
-     but if they don't fit on one line they're written as:
-<programlisting>
-{ arg1, arg2, arg3
-, arg4, ...
-, # Some comment...
-  argN
-}:
-</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Functions should list their expected arguments as precisely as possible. That is, write
-<programlisting>
-{ stdenv, fetchurl, perl }: <replaceable>...</replaceable>
-</programlisting>
-     instead of
-<programlisting>
-args: with args; <replaceable>...</replaceable>
-</programlisting>
-     or
-<programlisting>
-{ stdenv, fetchurl, perl, ... }: <replaceable>...</replaceable>
-</programlisting>
-    </para>
-    <para>
-     For functions that are truly generic in the number of arguments (such as wrappers around <varname>mkDerivation</varname>) that have some required arguments, you should write them using an <literal>@</literal>-pattern:
-<programlisting>
-{ stdenv, doCoverageAnalysis ? false, ... } @ args:
-
-stdenv.mkDerivation (args // {
-  <replaceable>...</replaceable> if doCoverageAnalysis then "bla" else "" <replaceable>...</replaceable>
-})
-</programlisting>
-     instead of
-<programlisting>
-args:
-
-args.stdenv.mkDerivation (args // {
-  <replaceable>...</replaceable> if args ? doCoverageAnalysis &amp;&amp; args.doCoverageAnalysis then "bla" else "" <replaceable>...</replaceable>
-})
-</programlisting>
-    </para>
-   </listitem>
-  </itemizedlist>
- </section>
- <section xml:id="sec-package-naming">
-  <title>Package naming</title>
-
-  <para>
-   The key words <emphasis>must</emphasis>, <emphasis>must not</emphasis>, <emphasis>required</emphasis>, <emphasis>shall</emphasis>, <emphasis>shall not</emphasis>, <emphasis>should</emphasis>, <emphasis>should not</emphasis>, <emphasis>recommended</emphasis>, <emphasis>may</emphasis>, and <emphasis>optional</emphasis> in this section are to be interpreted as described in <link xlink:href="https://tools.ietf.org/html/rfc2119">RFC 2119</link>. Only <emphasis>emphasized</emphasis> words are to be interpreted in this way.
-  </para>
-
-  <para>
-   In Nixpkgs, there are generally three different names associated with a package:
-   <itemizedlist>
-    <listitem>
-     <para>
-      The <varname>name</varname> attribute of the derivation (excluding the version part). This is what most users see, in particular when using <command>nix-env</command>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      The variable name used for the instantiated package in <filename>all-packages.nix</filename>, and when passing it as a dependency to other functions. Typically this is called the <emphasis>package attribute name</emphasis>. This is what Nix expression authors see. It can also be used when installing using <command>nix-env -iA</command>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      The filename for (the directory containing) the Nix expression.
-     </para>
-    </listitem>
-   </itemizedlist>
-   Most of the time, these are the same. For instance, the package <literal>e2fsprogs</literal> has a <varname>name</varname> attribute <literal>"e2fsprogs-<replaceable>version</replaceable>"</literal>, is bound to the variable name <varname>e2fsprogs</varname> in <filename>all-packages.nix</filename>, and the Nix expression is in <filename>pkgs/os-specific/linux/e2fsprogs/default.nix</filename>.
-  </para>
-
-  <para>
-   There are a few naming guidelines:
-   <itemizedlist>
-    <listitem>
-     <para>
-      The <literal>name</literal> attribute <emphasis>should</emphasis> be identical to the upstream package name.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      The <literal>name</literal> attribute <emphasis>must not</emphasis> contain uppercase letters — e.g., <literal>"mplayer-1.0rc2"</literal> instead of <literal>"MPlayer-1.0rc2"</literal>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      The version part of the <literal>name</literal> attribute <emphasis>must</emphasis> start with a digit (following a dash) — e.g., <literal>"hello-0.3.1rc2"</literal>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      If a package is not a release but a commit from a repository, then the version part of the name <emphasis>must</emphasis> be the date of that (fetched) commit. The date <emphasis>must</emphasis> be in <literal>"YYYY-MM-DD"</literal> format. Also append <literal>"unstable"</literal> to the name - e.g., <literal>"pkgname-unstable-2014-09-23"</literal>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      Dashes in the package name <emphasis>should</emphasis> be preserved in new variable names, rather than converted to underscores or camel cased — e.g., <varname>http-parser</varname> instead of <varname>http_parser</varname> or <varname>httpParser</varname>. The hyphenated style is preferred in all three package names.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      If there are multiple versions of a package, this <emphasis>should</emphasis> be reflected in the variable names in <filename>all-packages.nix</filename>, e.g. <varname>json-c-0-9</varname> and <varname>json-c-0-11</varname>. If there is an obvious “default” version, make an attribute like <literal>json-c = json-c-0-9;</literal>. See also <xref linkend="sec-versioning" />
-     </para>
-    </listitem>
-   </itemizedlist>
-  </para>
- </section>
- <section xml:id="sec-organisation">
-  <title>File naming and organisation</title>
-
-  <para>
-   Names of files and directories should be in lowercase, with dashes between words — not in camel case. For instance, it should be <filename>all-packages.nix</filename>, not <filename>allPackages.nix</filename> or <filename>AllPackages.nix</filename>.
-  </para>
-
-  <section xml:id="sec-hierarchy">
-   <title>Hierarchy</title>
-
-   <para>
-    Each package should be stored in its own directory somewhere in the <filename>pkgs/</filename> tree, i.e. in <filename>pkgs/<replaceable>category</replaceable>/<replaceable>subcategory</replaceable>/<replaceable>...</replaceable>/<replaceable>pkgname</replaceable></filename>. Below are some rules for picking the right category for a package. Many packages fall under several categories; what matters is the <emphasis>primary</emphasis> purpose of a package. For example, the <literal>libxml2</literal> package builds both a library and some tools; but it’s a library foremost, so it goes under <filename>pkgs/development/libraries</filename>.
-   </para>
-
-   <para>
-    When in doubt, consider refactoring the <filename>pkgs/</filename> tree, e.g. creating new categories or splitting up an existing category.
-   </para>
-
-   <variablelist>
-    <varlistentry>
-     <term>
-      If it’s used to support <emphasis>software development</emphasis>:
-     </term>
-     <listitem>
-      <variablelist>
-       <varlistentry>
-        <term>
-         If it’s a <emphasis>library</emphasis> used by other packages:
-        </term>
-        <listitem>
-         <para>
-          <filename>development/libraries</filename> (e.g. <filename>libxml2</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s a <emphasis>compiler</emphasis>:
-        </term>
-        <listitem>
-         <para>
-          <filename>development/compilers</filename> (e.g. <filename>gcc</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s an <emphasis>interpreter</emphasis>:
-        </term>
-        <listitem>
-         <para>
-          <filename>development/interpreters</filename> (e.g. <filename>guile</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s a (set of) development <emphasis>tool(s)</emphasis>:
-        </term>
-        <listitem>
-         <variablelist>
-          <varlistentry>
-           <term>
-            If it’s a <emphasis>parser generator</emphasis> (including lexers):
-           </term>
-           <listitem>
-            <para>
-             <filename>development/tools/parsing</filename> (e.g. <filename>bison</filename>, <filename>flex</filename>)
-            </para>
-           </listitem>
-          </varlistentry>
-          <varlistentry>
-           <term>
-            If it’s a <emphasis>build manager</emphasis>:
-           </term>
-           <listitem>
-            <para>
-             <filename>development/tools/build-managers</filename> (e.g. <filename>gnumake</filename>)
-            </para>
-           </listitem>
-          </varlistentry>
-          <varlistentry>
-           <term>
-            Else:
-           </term>
-           <listitem>
-            <para>
-             <filename>development/tools/misc</filename> (e.g. <filename>binutils</filename>)
-            </para>
-           </listitem>
-          </varlistentry>
-         </variablelist>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         Else:
-        </term>
-        <listitem>
-         <para>
-          <filename>development/misc</filename>
-         </para>
-        </listitem>
-       </varlistentry>
-      </variablelist>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      If it’s a (set of) <emphasis>tool(s)</emphasis>:
-     </term>
-     <listitem>
-      <para>
-       (A tool is a relatively small program, especially one intended to be used non-interactively.)
-      </para>
-      <variablelist>
-       <varlistentry>
-        <term>
-         If it’s for <emphasis>networking</emphasis>:
-        </term>
-        <listitem>
-         <para>
-          <filename>tools/networking</filename> (e.g. <filename>wget</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s for <emphasis>text processing</emphasis>:
-        </term>
-        <listitem>
-         <para>
-          <filename>tools/text</filename> (e.g. <filename>diffutils</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s a <emphasis>system utility</emphasis>, i.e., something related or essential to the operation of a system:
-        </term>
-        <listitem>
-         <para>
-          <filename>tools/system</filename> (e.g. <filename>cron</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s an <emphasis>archiver</emphasis> (which may include a compression function):
-        </term>
-        <listitem>
-         <para>
-          <filename>tools/archivers</filename> (e.g. <filename>zip</filename>, <filename>tar</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s a <emphasis>compression</emphasis> program:
-        </term>
-        <listitem>
-         <para>
-          <filename>tools/compression</filename> (e.g. <filename>gzip</filename>, <filename>bzip2</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s a <emphasis>security</emphasis>-related program:
-        </term>
-        <listitem>
-         <para>
-          <filename>tools/security</filename> (e.g. <filename>nmap</filename>, <filename>gnupg</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         Else:
-        </term>
-        <listitem>
-         <para>
-          <filename>tools/misc</filename>
-         </para>
-        </listitem>
-       </varlistentry>
-      </variablelist>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      If it’s a <emphasis>shell</emphasis>:
-     </term>
-     <listitem>
-      <para>
-       <filename>shells</filename> (e.g. <filename>bash</filename>)
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      If it’s a <emphasis>server</emphasis>:
-     </term>
-     <listitem>
-      <variablelist>
-       <varlistentry>
-        <term>
-         If it’s a web server:
-        </term>
-        <listitem>
-         <para>
-          <filename>servers/http</filename> (e.g. <filename>apache-httpd</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s an implementation of the X Windowing System:
-        </term>
-        <listitem>
-         <para>
-          <filename>servers/x11</filename> (e.g. <filename>xorg</filename> — this includes the client libraries and programs)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         Else:
-        </term>
-        <listitem>
-         <para>
-          <filename>servers/misc</filename>
-         </para>
-        </listitem>
-       </varlistentry>
-      </variablelist>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      If it’s a <emphasis>desktop environment</emphasis>:
-     </term>
-     <listitem>
-      <para>
-       <filename>desktops</filename> (e.g. <filename>kde</filename>, <filename>gnome</filename>, <filename>enlightenment</filename>)
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      If it’s a <emphasis>window manager</emphasis>:
-     </term>
-     <listitem>
-      <para>
-       <filename>applications/window-managers</filename> (e.g. <filename>awesome</filename>, <filename>stumpwm</filename>)
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      If it’s an <emphasis>application</emphasis>:
-     </term>
-     <listitem>
-      <para>
-       A (typically large) program with a distinct user interface, primarily used interactively.
-      </para>
-      <variablelist>
-       <varlistentry>
-        <term>
-         If it’s a <emphasis>version management system</emphasis>:
-        </term>
-        <listitem>
-         <para>
-          <filename>applications/version-management</filename> (e.g. <filename>subversion</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s for <emphasis>video playback / editing</emphasis>:
-        </term>
-        <listitem>
-         <para>
-          <filename>applications/video</filename> (e.g. <filename>vlc</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s for <emphasis>graphics viewing / editing</emphasis>:
-        </term>
-        <listitem>
-         <para>
-          <filename>applications/graphics</filename> (e.g. <filename>gimp</filename>)
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s for <emphasis>networking</emphasis>:
-        </term>
-        <listitem>
-         <variablelist>
-          <varlistentry>
-           <term>
-            If it’s a <emphasis>mailreader</emphasis>:
-           </term>
-           <listitem>
-            <para>
-             <filename>applications/networking/mailreaders</filename> (e.g. <filename>thunderbird</filename>)
-            </para>
-           </listitem>
-          </varlistentry>
-          <varlistentry>
-           <term>
-            If it’s a <emphasis>newsreader</emphasis>:
-           </term>
-           <listitem>
-            <para>
-             <filename>applications/networking/newsreaders</filename> (e.g. <filename>pan</filename>)
-            </para>
-           </listitem>
-          </varlistentry>
-          <varlistentry>
-           <term>
-            If it’s a <emphasis>web browser</emphasis>:
-           </term>
-           <listitem>
-            <para>
-             <filename>applications/networking/browsers</filename> (e.g. <filename>firefox</filename>)
-            </para>
-           </listitem>
-          </varlistentry>
-          <varlistentry>
-           <term>
-            Else:
-           </term>
-           <listitem>
-            <para>
-             <filename>applications/networking/misc</filename>
-            </para>
-           </listitem>
-          </varlistentry>
-         </variablelist>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         Else:
-        </term>
-        <listitem>
-         <para>
-          <filename>applications/misc</filename>
-         </para>
-        </listitem>
-       </varlistentry>
-      </variablelist>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      If it’s <emphasis>data</emphasis> (i.e., does not have a straight-forward executable semantics):
-     </term>
-     <listitem>
-      <variablelist>
-       <varlistentry>
-        <term>
-         If it’s a <emphasis>font</emphasis>:
-        </term>
-        <listitem>
-         <para>
-          <filename>data/fonts</filename>
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s an <emphasis>icon theme</emphasis>:
-        </term>
-        <listitem>
-         <para>
-          <filename>data/icons</filename>
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s related to <emphasis>SGML/XML processing</emphasis>:
-        </term>
-        <listitem>
-         <variablelist>
-          <varlistentry>
-           <term>
-            If it’s an <emphasis>XML DTD</emphasis>:
-           </term>
-           <listitem>
-            <para>
-             <filename>data/sgml+xml/schemas/xml-dtd</filename> (e.g. <filename>docbook</filename>)
-            </para>
-           </listitem>
-          </varlistentry>
-          <varlistentry>
-           <term>
-            If it’s an <emphasis>XSLT stylesheet</emphasis>:
-           </term>
-           <listitem>
-            <para>
-             (Okay, these are executable...)
-            </para>
-            <para>
-             <filename>data/sgml+xml/stylesheets/xslt</filename> (e.g. <filename>docbook-xsl</filename>)
-            </para>
-           </listitem>
-          </varlistentry>
-         </variablelist>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         If it’s a <emphasis>theme</emphasis> for a <emphasis>desktop environment</emphasis>,
-         a <emphasis>window manager</emphasis> or a <emphasis>display manager</emphasis>:
-        </term>
-        <listitem>
-         <para>
-          <filename>data/themes</filename>
-         </para>
-        </listitem>
-       </varlistentry>
-      </variablelist>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      If it’s a <emphasis>game</emphasis>:
-     </term>
-     <listitem>
-      <para>
-       <filename>games</filename>
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      Else:
-     </term>
-     <listitem>
-      <para>
-       <filename>misc</filename>
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
-
-  <section xml:id="sec-versioning">
-   <title>Versioning</title>
-
-   <para>
-    Because every version of a package in Nixpkgs creates a potential maintenance burden, old versions of a package should not be kept unless there is a good reason to do so. For instance, Nixpkgs contains several versions of GCC because other packages don’t build with the latest version of GCC. Other examples are having both the latest stable and latest pre-release version of a package, or to keep several major releases of an application that differ significantly in functionality.
-   </para>
-
-   <para>
-    If there is only one version of a package, its Nix expression should be named <filename>e2fsprogs/default.nix</filename>. If there are multiple versions, this should be reflected in the filename, e.g. <filename>e2fsprogs/1.41.8.nix</filename> and <filename>e2fsprogs/1.41.9.nix</filename>. The version in the filename should leave out unnecessary detail. For instance, if we keep the latest Firefox 2.0.x and 3.5.x versions in Nixpkgs, they should be named <filename>firefox/2.0.nix</filename> and <filename>firefox/3.5.nix</filename>, respectively (which, at a given point, might contain versions <literal>2.0.0.20</literal> and <literal>3.5.4</literal>). If a version requires many auxiliary files, you can use a subdirectory for each version, e.g. <filename>firefox/2.0/default.nix</filename> and <filename>firefox/3.5/default.nix</filename>.
-   </para>
-
-   <para>
-    All versions of a package <emphasis>must</emphasis> be included in <filename>all-packages.nix</filename> to make sure that they evaluate correctly.
-   </para>
-  </section>
- </section>
- <section xml:id="sec-sources">
-  <title>Fetching Sources</title>
-
-  <para>
-   There are multiple ways to fetch a package source in nixpkgs. The general guideline is that you should package reproducible sources with a high degree of availability. Right now there is only one fetcher which has mirroring support and that is <literal>fetchurl</literal>. Note that you should also prefer protocols which have a corresponding proxy environment variable.
-  </para>
-
-  <para>
-   You can find many source fetch helpers in <literal>pkgs/build-support/fetch*</literal>.
-  </para>
-
-  <para>
-   In the file <literal>pkgs/top-level/all-packages.nix</literal> you can find fetch helpers, these have names on the form <literal>fetchFrom*</literal>. The intention of these are to provide snapshot fetches but using the same api as some of the version controlled fetchers from <literal>pkgs/build-support/</literal>. As an example going from bad to good:
-   <itemizedlist>
-    <listitem>
-     <para>
-      Bad: Uses <literal>git://</literal> which won't be proxied.
-<programlisting>
-src = fetchgit {
-  url = "git://github.com/NixOS/nix.git";
-  rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
-  sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";
-}
-</programlisting>
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      Better: This is ok, but an archive fetch will still be faster.
-<programlisting>
-src = fetchgit {
-  url = "https://github.com/NixOS/nix.git";
-  rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
-  sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";
-}
-</programlisting>
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      Best: Fetches a snapshot archive and you get the rev you want.
-<programlisting>
-src = fetchFromGitHub {
-  owner = "NixOS";
-  repo = "nix";
-  rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
-  sha256 = "1i2yxndxb6yc9l6c99pypbd92lfq5aac4klq7y2v93c9qvx2cgpc";
-}
-</programlisting>
-      Find the value to put as <literal>sha256</literal> by running <literal>nix run -f '&lt;nixpkgs&gt;' nix-prefetch-github -c nix-prefetch-github --rev 1f795f9f44607cc5bec70d1300150bfefcef2aae NixOS nix</literal> or <literal>nix-prefetch-url --unpack https://github.com/NixOS/nix/archive/1f795f9f44607cc5bec70d1300150bfefcef2aae.tar.gz</literal>.
-     </para>
-    </listitem>
-   </itemizedlist>
-  </para>
- </section>
- <section xml:id="sec-source-hashes">
-  <title>Obtaining source hash</title>
-
-  <para>
-   Preferred source hash type is sha256. There are several ways to get it.
-  </para>
-
-  <orderedlist>
-   <listitem>
-    <para>
-     Prefetch URL (with <literal>nix-prefetch-<replaceable>XXX</replaceable> <replaceable>URL</replaceable></literal>, where <replaceable>XXX</replaceable> is one of <literal>url</literal>, <literal>git</literal>, <literal>hg</literal>, <literal>cvs</literal>, <literal>bzr</literal>, <literal>svn</literal>). Hash is printed to stdout.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Prefetch by package source (with <literal>nix-prefetch-url '&lt;nixpkgs&gt;' -A <replaceable>PACKAGE</replaceable>.src</literal>, where <replaceable>PACKAGE</replaceable> is package attribute name). Hash is printed to stdout.
-    </para>
-    <para>
-     This works well when you've upgraded existing package version and want to find out new hash, but is useless if package can't be accessed by attribute or package has multiple sources (<literal>.srcs</literal>, architecture-dependent sources, etc).
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Upstream provided hash: use it when upstream provides <literal>sha256</literal> or <literal>sha512</literal> (when upstream provides <literal>md5</literal>, don't use it, compute <literal>sha256</literal> instead).
-    </para>
-    <para>
-     A little nuance is that <literal>nix-prefetch-*</literal> tools produce hash encoded with <literal>base32</literal>, but upstream usually provides hexadecimal (<literal>base16</literal>) encoding. Fetchers understand both formats. Nixpkgs does not standardize on any one format.
-    </para>
-    <para>
-     You can convert between formats with nix-hash, for example:
-<screen>
-<prompt>$ </prompt>nix-hash --type sha256 --to-base32 <replaceable>HASH</replaceable>
-</screen>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Extracting hash from local source tarball can be done with <literal>sha256sum</literal>. Use <literal>nix-prefetch-url file:///path/to/tarball </literal> if you want base32 hash.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Fake hash: set fake hash in package expression, perform build and extract correct hash from error Nix prints.
-    </para>
-    <para>
-     For package updates it is enough to change one symbol to make hash fake. For new packages, you can use <literal>lib.fakeSha256</literal>, <literal>lib.fakeSha512</literal> or any other fake hash.
-    </para>
-    <para>
-     This is last resort method when reconstructing source URL is non-trivial and <literal>nix-prefetch-url -A</literal> isn't applicable (for example, <link xlink:href="https://github.com/NixOS/nixpkgs/blob/d2ab091dd308b99e4912b805a5eb088dd536adb9/pkgs/applications/video/kodi/default.nix#L73"> one of <literal>kodi</literal> dependencies</link>). The easiest way then would be replace hash with a fake one and rebuild. Nix build will fail and error message will contain desired hash.
-    </para>
-    <warning>
-     <para>
-      This method has security problems. Check below for details.
-     </para>
-    </warning>
-   </listitem>
-  </orderedlist>
-
-  <section xml:id="sec-source-hashes-security">
-   <title>Obtaining hashes securely</title>
-
-   <para>
-    Let's say Man-in-the-Middle (MITM) sits close to your network. Then instead of fetching source you can fetch malware, and instead of source hash you get hash of malware. Here are security considerations for this scenario:
-   </para>
-
-   <itemizedlist>
-    <listitem>
-     <para>
-      <literal>http://</literal> URLs are not secure to prefetch hash from;
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      hashes from upstream (in method 3) should be obtained via secure protocol;
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      <literal>https://</literal> URLs are secure in methods 1, 2, 3;
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      <literal>https://</literal> URLs are not secure in method 5. When obtaining hashes with fake hash method, TLS checks are disabled. So refetch source hash from several different networks to exclude MITM scenario. Alternatively, use fake hash method to make Nix error, but instead of extracting hash from error, extract <literal>https://</literal> URL and prefetch it with method 1.
-     </para>
-    </listitem>
-   </itemizedlist>
-  </section>
- </section>
- <section xml:id="sec-patches">
-  <title>Patches</title>
-
-  <para>
-   Patches available online should be retrieved using <literal>fetchpatch</literal>.
-  </para>
-
-  <para>
-<programlisting>
-patches = [
-  (fetchpatch {
-    name = "fix-check-for-using-shared-freetype-lib.patch";
-    url = "http://git.ghostscript.com/?p=ghostpdl.git;a=patch;h=8f5d285";
-    sha256 = "1f0k043rng7f0rfl9hhb89qzvvksqmkrikmm38p61yfx51l325xr";
-  })
-];
-</programlisting>
-  </para>
-
-  <para>
-   Otherwise, you can add a <literal>.patch</literal> file to the <literal>nixpkgs</literal> repository. In the interest of keeping our maintenance burden to a minimum, only patches that are unique to <literal>nixpkgs</literal> should be added in this way.
-  </para>
-
-  <para>
-<programlisting>
-patches = [ ./0001-changes.patch ];
-</programlisting>
-  </para>
-
-  <para>
-   If you do need to do create this sort of patch file, one way to do so is with git:
-   <orderedlist>
-    <listitem>
-     <para>
-      Move to the root directory of the source code you're patching.
-<screen>
-<prompt>$ </prompt>cd the/program/source</screen>
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      If a git repository is not already present, create one and stage all of the source files.
-<screen>
-<prompt>$ </prompt>git init
-<prompt>$ </prompt>git add .</screen>
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      Edit some files to make whatever changes need to be included in the patch.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      Use git to create a diff, and pipe the output to a patch file:
-<screen>
-<prompt>$ </prompt>git diff > nixpkgs/pkgs/the/package/0001-changes.patch</screen>
-     </para>
-    </listitem>
-   </orderedlist>
-  </para>
- </section>
-</chapter>
diff --git a/doc/contributing/contributing-to-documentation.chapter.md b/doc/contributing/contributing-to-documentation.chapter.md
new file mode 100644
index 00000000000..2f7ae32259c
--- /dev/null
+++ b/doc/contributing/contributing-to-documentation.chapter.md
@@ -0,0 +1,99 @@
+# Contributing to this documentation {#chap-contributing}
+
+The sources of the Nixpkgs manual are in the [doc](https://github.com/NixOS/nixpkgs/tree/master/doc) subdirectory of the Nixpkgs repository. The manual is still partially written in DocBook but it is progressively being converted to [Markdown](#sec-contributing-markup).
+
+You can quickly check your edits with `make`:
+
+```ShellSession
+$ cd /path/to/nixpkgs/doc
+$ nix-shell
+[nix-shell]$ make
+```
+
+If you experience problems, run `make debug` to help understand the docbook errors.
+
+After making modifications to the manual, it's important to build it before committing. You can do that as follows:
+
+```ShellSession
+$ cd /path/to/nixpkgs/doc
+$ nix-shell
+[nix-shell]$ make clean
+[nix-shell]$ nix-build .
+```
+
+If the build succeeds, the manual will be in `./result/share/doc/nixpkgs/manual.html`.
+
+## Syntax {#sec-contributing-markup}
+
+As per [RFC 0072](https://github.com/NixOS/rfcs/pull/72), all new documentation content should be written in [CommonMark](https://commonmark.org/) Markdown dialect.
+
+Additionally, the following syntax extensions are currently used:
+
+- []{#ssec-contributing-markup-anchors}
+  Explicitly defined **anchors** on headings, to allow linking to sections. These should be always used, to ensure the anchors can be linked even when the heading text changes, and to prevent conflicts between [automatically assigned identifiers](https://github.com/jgm/commonmark-hs/blob/master/commonmark-extensions/test/auto_identifiers.md).
+
+  It uses the widely compatible [header attributes](https://github.com/jgm/commonmark-hs/blob/master/commonmark-extensions/test/attributes.md) syntax:
+
+  ```markdown
+  ## Syntax {#sec-contributing-markup}
+  ```
+
+- []{#ssec-contributing-markup-anchors-inline}
+  **Inline anchors**, which allow linking arbitrary place in the text (e.g. individual list items, sentences…).
+
+  They are defined using a hybrid of the link syntax with the attributes syntax known from headings, called [bracketed spans](https://github.com/jgm/commonmark-hs/blob/master/commonmark-extensions/test/bracketed_spans.md):
+
+  ```markdown
+  - []{#ssec-gnome-hooks-glib} `glib` setup hook will populate `GSETTINGS_SCHEMAS_PATH` and then `wrapGAppsHook` will prepend it to `XDG_DATA_DIRS`.
+  ```
+
+- []{#ssec-contributing-markup-automatic-links}
+  If you **omit a link text** for a link pointing to a section, the text will be substituted automatically. For example, `[](#chap-contributing)` will result in [](#chap-contributing).
+
+  This syntax is taken from [MyST](https://myst-parser.readthedocs.io/en/latest/using/syntax.html#targets-and-cross-referencing).
+
+- []{#ssec-contributing-markup-admonitions}
+  **Admonitions**, set off from the text to bring attention to something.
+
+  It uses pandoc’s [fenced `div`s syntax](https://github.com/jgm/commonmark-hs/blob/master/commonmark-extensions/test/fenced_divs.md):
+
+  ```markdown
+  ::: {.warning}
+  This is a warning
+  :::
+  ```
+
+  which renders as
+
+  > ::: {.warning}
+  > This is a warning.
+  > :::
+
+  The following are supported:
+
+    - [`caution`](https://tdg.docbook.org/tdg/5.0/caution.html)
+    - [`important`](https://tdg.docbook.org/tdg/5.0/important.html)
+    - [`note`](https://tdg.docbook.org/tdg/5.0/note.html)
+    - [`tip`](https://tdg.docbook.org/tdg/5.0/tip.html)
+    - [`warning`](https://tdg.docbook.org/tdg/5.0/warning.html)
+
+- []{#ssec-contributing-markup-definition-lists}
+  [**Definition lists**](https://github.com/jgm/commonmark-hs/blob/master/commonmark-extensions/test/definition_lists.md), for defining a group of terms:
+
+  ```markdown
+  pear
+  :   green or yellow bulbous fruit
+
+  watermelon
+  :   green fruit with red flesh
+  ```
+
+  which renders as
+
+  > pear
+  > :   green or yellow bulbous fruit
+  >
+  > watermelon
+  > :   green fruit with red flesh
+
+For contributing to the legacy parts, please see [DocBook: The Definitive Guide](https://tdg.docbook.org/) or the [DocBook rocks! primer](https://web.archive.org/web/20200816233747/https://docbook.rocks/).
diff --git a/doc/contributing/contributing-to-documentation.xml b/doc/contributing/contributing-to-documentation.xml
deleted file mode 100644
index b0266043775..00000000000
--- a/doc/contributing/contributing-to-documentation.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-contributing">
- <title>Contributing to this documentation</title>
- <para>
-  The DocBook sources of the Nixpkgs manual are in the <filename
-xlink:href="https://github.com/NixOS/nixpkgs/tree/master/doc">doc</filename> subdirectory of the Nixpkgs repository.
- </para>
- <para>
-  You can quickly check your edits with <command>make</command>:
- </para>
-<screen>
-<prompt>$ </prompt>cd /path/to/nixpkgs/doc
-<prompt>$ </prompt>nix-shell
-<prompt>[nix-shell]$ </prompt>make
-</screen>
- <para>
-  If you experience problems, run <command>make debug</command> to help understand the docbook errors.
- </para>
- <para>
-  After making modifications to the manual, it's important to build it before committing. You can do that as follows:
-<screen>
-<prompt>$ </prompt>cd /path/to/nixpkgs/doc
-<prompt>$ </prompt>nix-shell
-<prompt>[nix-shell]$ </prompt>make clean
-<prompt>[nix-shell]$ </prompt>nix-build .
-</screen>
-  If the build succeeds, the manual will be in <filename>./result/share/doc/nixpkgs/manual.html</filename>.
- </para>
-</chapter>
diff --git a/doc/contributing/quick-start.chapter.md b/doc/contributing/quick-start.chapter.md
new file mode 100644
index 00000000000..96b30d3822c
--- /dev/null
+++ b/doc/contributing/quick-start.chapter.md
@@ -0,0 +1,77 @@
+# Quick Start to Adding a Package {#chap-quick-start}
+
+To add a package to Nixpkgs:
+
+1. Checkout the Nixpkgs source tree:
+
+   ```ShellSession
+   $ git clone https://github.com/NixOS/nixpkgs
+   $ cd nixpkgs
+   ```
+
+2. Find a good place in the Nixpkgs tree to add the Nix expression for your package. For instance, a library package typically goes into `pkgs/development/libraries/pkgname`, while a web browser goes into `pkgs/applications/networking/browsers/pkgname`. See [](#sec-organisation) for some hints on the tree organisation. Create a directory for your package, e.g.
+
+   ```ShellSession
+   $ mkdir pkgs/development/libraries/libfoo
+   ```
+
+3. In the package directory, create a Nix expression — a piece of code that describes how to build the package. In this case, it should be a _function_ that is called with the package dependencies as arguments, and returns a build of the package in the Nix store. The expression should usually be called `default.nix`.
+
+   ```ShellSession
+   $ emacs pkgs/development/libraries/libfoo/default.nix
+   $ git add pkgs/development/libraries/libfoo/default.nix
+   ```
+
+   You can have a look at the existing Nix expressions under `pkgs/` to see how it’s done. Here are some good ones:
+
+   - GNU Hello: [`pkgs/applications/misc/hello/default.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/hello/default.nix). Trivial package, which specifies some `meta` attributes which is good practice.
+
+   - GNU cpio: [`pkgs/tools/archivers/cpio/default.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/tools/archivers/cpio/default.nix). Also a simple package. The generic builder in `stdenv` does everything for you. It has no dependencies beyond `stdenv`.
+
+   - GNU Multiple Precision arithmetic library (GMP): [`pkgs/development/libraries/gmp/5.1.x.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/libraries/gmp/5.1.x.nix). Also done by the generic builder, but has a dependency on `m4`.
+
+   - Pan, a GTK-based newsreader: [`pkgs/applications/networking/newsreaders/pan/default.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/networking/newsreaders/pan/default.nix). Has an optional dependency on `gtkspell`, which is only built if `spellCheck` is `true`.
+
+   - Apache HTTPD: [`pkgs/servers/http/apache-httpd/2.4.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/servers/http/apache-httpd/2.4.nix). A bunch of optional features, variable substitutions in the configure flags, a post-install hook, and miscellaneous hackery.
+
+   - Thunderbird: [`pkgs/applications/networking/mailreaders/thunderbird/default.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/networking/mailreaders/thunderbird/default.nix). Lots of dependencies.
+
+   - JDiskReport, a Java utility: [`pkgs/tools/misc/jdiskreport/default.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/tools/misc/jdiskreport/default.nix). Nixpkgs doesn’t have a decent `stdenv` for Java yet so this is pretty ad-hoc.
+
+   - XML::Simple, a Perl module: [`pkgs/top-level/perl-packages.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/top-level/perl-packages.nix) (search for the `XMLSimple` attribute). Most Perl modules are so simple to build that they are defined directly in `perl-packages.nix`; no need to make a separate file for them.
+
+   - Adobe Reader: [`pkgs/applications/misc/adobe-reader/default.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/adobe-reader/default.nix). Shows how binary-only packages can be supported. In particular the [builder](https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/adobe-reader/builder.sh) uses `patchelf` to set the RUNPATH and ELF interpreter of the executables so that the right libraries are found at runtime.
+
+   Some notes:
+
+   - All [`meta`](#chap-meta) attributes are optional, but it’s still a good idea to provide at least the `description`, `homepage` and [`license`](#sec-meta-license).
+
+   - You can use `nix-prefetch-url url` to get the SHA-256 hash of source distributions. There are similar commands as `nix-prefetch-git` and `nix-prefetch-hg` available in `nix-prefetch-scripts` package.
+
+   - A list of schemes for `mirror://` URLs can be found in [`pkgs/build-support/fetchurl/mirrors.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/build-support/fetchurl/mirrors.nix).
+
+   The exact syntax and semantics of the Nix expression language, including the built-in function, are described in the Nix manual in the [chapter on writing Nix expressions](https://hydra.nixos.org/job/nix/trunk/tarball/latest/download-by-type/doc/manual/#chap-writing-nix-expressions).
+
+4. Add a call to the function defined in the previous step to [`pkgs/top-level/all-packages.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/top-level/all-packages.nix) with some descriptive name for the variable, e.g. `libfoo`.
+
+   ```ShellSession
+   $ emacs pkgs/top-level/all-packages.nix
+   ```
+
+   The attributes in that file are sorted by category (like “Development / Libraries”) that more-or-less correspond to the directory structure of Nixpkgs, and then by attribute name.
+
+5. To test whether the package builds, run the following command from the root of the nixpkgs source tree:
+
+   ```ShellSession
+   $ nix-build -A libfoo
+   ```
+
+   where `libfoo` should be the variable name defined in the previous step. You may want to add the flag `-K` to keep the temporary build directory in case something fails. If the build succeeds, a symlink `./result` to the package in the Nix store is created.
+
+6. If you want to install the package into your profile (optional), do
+
+   ```ShellSession
+   $ nix-env -f . -iA libfoo
+   ```
+
+7. Optionally commit the new package and open a pull request [to nixpkgs](https://github.com/NixOS/nixpkgs/pulls), or use [the Patches category](https://discourse.nixos.org/t/about-the-patches-category/477) on Discourse for sending a patch without a GitHub account.
diff --git a/doc/contributing/quick-start.xml b/doc/contributing/quick-start.xml
deleted file mode 100644
index 09d60834ec2..00000000000
--- a/doc/contributing/quick-start.xml
+++ /dev/null
@@ -1,152 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-quick-start">
- <title>Quick Start to Adding a Package</title>
- <para>
-  To add a package to Nixpkgs:
-  <orderedlist>
-   <listitem>
-    <para>
-     Checkout the Nixpkgs source tree:
-<screen>
-<prompt>$ </prompt>git clone https://github.com/NixOS/nixpkgs
-<prompt>$ </prompt>cd nixpkgs</screen>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Find a good place in the Nixpkgs tree to add the Nix expression for your package. For instance, a library package typically goes into <filename>pkgs/development/libraries/<replaceable>pkgname</replaceable></filename>, while a web browser goes into <filename>pkgs/applications/networking/browsers/<replaceable>pkgname</replaceable></filename>. See <xref linkend="sec-organisation" /> for some hints on the tree organisation. Create a directory for your package, e.g.
-<screen>
-<prompt>$ </prompt>mkdir pkgs/development/libraries/libfoo</screen>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     In the package directory, create a Nix expression — a piece of code that describes how to build the package. In this case, it should be a <emphasis>function</emphasis> that is called with the package dependencies as arguments, and returns a build of the package in the Nix store. The expression should usually be called <filename>default.nix</filename>.
-<screen>
-<prompt>$ </prompt>emacs pkgs/development/libraries/libfoo/default.nix
-<prompt>$ </prompt>git add pkgs/development/libraries/libfoo/default.nix</screen>
-    </para>
-    <para>
-     You can have a look at the existing Nix expressions under <filename>pkgs/</filename> to see how it’s done. Here are some good ones:
-     <itemizedlist>
-      <listitem>
-       <para>
-        GNU Hello: <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/hello/default.nix"><filename>pkgs/applications/misc/hello/default.nix</filename></link>. Trivial package, which specifies some <varname>meta</varname> attributes which is good practice.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        GNU cpio: <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/tools/archivers/cpio/default.nix"><filename>pkgs/tools/archivers/cpio/default.nix</filename></link>. Also a simple package. The generic builder in <varname>stdenv</varname> does everything for you. It has no dependencies beyond <varname>stdenv</varname>.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        GNU Multiple Precision arithmetic library (GMP): <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/libraries/gmp/5.1.x.nix"><filename>pkgs/development/libraries/gmp/5.1.x.nix</filename></link>. Also done by the generic builder, but has a dependency on <varname>m4</varname>.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        Pan, a GTK-based newsreader: <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/networking/newsreaders/pan/default.nix"><filename>pkgs/applications/networking/newsreaders/pan/default.nix</filename></link>. Has an optional dependency on <varname>gtkspell</varname>, which is only built if <varname>spellCheck</varname> is <literal>true</literal>.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        Apache HTTPD: <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/servers/http/apache-httpd/2.4.nix"><filename>pkgs/servers/http/apache-httpd/2.4.nix</filename></link>. A bunch of optional features, variable substitutions in the configure flags, a post-install hook, and miscellaneous hackery.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        Thunderbird: <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/networking/mailreaders/thunderbird/default.nix"><filename>pkgs/applications/networking/mailreaders/thunderbird/default.nix</filename></link>. Lots of dependencies.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        JDiskReport, a Java utility: <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/tools/misc/jdiskreport/default.nix"><filename>pkgs/tools/misc/jdiskreport/default.nix</filename></link>. Nixpkgs doesn’t have a decent <varname>stdenv</varname> for Java yet so this is pretty ad-hoc.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        XML::Simple, a Perl module: <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/top-level/perl-packages.nix"><filename>pkgs/top-level/perl-packages.nix</filename></link> (search for the <varname>XMLSimple</varname> attribute). Most Perl modules are so simple to build that they are defined directly in <filename>perl-packages.nix</filename>; no need to make a separate file for them.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        Adobe Reader: <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/adobe-reader/default.nix"><filename>pkgs/applications/misc/adobe-reader/default.nix</filename></link>. Shows how binary-only packages can be supported. In particular the <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/adobe-reader/builder.sh">builder</link> uses <command>patchelf</command> to set the RUNPATH and ELF interpreter of the executables so that the right libraries are found at runtime.
-       </para>
-      </listitem>
-     </itemizedlist>
-    </para>
-    <para>
-     Some notes:
-     <itemizedlist>
-      <listitem>
-       <para>
-        All <varname linkend="chap-meta">meta</varname> attributes are optional, but it’s still a good idea to provide at least the <varname>description</varname>, <varname>homepage</varname> and <varname
-          linkend="sec-meta-license">license</varname>.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        You can use <command>nix-prefetch-url</command> <replaceable>url</replaceable> to get the SHA-256 hash of source distributions. There are similar commands as <command>nix-prefetch-git</command> and <command>nix-prefetch-hg</command> available in <literal>nix-prefetch-scripts</literal> package.
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        A list of schemes for <literal>mirror://</literal> URLs can be found in <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/build-support/fetchurl/mirrors.nix"><filename>pkgs/build-support/fetchurl/mirrors.nix</filename></link>.
-       </para>
-      </listitem>
-     </itemizedlist>
-    </para>
-    <para>
-     The exact syntax and semantics of the Nix expression language, including the built-in function, are described in the Nix manual in the <link
-    xlink:href="https://hydra.nixos.org/job/nix/trunk/tarball/latest/download-by-type/doc/manual/#chap-writing-nix-expressions">chapter on writing Nix expressions</link>.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Add a call to the function defined in the previous step to <link
-    xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/top-level/all-packages.nix"><filename>pkgs/top-level/all-packages.nix</filename></link> with some descriptive name for the variable, e.g. <varname>libfoo</varname>.
-<screen>
-<prompt>$ </prompt>emacs pkgs/top-level/all-packages.nix</screen>
-    </para>
-    <para>
-     The attributes in that file are sorted by category (like “Development / Libraries”) that more-or-less correspond to the directory structure of Nixpkgs, and then by attribute name.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     To test whether the package builds, run the following command from the root of the nixpkgs source tree:
-<screen>
-<prompt>$ </prompt>nix-build -A libfoo</screen>
-     where <varname>libfoo</varname> should be the variable name defined in the previous step. You may want to add the flag <option>-K</option> to keep the temporary build directory in case something fails. If the build succeeds, a symlink <filename>./result</filename> to the package in the Nix store is created.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     If you want to install the package into your profile (optional), do
-<screen>
-<prompt>$ </prompt>nix-env -f . -iA libfoo</screen>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Optionally commit the new package and open a pull request <link
-     xlink:href="https://github.com/NixOS/nixpkgs/pulls">to nixpkgs</link>, or use <link
-     xlink:href="https://discourse.nixos.org/t/about-the-patches-category/477"> the Patches category</link> on Discourse for sending a patch without a GitHub account.
-    </para>
-   </listitem>
-  </orderedlist>
- </para>
-</chapter>
diff --git a/doc/contributing/reviewing-contributions.chapter.md b/doc/contributing/reviewing-contributions.chapter.md
new file mode 100644
index 00000000000..3f3ba60947c
--- /dev/null
+++ b/doc/contributing/reviewing-contributions.chapter.md
@@ -0,0 +1,207 @@
+# Reviewing contributions {#chap-reviewing-contributions}
+
+::: {.warning}
+The following section is a draft, and the policy for reviewing is still being discussed in issues such as [#11166](https://github.com/NixOS/nixpkgs/issues/11166) and [#20836](https://github.com/NixOS/nixpkgs/issues/20836).
+:::
+
+The Nixpkgs project receives a fairly high number of contributions via GitHub pull requests. Reviewing and approving these is an important task and a way to contribute to the project.
+
+The high change rate of Nixpkgs makes any pull request that remains open for too long subject to conflicts that will require extra work from the submitter or the merger. Reviewing pull requests in a timely manner and being responsive to the comments is the key to avoid this issue. GitHub provides sort filters that can be used to see the [most recently](https://github.com/NixOS/nixpkgs/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc) and the [least recently](https://github.com/NixOS/nixpkgs/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-asc) updated pull requests. We highly encourage looking at [this list of ready to merge, unreviewed pull requests](https://github.com/NixOS/nixpkgs/pulls?q=is%3Apr+is%3Aopen+review%3Anone+status%3Asuccess+-label%3A%222.status%3A+work-in-progress%22+no%3Aproject+no%3Aassignee+no%3Amilestone).
+
+When reviewing a pull request, please always be nice and polite. Controversial changes can lead to controversial opinions, but it is important to respect every community member and their work.
+
+GitHub provides reactions as a simple and quick way to provide feedback to pull requests or any comments. The thumb-down reaction should be used with care and if possible accompanied with some explanation so the submitter has directions to improve their contribution.
+
+pull request reviews should include a list of what has been reviewed in a comment, so other reviewers and mergers can know the state of the review.
+
+All the review template samples provided in this section are generic and meant as examples. Their usage is optional and the reviewer is free to adapt them to their liking.
+
+## Package updates {#reviewing-contributions-package-updates}
+
+A package update is the most trivial and common type of pull request. These pull requests mainly consist of updating the version part of the package name and the source hash.
+
+It can happen that non-trivial updates include patches or more complex changes.
+
+Reviewing process:
+
+- Ensure that the package versioning fits the guidelines.
+- Ensure that the commit text fits the guidelines.
+- Ensure that the package maintainers are notified.
+  - [CODEOWNERS](https://help.github.com/articles/about-codeowners) will make GitHub notify users based on the submitted changes, but it can happen that it misses some of the package maintainers.
+- Ensure that the meta field information is correct.
+  - License can change with version updates, so it should be checked to match the upstream license.
+  - If the package has no maintainer, a maintainer must be set. This can be the update submitter or a community member that accepts to take maintainership of the package.
+- Ensure that the code contains no typos.
+- Building the package locally.
+  - pull requests are often targeted to the master or staging branch, and building the pull request locally when it is submitted can trigger many source builds.
+  - It is possible to rebase the changes on nixos-unstable or nixpkgs-unstable for easier review by running the following commands from a nixpkgs clone.
+
+    ```ShellSession
+    $ git fetch origin nixos-unstable
+    $ git fetch origin pull/PRNUMBER/head
+    $ git rebase --onto nixos-unstable BASEBRANCH FETCH_HEAD
+    ```
+
+    - The first command fetches the nixos-unstable branch.
+    - The second command fetches the pull request changes, `PRNUMBER` is the number at the end of the pull request title and `BASEBRANCH` the base branch of the pull request.
+    - The third command rebases the pull request changes to the nixos-unstable branch.
+  - The [nixpkgs-review](https://github.com/Mic92/nixpkgs-review) tool can be used to review a pull request content in a single command. `PRNUMBER` should be replaced by the number at the end of the pull request title. You can also provide the full github pull request url.
+
+    ```ShellSession
+    $ nix-shell -p nixpkgs-review --run "nixpkgs-review pr PRNUMBER"
+    ```
+- Running every binary.
+
+Sample template for a package update review is provided below.
+
+```markdown
+##### Reviewed points
+
+- [ ] package name fits guidelines
+- [ ] package version fits guidelines
+- [ ] package build on ARCHITECTURE
+- [ ] executables tested on ARCHITECTURE
+- [ ] all depending packages build
+
+##### Possible improvements
+
+##### Comments
+```
+
+## New packages {#reviewing-contributions-new-packages}
+
+New packages are a common type of pull requests. These pull requests consists in adding a new nix-expression for a package.
+
+Review process:
+
+- Ensure that the package versioning fits the guidelines.
+- Ensure that the commit name fits the guidelines.
+- Ensure that the meta fields contain correct information.
+  - License must match the upstream license.
+  - Platforms should be set (or the package will not get binary substitutes).
+  - Maintainers must be set. This can be the package submitter or a community member that accepts taking up maintainership of the package.
+- Report detected typos.
+- Ensure the package source:
+  - Uses mirror URLs when available.
+  - Uses the most appropriate functions (e.g. packages from GitHub should use `fetchFromGitHub`).
+- Building the package locally.
+- Running every binary.
+
+Sample template for a new package review is provided below.
+
+```markdown
+##### Reviewed points
+
+- [ ] package path fits guidelines
+- [ ] package name fits guidelines
+- [ ] package version fits guidelines
+- [ ] package build on ARCHITECTURE
+- [ ] executables tested on ARCHITECTURE
+- [ ] `meta.description` is set and fits guidelines
+- [ ] `meta.license` fits upstream license
+- [ ] `meta.platforms` is set
+- [ ] `meta.maintainers` is set
+- [ ] build time only dependencies are declared in `nativeBuildInputs`
+- [ ] source is fetched using the appropriate function
+- [ ] phases are respected
+- [ ] patches that are remotely available are fetched with `fetchpatch`
+
+##### Possible improvements
+
+##### Comments
+```
+
+## Module updates {#reviewing-contributions-module-updates}
+
+Module updates are submissions changing modules in some ways. These often contains changes to the options or introduce new options.
+
+Reviewing process:
+
+- Ensure that the module maintainers are notified.
+  - [CODEOWNERS](https://help.github.com/articles/about-codeowners/) will make GitHub notify users based on the submitted changes, but it can happen that it misses some of the package maintainers.
+- Ensure that the module tests, if any, are succeeding.
+- Ensure that the introduced options are correct.
+  - Type should be appropriate (string related types differs in their merging capabilities, `optionSet` and `string` types are deprecated).
+  - Description, default and example should be provided.
+- Ensure that option changes are backward compatible.
+  - `mkRenamedOptionModule` and `mkAliasOptionModule` functions provide way to make option changes backward compatible.
+- Ensure that removed options are declared with `mkRemovedOptionModule`
+- Ensure that changes that are not backward compatible are mentioned in release notes.
+- Ensure that documentations affected by the change is updated.
+
+Sample template for a module update review is provided below.
+
+```markdown
+##### Reviewed points
+
+- [ ] changes are backward compatible
+- [ ] removed options are declared with `mkRemovedOptionModule`
+- [ ] changes that are not backward compatible are documented in release notes
+- [ ] module tests succeed on ARCHITECTURE
+- [ ] options types are appropriate
+- [ ] options description is set
+- [ ] options example is provided
+- [ ] documentation affected by the changes is updated
+
+##### Possible improvements
+
+##### Comments
+```
+
+## New modules {#reviewing-contributions-new-modules}
+
+New modules submissions introduce a new module to NixOS.
+
+Reviewing process:
+
+- Ensure that the module tests, if any, are succeeding.
+- Ensure that the introduced options are correct.
+  - Type should be appropriate (string related types differs in their merging capabilities, `optionSet` and `string` types are deprecated).
+  - Description, default and example should be provided.
+- Ensure that module `meta` field is present
+  - Maintainers should be declared in `meta.maintainers`.
+  - Module documentation should be declared with `meta.doc`.
+- Ensure that the module respect other modules functionality.
+  - For example, enabling a module should not open firewall ports by default.
+
+Sample template for a new module review is provided below.
+
+```markdown
+##### Reviewed points
+
+- [ ] module path fits the guidelines
+- [ ] module tests succeed on ARCHITECTURE
+- [ ] options have appropriate types
+- [ ] options have default
+- [ ] options have example
+- [ ] options have descriptions
+- [ ] No unneeded package is added to environment.systemPackages
+- [ ] meta.maintainers is set
+- [ ] module documentation is declared in meta.doc
+
+##### Possible improvements
+
+##### Comments
+```
+
+## Other submissions {#reviewing-contributions-other-submissions}
+
+Other type of submissions requires different reviewing steps.
+
+If you consider having enough knowledge and experience in a topic and would like to be a long-term reviewer for related submissions, please contact the current reviewers for that topic. They will give you information about the reviewing process. The main reviewers for a topic can be hard to find as there is no list, but checking past pull requests to see who reviewed or git-blaming the code to see who committed to that topic can give some hints.
+
+Container system, boot system and library changes are some examples of the pull requests fitting this category.
+
+## Merging pull requests {#reviewing-contributions--merging-pull-requests}
+
+It is possible for community members that have enough knowledge and experience on a special topic to contribute by merging pull requests.
+
+<!--
+The following paragraphs about how to deal with unactive contributors is just a proposition and should be modified to what the community agrees to be the right policy.
+
+Please note that contributors with commit rights unactive for more than three months will have their commit rights revoked.
+-->
+
+Please see the discussion in [GitHub nixpkgs issue #50105](https://github.com/NixOS/nixpkgs/issues/50105) for information on how to proceed to be granted this level of access.
+
+In a case a contributor definitively leaves the Nix community, they should create an issue or post on [Discourse](https://discourse.nixos.org) with references of packages and modules they maintain so the maintainership can be taken over by other contributors.
diff --git a/doc/contributing/reviewing-contributions.xml b/doc/contributing/reviewing-contributions.xml
deleted file mode 100644
index fe79d8d992b..00000000000
--- a/doc/contributing/reviewing-contributions.xml
+++ /dev/null
@@ -1,536 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-        xmlns:xlink="http://www.w3.org/1999/xlink"
-        xmlns:xi="http://www.w3.org/2001/XInclude"
-        version="5.0"
-        xml:id="chap-reviewing-contributions">
- <title>Reviewing contributions</title>
- <warning>
-  <para>
-   The following section is a draft, and the policy for reviewing is still being discussed in issues such as <link
-	   xlink:href="https://github.com/NixOS/nixpkgs/issues/11166">#11166 </link> and <link
-	   xlink:href="https://github.com/NixOS/nixpkgs/issues/20836">#20836 </link>.
-  </para>
- </warning>
- <para>
-  The Nixpkgs project receives a fairly high number of contributions via GitHub pull requests. Reviewing and approving these is an important task and a way to contribute to the project.
- </para>
- <para>
-  The high change rate of Nixpkgs makes any pull request that remains open for too long subject to conflicts that will require extra work from the submitter or the merger. Reviewing pull requests in a timely manner and being responsive to the comments is the key to avoid this issue. GitHub provides sort filters that can be used to see the <link
-  xlink:href="https://github.com/NixOS/nixpkgs/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-desc">most recently</link> and the <link
-  xlink:href="https://github.com/NixOS/nixpkgs/pulls?q=is%3Apr+is%3Aopen+sort%3Aupdated-asc">least recently</link> updated pull requests. We highly encourage looking at <link xlink:href="https://github.com/NixOS/nixpkgs/pulls?q=is%3Apr+is%3Aopen+review%3Anone+status%3Asuccess+-label%3A%222.status%3A+work-in-progress%22+no%3Aproject+no%3Aassignee+no%3Amilestone"> this list of ready to merge, unreviewed pull requests</link>.
- </para>
- <para>
-  When reviewing a pull request, please always be nice and polite. Controversial changes can lead to controversial opinions, but it is important to respect every community member and their work.
- </para>
- <para>
-  GitHub provides reactions as a simple and quick way to provide feedback to pull requests or any comments. The thumb-down reaction should be used with care and if possible accompanied with some explanation so the submitter has directions to improve their contribution.
- </para>
- <para>
-  pull request reviews should include a list of what has been reviewed in a comment, so other reviewers and mergers can know the state of the review.
- </para>
- <para>
-  All the review template samples provided in this section are generic and meant as examples. Their usage is optional and the reviewer is free to adapt them to their liking.
- </para>
- <section xml:id="reviewing-contributions-package-updates">
-  <title>Package updates</title>
-
-  <para>
-   A package update is the most trivial and common type of pull request. These pull requests mainly consist of updating the version part of the package name and the source hash.
-  </para>
-
-  <para>
-   It can happen that non-trivial updates include patches or more complex changes.
-  </para>
-
-  <para>
-   Reviewing process:
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Add labels to the pull request. (Requires commit rights)
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       <literal>8.has: package (update)</literal> and any topic label that fit the updated package.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the package versioning fits the guidelines.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the commit text fits the guidelines.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the package maintainers are notified.
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       <link xlink:href="https://help.github.com/articles/about-codeowners/">CODEOWNERS</link> will make GitHub notify users based on the submitted changes, but it can happen that it misses some of the package maintainers.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the meta field information is correct.
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       License can change with version updates, so it should be checked to match the upstream license.
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       If the package has no maintainer, a maintainer must be set. This can be the update submitter or a community member that accepts to take maintainership of the package.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the code contains no typos.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Building the package locally.
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       pull requests are often targeted to the master or staging branch, and building the pull request locally when it is submitted can trigger many source builds.
-      </para>
-      <para>
-       It is possible to rebase the changes on nixos-unstable or nixpkgs-unstable for easier review by running the following commands from a nixpkgs clone.
-<screen>
-<prompt>$ </prompt>git fetch origin nixos-unstable <co xml:id='reviewing-rebase-2' />
-<prompt>$ </prompt>git fetch origin pull/PRNUMBER/head <co xml:id='reviewing-rebase-3' />
-<prompt>$ </prompt>git rebase --onto nixos-unstable BASEBRANCH FETCH_HEAD <co
-  xml:id='reviewing-rebase-4' />
-</screen>
-       <calloutlist>
-        <callout arearefs='reviewing-rebase-2'>
-         <para>
-          Fetching the nixos-unstable branch.
-         </para>
-        </callout>
-        <callout arearefs='reviewing-rebase-3'>
-         <para>
-          Fetching the pull request changes, <varname>PRNUMBER</varname> is the number at the end of the pull request title and <varname>BASEBRANCH</varname> the base branch of the pull request.
-         </para>
-        </callout>
-        <callout arearefs='reviewing-rebase-4'>
-         <para>
-          Rebasing the pull request changes to the nixos-unstable branch.
-         </para>
-        </callout>
-       </calloutlist>
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       The <link xlink:href="https://github.com/Mic92/nixpkgs-review">nixpkgs-review</link> tool can be used to review a pull request content in a single command. <varname>PRNUMBER</varname> should be replaced by the number at the end of the pull request title. You can also provide the full github pull request url.
-      </para>
-<screen>
-<prompt>$ </prompt>nix-shell -p nixpkgs-review --run "nixpkgs-review pr PRNUMBER"
-</screen>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Running every binary.
-    </para>
-   </listitem>
-  </itemizedlist>
-
-  <example xml:id="reviewing-contributions-sample-package-update">
-   <title>Sample template for a package update review</title>
-<screen>
-##### Reviewed points
-
-- [ ] package name fits guidelines
-- [ ] package version fits guidelines
-- [ ] package build on ARCHITECTURE
-- [ ] executables tested on ARCHITECTURE
-- [ ] all depending packages build
-
-##### Possible improvements
-
-##### Comments
-
-</screen>
-  </example>
- </section>
- <section xml:id="reviewing-contributions-new-packages">
-  <title>New packages</title>
-
-  <para>
-   New packages are a common type of pull requests. These pull requests consists in adding a new nix-expression for a package.
-  </para>
-
-  <para>
-   Reviewing process:
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Add labels to the pull request. (Requires commit rights)
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       <literal>8.has: package (new)</literal> and any topic label that fit the new package.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the package versioning is fitting the guidelines.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the commit name is fitting the guidelines.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the meta field contains correct information.
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       License must be checked to be fitting upstream license.
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       Platforms should be set or the package will not get binary substitutes.
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       A maintainer must be set. This can be the package submitter or a community member that accepts to take maintainership of the package.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the code contains no typos.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure the package source.
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       Mirrors urls should be used when available.
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       The most appropriate function should be used (e.g. packages from GitHub should use <literal>fetchFromGitHub</literal>).
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Building the package locally.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Running every binary.
-    </para>
-   </listitem>
-  </itemizedlist>
-
-  <example xml:id="reviewing-contributions-sample-new-package">
-   <title>Sample template for a new package review</title>
-<screen>
-##### Reviewed points
-
-- [ ] package path fits guidelines
-- [ ] package name fits guidelines
-- [ ] package version fits guidelines
-- [ ] package build on ARCHITECTURE
-- [ ] executables tested on ARCHITECTURE
-- [ ] `meta.description` is set and fits guidelines
-- [ ] `meta.license` fits upstream license
-- [ ] `meta.platforms` is set
-- [ ] `meta.maintainers` is set
-- [ ] build time only dependencies are declared in `nativeBuildInputs`
-- [ ] source is fetched using the appropriate function
-- [ ] phases are respected
-- [ ] patches that are remotely available are fetched with `fetchpatch`
-
-##### Possible improvements
-
-##### Comments
-
-</screen>
-  </example>
- </section>
- <section xml:id="reviewing-contributions-module-updates">
-  <title>Module updates</title>
-
-  <para>
-   Module updates are submissions changing modules in some ways. These often contains changes to the options or introduce new options.
-  </para>
-
-  <para>
-   Reviewing process
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Add labels to the pull request. (Requires commit rights)
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       <literal>8.has: module (update)</literal> and any topic label that fit the module.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the module maintainers are notified.
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       <link xlink:href="https://help.github.com/articles/about-codeowners/">CODEOWNERS</link> will make GitHub notify users based on the submitted changes, but it can happen that it misses some of the package maintainers.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the module tests, if any, are succeeding.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the introduced options are correct.
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       Type should be appropriate (string related types differs in their merging capabilities, <literal>optionSet</literal> and <literal>string</literal> types are deprecated).
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       Description, default and example should be provided.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that option changes are backward compatible.
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       <literal>mkRenamedOptionModule</literal> and <literal>mkAliasOptionModule</literal> functions provide way to make option changes backward compatible.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that removed options are declared with <literal>mkRemovedOptionModule</literal>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that changes that are not backward compatible are mentioned in release notes.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that documentations affected by the change is updated.
-    </para>
-   </listitem>
-  </itemizedlist>
-
-  <example xml:id="reviewing-contributions-sample-module-update">
-   <title>Sample template for a module update review</title>
-<screen>
-##### Reviewed points
-
-- [ ] changes are backward compatible
-- [ ] removed options are declared with `mkRemovedOptionModule`
-- [ ] changes that are not backward compatible are documented in release notes
-- [ ] module tests succeed on ARCHITECTURE
-- [ ] options types are appropriate
-- [ ] options description is set
-- [ ] options example is provided
-- [ ] documentation affected by the changes is updated
-
-##### Possible improvements
-
-##### Comments
-
-</screen>
-  </example>
- </section>
- <section xml:id="reviewing-contributions-new-modules">
-  <title>New modules</title>
-
-  <para>
-   New modules submissions introduce a new module to NixOS.
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Add labels to the pull request. (Requires commit rights)
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       <literal>8.has: module (new)</literal> and any topic label that fit the module.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the module tests, if any, are succeeding.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the introduced options are correct.
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       Type should be appropriate (string related types differs in their merging capabilities, <literal>optionSet</literal> and <literal>string</literal> types are deprecated).
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       Description, default and example should be provided.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that module <literal>meta</literal> field is present
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       Maintainers should be declared in <literal>meta.maintainers</literal>.
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       Module documentation should be declared with <literal>meta.doc</literal>.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Ensure that the module respect other modules functionality.
-    </para>
-    <itemizedlist>
-     <listitem>
-      <para>
-       For example, enabling a module should not open firewall ports by default.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-  </itemizedlist>
-
-  <example xml:id="reviewing-contributions-sample-new-module">
-   <title>Sample template for a new module review</title>
-<screen>
-##### Reviewed points
-
-- [ ] module path fits the guidelines
-- [ ] module tests succeed on ARCHITECTURE
-- [ ] options have appropriate types
-- [ ] options have default
-- [ ] options have example
-- [ ] options have descriptions
-- [ ] No unneeded package is added to environment.systemPackages
-- [ ] meta.maintainers is set
-- [ ] module documentation is declared in meta.doc
-
-##### Possible improvements
-
-##### Comments
-
-</screen>
-  </example>
- </section>
- <section xml:id="reviewing-contributions-other-submissions">
-  <title>Other submissions</title>
-
-  <para>
-   Other type of submissions requires different reviewing steps.
-  </para>
-
-  <para>
-   If you consider having enough knowledge and experience in a topic and would like to be a long-term reviewer for related submissions, please contact the current reviewers for that topic. They will give you information about the reviewing process. The main reviewers for a topic can be hard to find as there is no list, but checking past pull requests to see who reviewed or git-blaming the code to see who committed to that topic can give some hints.
-  </para>
-
-  <para>
-   Container system, boot system and library changes are some examples of the pull requests fitting this category.
-  </para>
- </section>
- <section xml:id="reviewing-contributions--merging-pull-requests">
-  <title>Merging pull requests</title>
-
-  <para>
-   It is possible for community members that have enough knowledge and experience on a special topic to contribute by merging pull requests.
-  </para>
-
-  <para>
-   TODO: add the procedure to request merging rights.
-  </para>
-
-<!--
-The following paragraph about how to deal with unactive contributors is just a
-proposition and should be modified to what the community agrees to be the right
-policy.
-
-<para>Please note that contributors with commit rights unactive for more than
-  three months will have their commit rights revoked.</para>
--->
-
-  <para>
-   In a case a contributor definitively leaves the Nix community, they should create an issue or post on <link
-   xlink:href="https://discourse.nixos.org">Discourse</link> with references of packages and modules they maintain so the maintainership can be taken over by other contributors.
-  </para>
- </section>
-</chapter>
diff --git a/doc/contributing/submitting-changes.chapter.md b/doc/contributing/submitting-changes.chapter.md
new file mode 100644
index 00000000000..221ba300619
--- /dev/null
+++ b/doc/contributing/submitting-changes.chapter.md
@@ -0,0 +1,282 @@
+# Submitting changes {#chap-submitting-changes}
+
+## Making patches {#submitting-changes-making-patches}
+
+- Read [Manual (How to write packages for Nix)](https://nixos.org/nixpkgs/manual/).
+
+- Fork [the Nixpkgs repository](https://github.com/nixos/nixpkgs/) on GitHub.
+
+- Create a branch for your future fix.
+
+  - You can make branch from a commit of your local `nixos-version`. That will help you to avoid additional local compilations. Because you will receive packages from binary cache. For example
+
+    ```ShellSession
+    $ nixos-version --hash
+    0998212
+    $ git checkout 0998212
+    $ git checkout -b 'fix/pkg-name-update'
+    ```
+
+  - Please avoid working directly on the `master` branch.
+
+- Make commits of logical units.
+
+- If you removed pkgs or made some major NixOS changes, write about it in the release notes for the next stable release. For example `nixos/doc/manual/release-notes/rl-2003.xml`.
+
+- Check for unnecessary whitespace with `git diff --check` before committing.
+
+- Format the commit in a following way:
+
+  ```
+  (pkg-name | nixos/<module>): (from -> to | init at version | refactor | etc)
+  Additional information.
+  ```
+
+  - Examples:
+    - `nginx: init at 2.0.1`
+    - `firefox: 54.0.1 -> 55.0`
+    - `nixos/hydra: add bazBaz option`
+    - `nixos/nginx: refactor config generation`
+
+- Test your changes. If you work with
+
+  - nixpkgs:
+
+    - update pkg
+      - `nix-env -i pkg-name -f <path to your local nixpkgs folder>`
+    - add pkg
+      - Make sure it’s in `pkgs/top-level/all-packages.nix`
+      - `nix-env -i pkg-name -f <path to your local nixpkgs folder>`
+    - _If you don’t want to install pkg in you profile_.
+      - `nix-build -A pkg-attribute-name <path to your local nixpkgs folder>/default.nix` and check results in the folder `result`. It will appear in the same directory where you did `nix-build`.
+    - If you did `nix-env -i pkg-name` you can do `nix-env -e pkg-name` to uninstall it from your system.
+
+  - NixOS and its modules:
+    - You can add new module to your NixOS configuration file (usually it’s `/etc/nixos/configuration.nix`). And do `sudo nixos-rebuild test -I nixpkgs=<path to your local nixpkgs folder> --fast`.
+
+- If you have commits `pkg-name: oh, forgot to insert whitespace`: squash commits in this case. Use `git rebase -i`.
+
+- [Rebase](https://git-scm.com/book/en/v2/Git-Branching-Rebasing) your branch against current `master`.
+
+## Submitting changes {#submitting-changes-submitting-changes}
+
+- Push your changes to your fork of nixpkgs.
+- Create the pull request
+- Follow [the contribution guidelines](https://github.com/NixOS/nixpkgs/blob/master/CONTRIBUTING.md#submitting-changes).
+
+## Submitting security fixes {#submitting-changes-submitting-security-fixes}
+
+Security fixes are submitted in the same way as other changes and thus the same guidelines apply.
+
+- If a new version fixing the vulnerability has been released, update the package;
+- If the security fix comes in the form of a patch and a CVE is available, then add the patch to the Nixpkgs tree, and apply it to the package.
+  The name of the patch should be the CVE identifier, so e.g. `CVE-2019-13636.patch`; If a patch is fetched the name needs to be set as well, e.g.:
+
+  ```nix
+  (fetchpatch {
+    name = "CVE-2019-11068.patch";
+    url = "https://gitlab.gnome.org/GNOME/libxslt/commit/e03553605b45c88f0b4b2980adfbbb8f6fca2fd6.patch";
+    sha256 = "0pkpb4837km15zgg6h57bncp66d5lwrlvkr73h0lanywq7zrwhj8";
+  })
+  ```
+
+If a security fix applies to both master and a stable release then, similar to regular changes, they are preferably delivered via master first and cherry-picked to the release branch.
+
+Critical security fixes may by-pass the staging branches and be delivered directly to release branches such as `master` and `release-*`.
+
+## Deprecating/removing packages {#submitting-changes-deprecating-packages}
+
+There is currently no policy when to remove a package.
+
+Before removing a package, one should try to find a new maintainer or fix smaller issues first.
+
+### Steps to remove a package from Nixpkgs {#steps-to-remove-a-package-from-nixpkgs}
+
+We use jbidwatcher as an example for a discontinued project here.
+
+1. Have Nixpkgs checked out locally and up to date.
+1. Create a new branch for your change, e.g. `git checkout -b jbidwatcher`
+1. Remove the actual package including its directory, e.g. `rm -rf pkgs/applications/misc/jbidwatcher`
+1. Remove the package from the list of all packages (`pkgs/top-level/all-packages.nix`).
+1. Add an alias for the package name in `pkgs/top-level/aliases.nix` (There is also `pkgs/misc/vim-plugins/aliases.nix`. Package sets typically do not have aliases, so we can't add them there.)
+
+    For example in this case:
+
+    ```
+    jbidwatcher = throw "jbidwatcher was discontinued in march 2021"; # added 2021-03-15
+    ```
+
+    The throw message should explain in short why the package was removed for users that still have it installed.
+
+1. Test if the changes introduced any issues by running `nix-env -qaP -f . --show-trace`. It should show the list of packages without errors.
+1. Commit the changes. Explain again why the package was removed. If it was declared discontinued upstream, add a link to the source.
+
+    ```ShellSession
+    $ git add pkgs/applications/misc/jbidwatcher/default.nix pkgs/top-level/all-packages.nix pkgs/top-level/aliases.nix
+    $ git commit
+    ```
+
+    Example commit message:
+
+    ```
+    jbidwatcher: remove
+
+    project was discontinued in march 2021. the program does not work anymore because ebay changed the login.
+
+    https://web.archive.org/web/20210315205723/http://www.jbidwatcher.com/
+    ```
+
+1. Push changes to your GitHub fork with `git push`
+1. Create a pull request against Nixpkgs. Mention the package maintainer.
+
+This is how the pull request looks like in this case: [https://github.com/NixOS/nixpkgs/pull/116470](https://github.com/NixOS/nixpkgs/pull/116470)
+
+## Pull Request Template {#submitting-changes-pull-request-template}
+
+The pull request template helps determine what steps have been made for a contribution so far, and will help guide maintainers on the status of a change. The motivation section of the PR should include any extra details the title does not address and link any existing issues related to the pull request.
+
+When a PR is created, it will be pre-populated with some checkboxes detailed below:
+
+### Tested using sandboxing {#submitting-changes-tested-with-sandbox}
+
+When sandbox builds are enabled, Nix will setup an isolated environment for each build process. It is used to remove further hidden dependencies set by the build environment to improve reproducibility. This includes access to the network during the build outside of `fetch*` functions and files outside the Nix store. Depending on the operating system access to other resources are blocked as well (ex. inter process communication is isolated on Linux); see [sandbox](https://nixos.org/nix/manual/#conf-sandbox) in Nix manual for details.
+
+Sandboxing is not enabled by default in Nix due to a small performance hit on each build. In pull requests for [nixpkgs](https://github.com/NixOS/nixpkgs/) people are asked to test builds with sandboxing enabled (see `Tested using sandboxing` in the pull request template) because in<https://nixos.org/hydra/> sandboxing is also used.
+
+Depending if you use NixOS or other platforms you can use one of the following methods to enable sandboxing **before** building the package:
+
+- **Globally enable sandboxing on NixOS**: add the following to `configuration.nix`
+
+  ```nix
+  nix.useSandbox = true;
+  ```
+
+- **Globally enable sandboxing on non-NixOS platforms**: add the following to: `/etc/nix/nix.conf`
+
+  ```ini
+  sandbox = true
+  ```
+
+### Built on platform(s) {#submitting-changes-platform-diversity}
+
+Many Nix packages are designed to run on multiple platforms. As such, it’s important to let the maintainer know which platforms your changes have been tested on. It’s not always practical to test a change on all platforms, and is not required for a pull request to be merged. Only check the systems you tested the build on in this section.
+
+### Tested via one or more NixOS test(s) if existing and applicable for the change (look inside nixos/tests) {#submitting-changes-nixos-tests}
+
+Packages with automated tests are much more likely to be merged in a timely fashion because it doesn’t require as much manual testing by the maintainer to verify the functionality of the package. If there are existing tests for the package, they should be run to verify your changes do not break the tests. Tests can only be run on Linux. For more details on writing and running tests, see the [section in the NixOS manual](https://nixos.org/nixos/manual/index.html#sec-nixos-tests).
+
+### Tested compilation of all pkgs that depend on this change using `nixpkgs-review` {#submitting-changes-tested-compilation}
+
+If you are updating a package’s version, you can use nixpkgs-review to make sure all packages that depend on the updated package still compile correctly. The `nixpkgs-review` utility can look for and build all dependencies either based on uncommited changes with the `wip` option or specifying a github pull request number.
+
+review changes from pull request number 12345:
+
+```ShellSession
+nix run nixpkgs.nixpkgs-review -c nixpkgs-review pr 12345
+```
+
+review uncommitted changes:
+
+```ShellSession
+nix run nixpkgs.nixpkgs-review -c nixpkgs-review wip
+```
+
+review changes from last commit:
+
+```ShellSession
+nix run nixpkgs.nixpkgs-review -c nixpkgs-review rev HEAD
+```
+
+### Tested execution of all binary files (usually in `./result/bin/`) {#submitting-changes-tested-execution}
+
+It’s important to test any executables generated by a build when you change or create a package in nixpkgs. This can be done by looking in `./result/bin` and running any files in there, or at a minimum, the main executable for the package. For example, if you make a change to texlive, you probably would only check the binaries associated with the change you made rather than testing all of them.
+
+### Meets Nixpkgs contribution standards {#submitting-changes-contribution-standards}
+
+The last checkbox is fits [CONTRIBUTING.md](https://github.com/NixOS/nixpkgs/blob/master/CONTRIBUTING.md). The contributing document has detailed information on standards the Nix community has for commit messages, reviews, licensing of contributions you make to the project, etc\... Everyone should read and understand the standards the community has for contributing before submitting a pull request.
+
+## Hotfixing pull requests {#submitting-changes-hotfixing-pull-requests}
+
+- Make the appropriate changes in you branch.
+- Don’t create additional commits, do
+  - `git rebase -i`
+  - `git push --force` to your branch.
+
+## Commit policy {#submitting-changes-commit-policy}
+
+- Commits must be sufficiently tested before being merged, both for the master and staging branches.
+- Hydra builds for master and staging should not be used as testing platform, it’s a build farm for changes that have been already tested.
+- When changing the bootloader installation process, extra care must be taken. Grub installations cannot be rolled back, hence changes may break people’s installations forever. For any non-trivial change to the bootloader please file a PR asking for review, especially from \@edolstra.
+
+```{.graphviz caption="Staging workflow"}
+digraph {
+    "small changes" [shape=none]
+    "mass-rebuilds and other large changes" [shape=none]
+    "critical security fixes" [shape=none]
+    "broken staging-next fixes" [shape=none]
+
+    "small changes" -> master
+    "mass-rebuilds and other large changes" -> staging
+    "critical security fixes" -> master
+    "broken staging-next fixes" -> "staging-next"
+
+    "staging-next" -> master [color="#E85EB0"] [label="stabilization ends"] [fontcolor="#E85EB0"]
+    "staging" -> "staging-next" [color="#E85EB0"] [label="stabilization starts"] [fontcolor="#E85EB0"]
+
+    master -> "staging-next" -> staging [color="#5F5EE8"] [label="every six hours (GitHub Action)"] [fontcolor="#5F5EE8"]
+}
+```
+
+[This GitHub Action](https://github.com/NixOS/nixpkgs/blob/master/.github/workflows/merge-staging.yml) brings changes from `master` to `staging-next` and from `staging-next` to `staging` every 6 hours.
+
+
+### Master branch {#submitting-changes-master-branch}
+
+The `master` branch is the main development branch. It should only see non-breaking commits that do not cause mass rebuilds.
+
+### Staging branch {#submitting-changes-staging-branch}
+
+The `staging` branch is a development branch where mass-rebuilds go. It should only see non-breaking mass-rebuild commits. That means it is not to be used for testing, and changes must have been well tested already. If the branch is already in a broken state, please refrain from adding extra new breakages.
+
+### Staging-next branch {#submitting-changes-staging-next-branch}
+
+The `staging-next` branch is for stabilizing mass-rebuilds submitted to the `staging` branch prior to merging them into `master`. Mass-rebuilds must go via the `staging` branch. It must only see non-breaking commits that are fixing issues blocking it from being merged into the `master ` branch.
+
+If the branch is already in a broken state, please refrain from adding extra new breakages. Stabilize it for a few days and then merge into master.
+
+### Stable release branches {#submitting-changes-stable-release-branches}
+
+For cherry-picking a commit to a stable release branch (“backporting”), use `git cherry-pick -x <original commit>` so that the original commit id is included in the commit.
+
+Add a reason for the backport by using `git cherry-pick -xe <original commit>` instead when it is not obvious from the original commit message. It is not needed when it's a minor version update that includes security and bug fixes but don't add new features or when the commit fixes an otherwise broken package.
+
+For backporting Pull Requests to stable branches, assign label `backport <branch>` to the original Pull Requests and automation should take care of the rest once the Pull Requests is merged.
+
+Here is an example of a cherry-picked commit message with good reason description:
+
+```
+zfs: Keep trying root import until it works
+
+Works around #11003.
+
+(cherry picked from commit 98b213a11041af39b39473906b595290e2a4e2f9)
+
+Reason: several people cannot boot with ZFS on NVMe
+```
+
+Other examples of reasons are:
+
+- Previously the build would fail due to, e.g., `getaddrinfo` not being defined
+- The previous download links were all broken
+- Crash when starting on some X11 systems
+
+#### Acceptable backport criteria
+
+The stable branch does have some changes which cannot be backported. Most notable are breaking changes. The desire is to have stable users be uninterrupted when updating packages.
+
+However, many changes are able to be backported, including:
+- New Packages / Modules
+- Security / Patch updates
+- Version updates which include new functionality (but no breaking changes)
+- Services which require a client to be up-to-date regardless. (E.g. `spotify`, `steam`, or `discord`)
+- Security critical applications (E.g. `firefox`)
diff --git a/doc/contributing/submitting-changes.xml b/doc/contributing/submitting-changes.xml
deleted file mode 100644
index a88965f5cc6..00000000000
--- a/doc/contributing/submitting-changes.xml
+++ /dev/null
@@ -1,455 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-submitting-changes">
- <title>Submitting changes</title>
- <section xml:id="submitting-changes-making-patches">
-  <title>Making patches</title>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Read <link xlink:href="https://nixos.org/nixpkgs/manual/">Manual (How to write packages for Nix)</link>.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Fork <link xlink:href="https://github.com/nixos/nixpkgs/">the Nixpkgs repository</link> on GitHub.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Create a branch for your future fix.
-     <itemizedlist>
-      <listitem>
-       <para>
-        You can make branch from a commit of your local <command>nixos-version</command>. That will help you to avoid additional local compilations. Because you will receive packages from binary cache. For example
-<screen>
-<prompt>$ </prompt>nixos-version --hash
-0998212
-<prompt>$ </prompt>git checkout 0998212
-<prompt>$ </prompt>git checkout -b 'fix/pkg-name-update'
-</screen>
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        Please avoid working directly on the <command>master</command> branch.
-       </para>
-      </listitem>
-     </itemizedlist>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Make commits of logical units.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     If you removed pkgs or made some major NixOS changes, write about it in the release notes for the next stable release. For example <command>nixos/doc/manual/release-notes/rl-2003.xml</command>.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Check for unnecessary whitespace with <command>git diff --check</command> before committing.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Format the commit in a following way:
-    </para>
-<programlisting>
-(pkg-name | nixos/&lt;module>): (from -> to | init at version | refactor | etc)
-Additional information.
-</programlisting>
-    <itemizedlist>
-     <listitem>
-      <para>
-       Examples:
-       <itemizedlist>
-        <listitem>
-         <para>
-          <command>nginx: init at 2.0.1</command>
-         </para>
-        </listitem>
-        <listitem>
-         <para>
-          <command>firefox: 54.0.1 -> 55.0</command>
-         </para>
-        </listitem>
-        <listitem>
-         <para>
-          <command>nixos/hydra: add bazBaz option</command>
-         </para>
-        </listitem>
-        <listitem>
-         <para>
-          <command>nixos/nginx: refactor config generation</command>
-         </para>
-        </listitem>
-       </itemizedlist>
-      </para>
-     </listitem>
-    </itemizedlist>
-   </listitem>
-   <listitem>
-    <para>
-     Test your changes. If you work with
-     <itemizedlist>
-      <listitem>
-       <para>
-        nixpkgs:
-        <itemizedlist>
-         <listitem>
-          <para>
-           update pkg ->
-           <itemizedlist>
-            <listitem>
-             <para>
-              <command>nix-env -i pkg-name -f &lt;path to your local nixpkgs folder&gt;</command>
-             </para>
-            </listitem>
-           </itemizedlist>
-          </para>
-         </listitem>
-         <listitem>
-          <para>
-           add pkg ->
-           <itemizedlist>
-            <listitem>
-             <para>
-              Make sure it's in <command>pkgs/top-level/all-packages.nix</command>
-             </para>
-            </listitem>
-            <listitem>
-             <para>
-              <command>nix-env -i pkg-name -f &lt;path to your local nixpkgs folder&gt;</command>
-             </para>
-            </listitem>
-           </itemizedlist>
-          </para>
-         </listitem>
-         <listitem>
-          <para>
-           <emphasis>If you don't want to install pkg in you profile</emphasis>.
-           <itemizedlist>
-            <listitem>
-             <para>
-              <command>nix-build -A pkg-attribute-name &lt;path to your local nixpkgs folder&gt;/default.nix</command> and check results in the folder <command>result</command>. It will appear in the same directory where you did <command>nix-build</command>.
-             </para>
-            </listitem>
-           </itemizedlist>
-          </para>
-         </listitem>
-         <listitem>
-          <para>
-           If you did <command>nix-env -i pkg-name</command> you can do <command>nix-env -e pkg-name</command> to uninstall it from your system.
-          </para>
-         </listitem>
-        </itemizedlist>
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        NixOS and its modules:
-        <itemizedlist>
-         <listitem>
-          <para>
-           You can add new module to your NixOS configuration file (usually it's <command>/etc/nixos/configuration.nix</command>). And do <command>sudo nixos-rebuild test -I nixpkgs=&lt;path to your local nixpkgs folder&gt; --fast</command>.
-          </para>
-         </listitem>
-        </itemizedlist>
-       </para>
-      </listitem>
-     </itemizedlist>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     If you have commits <command>pkg-name: oh, forgot to insert whitespace</command>: squash commits in this case. Use <command>git rebase -i</command>.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     <link xlink:href="https://git-scm.com/book/en/v2/Git-Branching-Rebasing">Rebase</link> your branch against current <command>master</command>.
-    </para>
-   </listitem>
-  </itemizedlist>
- </section>
- <section xml:id="submitting-changes-submitting-changes">
-  <title>Submitting changes</title>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Push your changes to your fork of nixpkgs.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Create the pull request
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Follow <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/.github/CONTRIBUTING.md#submitting-changes">the contribution guidelines</link>.
-    </para>
-   </listitem>
-  </itemizedlist>
- </section>
- <section xml:id="submitting-changes-submitting-security-fixes">
-  <title>Submitting security fixes</title>
-
-  <para>
-   Security fixes are submitted in the same way as other changes and thus the same guidelines apply.
-  </para>
-
-  <para>
-   If the security fix comes in the form of a patch and a CVE is available, then the name of the patch should be the CVE identifier, so e.g. <literal>CVE-2019-13636.patch</literal> in the case of a patch that is included in the Nixpkgs tree. If a patch is fetched the name needs to be set as well, e.g.:
-  </para>
-
-<programlisting>
-   (fetchpatch {
-     name = "CVE-2019-11068.patch";
-     url = "https://gitlab.gnome.org/GNOME/libxslt/commit/e03553605b45c88f0b4b2980adfbbb8f6fca2fd6.patch";
-     sha256 = "0pkpb4837km15zgg6h57bncp66d5lwrlvkr73h0lanywq7zrwhj8";
-   })
-  </programlisting>
-
-  <para>
-   If a security fix applies to both master and a stable release then, similar to regular changes, they are preferably delivered via master first and cherry-picked to the release branch.
-  </para>
-
-  <para>
-   Critical security fixes may by-pass the staging branches and be delivered directly to release branches such as <literal>master</literal> and <literal>release-*</literal>.
-  </para>
- </section>
- <section xml:id="submitting-changes-pull-request-template">
-  <title>Pull Request Template</title>
-
-  <para>
-   The pull request template helps determine what steps have been made for a contribution so far, and will help guide maintainers on the status of a change. The motivation section of the PR should include any extra details the title does not address and link any existing issues related to the pull request.
-  </para>
-
-  <para>
-   When a PR is created, it will be pre-populated with some checkboxes detailed below:
-  </para>
-
-  <section xml:id="submitting-changes-tested-with-sandbox">
-   <title>Tested using sandboxing</title>
-
-   <para>
-    When sandbox builds are enabled, Nix will setup an isolated environment for each build process. It is used to remove further hidden dependencies set by the build environment to improve reproducibility. This includes access to the network during the build outside of <function>fetch*</function> functions and files outside the Nix store. Depending on the operating system access to other resources are blocked as well (ex. inter process communication is isolated on Linux); see <link
-      xlink:href="https://nixos.org/nix/manual/#conf-sandbox">sandbox</link> in Nix manual for details.
-   </para>
-
-   <para>
-    Sandboxing is not enabled by default in Nix due to a small performance hit on each build. In pull requests for <link
-        xlink:href="https://github.com/NixOS/nixpkgs/">nixpkgs</link> people are asked to test builds with sandboxing enabled (see <literal>Tested using sandboxing</literal> in the pull request template) because in<link
-        xlink:href="https://nixos.org/hydra/">https://nixos.org/hydra/</link> sandboxing is also used.
-   </para>
-
-   <para>
-    Depending if you use NixOS or other platforms you can use one of the following methods to enable sandboxing <emphasis role="bold">before</emphasis> building the package:
-    <itemizedlist>
-     <listitem>
-      <para>
-       <emphasis role="bold">Globally enable sandboxing on NixOS</emphasis>: add the following to <filename>configuration.nix</filename>
-<screen>nix.useSandbox = true;</screen>
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       <emphasis role="bold">Globally enable sandboxing on non-NixOS platforms</emphasis>: add the following to: <filename>/etc/nix/nix.conf</filename>
-<screen>sandbox = true</screen>
-      </para>
-     </listitem>
-    </itemizedlist>
-   </para>
-  </section>
-
-  <section xml:id="submitting-changes-platform-diversity">
-   <title>Built on platform(s)</title>
-
-   <para>
-    Many Nix packages are designed to run on multiple platforms. As such, it's important to let the maintainer know which platforms your changes have been tested on. It's not always practical to test a change on all platforms, and is not required for a pull request to be merged. Only check the systems you tested the build on in this section.
-   </para>
-  </section>
-
-  <section xml:id="submitting-changes-nixos-tests">
-   <title>Tested via one or more NixOS test(s) if existing and applicable for the change (look inside nixos/tests)</title>
-
-   <para>
-    Packages with automated tests are much more likely to be merged in a timely fashion because it doesn't require as much manual testing by the maintainer to verify the functionality of the package. If there are existing tests for the package, they should be run to verify your changes do not break the tests. Tests only apply to packages with NixOS modules defined and can only be run on Linux. For more details on writing and running tests, see the <link
-        xlink:href="https://nixos.org/nixos/manual/index.html#sec-nixos-tests">section in the NixOS manual</link>.
-   </para>
-  </section>
-
-  <section xml:id="submitting-changes-tested-compilation">
-   <title>Tested compilation of all pkgs that depend on this change using <command>nixpkgs-review</command></title>
-
-   <para>
-    If you are updating a package's version, you can use nixpkgs-review to make sure all packages that depend on the updated package still compile correctly. The <command>nixpkgs-review</command> utility can look for and build all dependencies either based on uncommited changes with the <literal>wip</literal> option or specifying a github pull request number.
-   </para>
-
-   <para>
-    review changes from pull request number 12345:
-    <screen>nix run nixpkgs.nixpkgs-review -c nixpkgs-review pr 12345</screen>
-   </para>
-
-   <para>
-    review uncommitted changes:
-    <screen>nix run nixpkgs.nixpkgs-review -c nixpkgs-review wip</screen>
-   </para>
-
-   <para>
-    review changes from last commit:
-    <screen>nix run nixpkgs.nixpkgs-review -c nixpkgs-review rev HEAD</screen>
-   </para>
-  </section>
-
-  <section xml:id="submitting-changes-tested-execution">
-   <title>Tested execution of all binary files (usually in <filename>./result/bin/</filename>)</title>
-
-   <para>
-    It's important to test any executables generated by a build when you change or create a package in nixpkgs. This can be done by looking in <filename>./result/bin</filename> and running any files in there, or at a minimum, the main executable for the package. For example, if you make a change to <package>texlive</package>, you probably would only check the binaries associated with the change you made rather than testing all of them.
-   </para>
-  </section>
-
-  <section xml:id="submitting-changes-contribution-standards">
-   <title>Meets Nixpkgs contribution standards</title>
-
-   <para>
-    The last checkbox is fits <link
-        xlink:href="https://github.com/NixOS/nixpkgs/blob/master/.github/CONTRIBUTING.md">CONTRIBUTING.md</link>. The contributing document has detailed information on standards the Nix community has for commit messages, reviews, licensing of contributions you make to the project, etc... Everyone should read and understand the standards the community has for contributing before submitting a pull request.
-   </para>
-  </section>
- </section>
- <section xml:id="submitting-changes-hotfixing-pull-requests">
-  <title>Hotfixing pull requests</title>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Make the appropriate changes in you branch.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Don't create additional commits, do
-     <itemizedlist>
-      <listitem>
-       <para>
-        <command>git rebase -i</command>
-       </para>
-      </listitem>
-      <listitem>
-       <para>
-        <command>git push --force</command> to your branch.
-       </para>
-      </listitem>
-     </itemizedlist>
-    </para>
-   </listitem>
-  </itemizedlist>
- </section>
- <section xml:id="submitting-changes-commit-policy">
-  <title>Commit policy</title>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     Commits must be sufficiently tested before being merged, both for the master and staging branches.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Hydra builds for master and staging should not be used as testing platform, it's a build farm for changes that have been already tested.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     When changing the bootloader installation process, extra care must be taken. Grub installations cannot be rolled back, hence changes may break people's installations forever. For any non-trivial change to the bootloader please file a PR asking for review, especially from @edolstra.
-    </para>
-   </listitem>
-  </itemizedlist>
-
-  <section xml:id="submitting-changes-master-branch">
-   <title>Master branch</title>
-   <para>
-    The <literal>master</literal> branch is the main development branch.
-    It should only see non-breaking commits that do not cause mass rebuilds.
-   </para>
-  </section>
-
-  <section xml:id="submitting-changes-staging-branch">
-   <title>Staging branch</title>
-   <para>
-    The <literal>staging</literal> branch is a development branch where mass-rebuilds go.
-    It should only see non-breaking mass-rebuild commits.
-    That means it is not to be used for testing, and changes must have been well tested already.
-    If the branch is already in a broken state, please refrain from adding extra new breakages.
-   </para>
-  </section>
-
-  <section xml:id="submitting-changes-staging-next-branch">
-   <title>Staging-next branch</title>
-   <para>
-    The <literal>staging-next</literal> branch is for stabilizing mass-rebuilds submitted to the <literal>staging</literal> branch prior to merging them into <literal>master</literal>.
-    Mass-rebuilds should go via the <literal>staging</literal> branch.
-    It should only see non-breaking commits that are fixing issues blocking it from being merged into the <literal>master </literal> branch.
-   </para>
-   <para>
-    If the branch is already in a broken state, please refrain from adding extra new breakages. Stabilize it for a few days and then merge into master.
-   </para>
-  </section>
-
-  <section xml:id="submitting-changes-stable-release-branches">
-   <title>Stable release branches</title>
-
-   <para>
-    For cherry-picking a commit to a stable release branch (<quote>backporting</quote>), use <literal>git cherry-pick -x &lt;original commit&gt;</literal> so that the original commit id is included in the commit.
-   </para>
-
-   <para>
-    Add a reason for the backport by using <literal>git cherry-pick -xe &lt;original commit&gt;</literal> instead when it is not obvious from the original commit message. It is not needed when it’s a minor version update that includes security and bug fixes but don’t add new features or when the commit fixes an otherwise broken package.
-   </para>
-
-   <para>
-    Here is an example of a cherry-picked commit message with good reason description:
-   </para>
-
-<screen>
-zfs: Keep trying root import until it works
-
-Works around #11003.
-
-(cherry picked from commit 98b213a11041af39b39473906b595290e2a4e2f9)
-
-Reason: several people cannot boot with ZFS on NVMe
-</screen>
-
-   <para>
-    Other examples of reasons are:
-   </para>
-
-   <itemizedlist spacing="compact">
-    <listitem>
-     <para>
-      Previously the build would fail due to, e.g., <literal>getaddrinfo</literal> not being defined
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      The previous download links were all broken
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      Crash when starting on some X11 systems
-     </para>
-    </listitem>
-   </itemizedlist>
-  </section>
- </section>
-</chapter>
diff --git a/doc/contributing/vulnerability-roundup.chapter.md b/doc/contributing/vulnerability-roundup.chapter.md
new file mode 100644
index 00000000000..d451420f981
--- /dev/null
+++ b/doc/contributing/vulnerability-roundup.chapter.md
@@ -0,0 +1,45 @@
+# Vulnerability Roundup {#chap-vulnerability-roundup}
+
+## Issues {#vulnerability-roundup-issues}
+
+Vulnerable packages in Nixpkgs are managed using issues.
+Currently opened ones can be found using the following:
+
+[github.com/NixOS/nixpkgs/issues?q=is:issue+is:open+"Vulnerability+roundup"](https://github.com/NixOS/nixpkgs/issues?q=is%3Aissue+is%3Aopen+%22Vulnerability+roundup%22)
+
+Each issue correspond to a vulnerable version of a package; As a consequence:
+
+- One issue can contain several CVEs;
+- One CVE can be shared across several issues;
+- A single package can be concerned by several issues.
+
+
+A "Vulnerability roundup" issue usually respects the following format:
+
+```txt
+<link to relevant package search on search.nix.gsc.io>, <link to relevant files in Nixpkgs on GitHub>
+
+<list of related CVEs, their CVSS score, and the impacted NixOS version>
+
+<list of the scanned Nixpkgs versions>
+
+<list of relevant contributors>
+```
+
+Note that there can be an extra comment containing links to previously reported (and still open) issues for the same package.
+
+
+## Triaging and Fixing {#vulnerability-roundup-triaging-and-fixing}
+
+**Note**: An issue can be a "false positive" (i.e. automatically opened, but without the package it refers to being actually vulnerable).
+If you find such a "false positive", comment on the issue an explanation of why it falls into this category, linking as much information as the necessary to help maintainers double check.
+
+If you are investigating a "true positive":
+
+- Find the earliest patched version or a code patch in the CVE details;
+- Is the issue already patched (version up-to-date or patch applied manually) in Nixpkgs's `master` branch?
+  - **No**:
+    - [Submit a security fix](#submitting-changes-submitting-security-fixes);
+    - Once the fix is merged into `master`, [submit the change to the vulnerable release branch(es)](https://nixos.org/manual/nixpkgs/stable/#submitting-changes-stable-release-branches);
+  - **Yes**: [Backport the change to the vulnerable release branch(es)](https://nixos.org/manual/nixpkgs/stable/#submitting-changes-stable-release-branches).
+- When the patch has made it into all the relevant branches (`master`, and the vulnerable releases), close the relevant issue(s).
diff --git a/doc/default.nix b/doc/default.nix
index d9051167dee..ac382ec8519 100644
--- a/doc/default.nix
+++ b/doc/default.nix
@@ -5,9 +5,17 @@ let
 in pkgs.stdenv.mkDerivation {
   name = "nixpkgs-manual";
 
-  buildInputs = with pkgs; [ pandoc libxml2 libxslt zip jing  xmlformat ];
+  nativeBuildInputs = with pkgs; [
+    pandoc
+    graphviz
+    libxml2
+    libxslt
+    zip
+    jing
+    xmlformat
+  ];
 
-  src = ./.;
+  src = lib.cleanSource ./.;
 
   postPatch = ''
     ln -s ${doc-support} ./doc-support/result
@@ -25,4 +33,7 @@ in pkgs.stdenv.mkDerivation {
     echo "doc manual $dest manual.html" >> $out/nix-support/hydra-build-products
     echo "doc manual $dest nixpkgs-manual.epub" >> $out/nix-support/hydra-build-products
   '';
+
+  # Environment variables
+  PANDOC_LUA_FILTERS_DIR = "${pkgs.pandoc-lua-filters}/share/pandoc/filters";
 }
diff --git a/doc/doc-support/lib-function-docs.nix b/doc/doc-support/lib-function-docs.nix
index 5199b949e7b..f6d613cac0b 100644
--- a/doc/doc-support/lib-function-docs.nix
+++ b/doc/doc-support/lib-function-docs.nix
@@ -22,5 +22,6 @@ with pkgs; stdenv.mkDerivation {
     docgen lists 'List manipulation functions'
     docgen debug 'Debugging functions'
     docgen options 'NixOS / nixpkgs option handling'
+    docgen sources 'Source filtering functions'
   '';
 }
diff --git a/doc/functions.xml b/doc/functions.xml
index 5a9240ec800..8ef530d307c 100644
--- a/doc/functions.xml
+++ b/doc/functions.xml
@@ -7,8 +7,8 @@
   The nixpkgs repository has several utility functions to manipulate Nix expressions.
  </para>
  <xi:include href="functions/library.xml" />
- <xi:include href="functions/generators.xml" />
- <xi:include href="functions/debug.xml" />
- <xi:include href="functions/prefer-remote-fetch.xml" />
- <xi:include href="functions/nix-gitignore.xml" />
+ <xi:include href="functions/generators.section.xml" />
+ <xi:include href="functions/debug.section.xml" />
+ <xi:include href="functions/prefer-remote-fetch.section.xml" />
+ <xi:include href="functions/nix-gitignore.section.xml" />
 </chapter>
diff --git a/doc/functions/debug.section.md b/doc/functions/debug.section.md
new file mode 100644
index 00000000000..b2d8589431a
--- /dev/null
+++ b/doc/functions/debug.section.md
@@ -0,0 +1,5 @@
+# Debugging Nix Expressions {#sec-debug}
+
+Nix is a unityped, dynamic language, this means every value can potentially appear anywhere. Since it is also non-strict, evaluation order and what ultimately is evaluated might surprise you. Therefore it is important to be able to debug nix expressions.
+
+In the `lib/debug.nix` file you will find a number of functions that help (pretty-)printing values while evaluation is running. You can even specify how deep these values should be printed recursively, and transform them on the fly. Please consult the docstrings in `lib/debug.nix` for usage information.
diff --git a/doc/functions/debug.xml b/doc/functions/debug.xml
deleted file mode 100644
index c27421f12e7..00000000000
--- a/doc/functions/debug.xml
+++ /dev/null
@@ -1,14 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-debug">
- <title>Debugging Nix Expressions</title>
-
- <para>
-  Nix is a unityped, dynamic language, this means every value can potentially appear anywhere. Since it is also non-strict, evaluation order and what ultimately is evaluated might surprise you. Therefore it is important to be able to debug nix expressions.
- </para>
-
- <para>
-  In the <literal>lib/debug.nix</literal> file you will find a number of functions that help (pretty-)printing values while evaluation is runnnig. You can even specify how deep these values should be printed recursively, and transform them on the fly. Please consult the docstrings in <literal>lib/debug.nix</literal> for usage information.
- </para>
-</section>
diff --git a/doc/functions/generators.section.md b/doc/functions/generators.section.md
new file mode 100644
index 00000000000..d54e5027c79
--- /dev/null
+++ b/doc/functions/generators.section.md
@@ -0,0 +1,56 @@
+# Generators {#sec-generators}
+Generators are functions that create file formats from nix data structures, e. g. for configuration files. There are generators available for: `INI`, `JSON` and `YAML`
+
+All generators follow a similar call interface: `generatorName configFunctions data`, where `configFunctions` is an attrset of user-defined functions that format nested parts of the content. They each have common defaults, so often they do not need to be set manually. An example is `mkSectionName ? (name: libStr.escape [ "[" "]" ] name)` from the `INI` generator. It receives the name of a section and sanitizes it. The default `mkSectionName` escapes `[` and `]` with a backslash.
+
+Generators can be fine-tuned to produce exactly the file format required by your application/service. One example is an INI-file format which uses `: ` as separator, the strings `"yes"`/`"no"` as boolean values and requires all string values to be quoted:
+
+```nix
+with lib;
+let
+  customToINI = generators.toINI {
+    # specifies how to format a key/value pair
+    mkKeyValue = generators.mkKeyValueDefault {
+      # specifies the generated string for a subset of nix values
+      mkValueString = v:
+             if v == true then ''"yes"''
+        else if v == false then ''"no"''
+        else if isString v then ''"${v}"''
+        # and delegats all other values to the default generator
+        else generators.mkValueStringDefault {} v;
+    } ":";
+  };
+
+# the INI file can now be given as plain old nix values
+in customToINI {
+  main = {
+    pushinfo = true;
+    autopush = false;
+    host = "localhost";
+    port = 42;
+  };
+  mergetool = {
+    merge = "diff3";
+  };
+}
+```
+
+This will produce the following INI file as nix string:
+
+```INI
+[main]
+autopush:"no"
+host:"localhost"
+port:42
+pushinfo:"yes"
+str\:ange:"very::strange"
+
+[mergetool]
+merge:"diff3"
+```
+
+::: {.note}
+Nix store paths can be converted to strings by enclosing a derivation attribute like so: `"${drv}"`.
+:::
+
+Detailed documentation for each generator can be found in `lib/generators.nix`.
diff --git a/doc/functions/generators.xml b/doc/functions/generators.xml
deleted file mode 100644
index 9ce1f85eb17..00000000000
--- a/doc/functions/generators.xml
+++ /dev/null
@@ -1,74 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-generators">
- <title>Generators</title>
-
- <para>
-  Generators are functions that create file formats from nix data structures, e. g. for configuration files. There are generators available for: <literal>INI</literal>, <literal>JSON</literal> and <literal>YAML</literal>
- </para>
-
- <para>
-  All generators follow a similar call interface: <code>generatorName configFunctions data</code>, where <literal>configFunctions</literal> is an attrset of user-defined functions that format nested parts of the content. They each have common defaults, so often they do not need to be set manually. An example is <code>mkSectionName ? (name: libStr.escape [ "[" "]" ] name)</code> from the <literal>INI</literal> generator. It receives the name of a section and sanitizes it. The default <literal>mkSectionName</literal> escapes <literal>[</literal> and <literal>]</literal> with a backslash.
- </para>
-
- <para>
-  Generators can be fine-tuned to produce exactly the file format required by your application/service. One example is an INI-file format which uses <literal>: </literal> as separator, the strings <literal>"yes"</literal>/<literal>"no"</literal> as boolean values and requires all string values to be quoted:
- </para>
-
-<programlisting>
-with lib;
-let
-  customToINI = generators.toINI {
-    # specifies how to format a key/value pair
-    mkKeyValue = generators.mkKeyValueDefault {
-      # specifies the generated string for a subset of nix values
-      mkValueString = v:
-             if v == true then ''"yes"''
-        else if v == false then ''"no"''
-        else if isString v then ''"${v}"''
-        # and delegats all other values to the default generator
-        else generators.mkValueStringDefault {} v;
-    } ":";
-  };
-
-# the INI file can now be given as plain old nix values
-in customToINI {
-  main = {
-    pushinfo = true;
-    autopush = false;
-    host = "localhost";
-    port = 42;
-  };
-  mergetool = {
-    merge = "diff3";
-  };
-}
-</programlisting>
-
- <para>
-  This will produce the following INI file as nix string:
- </para>
-
-<programlisting>
-[main]
-autopush:"no"
-host:"localhost"
-port:42
-pushinfo:"yes"
-str\:ange:"very::strange"
-
-[mergetool]
-merge:"diff3"
-</programlisting>
-
- <note>
-  <para>
-   Nix store paths can be converted to strings by enclosing a derivation attribute like so: <code>"${drv}"</code>.
-  </para>
- </note>
-
- <para>
-  Detailed documentation for each generator can be found in <literal>lib/generators.nix</literal>.
- </para>
-</section>
diff --git a/doc/functions/library.xml b/doc/functions/library.xml
index 6ffb944b5a6..21bcf5b88c9 100644
--- a/doc/functions/library.xml
+++ b/doc/functions/library.xml
@@ -25,4 +25,6 @@
  <xi:include href="./library/generated/debug.xml" />
 
  <xi:include href="./library/generated/options.xml" />
+
+ <xi:include href="./library/generated/sources.xml" />
 </section>
diff --git a/doc/functions/library/asserts.xml b/doc/functions/library/asserts.xml
index 10891039e86..7c94222ef13 100644
--- a/doc/functions/library/asserts.xml
+++ b/doc/functions/library/asserts.xml
@@ -103,7 +103,7 @@ stderr> assert failed
    <title>Ensuring a user provided a possible value</title>
 <programlisting><![CDATA[
 let sslLibrary = "bearssl";
-in lib.asserts.assertOneOf "sslLibrary" sslLibrary [ "openssl" "bearssl" ];
+in lib.asserts.assertOneOf "sslLibrary" sslLibrary [ "openssl" "libressl" ];
 => false
 stderr> trace: sslLibrary must be one of "openssl", "libressl", but is: "bearssl"
         ]]></programlisting>
diff --git a/doc/functions/library/attrsets.xml b/doc/functions/library/attrsets.xml
index 3c5823c2589..ef132514da1 100644
--- a/doc/functions/library/attrsets.xml
+++ b/doc/functions/library/attrsets.xml
@@ -7,7 +7,7 @@
  <section xml:id="function-library-lib.attrsets.attrByPath">
   <title><function>lib.attrset.attrByPath</function></title>
 
-  <subtitle><literal>attrByPath :: [String] -> Any -> AttrSet</literal>
+  <subtitle><literal>attrByPath :: [String] -> Any -> AttrSet -> Any</literal>
   </subtitle>
 
   <xi:include href="./locations.xml" xpointer="lib.attrsets.attrByPath" />
@@ -166,7 +166,7 @@ lib.attrsets.setAttrByPath [ "a" "b" ] 3
   <xi:include href="./locations.xml" xpointer="lib.attrsets.getAttrFromPath" />
 
   <para>
-   Like <xref linkend="function-library-lib.attrsets.attrByPath" /> except without a default, and it will throw if the value doesn't exist.
+   Like [](#function-library-lib.attrsets.attrByPath) except without a default, and it will throw if the value doesn't exist.
   </para>
 
   <variablelist>
@@ -855,7 +855,7 @@ lib.attrsets.mapAttrs' (name: value: lib.attrsets.nameValuePair ("foo_" + name)
   <title><function>lib.attrsets.mapAttrsToList</function></title>
 
   <subtitle><literal>mapAttrsToList :: (String -> Any -> Any) ->
-   AttrSet -> Any</literal>
+   AttrSet -> [Any]</literal>
   </subtitle>
 
   <xi:include href="./locations.xml" xpointer="lib.attrsets.mapAttrsToList" />
@@ -1480,7 +1480,7 @@ lib.attrsets.zipAttrsWith
   <xi:include href="./locations.xml" xpointer="lib.attrsets.zipAttrs" />
 
   <para>
-   Merge sets of attributes and combine each attribute value in to a list. Similar to <xref linkend="function-library-lib.attrsets.zipAttrsWith" /> where the merge function returns a list of all values.
+   Merge sets of attributes and combine each attribute value in to a list. Similar to [](#function-library-lib.attrsets.zipAttrsWith) where the merge function returns a list of all values.
   </para>
 
   <variablelist>
@@ -1677,8 +1677,7 @@ recursiveUpdate
   <xi:include href="./locations.xml" xpointer="lib.attrsets.recurseIntoAttrs" />
 
   <para>
-   Make various Nix tools consider the contents of the resulting
-   attribute set when looking for what to build, find, etc.
+   Make various Nix tools consider the contents of the resulting attribute set when looking for what to build, find, etc.
   </para>
 
   <para>
@@ -1711,4 +1710,42 @@ recursiveUpdate
   </example>
  </section>
 
+ <section xml:id="function-library-lib.attrsets.cartesianProductOfSets">
+  <title><function>lib.attrsets.cartesianProductOfSets</function></title>
+
+  <subtitle><literal>cartesianProductOfSets :: AttrSet -> [ AttrSet ]</literal>
+  </subtitle>
+
+  <xi:include href="./locations.xml" xpointer="lib.attrsets.cartesianProductOfSets" />
+
+  <para>
+   Return the cartesian product of attribute set value combinations.
+  </para>
+
+  <variablelist>
+   <varlistentry>
+    <term>
+     <varname>set</varname>
+    </term>
+    <listitem>
+     <para>
+      An attribute set with attributes that carry lists of values.
+     </para>
+    </listitem>
+   </varlistentry>
+  </variablelist>
+
+  <example xml:id="function-library-lib.attrsets.cartesianProductOfSets-example">
+   <title>Creating the cartesian product of a list of attribute values</title>
+<programlisting><![CDATA[
+cartesianProductOfSets { a = [ 1 2 ]; b = [ 10 20 ]; }
+=> [
+     { a = 1; b = 10; }
+     { a = 1; b = 20; }
+     { a = 2; b = 10; }
+     { a = 2; b = 20; }
+   ]
+]]></programlisting>
+  </example>
+ </section>
 </section>
diff --git a/doc/functions/nix-gitignore.section.md b/doc/functions/nix-gitignore.section.md
new file mode 100644
index 00000000000..2fb833b2300
--- /dev/null
+++ b/doc/functions/nix-gitignore.section.md
@@ -0,0 +1,49 @@
+# pkgs.nix-gitignore {#sec-pkgs-nix-gitignore}
+
+`pkgs.nix-gitignore` is a function that acts similarly to `builtins.filterSource` but also allows filtering with the help of the gitignore format.
+
+## Usage {#sec-pkgs-nix-gitignore-usage}
+
+`pkgs.nix-gitignore` exports a number of functions, but you\'ll most likely need either `gitignoreSource` or `gitignoreSourcePure`. As their first argument, they both accept either 1. a file with gitignore lines or 2. a string with gitignore lines, or 3. a list of either of the two. They will be concatenated into a single big string.
+
+```nix
+{ pkgs ? import <nixpkgs> {} }:
+
+ nix-gitignore.gitignoreSource [] ./source
+     # Simplest version
+
+ nix-gitignore.gitignoreSource "supplemental-ignores\n" ./source
+     # This one reads the ./source/.gitignore and concats the auxiliary ignores
+
+ nix-gitignore.gitignoreSourcePure "ignore-this\nignore-that\n" ./source
+     # Use this string as gitignore, don't read ./source/.gitignore.
+
+ nix-gitignore.gitignoreSourcePure ["ignore-this\nignore-that\n", ~/.gitignore] ./source
+     # It also accepts a list (of strings and paths) that will be concatenated
+     # once the paths are turned to strings via readFile.
+```
+
+These functions are derived from the `Filter` functions by setting the first filter argument to `(_: _: true)`:
+
+```nix
+gitignoreSourcePure = gitignoreFilterSourcePure (_: _: true);
+gitignoreSource = gitignoreFilterSource (_: _: true);
+```
+
+Those filter functions accept the same arguments the `builtins.filterSource` function would pass to its filters, thus `fn: gitignoreFilterSourcePure fn ""` should be extensionally equivalent to `filterSource`. The file is blacklisted if it\'s blacklisted by either your filter or the gitignoreFilter.
+
+If you want to make your own filter from scratch, you may use
+
+```nix
+gitignoreFilter = ign: root: filterPattern (gitignoreToPatterns ign) root;
+```
+
+## gitignore files in subdirectories {#sec-pkgs-nix-gitignore-usage-recursive}
+
+If you wish to use a filter that would search for .gitignore files in subdirectories, just like git does by default, use this function:
+
+```nix
+gitignoreFilterRecursiveSource = filter: patterns: root:
+# OR
+gitignoreRecursiveSource = gitignoreFilterSourcePure (_: _: true);
+```
diff --git a/doc/functions/nix-gitignore.xml b/doc/functions/nix-gitignore.xml
deleted file mode 100644
index 37a82b196cc..00000000000
--- a/doc/functions/nix-gitignore.xml
+++ /dev/null
@@ -1,70 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="sec-pkgs-nix-gitignore">
- <title>pkgs.nix-gitignore</title>
-
- <para>
-  <function>pkgs.nix-gitignore</function> is a function that acts similarly to <literal>builtins.filterSource</literal> but also allows filtering with the help of the gitignore format.
- </para>
-
- <section xml:id="sec-pkgs-nix-gitignore-usage">
-  <title>Usage</title>
-
-  <para>
-   <literal>pkgs.nix-gitignore</literal> exports a number of functions, but you'll most likely need either <literal>gitignoreSource</literal> or <literal>gitignoreSourcePure</literal>. As their first argument, they both accept either 1. a file with gitignore lines or 2. a string with gitignore lines, or 3. a list of either of the two. They will be concatenated into a single big string.
-  </para>
-
-<programlisting><![CDATA[
-{ pkgs ? import <nixpkgs> {} }:
-
- nix-gitignore.gitignoreSource [] ./source
-     # Simplest version
-
- nix-gitignore.gitignoreSource "supplemental-ignores\n" ./source
-     # This one reads the ./source/.gitignore and concats the auxiliary ignores
-
- nix-gitignore.gitignoreSourcePure "ignore-this\nignore-that\n" ./source
-     # Use this string as gitignore, don't read ./source/.gitignore.
-
- nix-gitignore.gitignoreSourcePure ["ignore-this\nignore-that\n", ~/.gitignore] ./source
-     # It also accepts a list (of strings and paths) that will be concatenated
-     # once the paths are turned to strings via readFile.
-  ]]></programlisting>
-
-  <para>
-   These functions are derived from the <literal>Filter</literal> functions by setting the first filter argument to <literal>(_: _: true)</literal>:
-  </para>
-
-<programlisting><![CDATA[
-gitignoreSourcePure = gitignoreFilterSourcePure (_: _: true);
-gitignoreSource = gitignoreFilterSource (_: _: true);
-  ]]></programlisting>
-
-  <para>
-   Those filter functions accept the same arguments the <literal>builtins.filterSource</literal> function would pass to its filters, thus <literal>fn: gitignoreFilterSourcePure fn ""</literal> should be extensionally equivalent to <literal>filterSource</literal>. The file is blacklisted iff it's blacklisted by either your filter or the gitignoreFilter.
-  </para>
-
-  <para>
-   If you want to make your own filter from scratch, you may use
-  </para>
-
-<programlisting><![CDATA[
-gitignoreFilter = ign: root: filterPattern (gitignoreToPatterns ign) root;
-  ]]></programlisting>
- </section>
-
- <section xml:id="sec-pkgs-nix-gitignore-usage-recursive">
-  <title>gitignore files in subdirectories</title>
-
-  <para>
-   If you wish to use a filter that would search for .gitignore files in subdirectories, just like git does by default, use this function:
-  </para>
-
-<programlisting><![CDATA[
-gitignoreFilterRecursiveSource = filter: patterns: root:
-# OR
-gitignoreRecursiveSource = gitignoreFilterSourcePure (_: _: true);
-  ]]></programlisting>
- </section>
-</section>
diff --git a/doc/functions/prefer-remote-fetch.section.md b/doc/functions/prefer-remote-fetch.section.md
new file mode 100644
index 00000000000..8760c100224
--- /dev/null
+++ b/doc/functions/prefer-remote-fetch.section.md
@@ -0,0 +1,17 @@
+# prefer-remote-fetch overlay {#sec-prefer-remote-fetch}
+
+`prefer-remote-fetch` is an overlay that download sources on remote builder. This is useful when the evaluating machine has a slow upload while the builder can fetch faster directly from the source. To use it, put the following snippet as a new overlay:
+
+```nix
+self: super:
+  (super.prefer-remote-fetch self super)
+```
+
+A full configuration example for that sets the overlay up for your own account, could look like this
+
+```ShellSession
+$ mkdir ~/.config/nixpkgs/overlays/
+$ cat > ~/.config/nixpkgs/overlays/prefer-remote-fetch.nix <<EOF
+  self: super: super.prefer-remote-fetch self super
+EOF
+```
diff --git a/doc/functions/prefer-remote-fetch.xml b/doc/functions/prefer-remote-fetch.xml
deleted file mode 100644
index 94d25d3d3ae..00000000000
--- a/doc/functions/prefer-remote-fetch.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/xinclude"
-         xml:id="sec-prefer-remote-fetch">
- <title>prefer-remote-fetch overlay</title>
-
- <para>
-  <function>prefer-remote-fetch</function> is an overlay that download sources on remote builder. This is useful when the evaluating machine has a slow upload while the builder can fetch faster directly from the source. To use it, put the following snippet as a new overlay:
-<programlisting>
-self: super:
-  (super.prefer-remote-fetch self super)
-</programlisting>
-  A full configuration example for that sets the overlay up for your own account, could look like this
-<screen>
-<prompt>$ </prompt>mkdir ~/.config/nixpkgs/overlays/
-<prompt>$ </prompt>cat &gt; ~/.config/nixpkgs/overlays/prefer-remote-fetch.nix &lt;&lt;EOF
-  self: super: super.prefer-remote-fetch self super
-EOF
-</screen>
- </para>
-</section>
diff --git a/doc/labelless-link-is-xref.lua b/doc/labelless-link-is-xref.lua
new file mode 100644
index 00000000000..67569b02091
--- /dev/null
+++ b/doc/labelless-link-is-xref.lua
@@ -0,0 +1,24 @@
+local function starts_with(start, str)
+  return str:sub(1, #start) == start
+end
+
+local function escape_xml_arg(arg)
+  amps = arg:gsub('&', '&amp;')
+  amps_quotes = amps:gsub('"', '&quot;')
+  amps_quotes_lt = amps_quotes:gsub('<', '&lt;')
+
+  return amps_quotes_lt
+end
+
+function Link(elem)
+  has_no_content = #elem.content == 0
+  targets_anchor = starts_with('#', elem.target)
+  has_no_attributes = elem.title == '' and elem.identifier == '' and #elem.classes == 0 and #elem.attributes == 0
+
+  if has_no_content and targets_anchor and has_no_attributes then
+    -- xref expects idref without the pound-sign
+    target_without_hash = elem.target:sub(2, #elem.target)
+
+    return pandoc.RawInline('docbook', '<xref linkend="' .. escape_xml_arg(target_without_hash) .. '" />')
+  end
+end
diff --git a/doc/languages-frameworks/agda.section.md b/doc/languages-frameworks/agda.section.md
index 9ce046d05b6..2b7c35f68d3 100644
--- a/doc/languages-frameworks/agda.section.md
+++ b/doc/languages-frameworks/agda.section.md
@@ -1,91 +1,178 @@
----
-title: Agda
-author: Alex Rice (alexarice)
-date: 2020-01-06
----
-# Agda
+# Agda {#agda}
 
-## How to use Agda
+## How to use Agda {#how-to-use-agda}
 
-Agda can be installed from `agda`:
-```
-$ nix-env -iA agda
-```
+Agda is available as the [agda](https://search.nixos.org/packages?channel=unstable&show=agda&from=0&size=30&sort=relevance&query=agda)
+package.
 
-To use agda with libraries, the `agda.withPackages` function can be used. This function either takes:
-+ A list of packages,
-+ or a function which returns a list of packages when given the `agdaPackages` attribute set,
-+ or an attribute set containing a list of packages and a GHC derivation for compilation (see below).
+The `agda` package installs an Agda-wrapper, which calls `agda` with `--library-file`
+set to a generated library-file within the nix store, this means your library-file in
+`$HOME/.agda/libraries` will be ignored. By default the agda package installs Agda
+with no libraries, i.e. the generated library-file is empty. To use Agda with libraries,
+the `agda.withPackages` function can be used. This function either takes:
 
-For example, suppose we wanted a version of agda which has access to the standard library. This can be obtained with the expressions:
+* A list of packages,
+* or a function which returns a list of packages when given the `agdaPackages` attribute set,
+* or an attribute set containing a list of packages and a GHC derivation for compilation (see below).
+* or an attribute set containing a function which returns a list of packages when given the `agdaPackages` attribute set and a GHC derivation for compilation (see below).
 
-```
+For example, suppose we wanted a version of Agda which has access to the standard library. This can be obtained with the expressions:
+
+```nix
 agda.withPackages [ agdaPackages.standard-library ]
 ```
 
 or
 
-```
+```nix
 agda.withPackages (p: [ p.standard-library ])
 ```
 
 or can be called as in the [Compiling Agda](#compiling-agda) section.
 
-If you want to use a library in your home directory (for instance if it is a development version) then typecheck it manually (using `agda.withPackages` if necessary) and then override the `src` attribute of the package to point to your local repository.
-
-Agda will not by default use these libraries. To tell agda to use the library we have some options:
-- Call `agda` with the library flag:
-```
-$ agda -l standard-library -i . MyFile.agda
-```
-- Write a `my-library.agda-lib` file for the project you are working on which may look like:
-```
-name: my-library
-include: .
-depend: standard-library
-```
-- Create the file `~/.agda/defaults` and add any libraries you want to use by default.
+If you want to use a different version of a library (for instance a development version)
+override the `src` attribute of the package to point to your local repository
+
+```nix
+agda.withPackages (p: [
+  (p.standard-library.overrideAttrs (oldAttrs: {
+    version = "local version";
+    src = /path/to/local/repo/agda-stdlib;
+  }))
+])
+```
+
+You can also reference a GitHub repository
+
+```nix
+agda.withPackages (p: [
+  (p.standard-library.overrideAttrs (oldAttrs: {
+    version = "1.5";
+    src =  fetchFromGitHub {
+      repo = "agda-stdlib";
+      owner = "agda";
+      rev = "v1.5";
+      sha256 = "16fcb7ssj6kj687a042afaa2gq48rc8abihpm14k684ncihb2k4w";
+    };
+  }))
+])
+```
+
+If you want to use a library not added to Nixpkgs, you can add a
+dependency to a local library by calling `agdaPackages.mkDerivation`.
+
+```nix
+agda.withPackages (p: [
+  (p.mkDerivation {
+    pname = "your-agda-lib";
+    version = "1.0.0";
+    src = /path/to/your-agda-lib;
+  })
+])
+```
+
+Again you can reference GitHub
+
+```nix
+agda.withPackages (p: [
+  (p.mkDerivation {
+    pname = "your-agda-lib";
+    version = "1.0.0";
+    src = fetchFromGitHub {
+      repo = "repo";
+      owner = "owner";
+      version = "...";
+      rev = "...";
+      sha256 = "...";
+    };
+  })
+])
+```
+
+See [Building Agda Packages](#building-agda-packages) for more information on `mkDerivation`.
+
+Agda will not by default use these libraries. To tell Agda to use a library we have some options:
+
+* Call `agda` with the library flag:
+  ```ShellSession
+  $ agda -l standard-library -i . MyFile.agda
+  ```
+* Write a `my-library.agda-lib` file for the project you are working on which may look like:
+  ```
+  name: my-library
+  include: .
+  depend: standard-library
+  ```
+* Create the file `~/.agda/defaults` and add any libraries you want to use by default.
 
 More information can be found in the [official Agda documentation on library management](https://agda.readthedocs.io/en/v2.6.1/tools/package-system.html).
 
-## Compiling Agda
-Agda modules can be compiled with the `--compile` flag. A version of `ghc` with `ieee` is made available to the Agda program via the `--with-compiler` flag.
+## Compiling Agda {#compiling-agda}
+
+Agda modules can be compiled using the GHC backend with the `--compile` flag. A version of `ghc` with `ieee754` is made available to the Agda program via the `--with-compiler` flag.
 This can be overridden by a different version of `ghc` as follows:
 
-```
+```nix
 agda.withPackages {
   pkgs = [ ... ];
   ghc = haskell.compiler.ghcHEAD;
 }
 ```
 
-## Writing Agda packages
-To write a nix derivation for an agda library, first check that the library has a `*.agda-lib` file.
+## Writing Agda packages {#writing-agda-packages}
+
+To write a nix derivation for an Agda library, first check that the library has a `*.agda-lib` file.
 
 A derivation can then be written using `agdaPackages.mkDerivation`. This has similar arguments to `stdenv.mkDerivation` with the following additions:
-+ `everythingFile` can be used to specify the location of the `Everything.agda` file, defaulting to `./Everything.agda`. If this file does not exist then either it should be patched in or the `buildPhase` should be overridden (see below).
-+ `libraryName` should be the name that appears in the `*.agda-lib` file, defaulting to `pname`.
-+ `libraryFile` should be the file name of the `*.agda-lib` file, defaulting to `${libraryName}.agda-lib`.
 
-### Building Agda packages
+* `everythingFile` can be used to specify the location of the `Everything.agda` file, defaulting to `./Everything.agda`. If this file does not exist then either it should be patched in or the `buildPhase` should be overridden (see below).
+* `libraryName` should be the name that appears in the `*.agda-lib` file, defaulting to `pname`.
+* `libraryFile` should be the file name of the `*.agda-lib` file, defaulting to `${libraryName}.agda-lib`.
+
+Here is an example `default.nix`
+
+```nix
+{ nixpkgs ?  <nixpkgs> }:
+with (import nixpkgs {});
+agdaPackages.mkDerivation {
+  version = "1.0";
+  pname = "my-agda-lib";
+  src = ./.;
+  buildInputs = [
+    agdaPackages.standard-library
+  ];
+}
+```
+
+### Building Agda packages {#building-agda-packages}
+
 The default build phase for `agdaPackages.mkDerivation` simply runs `agda` on the `Everything.agda` file.
 If something else is needed to build the package (e.g. `make`) then the `buildPhase` should be overridden.
 Additionally, a `preBuild` or `configurePhase` can be used if there are steps that need to be done prior to checking the `Everything.agda` file.
 `agda` and the Agda libraries contained in `buildInputs` are made available during the build phase.
 
-### Installing Agda packages
-The default install phase copies agda source files, agda interface files (`*.agdai`) and `*.agda-lib` files to the output directory.
+### Installing Agda packages {#installing-agda-packages}
+
+The default install phase copies Agda source files, Agda interface files (`*.agdai`) and `*.agda-lib` files to the output directory.
 This can be overridden.
 
-By default, agda sources are files ending on  `.agda`, or literate agda files ending on `.lagda`, `.lagda.tex`, `.lagda.org`, `.lagda.md`, `.lagda.rst`. The list of recognised agda source extensions can be extended by setting the `extraExtensions` config variable.
+By default, Agda sources are files ending on `.agda`, or literate Agda files ending on `.lagda`, `.lagda.tex`, `.lagda.org`, `.lagda.md`, `.lagda.rst`. The list of recognised Agda source extensions can be extended by setting the `extraExtensions` config variable.
 
-To add an agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other agda libraries, so the top line of the `default.nix` can look like:
-```
+## Adding Agda packages to Nixpkgs {#adding-agda-packages-to-nixpkgs}
+
+To add an Agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other Agda libraries, so the top line of the `default.nix` can look like:
+
+```nix
 { mkDerivation, standard-library, fetchFromGitHub }:
 ```
-and `mkDerivation` should be called instead of `agdaPackages.mkDerivation`. Here is an example skeleton derivation for iowa-stdlib:
 
-```
+Note that the derivation function is called with `mkDerivation` set to `agdaPackages.mkDerivation`, therefore you
+could use a similar set as in your `default.nix` from [Writing Agda Packages](#writing-agda-packages) with
+`agdaPackages.mkDerivation` replaced with `mkDerivation`.
+
+Here is an example skeleton derivation for iowa-stdlib:
+
+```nix
 mkDerivation {
   version = "1.5.0";
   pname = "iowa-stdlib";
@@ -101,6 +188,7 @@ mkDerivation {
   '';
 }
 ```
+
 This library has a file called `.agda-lib`, and so we give an empty string to `libraryFile` as nothing precedes `.agda-lib` in the filename. This file contains `name: IAL-1.3`, and so we let `libraryName =  "IAL-1.3"`. This library does not use an `Everything.agda` file and instead has a Makefile, so there is no need to set `everythingFile` and we set a custom `buildPhase`.
 
-When writing an agda package it is essential to make sure that no `.agda-lib` file gets added to the store as a single file (for example by using `writeText`). This causes agda to think that the nix store is a agda library and it will attempt to write to it whenever it typechecks something. See [https://github.com/agda/agda/issues/4613](https://github.com/agda/agda/issues/4613).
+When writing an Agda package it is essential to make sure that no `.agda-lib` file gets added to the store as a single file (for example by using `writeText`). This causes Agda to think that the nix store is a Agda library and it will attempt to write to it whenever it typechecks something. See [https://github.com/agda/agda/issues/4613](https://github.com/agda/agda/issues/4613).
diff --git a/doc/languages-frameworks/android.section.md b/doc/languages-frameworks/android.section.md
index f4f6c086a80..28128ead663 100644
--- a/doc/languages-frameworks/android.section.md
+++ b/doc/languages-frameworks/android.section.md
@@ -1,15 +1,10 @@
----
-title: Android
-author: Sander van der Burg
-date: 2018-11-18
----
-# Android
+# Android {#android}
 
 The Android build environment provides three major features and a number of
 supporting features.
 
-Deploying an Android SDK installation with plugins
---------------------------------------------------
+## Deploying an Android SDK installation with plugins {#deploying-an-android-sdk-installation-with-plugins}
+
 The first use case is deploying the SDK with a desired set of plugins or subsets
 of an SDK.
 
@@ -18,21 +13,19 @@ with import <nixpkgs> {};
 
 let
   androidComposition = androidenv.composeAndroidPackages {
-    toolsVersion = "25.2.5";
-    platformToolsVersion = "27.0.1";
-    buildToolsVersions = [ "27.0.3" ];
+    toolsVersion = "26.1.1";
+    platformToolsVersion = "30.0.5";
+    buildToolsVersions = [ "30.0.3" ];
     includeEmulator = false;
-    emulatorVersion = "27.2.0";
-    platformVersions = [ "24" ];
+    emulatorVersion = "30.3.4";
+    platformVersions = [ "28" "29" "30" ];
     includeSources = false;
-    includeDocs = false;
     includeSystemImages = false;
-    systemImageTypes = [ "default" ];
-    abiVersions = [ "armeabi-v7a" ];
-    lldbVersions = [ "2.0.2558144" ];
-    cmakeVersions = [ "3.6.4111459" ];
-    includeNDK = false;
-    ndkVersion = "16.1.4479499";
+    systemImageTypes = [ "google_apis_playstore" ];
+    abiVersions = [ "armeabi-v7a" "arm64-v8a" ];
+    cmakeVersions = [ "3.10.2" ];
+    includeNDK = true;
+    ndkVersions = ["22.0.7026061"];
     useGoogleAPIs = false;
     useGoogleTVAddOns = false;
     includeExtras = [
@@ -51,17 +44,19 @@ The following parameters are supported:
 
 * `toolsVersion`, specifies the version of the tools package to use
 * `platformsToolsVersion` specifies the version of the `platform-tools` plugin
-* `buildToolsVersion` specifies the versions of the `build-tools` plugins to
+* `buildToolsVersions` specifies the versions of the `build-tools` plugins to
   use.
 * `includeEmulator` specifies whether to deploy the emulator package (`false`
   by default). When enabled, the version of the emulator to deploy can be
   specified by setting the `emulatorVersion` parameter.
-* `includeDocs` specifies whether the documentation catalog should be included.
-* `lldbVersions` specifies what LLDB versions should be deployed.
 * `cmakeVersions` specifies which CMake versions should be deployed.
 * `includeNDK` specifies that the Android NDK bundle should be included.
   Defaults to: `false`.
-* `ndkVersion` specifies the NDK version that we want to use.
+* `ndkVersions` specifies the NDK versions that we want to use. These are linked
+  under the `ndk` directory of the SDK root, and the first is linked under the
+  `ndk-bundle` directory.
+* `ndkVersion` is equivalent to specifying one entry in `ndkVersions`, and
+  `ndkVersions` overrides this parameter if provided.
 * `includeExtras` is an array of identifier strings referring to arbitrary
   add-on packages that should be installed.
 * `platformVersions` specifies which platform SDK versions should be included.
@@ -87,6 +82,38 @@ For each requested system image we can specify the following options:
 
 Most of the function arguments have reasonable default settings.
 
+You can specify license names:
+
+* `extraLicenses` is a list of license names.
+  You can get these names from repo.json or `querypackages.sh licenses`. The SDK
+  license (`android-sdk-license`) is accepted for you if you set accept_license
+  to true. If you are doing something like working with preview SDKs, you will
+  want to add `android-sdk-preview-license` or whichever license applies here.
+
+Additionally, you can override the repositories that composeAndroidPackages will
+pull from:
+
+* `repoJson` specifies a path to a generated repo.json file. You can generate this
+  by running `generate.sh`, which in turn will call into `mkrepo.rb`.
+* `repoXmls` is an attribute set containing paths to repo XML files. If specified,
+  it takes priority over `repoJson`, and will trigger a local build writing out a
+  repo.json to the Nix store based on the given repository XMLs.
+
+```nix
+repoXmls = {
+  packages = [ ./xml/repository2-1.xml ];
+  images = [
+    ./xml/android-sys-img2-1.xml
+    ./xml/android-tv-sys-img2-1.xml
+    ./xml/android-wear-sys-img2-1.xml
+    ./xml/android-wear-cn-sys-img2-1.xml
+    ./xml/google_apis-sys-img2-1.xml
+    ./xml/google_apis_playstore-sys-img2-1.xml
+  ];
+  addons = [ ./xml/addon2-1.xml ];
+};
+```
+
 When building the above expression with:
 
 ```bash
@@ -109,8 +136,8 @@ in
 androidComposition.platform-tools
 ```
 
-Using predefine Android package compositions
---------------------------------------------
+## Using predefined Android package compositions {#using-predefined-android-package-compositions}
+
 In addition to composing an Android package set manually, it is also possible
 to use a predefined composition that contains all basic packages for a specific
 Android version, such as version 9.0 (API-level 28).
@@ -132,12 +159,13 @@ with import <nixpkgs> {};
 androidenv.androidPkgs_9_0.platform-tools
 ```
 
-Building an Android application
--------------------------------
+## Building an Android application {#building-an-android-application}
+
 In addition to the SDK, it is also possible to build an Ant-based Android
 project and automatically deploy all the Android plugins that a project
 requires.
 
+
 ```nix
 with import <nixpkgs> {};
 
@@ -172,8 +200,8 @@ to build Android apps. An Android APK gets exposed as a build product and can be
 installed on any Android device with a web browser by navigating to the build
 result page.
 
-Spawning emulator instances
----------------------------
+## Spawning emulator instances {#spawning-emulator-instances}
+
 For testing purposes, it can also be quite convenient to automatically generate
 scripts that spawn emulator instances with all desired configuration settings.
 
@@ -214,27 +242,104 @@ androidenv.emulateApp {
 In addition to prebuilt APKs, you can also bind the APK parameter to a
 `buildApp {}` function invocation shown in the previous example.
 
-Querying the available versions of each plugin
-----------------------------------------------
-When using any of the previously shown functions, it may be a bit inconvenient
-to find out what options are supported, since the Android SDK provides many
-plugins.
+## Notes on environment variables in Android projects {#notes-on-environment-variables-in-android-projects}
+
+* `ANDROID_SDK_ROOT` should point to the Android SDK. In your Nix expressions, this should be
+  `${androidComposition.androidsdk}/libexec/android-sdk`. Note that `ANDROID_HOME` is deprecated,
+  but if you rely on tools that need it, you can export it too.
+* `ANDROID_NDK_ROOT` should point to the Android NDK, if you're doing NDK development.
+  In your Nix expressions, this should be `${ANDROID_SDK_ROOT}/ndk-bundle`.
+
+If you are running the Android Gradle plugin, you need to export GRADLE_OPTS to override aapt2
+to point to the aapt2 binary in the Nix store as well, or use a FHS environment so the packaged
+aapt2 can run. If you don't want to use a FHS environment, something like this should work:
+
+```nix
+let
+  buildToolsVersion = "30.0.3";
+
+  # Use buildToolsVersion when you define androidComposition
+  androidComposition = <...>;
+in
+pkgs.mkShell rec {
+  ANDROID_SDK_ROOT = "${androidComposition.androidsdk}/libexec/android-sdk";
+  ANDROID_NDK_ROOT = "${ANDROID_SDK_ROOT}/ndk-bundle";
+
+  # Use the same buildToolsVersion here
+  GRADLE_OPTS = "-Dorg.gradle.project.android.aapt2FromMavenOverride=${ANDROID_SDK_ROOT}/build-tools/${buildToolsVersion}/aapt2";
+}
+```
+
+If you are using cmake, you need to add it to PATH in a shell hook or FHS env profile.
+The path is suffixed with a build number, but properly prefixed with the version.
+So, something like this should suffice:
+
+```nix
+let
+  cmakeVersion = "3.10.2";
+
+  # Use cmakeVersion when you define androidComposition
+  androidComposition = <...>;
+in
+pkgs.mkShell rec {
+  ANDROID_SDK_ROOT = "${androidComposition.androidsdk}/libexec/android-sdk";
+  ANDROID_NDK_ROOT = "${ANDROID_SDK_ROOT}/ndk-bundle";
+
+  # Use the same cmakeVersion here
+  shellHook = ''
+    export PATH="$(echo "$ANDROID_SDK_ROOT/cmake/${cmakeVersion}".*/bin):$PATH"
+  '';
+}
+```
+
+Note that running Android Studio with ANDROID_SDK_ROOT set will automatically write a
+`local.properties` file with `sdk.dir` set to $ANDROID_SDK_ROOT if one does not already
+exist. If you are using the NDK as well, you may have to add `ndk.dir` to this file.
+
+An example shell.nix that does all this for you is provided in examples/shell.nix.
+This shell.nix includes a shell hook that overwrites local.properties with the correct
+sdk.dir and ndk.dir values. This will ensure that the SDK and NDK directories will
+both be correct when you run Android Studio inside nix-shell.
 
-A shell script in the `pkgs/development/mobile/androidenv/` sub directory can be used to retrieve all
+## Notes on improving build.gradle compatibility {#notes-on-improving-build.gradle-compatibility}
+
+Ensure that your buildToolsVersion and ndkVersion match what is declared in androidenv.
+If you are using cmake, make sure its declared version is correct too.
+
+Otherwise, you may get cryptic errors from aapt2 and the Android Gradle plugin warning
+that it cannot install the build tools because the SDK directory is not writeable.
+
+```gradle
+android {
+    buildToolsVersion "30.0.3"
+    ndkVersion = "22.0.7026061"
+    externalNativeBuild {
+        cmake {
+            version "3.10.2"
+        }
+    }
+}
+
+```
+
+## Querying the available versions of each plugin {#querying-the-available-versions-of-each-plugin}
+
+repo.json provides all the options in one file now.
+
+A shell script in the `pkgs/development/mobile/androidenv/` subdirectory can be used to retrieve all
 possible options:
 
 ```bash
-sh ./querypackages.sh packages build-tools
+./querypackages.sh packages
 ```
 
-The above command-line instruction queries all build-tools versions in the
-generated `packages.nix` expression.
+The above command-line instruction queries all package versions in repo.json.
+
+## Updating the generated expressions {#updating-the-generated-expressions}
 
-Updating the generated expressions
-----------------------------------
-Most of the Nix expressions are generated from XML files that the Android
-package manager uses. To update the expressions run the `generate.sh` script
-that is stored in the `pkgs/development/mobile/androidenv/` sub directory:
+repo.json is generated from XML files that the Android Studio package manager uses.
+To update the expressions run the `generate.sh` script that is stored in the
+`pkgs/development/mobile/androidenv/` subdirectory:
 
 ```bash
 ./generate.sh
diff --git a/doc/languages-frameworks/beam.section.md b/doc/languages-frameworks/beam.section.md
new file mode 100644
index 00000000000..934e6cdca12
--- /dev/null
+++ b/doc/languages-frameworks/beam.section.md
@@ -0,0 +1,295 @@
+# BEAM Languages (Erlang, Elixir & LFE) {#sec-beam}
+
+## Introduction {#beam-introduction}
+
+In this document and related Nix expressions, we use the term, _BEAM_, to describe the environment. BEAM is the name of the Erlang Virtual Machine and, as far as we're concerned, from a packaging perspective, all languages that run on the BEAM are interchangeable. That which varies, like the build system, is transparent to users of any given BEAM package, so we make no distinction.
+
+## Available versions and deprecations schedule {#available-versions-and-deprecations-schedule}
+
+### Elixir {#elixir}
+
+nixpkgs follows the [official elixir deprecation schedule](https://hexdocs.pm/elixir/compatibility-and-deprecations.html) and keeps the last 5 released versions of Elixir available.
+
+## Structure {#beam-structure}
+
+All BEAM-related expressions are available via the top-level `beam` attribute, which includes:
+
+- `interpreters`: a set of compilers running on the BEAM, including multiple Erlang/OTP versions (`beam.interpreters.erlangR22`, etc), Elixir (`beam.interpreters.elixir`) and LFE (Lisp Flavoured Erlang) (`beam.interpreters.lfe`).
+
+- `packages`: a set of package builders (Mix and rebar3), each compiled with a specific Erlang/OTP version, e.g. `beam.packages.erlang22`.
+
+The default Erlang compiler, defined by `beam.interpreters.erlang`, is aliased as `erlang`. The default BEAM package set is defined by `beam.packages.erlang` and aliased at the top level as `beamPackages`.
+
+To create a package builder built with a custom Erlang version, use the lambda, `beam.packagesWith`, which accepts an Erlang/OTP derivation and produces a package builder similar to `beam.packages.erlang`.
+
+Many Erlang/OTP distributions available in `beam.interpreters` have versions with ODBC and/or Java enabled or without wx (no observer support). For example, there's `beam.interpreters.erlangR22_odbc_javac`, which corresponds to `beam.interpreters.erlangR22` and `beam.interpreters.erlangR22_nox`, which corresponds to `beam.interpreters.erlangR22`.
+
+## Build Tools {#build-tools}
+
+### Rebar3 {#build-tools-rebar3}
+
+We provide a version of Rebar3, under `rebar3`. We also provide a helper to fetch Rebar3 dependencies from a lockfile under `fetchRebar3Deps`.
+
+We also provide a version on Rebar3 with plugins included, under `rebar3WithPlugins`. This package is a function which takes two arguments: `plugins`, a list of nix derivations to include as plugins (loaded only when specified in `rebar.config`), and `globalPlugins`, which should always be loaded by rebar3. Example: `rebar3WithPlugins { globalPlugins = [beamPackages.pc]; }`.
+
+When adding a new plugin it is important that the `packageName` attribute is the same as the atom used by rebar3 to refer to the plugin.
+
+### Mix & Erlang.mk {#build-tools-other}
+
+Erlang.mk works exactly as expected. There is a bootstrap process that needs to be run, which is supported by the `buildErlangMk` derivation.
+
+For Elixir applications use `mixRelease` to make a release. See examples for more details.
+
+There is also a `buildMix` helper, whose behavior is closer to that of `buildErlangMk` and `buildRebar3`. The primary difference is that mixRelease makes a release, while buildMix only builds the package, making it useful for libraries and other dependencies.
+
+## How to Install BEAM Packages {#how-to-install-beam-packages}
+
+BEAM builders are not registered at the top level, simply because they are not relevant to the vast majority of Nix users. To install any of those builders into your profile, refer to them by their attribute path `beamPackages.rebar3`:
+
+```ShellSession
+$ nix-env -f "<nixpkgs>" -iA beamPackages.rebar3
+```
+
+## Packaging BEAM Applications {#packaging-beam-applications}
+
+### Erlang Applications {#packaging-erlang-applications}
+
+#### Rebar3 Packages {#rebar3-packages}
+
+The Nix function, `buildRebar3`, defined in `beam.packages.erlang.buildRebar3` and aliased at the top level, can be used to build a derivation that understands how to build a Rebar3 project.
+
+If a package needs to compile native code via Rebar3's port compilation mechanism, add `compilePort = true;` to the derivation.
+
+#### Erlang.mk Packages {#erlang-mk-packages}
+
+Erlang.mk functions similarly to Rebar3, except we use `buildErlangMk` instead of `buildRebar3`.
+
+#### Mix Packages {#mix-packages}
+
+`mixRelease` is used to make a release in the mix sense. Dependencies will need to be fetched with `fetchMixDeps` and passed to it.
+
+#### mixRelease - Elixir Phoenix example {#mixrelease---elixir-phoenix-example}
+
+Here is how your `default.nix` file would look.
+
+```nix
+with import <nixpkgs> { };
+
+let
+  packages = beam.packagesWith beam.interpreters.erlang;
+  src = builtins.fetchgit {
+    url = "ssh://git@github.com/your_id/your_repo";
+    rev = "replace_with_your_commit";
+  };
+
+  pname = "your_project";
+  version = "0.0.1";
+  mixEnv = "prod";
+
+  mixFodDeps = packages.fetchMixDeps {
+    pname = "mix-deps-${pname}";
+    inherit src mixEnv version;
+    # nix will complain and tell you the right value to replace this with
+    sha256 = lib.fakeSha256;
+    # if you have build time environment variables add them here
+    MY_ENV_VAR="my_value";
+  };
+
+  nodeDependencies = (pkgs.callPackage ./assets/default.nix { }).shell.nodeDependencies;
+
+  frontEndFiles = stdenvNoCC.mkDerivation {
+    pname = "frontend-${pname}";
+
+    nativeBuildInputs = [ nodejs ];
+
+    inherit version src;
+
+    buildPhase = ''
+      cp -r ./assets $TEMPDIR
+
+      mkdir -p $TEMPDIR/assets/node_modules/.cache
+      cp -r ${nodeDependencies}/lib/node_modules $TEMPDIR/assets
+      export PATH="${nodeDependencies}/bin:$PATH"
+
+      cd $TEMPDIR/assets
+      webpack --config ./webpack.config.js
+      cd ..
+    '';
+
+    installPhase = ''
+      cp -r ./priv/static $out/
+    '';
+
+    outputHashAlgo = "sha256";
+    outputHashMode = "recursive";
+    # nix will complain and tell you the right value to replace this with
+    outputHash = lib.fakeSha256;
+
+    impureEnvVars = lib.fetchers.proxyImpureEnvVars;
+  };
+
+
+in packages.mixRelease {
+  inherit src pname version mixEnv mixFodDeps;
+  # if you have build time environment variables add them here
+  MY_ENV_VAR="my_value";
+  preInstall = ''
+    mkdir -p ./priv/static
+    cp -r ${frontEndFiles} ./priv/static
+  '';
+}
+```
+
+Setup will require the following steps:
+
+- Move your secrets to runtime environment variables. For more information refer to the [runtime.exs docs](https://hexdocs.pm/mix/Mix.Tasks.Release.html#module-runtime-configuration). On a fresh Phoenix build that would mean that both `DATABASE_URL` and `SECRET_KEY` need to be moved to `runtime.exs`.
+- `cd assets` and `nix-shell -p node2nix --run node2nix --development` will generate a Nix expression containing your frontend dependencies
+- commit and push those changes
+- you can now `nix-build .`
+- To run the release, set the `RELEASE_TMP` environment variable to a directory that your program has write access to. It will be used to store the BEAM settings.
+
+#### Example of creating a service for an Elixir - Phoenix project {#example-of-creating-a-service-for-an-elixir---phoenix-project}
+
+In order to create a service with your release, you could add a `service.nix`
+in your project with the following
+
+```nix
+{config, pkgs, lib, ...}:
+
+let
+  release = pkgs.callPackage ./default.nix;
+  release_name = "app";
+  working_directory = "/home/app";
+in
+{
+  systemd.services.${release_name} = {
+    wantedBy = [ "multi-user.target" ];
+    after = [ "network.target" "postgresql.service" ];
+    requires = [ "network-online.target" "postgresql.service" ];
+    description = "my app";
+    environment = {
+      # RELEASE_TMP is used to write the state of the
+      # VM configuration when the system is running
+      # it needs to be a writable directory
+      RELEASE_TMP = working_directory;
+      # can be generated in an elixir console with
+      # Base.encode32(:crypto.strong_rand_bytes(32))
+      RELEASE_COOKIE = "my_cookie";
+      MY_VAR = "my_var";
+    };
+    serviceConfig = {
+      Type = "exec";
+      DynamicUser = true;
+      WorkingDirectory = working_directory;
+      # Implied by DynamicUser, but just to emphasize due to RELEASE_TMP
+      PrivateTmp = true;
+      ExecStart = ''
+        ${release}/bin/${release_name} start
+      '';
+      ExecStop = ''
+        ${release}/bin/${release_name} stop
+      '';
+      ExecReload = ''
+        ${release}/bin/${release_name} restart
+      '';
+      Restart = "on-failure";
+      RestartSec = 5;
+      StartLimitBurst = 3;
+      StartLimitInterval = 10;
+    };
+    # disksup requires bash
+    path = [ pkgs.bash ];
+  };
+
+  environment.systemPackages = [ release ];
+}
+```
+
+## How to Develop {#how-to-develop}
+
+### Creating a Shell {#creating-a-shell}
+
+Usually, we need to create a `shell.nix` file and do our development inside of the environment specified therein. Just install your version of Erlang and any other interpreters, and then use your normal build tools. As an example with Elixir:
+
+```nix
+{ pkgs ? import "<nixpkgs"> {} }:
+
+with pkgs;
+
+let
+
+  elixir = beam.packages.erlangR22.elixir_1_9;
+
+in
+mkShell {
+  buildInputs = [ elixir ];
+
+  ERL_INCLUDE_PATH="${erlang}/lib/erlang/usr/include";
+}
+```
+
+#### Elixir - Phoenix project {#elixir---phoenix-project}
+
+Here is an example `shell.nix`.
+
+```nix
+with import <nixpkgs> { };
+
+let
+  # define packages to install
+  basePackages = [
+    git
+    # replace with beam.packages.erlang.elixir_1_11 if you need
+    beam.packages.erlang.elixir
+    nodejs
+    postgresql_13
+    # only used for frontend dependencies
+    # you are free to use yarn2nix as well
+    nodePackages.node2nix
+    # formatting js file
+    nodePackages.prettier
+  ];
+
+  inputs = basePackages ++ lib.optionals stdenv.isLinux [ inotify-tools ]
+    ++ lib.optionals stdenv.isDarwin
+    (with darwin.apple_sdk.frameworks; [ CoreFoundation CoreServices ]);
+
+  # define shell startup command
+  hooks = ''
+    # this allows mix to work on the local directory
+    mkdir -p .nix-mix .nix-hex
+    export MIX_HOME=$PWD/.nix-mix
+    export HEX_HOME=$PWD/.nix-mix
+    export PATH=$MIX_HOME/bin:$HEX_HOME/bin:$PATH
+    # TODO: not sure how to make hex available without installing it afterwards.
+    mix local.hex --if-missing
+    export LANG=en_US.UTF-8
+    export ERL_AFLAGS="-kernel shell_history enabled"
+
+    # postges related
+    # keep all your db data in a folder inside the project
+    export PGDATA="$PWD/db"
+
+    # phoenix related env vars
+    export POOL_SIZE=15
+    export DB_URL="postgresql://postgres:postgres@localhost:5432/db"
+    export PORT=4000
+    export MIX_ENV=dev
+    # add your project env vars here, word readable in the nix store.
+    export ENV_VAR="your_env_var"
+  '';
+
+in mkShell {
+  buildInputs = inputs;
+  shellHook = hooks;
+}
+```
+
+Initializing the project will require the following steps:
+
+- create the db directory `initdb ./db` (inside your mix project folder)
+- create the postgres user `createuser postgres -ds`
+- create the db `createdb db`
+- start the postgres instance `pg_ctl -l "$PGDATA/server.log" start`
+- add the `/db` folder to your `.gitignore`
+- you can start your phoenix server and get a shell with `iex -S mix phx.server`
diff --git a/doc/languages-frameworks/beam.xml b/doc/languages-frameworks/beam.xml
deleted file mode 100644
index 1d307e1d6dc..00000000000
--- a/doc/languages-frameworks/beam.xml
+++ /dev/null
@@ -1,159 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-beam">
- <title>BEAM Languages (Erlang, Elixir &amp; LFE)</title>
-
- <section xml:id="beam-introduction">
-  <title>Introduction</title>
-
-  <para>
-   In this document and related Nix expressions, we use the term, <emphasis>BEAM</emphasis>, to describe the environment. BEAM is the name of the Erlang Virtual Machine and, as far as we're concerned, from a packaging perspective, all languages that run on the BEAM are interchangeable. That which varies, like the build system, is transparent to users of any given BEAM package, so we make no distinction.
-  </para>
- </section>
-
- <section xml:id="beam-structure">
-  <title>Structure</title>
-
-  <para>
-   All BEAM-related expressions are available via the top-level <literal>beam</literal> attribute, which includes:
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     <literal>interpreters</literal>: a set of compilers running on the BEAM, including multiple Erlang/OTP versions (<literal>beam.interpreters.erlangR19</literal>, etc), Elixir (<literal>beam.interpreters.elixir</literal>) and LFE (<literal>beam.interpreters.lfe</literal>).
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     <literal>packages</literal>: a set of package builders (Mix and rebar3), each compiled with a specific Erlang/OTP version, e.g. <literal>beam.packages.erlangR19</literal>.
-    </para>
-   </listitem>
-  </itemizedlist>
-
-  <para>
-   The default Erlang compiler, defined by <literal>beam.interpreters.erlang</literal>, is aliased as <literal>erlang</literal>. The default BEAM package set is defined by <literal>beam.packages.erlang</literal> and aliased at the top level as <literal>beamPackages</literal>.
-  </para>
-
-  <para>
-   To create a package builder built with a custom Erlang version, use the lambda, <literal>beam.packagesWith</literal>, which accepts an Erlang/OTP derivation and produces a package builder similar to <literal>beam.packages.erlang</literal>.
-  </para>
-
-  <para>
-   Many Erlang/OTP distributions available in <literal>beam.interpreters</literal> have versions with ODBC and/or Java enabled or without wx (no observer support). For example, there's <literal>beam.interpreters.erlangR22_odbc_javac</literal>, which corresponds to <literal>beam.interpreters.erlangR22</literal> and <literal>beam.interpreters.erlangR22_nox</literal>, which corresponds to <literal>beam.interpreters.erlangR22</literal>.
-  </para>
- </section>
-
- <section xml:id="build-tools">
-  <title>Build Tools</title>
-
-  <section xml:id="build-tools-rebar3">
-   <title>Rebar3</title>
-
-   <para>
-    We provide a version of Rebar3, under <literal>rebar3</literal>. We also provide a helper to fetch Rebar3 dependencies from a lockfile under <literal>fetchRebar3Deps</literal>.
-   </para>
-  </section>
-
-  <section xml:id="build-tools-other">
-   <title>Mix &amp; Erlang.mk</title>
-
-   <para>
-    Both Mix and Erlang.mk work exactly as expected. There is a bootstrap process that needs to be run for both, however, which is supported by the <literal>buildMix</literal> and <literal>buildErlangMk</literal> derivations, respectively.
-   </para>
-  </section>
- </section>
-
- <section xml:id="how-to-install-beam-packages">
-  <title>How to Install BEAM Packages</title>
-
-  <para>
-   BEAM builders are not registered at the top level, simply because they are not relevant to the vast majority of Nix users.
-   To install any of those builders into your profile, refer to them by their attribute path <literal>beamPackages.rebar3</literal>:
-  </para>
-
-  <screen>
-  <prompt>$ </prompt>nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA beamPackages.rebar3
-  </screen>
-</section>
-
- <section xml:id="packaging-beam-applications">
-  <title>Packaging BEAM Applications</title>
-
-  <section  xml:id="packaging-erlang-applications">
-   <title>Erlang Applications</title>
-
-   <section xml:id="rebar3-packages">
-    <title>Rebar3 Packages</title>
-
-    <para>
-     The Nix function, <literal>buildRebar3</literal>, defined in <literal>beam.packages.erlang.buildRebar3</literal> and aliased at the top level, can be used to build a derivation that understands how to build a Rebar3 project.
-    </para>
-
-    <para>
-     If a package needs to compile native code via Rebar3's port compilation mechanism, add <literal>compilePort = true;</literal> to the derivation.
-    </para>
-   </section>
-
-   <section xml:id="erlang-mk-packages">
-    <title>Erlang.mk Packages</title>
-
-    <para>
-     Erlang.mk functions similarly to Rebar3, except we use <literal>buildErlangMk</literal> instead of <literal>buildRebar3</literal>.
-    </para>
-
-   </section>
-
-   <section xml:id="mix-packages">
-    <title>Mix Packages</title>
-
-    <para>
-     Mix functions similarly to Rebar3, except we use <literal>buildMix</literal> instead of <literal>buildRebar3</literal>.
-    </para>
-
-    <para>
-     Alternatively, we can use <literal>buildHex</literal> as a shortcut:
-    </para>
-   </section>
-  </section>
- </section>
-
- <section xml:id="how-to-develop">
-  <title>How to Develop</title>
-
-  <section xml:id="creating-a-shell">
-   <title>Creating a Shell</title>
-
-  <para>
-    Usually, we need to create a <literal>shell.nix</literal> file and do our development inside of the environment specified therein. Just install your version of erlang and other interpreter, and then user your normal build tools.
-    As an example with elixir:
-  </para>
-
-<programlisting>
-{ pkgs ? import &quot;&lt;nixpkgs&quot;&gt; {} }:
-
-with pkgs;
-
-let
-
-  elixir = beam.packages.erlangR22.elixir_1_9;
-
-in
-mkShell {
-  buildInputs = [ elixir ];
-
-  ERL_INCLUDE_PATH="${erlang}/lib/erlang/usr/include";
-}
-</programlisting>
-
-   <section xml:id="building-in-a-shell">
-    <title>Building in a Shell (for Mix Projects)</title>
-
-    <para>
-     Using a <literal>shell.nix</literal> as described (see <xref
-      linkend="creating-a-shell"/>) should just work.
-    </para>
-   </section>
-  </section>
- </section>
-</section>
diff --git a/doc/languages-frameworks/bower.section.md b/doc/languages-frameworks/bower.section.md
new file mode 100644
index 00000000000..6226dc0702d
--- /dev/null
+++ b/doc/languages-frameworks/bower.section.md
@@ -0,0 +1,158 @@
+# Bower {#sec-bower}
+
+[Bower](https://bower.io) is a package manager for web site front-end components. Bower packages (comprising of build artefacts and sometimes sources) are stored in `git` repositories, typically on Github. The package registry is run by the Bower team with package metadata coming from the `bower.json` file within each package.
+
+The end result of running Bower is a `bower_components` directory which can be included in the web app's build process.
+
+Bower can be run interactively, by installing `nodePackages.bower`. More interestingly, the Bower components can be declared in a Nix derivation, with the help of `nodePackages.bower2nix`.
+
+## bower2nix usage {#ssec-bower2nix-usage}
+
+Suppose you have a `bower.json` with the following contents:
+
+### Example bower.json {#ex-bowerJson}
+
+```json
+  "name": "my-web-app",
+  "dependencies": {
+    "angular": "~1.5.0",
+    "bootstrap": "~3.3.6"
+  }
+```
+
+Running `bower2nix` will produce something like the following output:
+
+```nix
+{ fetchbower, buildEnv }:
+buildEnv { name = "bower-env"; ignoreCollisions = true; paths = [
+  (fetchbower "angular" "1.5.3" "~1.5.0" "1749xb0firxdra4rzadm4q9x90v6pzkbd7xmcyjk6qfza09ykk9y")
+  (fetchbower "bootstrap" "3.3.6" "~3.3.6" "1vvqlpbfcy0k5pncfjaiskj3y6scwifxygfqnw393sjfxiviwmbv")
+  (fetchbower "jquery" "2.2.2" "1.9.1 - 2" "10sp5h98sqwk90y4k6hbdviwqzvzwqf47r3r51pakch5ii2y7js1")
+];
+```
+
+Using the `bower2nix` command line arguments, the output can be redirected to a file. A name like `bower-packages.nix` would be fine.
+
+The resulting derivation is a union of all the downloaded Bower packages (and their dependencies). To use it, they still need to be linked together by Bower, which is where `buildBowerComponents` is useful.
+
+## buildBowerComponents function {#ssec-build-bower-components}
+
+The function is implemented in [pkgs/development/bower-modules/generic/default.nix](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/bower-modules/generic/default.nix).
+
+### Example buildBowerComponents {#ex-buildBowerComponents}
+
+```{=docbook}
+<programlisting language="nix">
+bowerComponents = buildBowerComponents {
+  name = "my-web-app";
+  generated = ./bower-packages.nix; <co xml:id="ex-buildBowerComponents-1" />
+  src = myWebApp; <co xml:id="ex-buildBowerComponents-2" />
+};
+</programlisting>
+```
+
+In ["buildBowerComponents" example](#ex-buildBowerComponents) the following arguments are of special significance to the function:
+
+```{=docbook}
+<calloutlist>
+  <callout arearefs="ex-buildBowerComponents-1">
+    <para>
+      <varname>generated</varname> specifies the file which was created by <command>bower2nix</command>.
+    </para>
+    </callout>
+      <callout arearefs="ex-buildBowerComponents-2">
+    <para>
+      <varname>src</varname> is your project's sources. It needs to contain a <filename>bower.json</filename> file.
+    </para>
+  </callout>
+</calloutlist>
+```
+
+`buildBowerComponents` will run Bower to link together the output of `bower2nix`, resulting in a `bower_components` directory which can be used.
+
+Here is an example of a web frontend build process using `gulp`. You might use `grunt`, or anything else.
+
+### Example build script (gulpfile.js) {#ex-bowerGulpFile}
+
+```javascript
+var gulp = require('gulp');
+
+gulp.task('default', [], function () {
+  gulp.start('build');
+});
+
+gulp.task('build', [], function () {
+  console.log("Just a dummy gulp build");
+  gulp
+    .src(["./bower_components/**/*"])
+    .pipe(gulp.dest("./gulpdist/"));
+});
+```
+
+### Example Full example — default.nix {#ex-buildBowerComponentsDefaultNix}
+
+```{=docbook}
+<programlisting language="nix">
+{ myWebApp ? { outPath = ./.; name = "myWebApp"; }
+, pkgs ? import &lt;nixpkgs&gt; {}
+}:
+
+pkgs.stdenv.mkDerivation {
+  name = "my-web-app-frontend";
+  src = myWebApp;
+
+  buildInputs = [ pkgs.nodePackages.gulp ];
+
+  bowerComponents = pkgs.buildBowerComponents { <co xml:id="ex-buildBowerComponentsDefault-1" />
+    name = "my-web-app";
+    generated = ./bower-packages.nix;
+    src = myWebApp;
+  };
+
+  buildPhase = ''
+    cp --reflink=auto --no-preserve=mode -R $bowerComponents/bower_components . <co xml:id="ex-buildBowerComponentsDefault-2" />
+    export HOME=$PWD <co xml:id="ex-buildBowerComponentsDefault-3" />
+    ${pkgs.nodePackages.gulp}/bin/gulp build <co xml:id="ex-buildBowerComponentsDefault-4" />
+  '';
+
+  installPhase = "mv gulpdist $out";
+}
+</programlisting>
+```
+
+A few notes about [Full example — `default.nix`](#ex-buildBowerComponentsDefaultNix):
+
+```{=docbook}
+<calloutlist>
+  <callout arearefs="ex-buildBowerComponentsDefault-1">
+    <para>
+      The result of <varname>buildBowerComponents</varname> is an input to the frontend build.
+    </para>
+  </callout>
+  <callout arearefs="ex-buildBowerComponentsDefault-2">
+    <para>
+      Whether to symlink or copy the <filename>bower_components</filename> directory depends on the build tool in use. In this case a copy is used to avoid <command>gulp</command> silliness with permissions.
+    </para>
+  </callout>
+  <callout arearefs="ex-buildBowerComponentsDefault-3">
+    <para>
+      <command>gulp</command> requires <varname>HOME</varname> to refer to a writeable directory.
+    </para>
+  </callout>
+  <callout arearefs="ex-buildBowerComponentsDefault-4">
+    <para>
+      The actual build command. Other tools could be used.
+    </para>
+  </callout>
+</calloutlist>
+```
+
+## Troubleshooting {#ssec-bower2nix-troubleshooting}
+
+### ENOCACHE errors from buildBowerComponents {#enocache-errors-from-buildbowercomponents}
+
+This means that Bower was looking for a package version which doesn't exist in the generated `bower-packages.nix`.
+
+If `bower.json` has been updated, then run `bower2nix` again.
+
+It could also be a bug in `bower2nix` or `fetchbower`. If possible, try reformulating the version specification in `bower.json`.
diff --git a/doc/languages-frameworks/bower.xml b/doc/languages-frameworks/bower.xml
deleted file mode 100644
index b0738cad293..00000000000
--- a/doc/languages-frameworks/bower.xml
+++ /dev/null
@@ -1,196 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-bower">
- <title>Bower</title>
-
- <para>
-  <link xlink:href="http://bower.io">Bower</link> is a package manager for web site front-end components. Bower packages (comprising of build artefacts and sometimes sources) are stored in <command>git</command> repositories, typically on Github. The package registry is run by the Bower team with package metadata coming from the <filename>bower.json</filename> file within each package.
- </para>
-
- <para>
-  The end result of running Bower is a <filename>bower_components</filename> directory which can be included in the web app's build process.
- </para>
-
- <para>
-  Bower can be run interactively, by installing <varname>nodePackages.bower</varname>. More interestingly, the Bower components can be declared in a Nix derivation, with the help of <varname>nodePackages.bower2nix</varname>.
- </para>
-
- <section xml:id="ssec-bower2nix-usage">
-  <title><command>bower2nix</command> usage</title>
-
-  <para>
-   Suppose you have a <filename>bower.json</filename> with the following contents:
-   <example xml:id="ex-bowerJson">
-    <title><filename>bower.json</filename></title>
-<programlisting language="json">
-<![CDATA[{
-  "name": "my-web-app",
-  "dependencies": {
-    "angular": "~1.5.0",
-    "bootstrap": "~3.3.6"
-  }
-}]]>
-</programlisting>
-   </example>
-  </para>
-
-  <para>
-   Running <command>bower2nix</command> will produce something like the following output:
-<programlisting language="nix">
-<![CDATA[{ fetchbower, buildEnv }:
-buildEnv { name = "bower-env"; ignoreCollisions = true; paths = [
-  (fetchbower "angular" "1.5.3" "~1.5.0" "1749xb0firxdra4rzadm4q9x90v6pzkbd7xmcyjk6qfza09ykk9y")
-  (fetchbower "bootstrap" "3.3.6" "~3.3.6" "1vvqlpbfcy0k5pncfjaiskj3y6scwifxygfqnw393sjfxiviwmbv")
-  (fetchbower "jquery" "2.2.2" "1.9.1 - 2" "10sp5h98sqwk90y4k6hbdviwqzvzwqf47r3r51pakch5ii2y7js1")
-]; }]]>
-</programlisting>
-  </para>
-
-  <para>
-   Using the <command>bower2nix</command> command line arguments, the output can be redirected to a file. A name like <filename>bower-packages.nix</filename> would be fine.
-  </para>
-
-  <para>
-   The resulting derivation is a union of all the downloaded Bower packages (and their dependencies). To use it, they still need to be linked together by Bower, which is where <varname>buildBowerComponents</varname> is useful.
-  </para>
- </section>
-
- <section xml:id="ssec-build-bower-components">
-  <title><varname>buildBowerComponents</varname> function</title>
-
-  <para>
-   The function is implemented in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/bower-modules/generic/default.nix"> <filename>pkgs/development/bower-modules/generic/default.nix</filename></link>. Example usage:
-   <example xml:id="ex-buildBowerComponents">
-    <title>buildBowerComponents</title>
-<programlisting language="nix">
-bowerComponents = buildBowerComponents {
-  name = "my-web-app";
-  generated = ./bower-packages.nix; <co xml:id="ex-buildBowerComponents-1" />
-  src = myWebApp; <co xml:id="ex-buildBowerComponents-2" />
-};
-</programlisting>
-   </example>
-  </para>
-
-  <para>
-   In <xref linkend="ex-buildBowerComponents" />, the following arguments are of special significance to the function:
-   <calloutlist>
-    <callout arearefs="ex-buildBowerComponents-1">
-     <para>
-      <varname>generated</varname> specifies the file which was created by <command>bower2nix</command>.
-     </para>
-    </callout>
-    <callout arearefs="ex-buildBowerComponents-2">
-     <para>
-      <varname>src</varname> is your project's sources. It needs to contain a <filename>bower.json</filename> file.
-     </para>
-    </callout>
-   </calloutlist>
-  </para>
-
-  <para>
-   <varname>buildBowerComponents</varname> will run Bower to link together the output of <command>bower2nix</command>, resulting in a <filename>bower_components</filename> directory which can be used.
-  </para>
-
-  <para>
-   Here is an example of a web frontend build process using <command>gulp</command>. You might use <command>grunt</command>, or anything else.
-  </para>
-
-  <example xml:id="ex-bowerGulpFile">
-   <title>Example build script (<filename>gulpfile.js</filename>)</title>
-<programlisting language="javascript">
-<![CDATA[var gulp = require('gulp');
-
-gulp.task('default', [], function () {
-  gulp.start('build');
-});
-
-gulp.task('build', [], function () {
-  console.log("Just a dummy gulp build");
-  gulp
-    .src(["./bower_components/**/*"])
-    .pipe(gulp.dest("./gulpdist/"));
-});]]>
-</programlisting>
-  </example>
-
-  <example xml:id="ex-buildBowerComponentsDefaultNix">
-   <title>Full example — <filename>default.nix</filename></title>
-<programlisting language="nix">
-{ myWebApp ? { outPath = ./.; name = "myWebApp"; }
-, pkgs ? import &lt;nixpkgs&gt; {}
-}:
-
-pkgs.stdenv.mkDerivation {
-  name = "my-web-app-frontend";
-  src = myWebApp;
-
-  buildInputs = [ pkgs.nodePackages.gulp ];
-
-  bowerComponents = pkgs.buildBowerComponents { <co xml:id="ex-buildBowerComponentsDefault-1" />
-    name = "my-web-app";
-    generated = ./bower-packages.nix;
-    src = myWebApp;
-  };
-
-  buildPhase = ''
-    cp --reflink=auto --no-preserve=mode -R $bowerComponents/bower_components . <co xml:id="ex-buildBowerComponentsDefault-2" />
-    export HOME=$PWD <co xml:id="ex-buildBowerComponentsDefault-3" />
-    ${pkgs.nodePackages.gulp}/bin/gulp build <co xml:id="ex-buildBowerComponentsDefault-4" />
-  '';
-
-  installPhase = "mv gulpdist $out";
-}
-</programlisting>
-  </example>
-
-  <para>
-   A few notes about <xref linkend="ex-buildBowerComponentsDefaultNix" />:
-   <calloutlist>
-    <callout arearefs="ex-buildBowerComponentsDefault-1">
-     <para>
-      The result of <varname>buildBowerComponents</varname> is an input to the frontend build.
-     </para>
-    </callout>
-    <callout arearefs="ex-buildBowerComponentsDefault-2">
-     <para>
-      Whether to symlink or copy the <filename>bower_components</filename> directory depends on the build tool in use. In this case a copy is used to avoid <command>gulp</command> silliness with permissions.
-     </para>
-    </callout>
-    <callout arearefs="ex-buildBowerComponentsDefault-3">
-     <para>
-      <command>gulp</command> requires <varname>HOME</varname> to refer to a writeable directory.
-     </para>
-    </callout>
-    <callout arearefs="ex-buildBowerComponentsDefault-4">
-     <para>
-      The actual build command. Other tools could be used.
-     </para>
-    </callout>
-   </calloutlist>
-  </para>
- </section>
-
- <section xml:id="ssec-bower2nix-troubleshooting">
-  <title>Troubleshooting</title>
-
-  <variablelist>
-   <varlistentry>
-    <term>
-     <literal>ENOCACHE</literal> errors from <varname>buildBowerComponents</varname>
-    </term>
-    <listitem>
-     <para>
-      This means that Bower was looking for a package version which doesn't exist in the generated <filename>bower-packages.nix</filename>.
-     </para>
-     <para>
-      If <filename>bower.json</filename> has been updated, then run <command>bower2nix</command> again.
-     </para>
-     <para>
-      It could also be a bug in <command>bower2nix</command> or <command>fetchbower</command>. If possible, try reformulating the version specification in <filename>bower.json</filename>.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
- </section>
-</section>
diff --git a/doc/languages-frameworks/coq.section.md b/doc/languages-frameworks/coq.section.md
new file mode 100644
index 00000000000..0674c5a4702
--- /dev/null
+++ b/doc/languages-frameworks/coq.section.md
@@ -0,0 +1,81 @@
+# Coq and coq packages {#sec-language-coq}
+
+## Coq derivation: `coq` {#coq-derivation-coq}
+
+The Coq derivation is overridable through the `coq.override overrides`, where overrides is an attribute set which contains the arguments to override. We recommend overriding either of the following
+
+* `version` (optional, defaults to the latest version of Coq selected for nixpkgs, see `pkgs/top-level/coq-packages` to witness this choice), which follows the conventions explained in the `coqPackages` section below,
+* `customOCamlPackage` (optional, defaults to `null`, which lets Coq choose a version automatically), which can be set to any of the ocaml packages attribute of `ocaml-ng` (such as `ocaml-ng.ocamlPackages_4_10` which is the default for Coq 8.11 for example).
+* `coq-version` (optional, defaults to the short version e.g. "8.10"), is a version number of the form "x.y" that indicates which Coq's version build behavior to mimic when using a source which is not a release. E.g. `coq.override { version = "d370a9d1328a4e1cdb9d02ee032f605a9d94ec7a"; coq-version = "8.10"; }`.
+
+## Coq packages attribute sets: `coqPackages` {#coq-packages-attribute-sets-coqpackages}
+
+The recommended way of defining a derivation for a Coq library, is to use the `coqPackages.mkCoqDerivation` function, which is essentially a specialization of `mkDerivation` taking into account most of the specifics of Coq libraries. The following attributes are supported:
+
+* `pname` (required) is the name of the package,
+* `version` (optional, defaults to `null`), is the version to fetch and build,
+  this attribute is interpreted in several ways depending on its type and pattern:
+  * if it is a known released version string, i.e. from the `release` attribute below, the according release is picked, and the `version` attribute of the resulting derivation is set to this release string,
+  * if it is a majorMinor `"x.y"` prefix of a known released version (as defined above), then the latest `"x.y.z"` known released version is selected (for the ordering given by `versionAtLeast`),
+  * if it is a path or a string representing an absolute path (i.e. starting with `"/"`), the provided path is selected as a source, and the `version` attribute of the resulting derivation is set to `"dev"`,
+  * if it is a string of the form `owner:branch` then it tries to download the `branch` of owner `owner` for a project of the same name using the same vcs, and the `version` attribute of the resulting derivation is set to `"dev"`, additionally if the owner is not provided (i.e. if the `owner:` prefix is missing), it defaults to the original owner of the package (see below),
+  * if it is a string of the form `"#N"`, and the domain is github, then it tries to download the current head of the pull request `#N` from github,
+* `defaultVersion` (optional). Coq libraries may be compatible with some specific versions of Coq only. The `defaultVersion` attribute is used when no `version` is provided (or if `version = null`) to select the version of the library to use by default, depending on the context. This selection will mainly depend on a `coq` version number but also possibly on other packages versions (e.g. `mathcomp`). If its value ends up to be `null`, the package is marked for removal in end-user `coqPackages` attribute set.
+* `release` (optional, defaults to `{}`), lists all the known releases of the library and for each of them provides an attribute set with at least a `sha256` attribute (you may put the empty string `""` in order to automatically insert a fake sha256, this will trigger an error which will allow you to find the correct sha256), each attribute set of the list of releases also takes optional overloading arguments for the fetcher as below (i.e.`domain`, `owner`, `repo`, `rev` assuming the default fetcher is used) and optional overrides for the result of the fetcher (i.e. `version` and `src`).
+* `fetcher` (optional, defaults to a generic fetching mechanism supporting github or gitlab based infrastructures), is a function that takes at least an `owner`, a `repo`, a `rev`, and a `sha256` and returns an attribute set with a `version` and `src`.
+* `repo` (optional, defaults to the value of `pname`),
+* `owner` (optional, defaults to `"coq-community"`).
+* `domain` (optional, defaults to `"github.com"`), domains including the strings `"github"` or `"gitlab"` in their names are automatically supported, otherwise, one must change the `fetcher` argument to support them (cf `pkgs/development/coq-modules/heq/default.nix` for an example),
+* `releaseRev` (optional, defaults to `(v: v)`), provides a default mapping from release names to revision hashes/branch names/tags,
+* `displayVersion` (optional), provides a way to alter the computation of `name` from `pname`, by explaining how to display version numbers,
+* `namePrefix` (optional), provides a way to alter the computation of `name` from `pname`, by explaining which dependencies must occur in `name`,
+* `extraBuildInputs` (optional), by default `buildInputs` just contains `coq`, this allows to add more build inputs,
+* `mlPlugin` (optional, defaults to `false`). Some extensions (plugins) might require OCaml and sometimes other OCaml packages. Standard dependencies can be added by setting the current option to `true`. For a finer grain control, the `coq.ocamlPackages` attribute can be used in `extraBuildInputs` to depend on the same package set Coq was built against.
+* `useDune2ifVersion` (optional, default to `(x: false)` uses Dune2 to build the package if the provided predicate evaluates to true on the version, e.g. `useDune2if = versions.isGe "1.1"`  will use dune if the version of the package is greater or equal to `"1.1"`,
+* `useDune2` (optional, defaults to `false`) uses Dune2 to build the package if set to true, the presence of this attribute overrides the behavior of the previous one.
+* `enableParallelBuilding` (optional, defaults to `true`), since it is activated by default, we provide a way to disable it.
+* `extraInstallFlags` (optional), allows to extend `installFlags` which initializes the variable `COQMF_COQLIB` so as to install in the proper subdirectory. Indeed Coq libraries should be installed in `$(out)/lib/coq/${coq.coq-version}/user-contrib/`. Such directories are automatically added to the `$COQPATH` environment variable by the hook defined in the Coq derivation.
+* `setCOQBIN` (optional, defaults to `true`), by default, the environment variable `$COQBIN` is set to the current Coq's binary, but one can disable this behavior by setting it to `false`,
+* `useMelquiondRemake` (optional, default to `null`) is an attribute set, which, if given, overloads the `preConfigurePhases`, `configureFlags`, `buildPhase`, and `installPhase` attributes of the derivation for a specific use in libraries using `remake` as set up by Guillaume Melquiond for `flocq`, `gappalib`, `interval`, and `coquelicot` (see the corresponding derivation for concrete examples of use of this option). For backward compatibility, the attribute `useMelquiondRemake.logpath` must be set to the logical root of the library (otherwise, one can pass `useMelquiondRemake = {}` to activate this without backward compatibility).
+* `dropAttrs`, `keepAttrs`, `dropDerivationAttrs` are all optional and allow to tune which attribute is added or removed from the final call to `mkDerivation`.
+
+It also takes other standard `mkDerivation` attributes, they are added as such, except for `meta` which extends an automatically computed `meta` (where the `platform` is the same as `coq` and the homepage is automatically computed).
+
+Here is a simple package example. It is a pure Coq library, thus it depends on Coq. It builds on the Mathematical Components library, thus it also takes some `mathcomp` derivations as `extraBuildInputs`.
+
+```nix
+{ lib, mkCoqDerivation, version ? null
+, coq, mathcomp, mathcomp-finmap, mathcomp-bigenough }:
+with lib; mkCoqDerivation {
+  /* namePrefix leads to e.g. `name = coq8.11-mathcomp1.11-multinomials-1.5.2` */
+  namePrefix = [ "coq" "mathcomp" ];
+  pname = "multinomials";
+  owner = "math-comp";
+  inherit version;
+  defaultVersion =  with versions; switch [ coq.version mathcomp.version ] [
+      { cases = [ (range "8.7" "8.12")  "1.11.0" ];             out = "1.5.2"; }
+      { cases = [ (range "8.7" "8.11")  (range "1.8" "1.10") ]; out = "1.5.0"; }
+      { cases = [ (range "8.7" "8.10")  (range "1.8" "1.10") ]; out = "1.4"; }
+      { cases = [ "8.6"                 (range "1.6" "1.7") ];  out = "1.1"; }
+    ] null;
+  release = {
+    "1.5.2".sha256 = "15aspf3jfykp1xgsxf8knqkxv8aav2p39c2fyirw7pwsfbsv2c4s";
+    "1.5.1".sha256 = "13nlfm2wqripaq671gakz5mn4r0xwm0646araxv0nh455p9ndjs3";
+    "1.5.0".sha256 = "064rvc0x5g7y1a0nip6ic91vzmq52alf6in2bc2dmss6dmzv90hw";
+    "1.5.0".rev    = "1.5";
+    "1.4".sha256   = "0vnkirs8iqsv8s59yx1fvg1nkwnzydl42z3scya1xp1b48qkgn0p";
+    "1.3".sha256   = "0l3vi5n094nx3qmy66hsv867fnqm196r8v605kpk24gl0aa57wh4";
+    "1.2".sha256   = "1mh1w339dslgv4f810xr1b8v2w7rpx6fgk9pz96q0fyq49fw2xcq";
+    "1.1".sha256   = "1q8alsm89wkc0lhcvxlyn0pd8rbl2nnxg81zyrabpz610qqjqc3s";
+    "1.0".sha256   = "1qmbxp1h81cy3imh627pznmng0kvv37k4hrwi2faa101s6bcx55m";
+  };
+
+  propagatedBuildInputs =
+    [ mathcomp.ssreflect mathcomp.algebra mathcomp-finmap mathcomp-bigenough ];
+
+  meta = {
+    description = "A Coq/SSReflect Library for Monoidal Rings and Multinomials";
+    license = licenses.cecill-c;
+  };
+}
+```
diff --git a/doc/languages-frameworks/coq.xml b/doc/languages-frameworks/coq.xml
deleted file mode 100644
index 86d9226166f..00000000000
--- a/doc/languages-frameworks/coq.xml
+++ /dev/null
@@ -1,52 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-language-coq">
- <title>Coq</title>
-
- <para>
-  Coq libraries should be installed in <literal>$(out)/lib/coq/${coq.coq-version}/user-contrib/</literal>. Such directories are automatically added to the <literal>$COQPATH</literal> environment variable by the hook defined in the Coq derivation.
- </para>
-
- <para>
-  Some extensions (plugins) might require OCaml and sometimes other OCaml packages. The <literal>coq.ocamlPackages</literal> attribute can be used to depend on the same package set Coq was built against.
- </para>
-
- <para>
-  Coq libraries may be compatible with some specific versions of Coq only. The <literal>compatibleCoqVersions</literal> attribute is used to precisely select those versions of Coq that are compatible with this derivation.
- </para>
-
- <para>
-  Here is a simple package example. It is a pure Coq library, thus it depends on Coq. It builds on the Mathematical Components library, thus it also takes <literal>mathcomp</literal> as <literal>buildInputs</literal>. Its <literal>Makefile</literal> has been generated using <literal>coq_makefile</literal> so we only have to set the <literal>$COQLIB</literal> variable at install time.
- </para>
-
-<programlisting>
-{ stdenv, fetchFromGitHub, coq, mathcomp }:
-
-stdenv.mkDerivation rec {
-  name = "coq${coq.coq-version}-multinomials-${version}";
-  version = "1.0";
-  src = fetchFromGitHub {
-    owner = "math-comp";
-    repo = "multinomials";
-    rev = version;
-    sha256 = "1qmbxp1h81cy3imh627pznmng0kvv37k4hrwi2faa101s6bcx55m";
-  };
-
-  buildInputs = [ coq ];
-  propagatedBuildInputs = [ mathcomp ];
-
-  installFlags = "COQLIB=$(out)/lib/coq/${coq.coq-version}/";
-
-  meta = {
-    description = "A Coq/SSReflect Library for Monoidal Rings and Multinomials";
-    inherit (src.meta) homepage;
-    license = stdenv.lib.licenses.cecill-b;
-    inherit (coq.meta) platforms;
-  };
-
-  passthru = {
-    compatibleCoqVersions = v: builtins.elem v [ "8.5" "8.6" "8.7" ];
-  };
-}
-</programlisting>
-</section>
diff --git a/doc/languages-frameworks/crystal.section.md b/doc/languages-frameworks/crystal.section.md
index af0853dbf75..cbe31f9f0b2 100644
--- a/doc/languages-frameworks/crystal.section.md
+++ b/doc/languages-frameworks/crystal.section.md
@@ -1,10 +1,11 @@
-# Crystal
+# Crystal {#crystal}
 
-## Building a Crystal package
+## Building a Crystal package {#building-a-crystal-package}
 
 This section uses [Mint](https://github.com/mint-lang/mint) as an example for how to build a Crystal package.
 
 If the Crystal project has any dependencies, the first step is to get a `shards.nix` file encoding those. Get a copy of the project and go to its root directory such that its `shard.lock` file is in the current directory, then run `crystal2nix` in it
+
 ```bash
 $ git clone https://github.com/mint-lang/mint
 $ cd mint
@@ -15,6 +16,7 @@ $ nix-shell -p crystal2nix --run crystal2nix
 This should have generated a `shards.nix` file.
 
 Next create a Nix file for your derivation and use `pkgs.crystal.buildCrystalPackage` as follows:
+
 ```nix
 with import <nixpkgs> {};
 crystal.buildCrystalPackage rec {
diff --git a/doc/languages-frameworks/dhall.section.md b/doc/languages-frameworks/dhall.section.md
new file mode 100644
index 00000000000..d1adcbf736b
--- /dev/null
+++ b/doc/languages-frameworks/dhall.section.md
@@ -0,0 +1,432 @@
+# Dhall {#sec-language-dhall}
+
+The Nixpkgs support for Dhall assumes some familiarity with Dhall's language
+support for importing Dhall expressions, which is documented here:
+
+* [`dhall-lang.org` - Installing packages](https://docs.dhall-lang.org/tutorials/Language-Tour.html#installing-packages)
+
+## Remote imports {#ssec-dhall-remote-imports}
+
+Nixpkgs bypasses Dhall's support for remote imports using Dhall's
+semantic integrity checks.  Specifically, any Dhall import can be protected by
+an integrity check like:
+
+```dhall
+https://prelude.dhall-lang.org/v20.1.0/package.dhall
+  sha256:26b0ef498663d269e4dc6a82b0ee289ec565d683ef4c00d0ebdd25333a5a3c98
+```
+
+… and if the import is cached then the interpreter will load the import from
+cache instead of fetching the URL.
+
+Nixpkgs uses this trick to add all of a Dhall expression's dependencies into the
+cache so that the Dhall interpreter never needs to resolve any remote URLs.  In
+fact, Nixpkgs uses a Dhall interpreter with remote imports disabled when
+packaging Dhall expressions to enforce that the interpreter never resolves a
+remote import.  This means that Nixpkgs only supports building Dhall expressions
+if all of their remote imports are protected by semantic integrity checks.
+
+Instead of remote imports, Nixpkgs uses Nix to fetch remote Dhall code.  For
+example, the Prelude Dhall package uses `pkgs.fetchFromGitHub` to fetch the
+`dhall-lang` repository containing the Prelude.  Relying exclusively on Nix
+to fetch Dhall code ensures that Dhall packages built using Nix remain pure and
+also behave well when built within a sandbox.
+
+## Packaging a Dhall expression from scratch {#ssec-dhall-packaging-expression}
+
+We can illustrate how Nixpkgs integrates Dhall by beginning from the following
+trivial Dhall expression with one dependency (the Prelude):
+
+```dhall
+-- ./true.dhall
+
+let Prelude = https://prelude.dhall-lang.org/v20.1.0/package.dhall
+
+in  Prelude.Bool.not False
+```
+
+As written, this expression cannot be built using Nixpkgs because the
+expression does not protect the Prelude import with a semantic integrity
+check, so the first step is to freeze the expression using `dhall freeze`,
+like this:
+
+```bash
+$ dhall freeze --inplace ./true.dhall
+```
+
+… which gives us:
+
+```dhall
+-- ./true.dhall
+
+let Prelude =
+      https://prelude.dhall-lang.org/v20.1.0/package.dhall
+        sha256:26b0ef498663d269e4dc6a82b0ee289ec565d683ef4c00d0ebdd25333a5a3c98
+
+in  Prelude.Bool.not False
+```
+
+To package that expression, we create a `./true.nix` file containing the
+following specification for the Dhall package:
+
+```nix
+# ./true.nix
+
+{ buildDhallPackage, Prelude }:
+
+buildDhallPackage {
+  name = "true";
+  code = ./true.dhall;
+  dependencies = [ Prelude ];
+  source = true;
+}
+```
+
+… and we complete the build by incorporating that Dhall package into the
+`pkgs.dhallPackages` hierarchy using an overlay, like this:
+
+```nix
+# ./example.nix
+
+let
+  nixpkgs = builtins.fetchTarball {
+    url    = "https://github.com/NixOS/nixpkgs/archive/94b2848559b12a8ed1fe433084686b2a81123c99.tar.gz";
+    sha256 = "1pbl4c2dsaz2lximgd31m96jwbps6apn3anx8cvvhk1gl9rkg107";
+  };
+
+  dhallOverlay = self: super: {
+    true = self.callPackage ./true.nix { };
+  };
+
+  overlay = self: super: {
+    dhallPackages = super.dhallPackages.override (old: {
+      overrides =
+        self.lib.composeExtensions (old.overrides or (_: _: {})) dhallOverlay;
+    });
+  };
+
+  pkgs = import nixpkgs { config = {}; overlays = [ overlay ]; };
+
+in
+  pkgs
+```
+
+… which we can then build using this command:
+
+```bash
+$ nix build --file ./example.nix dhallPackages.true
+```
+
+## Contents of a Dhall package {#ssec-dhall-package-contents}
+
+The above package produces the following directory tree:
+
+```bash
+$ tree -a ./result
+result
+├── .cache
+│   └── dhall
+│       └── 122027abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+├── binary.dhall
+└── source.dhall
+```
+
+… where:
+
+* `source.dhall` contains the result of interpreting our Dhall package:
+
+  ```bash
+  $ cat ./result/source.dhall
+  True
+  ```
+
+* The `.cache` subdirectory contains one binary cache product encoding the
+  same result as `source.dhall`:
+
+  ```bash
+  $ dhall decode < ./result/.cache/dhall/122027abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+  True
+  ```
+
+* `binary.dhall` contains a Dhall expression which handles fetching and decoding
+  the same cache product:
+
+  ```bash
+  $ cat ./result/binary.dhall
+  missing sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+  $ cp -r ./result/.cache .cache
+
+  $ chmod -R u+w .cache
+
+  $ XDG_CACHE_HOME=.cache dhall --file ./result/binary.dhall
+  True
+  ```
+
+The `source.dhall` file is only present for packages that specify
+`source = true;`.  By default, Dhall packages omit the `source.dhall` in order
+to conserve disk space when they are used exclusively as dependencies.  For
+example, if we build the Prelude package it will only contain the binary
+encoding of the expression:
+
+```bash
+$ nix build --file ./example.nix dhallPackages.Prelude
+
+$ tree -a result
+result
+├── .cache
+│   └── dhall
+│       └── 122026b0ef498663d269e4dc6a82b0ee289ec565d683ef4c00d0ebdd25333a5a3c98
+└── binary.dhall
+
+2 directories, 2 files
+```
+
+Typically, you only specify `source = true;` for the top-level Dhall expression
+of interest (such as our example `true.nix` Dhall package).  However, if you
+wish to specify `source = true` for all Dhall packages, then you can amend the
+Dhall overlay like this:
+
+```nix
+  dhallOverrides = self: super: {
+    # Enable source for all Dhall packages
+    buildDhallPackage =
+      args: super.buildDhallPackage (args // { source = true; });
+
+    true = self.callPackage ./true.nix { };
+  };
+```
+
+… and now the Prelude will contain the fully decoded result of interpreting
+the Prelude:
+
+```bash
+$ nix build --file ./example.nix dhallPackages.Prelude
+
+$ tree -a result
+result
+├── .cache
+│   └── dhall
+│       └── 122026b0ef498663d269e4dc6a82b0ee289ec565d683ef4c00d0ebdd25333a5a3c98
+├── binary.dhall
+└── source.dhall
+
+$ cat ./result/source.dhall
+{ Bool =
+  { and =
+      \(_ : List Bool) ->
+        List/fold Bool _ Bool (\(_ : Bool) -> \(_ : Bool) -> _@1 && _) True
+  , build = \(_ : Type -> _ -> _@1 -> _@2) -> _ Bool True False
+  , even =
+      \(_ : List Bool) ->
+        List/fold Bool _ Bool (\(_ : Bool) -> \(_ : Bool) -> _@1 == _) True
+  , fold =
+      \(_ : Bool) ->
+…
+```
+
+## Packaging functions {#ssec-dhall-packaging-functions}
+
+We already saw an example of using `buildDhallPackage` to create a Dhall
+package from a single file, but most Dhall packages consist of more than one
+file and there are two derived utilities that you may find more useful when
+packaging multiple files:
+
+* `buildDhallDirectoryPackage` - build a Dhall package from a local directory
+
+* `buildDhallGitHubPackage` - build a Dhall package from a GitHub repository
+
+The `buildDhallPackage` is the lowest-level function and accepts the following
+arguments:
+
+* `name`: The name of the derivation
+
+* `dependencies`: Dhall dependencies to build and cache ahead of time
+
+* `code`: The top-level expression to build for this package
+
+  Note that the `code` field accepts an arbitrary Dhall expression.  You're
+  not limited to just a file.
+
+* `source`: Set to `true` to include the decoded result as `source.dhall` in the
+  build product, at the expense of requiring more disk space
+
+* `documentationRoot`: Set to the root directory of the package if you want
+  `dhall-docs` to generate documentation underneath the `docs` subdirectory of
+  the build product
+
+The `buildDhallDirectoryPackage` is a higher-level function implemented in terms
+of `buildDhallPackage` that accepts the following arguments:
+
+* `name`: Same as `buildDhallPackage`
+
+* `dependencies`: Same as `buildDhallPackage`
+
+* `source`: Same as `buildDhallPackage`
+
+* `src`: The directory containing Dhall code that you want to turn into a Dhall
+  package
+
+* `file`: The top-level file (`package.dhall` by default) that is the entrypoint
+  to the rest of the package
+
+* `document`: Set to `true` to generate documentation for the package
+
+The `buildDhallGitHubPackage` is another higher-level function implemented in
+terms of `buildDhallPackage` that accepts the following arguments:
+
+* `name`: Same as `buildDhallPackage`
+
+* `dependencies`: Same as `buildDhallPackage`
+
+* `source`: Same as `buildDhallPackage`
+
+* `owner`: The owner of the repository
+
+* `repo`: The repository name
+
+* `rev`: The desired revision (or branch, or tag)
+
+* `directory`: The subdirectory of the Git repository to package (if a
+  directory other than the root of the repository)
+
+* `file`: The top-level file (`${directory}/package.dhall` by default) that is
+  the entrypoint to the rest of the package
+
+* `document`: Set to `true` to generate documentation for the package
+
+Additionally, `buildDhallGitHubPackage` accepts the same arguments as
+`fetchFromGitHub`, such as `sha256` or `fetchSubmodules`.
+
+## `dhall-to-nixpkgs` {#ssec-dhall-dhall-to-nixpkgs}
+
+You can use the `dhall-to-nixpkgs` command-line utility to automate
+packaging Dhall code.  For example:
+
+```bash
+$ nix-env --install --attr haskellPackages.dhall-nixpkgs
+
+$ nix-env --install --attr nix-prefetch-git  # Used by dhall-to-nixpkgs
+
+$ dhall-to-nixpkgs github https://github.com/Gabriel439/dhall-semver.git
+{ buildDhallGitHubPackage, Prelude }:
+  buildDhallGitHubPackage {
+    name = "dhall-semver";
+    githubBase = "github.com";
+    owner = "Gabriel439";
+    repo = "dhall-semver";
+    rev = "2d44ae605302ce5dc6c657a1216887fbb96392a4";
+    fetchSubmodules = false;
+    sha256 = "0y8shvp8srzbjjpmnsvz9c12ciihnx1szs0yzyi9ashmrjvd0jcz";
+    directory = "";
+    file = "package.dhall";
+    source = false;
+    document = false;
+    dependencies = [ (Prelude.overridePackage { file = "package.dhall"; }) ];
+    }
+```
+
+The utility takes care of automatically detecting remote imports and converting
+them to package dependencies.  You can also use the utility on local
+Dhall directories, too:
+
+```bash
+$ dhall-to-nixpkgs directory ~/proj/dhall-semver
+{ buildDhallDirectoryPackage, Prelude }:
+  buildDhallDirectoryPackage {
+    name = "proj";
+    src = /Users/gabriel/proj/dhall-semver;
+    file = "package.dhall";
+    source = false;
+    document = false;
+    dependencies = [ (Prelude.overridePackage { file = "package.dhall"; }) ];
+    }
+```
+
+## Overriding dependency versions {#ssec-dhall-overriding-dependency-versions}
+
+Suppose that we change our `true.dhall` example expression to depend on an older
+version of the Prelude (19.0.0):
+
+```dhall
+-- ./true.dhall
+
+let Prelude =
+      https://prelude.dhall-lang.org/v19.0.0/package.dhall
+        sha256:eb693342eb769f782174157eba9b5924cf8ac6793897fc36a31ccbd6f56dafe2
+
+in  Prelude.Bool.not False
+```
+
+If we try to rebuild that expression the build will fail:
+
+```
+$ nix build --file ./example.nix dhallPackages.true
+builder for '/nix/store/0f1hla7ff1wiaqyk1r2ky4wnhnw114fi-true.drv' failed with exit code 1; last 10 log lines:
+
+  Dhall was compiled without the 'with-http' flag.
+
+  The requested URL was: https://prelude.dhall-lang.org/v19.0.0/package.dhall
+
+
+  4│       https://prelude.dhall-lang.org/v19.0.0/package.dhall
+  5│         sha256:eb693342eb769f782174157eba9b5924cf8ac6793897fc36a31ccbd6f56dafe2
+
+  /nix/store/rsab4y99h14912h4zplqx2iizr5n4rc2-true.dhall:4:7
+[1 built (1 failed), 0.0 MiB DL]
+error: build of '/nix/store/0f1hla7ff1wiaqyk1r2ky4wnhnw114fi-true.drv' failed
+```
+
+… because the default Prelude selected by Nixpkgs revision
+`94b2848559b12a8ed1fe433084686b2a81123c99is` is version 20.1.0, which doesn't
+have the same integrity check as version 19.0.0.  This means that version
+19.0.0 is not cached and the interpreter is not allowed to fall back to
+importing the URL.
+
+However, we can override the default Prelude version by using `dhall-to-nixpkgs`
+to create a Dhall package for our desired Prelude:
+
+```bash
+$ dhall-to-nixpkgs github https://github.com/dhall-lang/dhall-lang.git \
+    --name Prelude \
+    --directory Prelude \
+    --rev v19.0.0 \
+    > Prelude.nix
+```
+
+… and then referencing that package in our Dhall overlay, by either overriding
+the Prelude globally for all packages, like this:
+
+```bash
+  dhallOverrides = self: super: {
+    true = self.callPackage ./true.nix { };
+
+    Prelude = self.callPackage ./Prelude.nix { };
+  };
+```
+
+… or selectively overriding the Prelude dependency for just the `true` package,
+like this:
+
+```bash
+  dhallOverrides = self: super: {
+    true = self.callPackage ./true.nix {
+      Prelude = self.callPackage ./Prelude.nix { };
+    };
+  };
+```
+
+## Overrides {#ssec-dhall-overrides}
+
+You can override any of the arguments to `buildDhallGitHubPackage` or
+`buildDhallDirectoryPackage` using the `overridePackage` attribute of a package.
+For example, suppose we wanted to selectively enable `source = true` just for the Prelude.  We can do that like this:
+
+```nix
+  dhallOverrides = self: super: {
+    Prelude = super.Prelude.overridePackage { source = true; };
+
+    …
+  };
+```
+
+[semantic-integrity-checks]: https://docs.dhall-lang.org/tutorials/Language-Tour.html#installing-packages
diff --git a/doc/languages-frameworks/dotnet.section.md b/doc/languages-frameworks/dotnet.section.md
index c56f4728bed..1bcb6e45210 100644
--- a/doc/languages-frameworks/dotnet.section.md
+++ b/doc/languages-frameworks/dotnet.section.md
@@ -1,31 +1,31 @@
-# Dotnet
+# Dotnet {#dotnet}
 
-## Local Development Workflow
+## Local Development Workflow {#local-development-workflow}
 
 For local development, it's recommended to use nix-shell to create a dotnet environment:
 
-```
+```nix
 # shell.nix
 with import <nixpkgs> {};
 
 mkShell {
   name = "dotnet-env";
-  buildInputs = [
+  packages = [
     dotnet-sdk_3
   ];
 }
 ```
 
-### Using many sdks in a workflow
+### Using many sdks in a workflow {#using-many-sdks-in-a-workflow}
 
 It's very likely that more than one sdk will be needed on a given project. Dotnet provides several different frameworks (E.g dotnetcore, aspnetcore, etc.) as well as many versions for a given framework. Normally, dotnet is able to fetch a framework and install it relative to the executable. However, this would mean writing to the nix store in nixpkgs, which is read-only. To support the many-sdk use case, one can compose an environment using `dotnetCorePackages.combinePackages`:
 
-```
+```nix
 with import <nixpkgs> {};
 
 mkShell {
   name = "dotnet-env";
-  buildInputs = [
+  packages = [
     (with dotnetCorePackages; combinePackages [
       sdk_3_1
       sdk_3_0
@@ -37,7 +37,7 @@ mkShell {
 
 This will produce a dotnet installation that has the dotnet 3.1, 3.0, and 2.1 sdk. The first sdk listed will have it's cli utility present in the resulting environment. Example info output:
 
-```
+```ShellSession
 $ dotnet --info
 .NET Core SDK (reflecting any global.json):
  Version:   3.1.101
@@ -60,15 +60,15 @@ $ dotnet --info
   Microsoft.NETCore.App 3.1.1 [/nix/store/iiv98i2jdi226dgh4jzkkj2ww7f8jgpd-dotnet-core-combined/shared/Microsoft.NETCore.App]
 ```
 
-## dotnet-sdk vs dotnetCorePackages.sdk
+## dotnet-sdk vs dotnetCorePackages.sdk {#dotnet-sdk-vs-dotnetcorepackages.sdk}
 
 The `dotnetCorePackages.sdk_X_Y` is preferred over the old dotnet-sdk as both major and minor version are very important for a dotnet environment. If a given minor version isn't present (or was changed), then this will likely break your ability to build a project.
 
-## dotnetCorePackages.sdk vs dotnetCorePackages.netcore vs dotnetCorePackages.aspnetcore
+## dotnetCorePackages.sdk vs dotnetCorePackages.net vs dotnetCorePackages.netcore vs dotnetCorePackages.aspnetcore {#dotnetcorepackages.sdk-vs-dotnetcorepackages.net-vs-dotnetcorepackages.netcore-vs-dotnetcorepackages.aspnetcore}
 
-The `dotnetCorePackages.sdk` contains both a runtime and the full sdk of a given version. The `netcore` and `aspnetcore` packages are meant to serve as minimal runtimes to deploy alongside already built applications.
+The `dotnetCorePackages.sdk` contains both a runtime and the full sdk of a given version. The `net`, `netcore` and `aspnetcore` packages are meant to serve as minimal runtimes to deploy alongside already built applications. For runtime versions >= .NET 5 `net` is used while `netcore` is used for older .NET Core runtime version.
 
-## Packaging a Dotnet Application
+## Packaging a Dotnet Application {#packaging-a-dotnet-application}
 
 Ideally, we would like to build against the sdk, then only have the dotnet runtime available in the runtime closure.
 
diff --git a/doc/languages-frameworks/emscripten.section.md b/doc/languages-frameworks/emscripten.section.md
index 3663f962d5f..b3ddf0cedae 100644
--- a/doc/languages-frameworks/emscripten.section.md
+++ b/doc/languages-frameworks/emscripten.section.md
@@ -1,4 +1,4 @@
-# Emscripten
+# Emscripten {#emscripten}
 
 [Emscripten](https://github.com/kripken/emscripten): An LLVM-to-JavaScript Compiler
 
@@ -27,16 +27,14 @@ Modes of use of `emscripten`:
     * dev-shell for zlib implementation hacking:
         * `nix-shell -A emscriptenPackages.zlib`
 
-
-## Imperative usage
+## Imperative usage {#imperative-usage}
 
 A few things to note:
 
 * `export EMCC_DEBUG=2` is nice for debugging
 * `~/.emscripten`, the build artifact cache sometimes creates issues and needs to be removed from time to time
 
-
-## Declarative usage
+## Declarative usage {#declarative-usage}
 
 Let's see two different examples from `pkgs/top-level/emscripten-packages.nix`:
 
@@ -50,7 +48,7 @@ A special requirement of the `pkgs.buildEmscriptenPackage` is the `doCheck = tru
 * Use `export EMCC_DEBUG=2` from within a emscriptenPackage's `phase` to get more detailed debug output what is going wrong.
 * ~/.emscripten cache is requiring us to set `HOME=$TMPDIR` in individual phases. This makes compilation slower but also makes it more deterministic.
 
-### Usage 1: pkgs.zlib.override
+### Usage 1: pkgs.zlib.override {#usage-1-pkgs.zlib.override}
 
 This example uses `zlib` from nixpkgs but instead of compiling **C** to **ELF** it compiles **C** to **JS** since we were using `pkgs.zlib.override` and changed stdenv to `pkgs.emscriptenStdenv`. A few adaptions and hacks were set in place to make it working. One advantage is that when `pkgs.zlib` is updated, it will automatically update this package as well. However, this can also be the downside...
 
@@ -60,7 +58,7 @@ See the `zlib` example:
       stdenv = pkgs.emscriptenStdenv;
     }).overrideDerivation
     (old: rec {
-      buildInputs = old.buildInputs ++ [ pkgconfig ];
+      buildInputs = old.buildInputs ++ [ pkg-config ];
       # we need to reset this setting!
       NIX_CFLAGS_COMPILE="";
       configurePhase = ''
@@ -102,7 +100,7 @@ See the `zlib` example:
         echo "================= /testing zlib using node ================="
       '';
 
-      postPatch = pkgs.stdenv.lib.optionalString pkgs.stdenv.isDarwin ''
+      postPatch = pkgs.lib.optionalString pkgs.stdenv.isDarwin ''
         substituteInPlace configure \
           --replace '/usr/bin/libtool' 'ar' \
           --replace 'AR="libtool"' 'AR="ar"' \
@@ -110,15 +108,15 @@ See the `zlib` example:
       '';
     });
 
-### Usage 2: pkgs.buildEmscriptenPackage
+### Usage 2: pkgs.buildEmscriptenPackage {#usage-2-pkgs.buildemscriptenpackage}
 
 This `xmlmirror` example features a emscriptenPackage which is defined completely from this context and no `pkgs.zlib.override` is used.
 
     xmlmirror = pkgs.buildEmscriptenPackage rec {
       name = "xmlmirror";
 
-      buildInputs = [ pkgconfig autoconf automake libtool gnumake libxml2 nodejs openjdk json_c ];
-      nativeBuildInputs = [ pkgconfig zlib ];
+      buildInputs = [ pkg-config autoconf automake libtool gnumake libxml2 nodejs openjdk json_c ];
+      nativeBuildInputs = [ pkg-config zlib ];
 
       src = pkgs.fetchgit {
         url = "https://gitlab.com/odfplugfest/xmlmirror.git";
@@ -165,7 +163,7 @@ This `xmlmirror` example features a emscriptenPackage which is defined completel
       '';
     };
 
-### Declarative debugging
+### Declarative debugging {#declarative-debugging}
 
 Use `nix-shell -I nixpkgs=/some/dir/nixpkgs -A emscriptenPackages.libz` and from there you can go trough the individual steps. This makes it easy to build a good `unit test` or list the files of the project.
 
@@ -177,7 +175,7 @@ Use `nix-shell -I nixpkgs=/some/dir/nixpkgs -A emscriptenPackages.libz` and from
 6. `buildPhase`
 7. ... happy hacking...
 
-## Summary
+## Summary {#summary}
 
 Using this toolchain makes it easy to leverage `nix` from NixOS, MacOSX or even Windows (WSL+ubuntu+nix). This toolchain is reproducible, behaves like the rest of the packages from nixpkgs and contains a set of well working examples to learn and adapt from.
 
diff --git a/doc/languages-frameworks/gnome.section.md b/doc/languages-frameworks/gnome.section.md
new file mode 100644
index 00000000000..11b49f4f235
--- /dev/null
+++ b/doc/languages-frameworks/gnome.section.md
@@ -0,0 +1,204 @@
+# GNOME {#sec-language-gnome}
+
+## Packaging GNOME applications {#ssec-gnome-packaging}
+
+Programs in the GNOME universe are written in various languages but they all use GObject-based libraries like GLib, GTK or GStreamer. These libraries are often modular, relying on looking into certain directories to find their modules. However, due to Nix’s specific file system organization, this will fail without our intervention. Fortunately, the libraries usually allow overriding the directories through environment variables, either natively or thanks to a patch in nixpkgs. [Wrapping](#fun-wrapProgram) the executables to ensure correct paths are available to the application constitutes a significant part of packaging a modern desktop application. In this section, we will describe various modules needed by such applications, environment variables needed to make the modules load, and finally a script that will do the work for us.
+
+### Settings {#ssec-gnome-settings}
+
+[GSettings](https://developer.gnome.org/gio/stable/GSettings.html) API is often used for storing settings. GSettings schemas are required, to know the type and other metadata of the stored values. GLib looks for `glib-2.0/schemas/gschemas.compiled` files inside the directories of `XDG_DATA_DIRS`.
+
+On Linux, GSettings API is implemented using [dconf](https://wiki.gnome.org/Projects/dconf) backend. You will need to add `dconf` [GIO module](#ssec-gnome-gio-modules) to `GIO_EXTRA_MODULES` variable, otherwise the `memory` backend will be used and the saved settings will not be persistent.
+
+Last you will need the dconf database D-Bus service itself. You can enable it using `programs.dconf.enable`.
+
+Some applications will also require `gsettings-desktop-schemas` for things like reading proxy configuration or user interface customization. This dependency is often not mentioned by upstream, you should grep for `org.gnome.desktop` and `org.gnome.system` to see if the schemas are needed.
+
+### GIO modules {#ssec-gnome-gio-modules}
+
+GLib’s [GIO](https://developer.gnome.org/gio/stable/ch01.html) library supports several [extension points](https://developer.gnome.org/gio/stable/extending-gio.html). Notably, they allow:
+
+* implementing settings backends (already [mentioned](#ssec-gnome-settings))
+* adding TLS support
+* proxy settings
+* virtual file systems
+
+The modules are typically installed to `lib/gio/modules/` directory of a package and you need to add them to `GIO_EXTRA_MODULES` if you need any of those features.
+
+In particular, we recommend:
+
+* adding `dconf.lib` for any software on Linux that reads [GSettings](#ssec-gnome-settings) (even transitivily through e.g. GTK’s file manager)
+* adding `glib-networking` for any software that accesses network using GIO or libsoup – glib-networking contains a module that implements TLS support and loads system-wide proxy settings
+
+To allow software to use various virtual file systems, `gvfs` package can be also added. But that is usually an optional feature so we typically use `gvfs` from the system (e.g. installed globally using NixOS module).
+
+### GdkPixbuf loaders {#ssec-gnome-gdk-pixbuf-loaders}
+
+GTK applications typically use [GdkPixbuf](https://developer.gnome.org/gdk-pixbuf/stable/) to load images. But `gdk-pixbuf` package only supports basic bitmap formats like JPEG, PNG or TIFF, requiring to use third-party loader modules for other formats. This is especially painful since GTK itself includes SVG icons, which cannot be rendered without a loader provided by `librsvg`.
+
+Unlike other libraries mentioned in this section, GdkPixbuf only supports a single value in its controlling environment variable `GDK_PIXBUF_MODULE_FILE`. It is supposed to point to a cache file containing information about the available loaders. Each loader package will contain a `lib/gdk-pixbuf-2.0/2.10.0/loaders.cache` file describing the default loaders in `gdk-pixbuf` package plus the loader contained in the package itself. If you want to use multiple third-party loaders, you will need to create your own cache file manually. Fortunately, this is pretty rare as [not many loaders exist](https://gitlab.gnome.org/federico/gdk-pixbuf-survey/blob/master/src/modules.md).
+
+`gdk-pixbuf` contains [a setup hook](#ssec-gnome-hooks-gdk-pixbuf) that sets `GDK_PIXBUF_MODULE_FILE` from dependencies but as mentioned in further section, it is pretty limited. Loaders should propagate this setup hook.
+
+### Icons {#ssec-gnome-icons}
+
+When an application uses icons, an icon theme should be available in `XDG_DATA_DIRS` during runtime. The package for the default, icon-less [hicolor-icon-theme](https://www.freedesktop.org/wiki/Software/icon-theme/) (should be propagated by every icon theme) contains [a setup hook](#ssec-gnome-hooks-hicolor-icon-theme) that will pick up icon themes from `buildInputs` and pass it to our wrapper. Unfortunately, relying on that would mean every user has to download the theme included in the package expression no matter their preference. For that reason, we leave the installation of icon theme on the user. If you use one of the desktop environments, you probably already have an icon theme installed.
+
+To avoid costly file system access when locating icons, GTK, [as well as Qt](https://woboq.com/blog/qicon-reads-gtk-icon-cache-in-qt57.html), can rely on `icon-theme.cache` files from the themes' top-level directories. These files are generated using `gtk-update-icon-cache`, which is expected to be run whenever an icon is added or removed to an icon theme (typically an application icon into `hicolor` theme) and some programs do indeed run this after icon installation. However, since packages are installed into their own prefix by Nix, this would lead to conflicts. For that reason, `gtk3` provides a [setup hook](#ssec-gnome-hooks-gtk-drop-icon-theme-cache) that will clean the file from installation. Since most applications only ship their own icon that will be loaded on start-up, it should not affect them too much. On the other hand, icon themes are much larger and more widely used so we need to cache them. Because we recommend installing icon themes globally, we will generate the cache files from all packages in a profile using a NixOS module. You can enable the cache generation using `gtk.iconCache.enable` option if your desktop environment does not already do that.
+
+### Packaging icon themes {#ssec-icon-theme-packaging}
+
+Icon themes may inherit from other icon themes. The inheritance is specified using the `Inherits` key in the `index.theme` file distributed with the icon theme. According to the [icon theme specification](https://specifications.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html), icons not provided by the theme are looked for in its parent icon themes. Therefore the parent themes should be installed as dependencies for a more complete experience regarding the icon sets used.
+
+The package `hicolor-icon-theme` provides a setup hook which makes symbolic links for the parent themes into the directory `share/icons` of the current theme directory in the nix store, making sure they can be found at runtime. For that to work the packages providing parent icon themes should be listed as propagated build dependencies, together with `hicolor-icon-theme`.
+
+Also make sure that `icon-theme.cache` is installed for each theme provided by the package, and set `dontDropIconThemeCache` to `true` so that the cache file is not removed by the `gtk3` setup hook.
+
+### GTK Themes {#ssec-gnome-themes}
+
+Previously, a GTK theme needed to be in `XDG_DATA_DIRS`. This is no longer necessary for most programs since GTK incorporated Adwaita theme. Some programs (for example, those designed for [elementary HIG](https://elementary.io/docs/human-interface-guidelines#human-interface-guidelines)) might require a special theme like `pantheon.elementary-gtk-theme`.
+
+### GObject introspection typelibs {#ssec-gnome-typelibs}
+
+[GObject introspection](https://wiki.gnome.org/Projects/GObjectIntrospection) allows applications to use C libraries in other languages easily. It does this through `typelib` files searched in `GI_TYPELIB_PATH`.
+
+### Various plug-ins {#ssec-gnome-plugins}
+
+If your application uses [GStreamer](https://gstreamer.freedesktop.org/) or [Grilo](https://wiki.gnome.org/Projects/Grilo), you should set `GST_PLUGIN_SYSTEM_PATH_1_0` and `GRL_PLUGIN_PATH`, respectively.
+
+## Onto `wrapGAppsHook` {#ssec-gnome-hooks}
+
+Given the requirements above, the package expression would become messy quickly:
+
+```nix
+preFixup = ''
+  for f in $(find $out/bin/ $out/libexec/ -type f -executable); do
+    wrapProgram "$f" \
+      --prefix GIO_EXTRA_MODULES : "${getLib dconf}/lib/gio/modules" \
+      --prefix XDG_DATA_DIRS : "$out/share" \
+      --prefix XDG_DATA_DIRS : "$out/share/gsettings-schemas/${name}" \
+      --prefix XDG_DATA_DIRS : "${gsettings-desktop-schemas}/share/gsettings-schemas/${gsettings-desktop-schemas.name}" \
+      --prefix XDG_DATA_DIRS : "${hicolor-icon-theme}/share" \
+      --prefix GI_TYPELIB_PATH : "${lib.makeSearchPath "lib/girepository-1.0" [ pango json-glib ]}"
+  done
+'';
+```
+
+Fortunately, there is [`wrapGAppsHook`]{#ssec-gnome-hooks-wrapgappshook}. It works in conjunction with other setup hooks that populate environment variables, and it will then wrap all executables in `bin` and `libexec` directories using said variables.
+
+For convenience, it also adds `dconf.lib` for a GIO module implementing a GSettings backend using `dconf`, `gtk3` for GSettings schemas, and `librsvg` for GdkPixbuf loader to the closure. There is also [`wrapGAppsHook4`]{#ssec-gnome-hooks-wrapgappshook4}, which replaces GTK 3 with GTK 4. And in case you are packaging a program without a graphical interface, you might want to use [`wrapGAppsNoGuiHook`]{#ssec-gnome-hooks-wrapgappsnoguihook}, which runs the same script as `wrapGAppsHook` but does not bring `gtk3` and `librsvg` into the closure.
+
+- `wrapGAppsHook` itself will add the package’s `share` directory to `XDG_DATA_DIRS`.
+
+- []{#ssec-gnome-hooks-glib} `glib` setup hook will populate `GSETTINGS_SCHEMAS_PATH` and then `wrapGAppsHook` will prepend it to `XDG_DATA_DIRS`.
+
+- []{#ssec-gnome-hooks-gdk-pixbuf} `gdk-pixbuf` setup hook will populate `GDK_PIXBUF_MODULE_FILE` with the path to biggest `loaders.cache` file from the dependencies containing [GdkPixbuf loaders](ssec-gnome-gdk-pixbuf-loaders). This works fine when there are only two packages containing loaders (`gdk-pixbuf` and e.g. `librsvg`) – it will choose the second one, reasonably expecting that it will be bigger since it describes extra loader in addition to the default ones. But when there are more than two loader packages, this logic will break. One possible solution would be constructing a custom cache file for each package containing a program like `services/x11/gdk-pixbuf.nix` NixOS module does. `wrapGAppsHook` copies the `GDK_PIXBUF_MODULE_FILE` environment variable into the produced wrapper.
+
+- []{#ssec-gnome-hooks-gtk-drop-icon-theme-cache} One of `gtk3`’s setup hooks will remove `icon-theme.cache` files from package’s icon theme directories to avoid conflicts. Icon theme packages should prevent this with `dontDropIconThemeCache = true;`.
+
+- []{#ssec-gnome-hooks-dconf} `dconf.lib` is a dependency of `wrapGAppsHook`, which then also adds it to the `GIO_EXTRA_MODULES` variable.
+
+- []{#ssec-gnome-hooks-hicolor-icon-theme} `hicolor-icon-theme`’s setup hook will add icon themes to `XDG_ICON_DIRS` which is prepended to `XDG_DATA_DIRS` by `wrapGAppsHook`.
+
+- []{#ssec-gnome-hooks-gobject-introspection} `gobject-introspection` setup hook populates `GI_TYPELIB_PATH` variable with `lib/girepository-1.0` directories of dependencies, which is then added to wrapper by `wrapGAppsHook`. It also adds `share` directories of dependencies to `XDG_DATA_DIRS`, which is intended to promote GIR files but it also [pollutes the closures](https://github.com/NixOS/nixpkgs/issues/32790) of packages using `wrapGAppsHook`.
+
+  ::: {.warning}
+  The setup hook [currently](https://github.com/NixOS/nixpkgs/issues/56943) does not work in expressions with `strictDeps` enabled, like Python packages. In those cases, you will need to disable it with `strictDeps = false;`.
+  :::
+
+- []{#ssec-gnome-hooks-gst-grl-plugins} Setup hooks of `gst_all_1.gstreamer` and `grilo` will populate the `GST_PLUGIN_SYSTEM_PATH_1_0` and `GRL_PLUGIN_PATH` variables, respectively, which will then be added to the wrapper by `wrapGAppsHook`.
+
+You can also pass additional arguments to `makeWrapper` using `gappsWrapperArgs` in `preFixup` hook:
+
+```nix
+preFixup = ''
+  gappsWrapperArgs+=(
+    # Thumbnailers
+    --prefix XDG_DATA_DIRS : "${gdk-pixbuf}/share"
+    --prefix XDG_DATA_DIRS : "${librsvg}/share"
+    --prefix XDG_DATA_DIRS : "${shared-mime-info}/share"
+  )
+'';
+```
+
+## Updating GNOME packages {#ssec-gnome-updating}
+
+Most GNOME package offer [`updateScript`](#var-passthru-updateScript), it is therefore possible to update to latest source tarball by running `nix-shell maintainers/scripts/update.nix --argstr package gnome.nautilus` or even en masse with `nix-shell maintainers/scripts/update.nix --argstr path gnome`. Read the package’s `NEWS` file to see what changed.
+
+## Frequently encountered issues {#ssec-gnome-common-issues}
+
+#### `GLib-GIO-ERROR **: 06:04:50.903: No GSettings schemas are installed on the system` {#ssec-gnome-common-issues-no-schemas}
+
+There are no schemas available in `XDG_DATA_DIRS`. Temporarily add a random package containing schemas like `gsettings-desktop-schemas` to `buildInputs`. [`glib`](#ssec-gnome-hooks-glib) and [`wrapGAppsHook`](#ssec-gnome-hooks-wrapgappshook) setup hooks will take care of making the schemas available to application and you will see the actual missing schemas with the [next error](#ssec-gnome-common-issues-missing-schema). Or you can try looking through the source code for the actual schemas used.
+
+#### `GLib-GIO-ERROR **: 06:04:50.903: Settings schema ‘org.gnome.foo’ is not installed` {#ssec-gnome-common-issues-missing-schema}
+
+Package is missing some GSettings schemas. You can find out the package containing the schema with `nix-locate org.gnome.foo.gschema.xml` and let the hooks handle the wrapping as [above](#ssec-gnome-common-issues-no-schemas).
+
+#### When using `wrapGAppsHook` with special derivers you can end up with double wrapped binaries. {#ssec-gnome-common-issues-double-wrapped}
+
+This is because derivers like `python.pkgs.buildPythonApplication` or `qt5.mkDerivation` have setup-hooks automatically added that produce wrappers with makeWrapper. The simplest way to workaround that is to disable the `wrapGAppsHook` automatic wrapping with `dontWrapGApps = true;` and pass the arguments it intended to pass to makeWrapper to another.
+
+In the case of a Python application it could look like:
+
+```nix
+python3.pkgs.buildPythonApplication {
+  pname = "gnome-music";
+  version = "3.32.2";
+
+  nativeBuildInputs = [
+    wrapGAppsHook
+    gobject-introspection
+    ...
+  ];
+
+  dontWrapGApps = true;
+
+  # Arguments to be passed to `makeWrapper`, only used by buildPython*
+  preFixup = ''
+    makeWrapperArgs+=("''${gappsWrapperArgs[@]}")
+  '';
+}
+```
+
+And for a QT app like:
+
+```nix
+mkDerivation {
+  pname = "calibre";
+  version = "3.47.0";
+
+  nativeBuildInputs = [
+    wrapGAppsHook
+    qmake
+    ...
+  ];
+
+  dontWrapGApps = true;
+
+  # Arguments to be passed to `makeWrapper`, only used by qt5’s mkDerivation
+  preFixup = ''
+    qtWrapperArgs+=("''${gappsWrapperArgs[@]}")
+  '';
+}
+```
+
+#### I am packaging a project that cannot be wrapped, like a library or GNOME Shell extension. {#ssec-gnome-common-issues-unwrappable-package}
+
+You can rely on applications depending on the library setting the necessary environment variables but that is often easy to miss. Instead we recommend to patch the paths in the source code whenever possible. Here are some examples:
+
+- []{#ssec-gnome-common-issues-unwrappable-package-gnome-shell-ext} [Replacing a `GI_TYPELIB_PATH` in GNOME Shell extension](https://github.com/NixOS/nixpkgs/blob/7bb8f05f12ca3cff9da72b56caa2f7472d5732bc/pkgs/desktops/gnome-3/core/gnome-shell-extensions/default.nix#L21-L24) – we are using `substituteAll` to include the path to a typelib into a patch.
+
+- []{#ssec-gnome-common-issues-unwrappable-package-gsettings} The following examples are hardcoding GSettings schema paths. To get the schema paths we use the functions
+
+  * `glib.getSchemaPath` Takes a nix package attribute as an argument.
+
+  * `glib.makeSchemaPath` Takes a package output like `$out` and a derivation name. You should use this if the schemas you need to hardcode are in the same derivation.
+
+  []{#ssec-gnome-common-issues-unwrappable-package-gsettings-vala} [Hard-coding GSettings schema path in Vala plug-in (dynamically loaded library)](https://github.com/NixOS/nixpkgs/blob/7bb8f05f12ca3cff9da72b56caa2f7472d5732bc/pkgs/desktops/pantheon/apps/elementary-files/default.nix#L78-L86) – here, `substituteAll` cannot be used since the schema comes from the same package preventing us from pass its path to the function, probably due to a [Nix bug](https://github.com/NixOS/nix/issues/1846).
+
+  []{#ssec-gnome-common-issues-unwrappable-package-gsettings-c} [Hard-coding GSettings schema path in C library](https://github.com/NixOS/nixpkgs/blob/29c120c065d03b000224872251bed93932d42412/pkgs/development/libraries/glib-networking/default.nix#L31-L34) – nothing special other than using [Coccinelle patch](https://github.com/NixOS/nixpkgs/pull/67957#issuecomment-527717467) to generate the patch itself.
+
+#### I need to wrap a binary outside `bin` and `libexec` directories. {#ssec-gnome-common-issues-weird-location}
+
+You can manually trigger the wrapping with `wrapGApp` in `preFixup` phase. It takes a path to a program as a first argument; the remaining arguments are passed directly to [`wrapProgram`](#fun-wrapProgram) function.
diff --git a/doc/languages-frameworks/gnome.xml b/doc/languages-frameworks/gnome.xml
deleted file mode 100644
index 159216ca981..00000000000
--- a/doc/languages-frameworks/gnome.xml
+++ /dev/null
@@ -1,299 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xml:id="sec-language-gnome">
- <title>GNOME</title>
-
- <section xml:id="ssec-gnome-packaging">
-  <title>Packaging GNOME applications</title>
-
-  <para>
-   Programs in the GNOME universe are written in various languages but they all use GObject-based libraries like GLib, GTK or GStreamer. These libraries are often modular, relying on looking into certain directories to find their modules. However, due to Nix’s specific file system organization, this will fail without our intervention. Fortunately, the libraries usually allow overriding the directories through environment variables, either natively or thanks to a patch in nixpkgs. <link xlink:href="#fun-wrapProgram">Wrapping</link> the executables to ensure correct paths are available to the application constitutes a significant part of packaging a modern desktop application. In this section, we will describe various modules needed by such applications, environment variables needed to make the modules load, and finally a script that will do the work for us.
-  </para>
-
-  <section xml:id="ssec-gnome-settings">
-   <title>Settings</title>
-
-   <para>
-    <link xlink:href="https://developer.gnome.org/gio/stable/GSettings.html">GSettings</link> API is often used for storing settings. GSettings schemas are required, to know the type and other metadata of the stored values. GLib looks for <filename>glib-2.0/schemas/gschemas.compiled</filename> files inside the directories of <envar>XDG_DATA_DIRS</envar>.
-   </para>
-
-   <para>
-    On Linux, GSettings API is implemented using <link xlink:href="https://wiki.gnome.org/Projects/dconf">dconf</link> backend. You will need to add <literal>dconf</literal> GIO module to <envar>GIO_EXTRA_MODULES</envar> variable, otherwise the <literal>memory</literal> backend will be used and the saved settings will not be persistent.
-   </para>
-
-   <para>
-    Last you will need the dconf database D-Bus service itself. You can enable it using <option>programs.dconf.enable</option>.
-   </para>
-
-   <para>
-    Some applications will also require <package>gsettings-desktop-schemas</package> for things like reading proxy configuration or user interface customization. This dependency is often not mentioned by upstream, you should grep for <literal>org.gnome.desktop</literal> and <literal>org.gnome.system</literal> to see if the schemas are needed.
-   </para>
-  </section>
-
-  <section xml:id="ssec-gnome-icons">
-   <title>Icons</title>
-
-   <para>
-    When an application uses icons, an icon theme should be available in <envar>XDG_DATA_DIRS</envar> during runtime. The package for the default, icon-less <link xlink:href="https://www.freedesktop.org/wiki/Software/icon-theme/">hicolor-icon-theme</link> (should be propagated by every icon theme) contains <link linkend="ssec-gnome-hooks-hicolor-icon-theme">a setup hook</link> that will pick up icon themes from <literal>buildInputs</literal> and pass it to our wrapper. Unfortunately, relying on that would mean every user has to download the theme included in the package expression no matter their preference. For that reason, we leave the installation of icon theme on the user. If you use one of the desktop environments, you probably already have an icon theme installed.
-   </para>
-
-   <para>
-    To avoid costly file system access when locating icons, GTK, <link xlink:href="https://woboq.com/blog/qicon-reads-gtk-icon-cache-in-qt57.html">as well as Qt</link>, can rely on <filename>icon-theme.cache</filename> files from the themes’ top-level directories. These files are generated using <command>gtk-update-icon-cache</command>, which is expected to be run whenever an icon is added or removed to an icon theme (typically an application icon into <literal>hicolor</literal> theme) and some programs do indeed run this after icon installation. However, since packages are installed into their own prefix by Nix, this would lead to conflicts. For that reason, <package>gtk3</package> provides a <link xlink:href="#ssec-gnome-hooks-gtk-drop-icon-theme-cache">setup hook</link> that will clean the file from installation. Since most applications only ship their own icon that will be loaded on start-up, it should not affect them too much. On the other hand, icon themes are much larger and more widely used so we need to cache them. Because we recommend installing icon themes globally, we will generate the cache files from all packages in a profile using a NixOS module. You can enable the cache generation using <option>gtk.iconCache.enable</option> option if your desktop environment does not already do that.
-   </para>
-  </section>
-
-  <section xml:id="ssec-icon-theme-packaging">
-    <title>Packaging icon themes</title>
-
-    <para>
-      Icon themes may inherit from other icon themes. The inheritance is specified using the <literal>Inherits</literal> key in the <filename>index.theme</filename> file distributed with the icon theme. According to the <link xlink:href="https://specifications.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html">icon theme specification</link>, icons not provided by the theme are looked for in its parent icon themes. Therefore the parent themes should be installed as dependencies for a more complete experience regarding the icon sets used.
-    </para>
-
-    <para>
-      The package <package>hicolor-icon-theme</package> provides a setup hook which makes symbolic links for the parent themes into the directory <filename>share/icons</filename> of the current theme directory in the nix store, making sure they can be found at runtime. For that to work the packages providing parent icon themes should be listed as propagated build dependencies, together with <package>hicolor-icon-theme</package>.
-    </para>
-
-    <para>
-      Also make sure that <filename>icon-theme.cache</filename> is installed for each theme provided by the package, and set <code>dontDropIconThemeCache</code> to <code>true</code> so that the cache file is not removed by the <package>gtk3</package> setup hook.
-    </para>
-
-  </section>
-
-  <section xml:id="ssec-gnome-themes">
-   <title>GTK Themes</title>
-
-   <para>
-    Previously, a GTK theme needed to be in <envar>XDG_DATA_DIRS</envar>. This is no longer necessary for most programs since GTK incorporated Adwaita theme. Some programs (for example, those designed for <link xlink:href="https://elementary.io/docs/human-interface-guidelines#human-interface-guidelines">elementary HIG</link>) might require a special theme like <package>pantheon.elementary-gtk-theme</package>.
-   </para>
-  </section>
-
-  <section xml:id="ssec-gnome-typelibs">
-   <title>GObject introspection typelibs</title>
-
-   <para>
-    <link xlink:href="https://wiki.gnome.org/Projects/GObjectIntrospection">GObject introspection</link> allows applications to use C libraries in other languages easily. It does this through <literal>typelib</literal> files searched in <envar>GI_TYPELIB_PATH</envar>.
-   </para>
-  </section>
-
-  <section xml:id="ssec-gnome-plugins">
-   <title>Various plug-ins</title>
-
-   <para>
-    If your application uses <link xlink:href="https://gstreamer.freedesktop.org/">GStreamer</link> or <link xlink:href="https://wiki.gnome.org/Projects/Grilo">Grilo</link>, you should set <envar>GST_PLUGIN_SYSTEM_PATH_1_0</envar> and <envar>GRL_PLUGIN_PATH</envar>, respectively.
-   </para>
-  </section>
- </section>
-
- <section xml:id="ssec-gnome-hooks">
-  <title>Onto <package>wrapGAppsHook</package></title>
-
-  <para>
-   Given the requirements above, the package expression would become messy quickly:
-<programlisting>
-preFixup = ''
-  for f in $(find $out/bin/ $out/libexec/ -type f -executable); do
-    wrapProgram "$f" \
-      --prefix GIO_EXTRA_MODULES : "${getLib dconf}/lib/gio/modules" \
-      --prefix XDG_DATA_DIRS : "$out/share" \
-      --prefix XDG_DATA_DIRS : "$out/share/gsettings-schemas/${name}" \
-      --prefix XDG_DATA_DIRS : "${gsettings-desktop-schemas}/share/gsettings-schemas/${gsettings-desktop-schemas.name}" \
-      --prefix XDG_DATA_DIRS : "${hicolor-icon-theme}/share" \
-      --prefix GI_TYPELIB_PATH : "${lib.makeSearchPath "lib/girepository-1.0" [ pango json-glib ]}"
-  done
-'';
-</programlisting>
-   Fortunately, there is <package>wrapGAppsHook</package>, that does the wrapping for us. In particular, it works in conjunction with other setup hooks that will populate the variable:
-   <itemizedlist>
-    <listitem xml:id="ssec-gnome-hooks-wrapgappshook">
-     <para>
-      <package>wrapGAppsHook</package> itself will add the package’s <filename>share</filename> directory to <envar>XDG_DATA_DIRS</envar>.
-     </para>
-    </listitem>
-    <listitem xml:id="ssec-gnome-hooks-glib">
-     <para>
-      <package>glib</package> setup hook will populate <envar>GSETTINGS_SCHEMAS_PATH</envar> and then <package>wrapGAppsHook</package> will prepend it to <envar>XDG_DATA_DIRS</envar>.
-     </para>
-    </listitem>
-    <listitem xml:id="ssec-gnome-hooks-gtk-drop-icon-theme-cache">
-     <para>
-      One of <package>gtk3</package>’s setup hooks will remove <filename>icon-theme.cache</filename> files from package’s icon theme directories to avoid conflicts. Icon theme packages should prevent this with <code>dontDropIconThemeCache = true;</code>.
-     </para>
-    </listitem>
-    <listitem xml:id="ssec-gnome-hooks-dconf">
-     <para>
-      <package>dconf.lib</package> is a dependency of <package>wrapGAppsHook</package>, which then also adds it to the <envar>GIO_EXTRA_MODULES</envar> variable.
-     </para>
-    </listitem>
-    <listitem xml:id="ssec-gnome-hooks-hicolor-icon-theme">
-     <para>
-      <package>hicolor-icon-theme</package>’s setup hook will add icon themes to <envar>XDG_ICON_DIRS</envar> which is prepended to <envar>XDG_DATA_DIRS</envar> by <package>wrapGAppsHook</package>.
-     </para>
-    </listitem>
-    <listitem xml:id="ssec-gnome-hooks-gobject-introspection">
-     <para>
-      <package>gobject-introspection</package> setup hook populates <envar>GI_TYPELIB_PATH</envar> variable with <filename>lib/girepository-1.0</filename> directories of dependencies, which is then added to wrapper by <package>wrapGAppsHook</package>. It also adds <filename>share</filename> directories of dependencies to <envar>XDG_DATA_DIRS</envar>, which is intended to promote GIR files but it also <link xlink:href="https://github.com/NixOS/nixpkgs/issues/32790">pollutes the closures</link> of packages using <package>wrapGAppsHook</package>.
-     </para>
-     <warning>
-      <para>
-       The setup hook <link xlink:href="https://github.com/NixOS/nixpkgs/issues/56943">currently</link> does not work in expressions with <literal>strictDeps</literal> enabled, like Python packages. In those cases, you will need to disable it with <code>strictDeps = false;</code>.
-      </para>
-     </warning>
-    </listitem>
-    <listitem xml:id="ssec-gnome-hooks-gst-grl-plugins">
-     <para>
-      Setup hooks of <package>gst_all_1.gstreamer</package> and <package>gnome3.grilo</package> will populate the <envar>GST_PLUGIN_SYSTEM_PATH_1_0</envar> and <envar>GRL_PLUGIN_PATH</envar> variables, respectively, which will then be added to the wrapper by <literal>wrapGAppsHook</literal>.
-     </para>
-    </listitem>
-   </itemizedlist>
-  </para>
-
-  <para>
-   You can also pass additional arguments to <literal>makeWrapper</literal> using <literal>gappsWrapperArgs</literal> in <literal>preFixup</literal> hook:
-<programlisting>
-preFixup = ''
-  gappsWrapperArgs+=(
-    # Thumbnailers
-    --prefix XDG_DATA_DIRS : "${gdk-pixbuf}/share"
-    --prefix XDG_DATA_DIRS : "${librsvg}/share"
-    --prefix XDG_DATA_DIRS : "${shared-mime-info}/share"
-  )
-'';
-</programlisting>
-  </para>
- </section>
-
- <section xml:id="ssec-gnome-updating">
-  <title>Updating GNOME packages</title>
-
-  <para>
-   Most GNOME package offer <link linkend="var-passthru-updateScript"><literal>updateScript</literal></link>, it is therefore possible to update to latest source tarball by running <command>nix-shell maintainers/scripts/update.nix --argstr package gnome3.nautilus</command> or even en masse with <command>nix-shell maintainers/scripts/update.nix --argstr path gnome3</command>. Read the package’s <filename>NEWS</filename> file to see what changed.
-  </para>
- </section>
-
- <section xml:id="ssec-gnome-common-issues">
-  <title>Frequently encountered issues</title>
-
-  <variablelist>
-   <varlistentry xml:id="ssec-gnome-common-issues-no-schemas">
-    <term>
-     <computeroutput>GLib-GIO-ERROR **: <replaceable>06:04:50.903</replaceable>: No GSettings schemas are installed on the system</computeroutput>
-    </term>
-    <listitem>
-     <para>
-      There are no schemas avalable in <envar>XDG_DATA_DIRS</envar>. Temporarily add a random package containing schemas like <package>gsettings-desktop-schemas</package> to <literal>buildInputs</literal>. <link linkend="ssec-gnome-hooks-glib"><package>glib</package></link> and <link linkend="ssec-gnome-hooks-wrapgappshook"><package>wrapGAppsHook</package></link> setup hooks will take care of making the schemas available to application and you will see the actual missing schemas with the <link linkend="ssec-gnome-common-issues-missing-schema">next error</link>. Or you can try looking through the source code for the actual schemas used.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="ssec-gnome-common-issues-missing-schema">
-    <term>
-     <computeroutput>GLib-GIO-ERROR **: <replaceable>06:04:50.903</replaceable>: Settings schema ‘<replaceable>org.gnome.foo</replaceable>’ is not installed</computeroutput>
-    </term>
-    <listitem>
-     <para>
-      Package is missing some GSettings schemas. You can find out the package containing the schema with <command>nix-locate <replaceable>org.gnome.foo</replaceable>.gschema.xml</command> and let the hooks handle the wrapping as <link linkend="ssec-gnome-common-issues-no-schemas">above</link>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="ssec-gnome-common-issues-double-wrapped">
-    <term>
-     When using <package>wrapGAppsHook</package> with special derivers you can end up with double wrapped binaries.
-    </term>
-    <listitem>
-     <para>
-      This is because derivers like <function>python.pkgs.buildPythonApplication</function> or <function>qt5.mkDerivation</function> have setup-hooks automatically added that produce wrappers with <package>makeWrapper</package>. The simplest way to workaround that is to disable the <package>wrapGAppsHook</package> automatic wrapping with <code>dontWrapGApps = true;</code> and pass the arguments it intended to pass to <package>makeWrapper</package> to another.
-     </para>
-     <para>
-      In the case of a Python application it could look like:
-<programlisting>
-python3.pkgs.buildPythonApplication {
-  pname = "gnome-music";
-  version = "3.32.2";
-
-  nativeBuildInputs = [
-    wrapGAppsHook
-    gobject-introspection
-    ...
-  ];
-
-  dontWrapGApps = true;
-
-  # Arguments to be passed to `makeWrapper`, only used by buildPython*
-  preFixup = ''
-    makeWrapperArgs+=("''${gappsWrapperArgs[@]}")
-  '';
-}
-</programlisting>
-      And for a QT app like:
-<programlisting>
-mkDerivation {
-  pname = "calibre";
-  version = "3.47.0";
-
-  nativeBuildInputs = [
-    wrapGAppsHook
-    qmake
-    ...
-  ];
-
-  dontWrapGApps = true;
-
-  # Arguments to be passed to `makeWrapper`, only used by qt5’s mkDerivation
-  preFixup = ''
-    qtWrapperArgs+=("''${gappsWrapperArgs[@]}")
-  '';
-}
-</programlisting>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="ssec-gnome-common-issues-unwrappable-package">
-    <term>
-     I am packaging a project that cannot be wrapped, like a library or GNOME Shell extension.
-    </term>
-    <listitem>
-     <para>
-      You can rely on applications depending on the library setting the necessary environment variables but that is often easy to miss. Instead we recommend to patch the paths in the source code whenever possible. Here are some examples:
-      <itemizedlist>
-       <listitem xml:id="ssec-gnome-common-issues-unwrappable-package-gnome-shell-ext">
-        <para>
-         <link xlink:href="https://github.com/NixOS/nixpkgs/blob/7bb8f05f12ca3cff9da72b56caa2f7472d5732bc/pkgs/desktops/gnome-3/core/gnome-shell-extensions/default.nix#L21-L24">Replacing a <envar>GI_TYPELIB_PATH</envar> in GNOME Shell extension</link> – we are using <function>substituteAll</function> to include the path to a typelib into a patch.
-        </para>
-       </listitem>
-       <listitem xml:id="ssec-gnome-common-issues-unwrappable-package-gsettings">
-        <para>
-         The following examples are hardcoding GSettings schema paths. To get the schema paths we use the functions
-         <itemizedlist>
-          <listitem>
-           <para>
-            <function>glib.getSchemaPath</function> Takes a nix package attribute as an argument.
-           </para>
-          </listitem>
-          <listitem>
-           <para>
-            <function>glib.makeSchemaPath</function> Takes a package output like <literal>$out</literal> and a derivation name. You should use this if the schemas you need to hardcode are in the same derivation.
-           </para>
-          </listitem>
-         </itemizedlist>
-        </para>
-        <para xml:id="ssec-gnome-common-issues-unwrappable-package-gsettings-vala">
-         <link xlink:href="https://github.com/NixOS/nixpkgs/blob/7bb8f05f12ca3cff9da72b56caa2f7472d5732bc/pkgs/desktops/pantheon/apps/elementary-files/default.nix#L78-L86">Hard-coding GSettings schema path in Vala plug-in (dynamically loaded library)</link> – here, <function>substituteAll</function> cannot be used since the schema comes from the same package preventing us from pass its path to the function, probably due to a <link xlink:href="https://github.com/NixOS/nix/issues/1846">Nix bug</link>.
-        </para>
-        <para xml:id="ssec-gnome-common-issues-unwrappable-package-gsettings-c">
-         <link xlink:href="https://github.com/NixOS/nixpkgs/blob/29c120c065d03b000224872251bed93932d42412/pkgs/development/libraries/glib-networking/default.nix#L31-L34">Hard-coding GSettings schema path in C library</link> – nothing special other than using <link xlink:href="https://github.com/NixOS/nixpkgs/pull/67957#issuecomment-527717467">Coccinelle patch</link> to generate the patch itself.
-        </para>
-       </listitem>
-      </itemizedlist>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="ssec-gnome-common-issues-weird-location">
-    <term>
-     I need to wrap a binary outside <filename>bin</filename> and <filename>libexec</filename> directories.
-    </term>
-    <listitem>
-     <para>
-      You can manually trigger the wrapping with <function>wrapGApp</function> in <literal>preFixup</literal> phase. It takes a path to a program as a first argument; the remaining arguments are passed directly to <function xlink:href="#fun-wrapProgram">wrapProgram</function> function.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
- </section>
-</section>
diff --git a/doc/languages-frameworks/go.section.md b/doc/languages-frameworks/go.section.md
new file mode 100644
index 00000000000..b20a8d0c354
--- /dev/null
+++ b/doc/languages-frameworks/go.section.md
@@ -0,0 +1,143 @@
+# Go {#sec-language-go}
+
+## Go modules {#ssec-language-go}
+
+The function `buildGoModule` builds Go programs managed with Go modules. It builds a [Go Modules](https://github.com/golang/go/wiki/Modules) through a two phase build:
+
+- An intermediate fetcher derivation. This derivation will be used to fetch all of the dependencies of the Go module.
+- A final derivation will use the output of the intermediate derivation to build the binaries and produce the final output.
+
+### Example for `buildGoModule` {#ex-buildGoModule}
+
+In the following is an example expression using `buildGoModule`, the following arguments are of special significance to the function:
+
+- `vendorSha256`: is the hash of the output of the intermediate fetcher derivation. `vendorSha256` can also take `null` as an input. When `null` is used as a value, rather than fetching the dependencies and vendoring them, we use the vendoring included within the source repo. If you'd like to not have to update this field on dependency changes, run `go mod vendor` in your source repo and set `vendorSha256 = null;`
+- `runVend`: runs the vend command to generate the vendor directory. This is useful if your code depends on c code and go mod tidy does not include the needed sources to build.
+
+```nix
+pet = buildGoModule rec {
+  pname = "pet";
+  version = "0.3.4";
+
+  src = fetchFromGitHub {
+    owner = "knqyf263";
+    repo = "pet";
+    rev = "v${version}";
+    sha256 = "0m2fzpqxk7hrbxsgqplkg7h2p7gv6s1miymv3gvw0cz039skag0s";
+  };
+
+  vendorSha256 = "1879j77k96684wi554rkjxydrj8g3hpp0kvxz03sd8dmwr3lh83j";
+
+  runVend = true;
+
+  meta = with lib; {
+    description = "Simple command-line snippet manager, written in Go";
+    homepage = "https://github.com/knqyf263/pet";
+    license = licenses.mit;
+    maintainers = with maintainers; [ kalbasit ];
+    platforms = platforms.linux ++ platforms.darwin;
+  };
+}
+```
+
+## `buildGoPackage` (legacy) {#ssec-go-legacy}
+
+The function `buildGoPackage` builds legacy Go programs, not supporting Go modules.
+
+### Example for `buildGoPackage` {#example-for-buildgopackage}
+
+In the following is an example expression using buildGoPackage, the following arguments are of special significance to the function:
+
+- `goPackagePath` specifies the package's canonical Go import path.
+- `goDeps` is where the Go dependencies of a Go program are listed as a list of package source identified by Go import path. It could be imported as a separate `deps.nix` file for readability. The dependency data structure is described below.
+
+```nix
+deis = buildGoPackage rec {
+  pname = "deis";
+  version = "1.13.0";
+
+  goPackagePath = "github.com/deis/deis";
+
+  src = fetchFromGitHub {
+    owner = "deis";
+    repo = "deis";
+    rev = "v${version}";
+    sha256 = "1qv9lxqx7m18029lj8cw3k7jngvxs4iciwrypdy0gd2nnghc68sw";
+  };
+
+  goDeps = ./deps.nix;
+}
+```
+
+The `goDeps` attribute can be imported from a separate `nix` file that defines which Go libraries are needed and should be included in `GOPATH` for `buildPhase`:
+
+```nix
+# deps.nix
+[ # goDeps is a list of Go dependencies.
+  {
+    # goPackagePath specifies Go package import path.
+    goPackagePath = "gopkg.in/yaml.v2";
+    fetch = {
+      # `fetch type` that needs to be used to get package source.
+      # If `git` is used there should be `url`, `rev` and `sha256` defined next to it.
+      type = "git";
+      url = "https://gopkg.in/yaml.v2";
+      rev = "a83829b6f1293c91addabc89d0571c246397bbf4";
+      sha256 = "1m4dsmk90sbi17571h6pld44zxz7jc4lrnl4f27dpd1l8g5xvjhh";
+    };
+  }
+  {
+    goPackagePath = "github.com/docopt/docopt-go";
+    fetch = {
+      type = "git";
+      url = "https://github.com/docopt/docopt-go";
+      rev = "784ddc588536785e7299f7272f39101f7faccc3f";
+      sha256 = "0wwz48jl9fvl1iknvn9dqr4gfy1qs03gxaikrxxp9gry6773v3sj";
+    };
+  }
+]
+```
+
+To extract dependency information from a Go package in automated way use [go2nix](https://github.com/kamilchm/go2nix). It can produce complete derivation and `goDeps` file for Go programs.
+
+You may use Go packages installed into the active Nix profiles by adding the following to your ~/.bashrc:
+
+```bash
+for p in $NIX_PROFILES; do
+    GOPATH="$p/share/go:$GOPATH"
+done
+```
+
+## Attributes used by the builders {#ssec-go-common-attributes}
+
+Both `buildGoModule` and `buildGoPackage` can be tweaked to behave slightly differently, if the following attributes are used:
+
+### `buildFlagsArray` and `buildFlags`: {#ex-goBuildFlags-noarray}
+
+These attributes set build flags supported by `go build`. We recommend using `buildFlagsArray`.
+
+```nix
+  buildFlagsArray = [
+    "-tags=release"
+  ];
+```
+
+### `ldflags` {#var-go-ldflags}
+
+Arguments to pass to the Go linker tool via the `-ldflags` argument of `go build`. The most common use case for this argument is to make the resulting executable aware of its own version. For example:
+
+```nix
+  ldflags = [
+    "-s" "-w"
+    "-X main.Version=${version}"
+    "-X main.Commit=${version}"
+  ];
+```
+
+### `deleteVendor` {#var-go-deleteVendor}
+
+Removes the pre-existing vendor directory. This should only be used if the dependencies included in the vendor folder are broken or incomplete.
+
+### `subPackages` {#var-go-subPackages}
+
+Limits the builder from building child packages that have not been listed. If `subPackages` is not specified, all child packages will be built.
diff --git a/doc/languages-frameworks/go.xml b/doc/languages-frameworks/go.xml
deleted file mode 100644
index 26414f23c7d..00000000000
--- a/doc/languages-frameworks/go.xml
+++ /dev/null
@@ -1,217 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-language-go">
- <title>Go</title>
-
- <section xml:id="ssec-go-modules">
-  <title>Go modules</title>
-
-  <para>
-   The function <varname> buildGoModule </varname> builds Go programs managed with Go modules. It builds a <link xlink:href="https://github.com/golang/go/wiki/Modules">Go modules</link> through a two phase build:
-   <itemizedlist>
-    <listitem>
-     <para>
-      An intermediate fetcher derivation. This derivation will be used to fetch all of the dependencies of the Go module.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      A final derivation will use the output of the intermediate derivation to build the binaries and produce the final output.
-     </para>
-    </listitem>
-   </itemizedlist>
-  </para>
-
-  <example xml:id='ex-buildGoModule'>
-   <title>buildGoModule</title>
-<programlisting>
-pet = buildGoModule rec {
-  pname = "pet";
-  version = "0.3.4";
-
-  src = fetchFromGitHub {
-    owner = "knqyf263";
-    repo = "pet";
-    rev = "v${version}";
-    sha256 = "0m2fzpqxk7hrbxsgqplkg7h2p7gv6s1miymv3gvw0cz039skag0s";
-  };
-
-  vendorSha256 = "1879j77k96684wi554rkjxydrj8g3hpp0kvxz03sd8dmwr3lh83j"; <co xml:id='ex-buildGoModule-1' />
-
-  subPackages = [ "." ]; <co xml:id='ex-buildGoModule-2' />
-
-  deleteVendor = true; <co xml:id='ex-buildGoModule-3' />
-
-  runVend = true; <co xml:id='ex-buildGoModule-4' />
-
-  meta = with lib; {
-    description = "Simple command-line snippet manager, written in Go";
-    homepage = "https://github.com/knqyf263/pet";
-    license = licenses.mit;
-    maintainers = with maintainers; [ kalbasit ];
-    platforms = platforms.linux ++ platforms.darwin;
-  };
-}
-</programlisting>
-  </example>
-
-  <para>
-   <xref linkend='ex-buildGoModule'/> is an example expression using buildGoModule, the following arguments are of special significance to the function:
-   <calloutlist>
-    <callout arearefs='ex-buildGoModule-1'>
-     <para>
-      <varname>vendorSha256</varname> is the hash of the output of the intermediate fetcher derivation.
-     </para>
-    </callout>
-    <callout arearefs='ex-buildGoModule-2'>
-     <para>
-      <varname>subPackages</varname> limits the builder from building child packages that have not been listed. If <varname>subPackages</varname> is not specified, all child packages will be built.
-     </para>
-    </callout>
-    <callout arearefs='ex-buildGoModule-3'>
-     <para>
-      <varname>deleteVendor</varname> removes the pre-existing vendor directory and fetches the dependencies. This should only be used if the dependencies included in the vendor folder are broken or incomplete.
-     </para>
-    </callout>
-    <callout arearefs='ex-buildGoModule-4'>
-     <para>
-      <varname>runVend</varname> runs the vend command to generate the vendor directory. This is useful if your code depends on c code and go mod tidy does not include the needed sources to build.
-     </para>
-    </callout>
-   </calloutlist>
-  </para>
-
-  <para>
-    <varname>vendorSha256</varname> can also take <varname>null</varname> as an input.
-
-    When `null` is used as a value, rather than fetching the dependencies
-    and vendoring them, we use the vendoring included within the source repo.
-    If you'd like to not have to update this field on dependency changes,
-    run `go mod vendor` in your source repo and set 'vendorSha256 = null;'
-  </para>
- </section>
-
- <section xml:id="ssec-go-legacy">
-  <title>Go legacy</title>
-
-  <para>
-   The function <varname> buildGoPackage </varname> builds legacy Go programs, not supporting Go modules.
-  </para>
-
-  <example xml:id='ex-buildGoPackage'>
-   <title>buildGoPackage</title>
-<programlisting>
-deis = buildGoPackage rec {
-  pname = "deis";
-  version = "1.13.0";
-
-  goPackagePath = "github.com/deis/deis"; <co xml:id='ex-buildGoPackage-1' />
-  subPackages = [ "client" ]; <co xml:id='ex-buildGoPackage-2' />
-
-  src = fetchFromGitHub {
-    owner = "deis";
-    repo = "deis";
-    rev = "v${version}";
-    sha256 = "1qv9lxqx7m18029lj8cw3k7jngvxs4iciwrypdy0gd2nnghc68sw";
-  };
-
-  goDeps = ./deps.nix; <co xml:id='ex-buildGoPackage-3' />
-
-  buildFlags = [ "--tags" "release" ]; <co xml:id='ex-buildGoPackage-4' />
-}
-</programlisting>
-  </example>
-
-  <para>
-   <xref linkend='ex-buildGoPackage'/> is an example expression using buildGoPackage, the following arguments are of special significance to the function:
-   <calloutlist>
-    <callout arearefs='ex-buildGoPackage-1'>
-     <para>
-      <varname>goPackagePath</varname> specifies the package's canonical Go import path.
-     </para>
-    </callout>
-    <callout arearefs='ex-buildGoPackage-2'>
-     <para>
-      <varname>subPackages</varname> limits the builder from building child packages that have not been listed. If <varname>subPackages</varname> is not specified, all child packages will be built.
-     </para>
-     <para>
-      In this example only <literal>github.com/deis/deis/client</literal> will be built.
-     </para>
-    </callout>
-    <callout arearefs='ex-buildGoPackage-3'>
-     <para>
-      <varname>goDeps</varname> is where the Go dependencies of a Go program are listed as a list of package source identified by Go import path. It could be imported as a separate <varname>deps.nix</varname> file for readability. The dependency data structure is described below.
-     </para>
-    </callout>
-    <callout arearefs='ex-buildGoPackage-4'>
-     <para>
-      <varname>buildFlags</varname> is a list of flags passed to the go build command.
-     </para>
-    </callout>
-   </calloutlist>
-  </para>
-
-  <para>
-   The <varname>goDeps</varname> attribute can be imported from a separate <varname>nix</varname> file that defines which Go libraries are needed and should be included in <varname>GOPATH</varname> for <varname>buildPhase</varname>.
-  </para>
-
-  <example xml:id='ex-goDeps'>
-   <title>deps.nix</title>
-<programlisting>
-[ <co xml:id='ex-goDeps-1' />
-  {
-    goPackagePath = "gopkg.in/yaml.v2"; <co xml:id='ex-goDeps-2' />
-    fetch = {
-      type = "git"; <co xml:id='ex-goDeps-3' />
-      url = "https://gopkg.in/yaml.v2";
-      rev = "a83829b6f1293c91addabc89d0571c246397bbf4";
-      sha256 = "1m4dsmk90sbi17571h6pld44zxz7jc4lrnl4f27dpd1l8g5xvjhh";
-    };
-  }
-  {
-    goPackagePath = "github.com/docopt/docopt-go";
-    fetch = {
-      type = "git";
-      url = "https://github.com/docopt/docopt-go";
-      rev = "784ddc588536785e7299f7272f39101f7faccc3f";
-      sha256 = "0wwz48jl9fvl1iknvn9dqr4gfy1qs03gxaikrxxp9gry6773v3sj";
-    };
-  }
-]
-</programlisting>
-  </example>
-
-  <para>
-   <calloutlist>
-    <callout arearefs='ex-goDeps-1'>
-     <para>
-      <varname>goDeps</varname> is a list of Go dependencies.
-     </para>
-    </callout>
-    <callout arearefs='ex-goDeps-2'>
-     <para>
-      <varname>goPackagePath</varname> specifies Go package import path.
-     </para>
-    </callout>
-    <callout arearefs='ex-goDeps-3'>
-     <para>
-      <varname>fetch type</varname> that needs to be used to get package source. If <varname>git</varname> is used there should be <varname>url</varname>, <varname>rev</varname> and <varname>sha256</varname> defined next to it.
-     </para>
-    </callout>
-   </calloutlist>
-  </para>
-
-  <para>
-   To extract dependency information from a Go package in automated way use <link xlink:href="https://github.com/kamilchm/go2nix">go2nix</link>. It can produce complete derivation and <varname>goDeps</varname> file for Go programs.
-  </para>
-
-  <para>
-   You may use Go packages installed into the active Nix profiles by adding the following to your ~/.bashrc:
-<screen>
-for p in $NIX_PROFILES; do
-    GOPATH="$p/share/go:$GOPATH"
-done
-</screen>
-  </para>
- </section>
-</section>
diff --git a/doc/languages-frameworks/haskell.section.md b/doc/languages-frameworks/haskell.section.md
index cba4d0561b0..1fda505a225 100644
--- a/doc/languages-frameworks/haskell.section.md
+++ b/doc/languages-frameworks/haskell.section.md
@@ -1,1094 +1,7 @@
----
-title: User's Guide for Haskell in Nixpkgs
-author: Peter Simons
-date: 2015-06-01
----
-# Haskell
+# Haskell {#haskell}
 
-
-## How to install Haskell packages
-
-Nixpkgs distributes build instructions for all Haskell packages registered on
-[Hackage](http://hackage.haskell.org/), but strangely enough normal Nix package
-lookups don't seem to discover any of them, except for the default version of ghc, cabal-install, and stack:
-```
-$ nix-env -i alex
-error: selector ‘alex’ matches no derivations
-$ nix-env -qa ghc
-ghc-7.10.2
-```
-
-The Haskell package set is not registered in the top-level namespace because it
-is *huge*. If all Haskell packages were visible to these commands, then
-name-based search/install operations would be much slower than they are now. We
-avoided that by keeping all Haskell-related packages in a separate attribute
-set called `haskellPackages`, which the following command will list:
-```
-$ nix-env -f "<nixpkgs>" -qaP -A haskellPackages
-haskellPackages.a50                                             a50-0.5
-haskellPackages.AAI                                             AAI-0.2.0.1
-haskellPackages.abacate                                         abacate-0.0.0.0
-haskellPackages.abc-puzzle                                      abc-puzzle-0.2.1
-haskellPackages.abcBridge                                       abcBridge-0.15
-haskellPackages.abcnotation                                     abcnotation-1.9.0
-haskellPackages.abeson                                          abeson-0.1.0.1
-[... some 14000 entries omitted  ...]
-```
-
-To install any of those packages into your profile, refer to them by their
-attribute path (first column):
-```shell
-nix-env -f "<nixpkgs>" -iA haskellPackages.Allure ...
-```
-
-The attribute path of any Haskell packages corresponds to the name of that
-particular package on Hackage: the package `cabal-install` has the attribute
-`haskellPackages.cabal-install`, and so on. (Actually, this convention causes
-trouble with packages like `3dmodels` and `4Blocks`, because these names are
-invalid identifiers in the Nix language. The issue of how to deal with these
-rare corner cases is currently unresolved.)
-
-Haskell packages whose Nix name (second column) begins with a `haskell-` prefix
-are packages that provide a library whereas packages without that prefix
-provide just executables. Libraries may provide executables too, though: the
-package `haskell-pandoc`, for example, installs both a library and an
-application. You can install and use Haskell executables just like any other
-program in Nixpkgs, but using Haskell libraries for development is a bit
-trickier and we'll address that subject in great detail in section [How to
-create a development environment](#how-to-create-a-development-environment).
-
-Attribute paths are deterministic inside of Nixpkgs, but the path necessary to
-reach Nixpkgs varies from system to system. We dodged that problem by giving
-`nix-env` an explicit `-f "<nixpkgs>"` parameter, but if you call `nix-env`
-without that flag, then chances are the invocation fails:
-```
-$ nix-env -iA haskellPackages.cabal-install
-error: attribute ‘haskellPackages’ in selection path
-       ‘haskellPackages.cabal-install’ not found
-```
-
-On NixOS, for example, Nixpkgs does *not* exist in the top-level namespace by
-default. To figure out the proper attribute path, it's easiest to query for the
-path of a well-known Nixpkgs package, i.e.:
-```
-$ nix-env -qaP coreutils
-nixos.coreutils  coreutils-8.23
-```
-
-If your system responds like that (most NixOS installations will), then the
-attribute path to `haskellPackages` is `nixos.haskellPackages`. Thus, if you
-want to use `nix-env` without giving an explicit `-f` flag, then that's the way
-to do it:
-```shell
-nix-env -qaP -A nixos.haskellPackages
-nix-env -iA nixos.haskellPackages.cabal-install
-```
-
-Our current default compiler is GHC 8.8.x and the `haskellPackages` set
-contains packages built with that particular version. Nixpkgs contains the last
-three major releases of GHC and there is a whole family of package sets
-available that defines Hackage packages built with each of those compilers,
-too:
-```shell
-nix-env -f "<nixpkgs>" -qaP -A haskell.packages.ghc865
-nix-env -f "<nixpkgs>" -qaP -A haskell.packages.ghc8101
-```
-
-The name `haskellPackages` is really just a synonym for
-`haskell.packages.ghc882`, because we prefer that package set internally and
-recommend it to our users as their default choice, but ultimately you are free
-to compile your Haskell packages with any GHC version you please. The following
-command displays the complete list of available compilers:
-```
-$ nix-env -f "<nixpkgs>" -qaP -A haskell.compiler
-haskell.compiler.ghc8101                 ghc-8.10.1
-haskell.compiler.integer-simple.ghc8101  ghc-8.10.1
-haskell.compiler.ghcHEAD                 ghc-8.11.20200505
-haskell.compiler.integer-simple.ghcHEAD  ghc-8.11.20200505
-haskell.compiler.ghc822Binary            ghc-8.2.2-binary
-haskell.compiler.ghc844                  ghc-8.4.4
-haskell.compiler.ghc863Binary            ghc-8.6.3-binary
-haskell.compiler.ghc865                  ghc-8.6.5
-haskell.compiler.integer-simple.ghc865   ghc-8.6.5
-haskell.compiler.ghc882                  ghc-8.8.2
-haskell.compiler.integer-simple.ghc882   ghc-8.8.2
-haskell.compiler.ghc883                  ghc-8.8.3
-haskell.compiler.integer-simple.ghc883   ghc-8.8.3
-haskell.compiler.ghcjs                   ghcjs-8.6.0.1
-```
-
-We have no package sets for `jhc` or `uhc` yet, unfortunately, but for every
-version of GHC listed above, there exists a package set based on that compiler.
-Also, the attributes `haskell.compiler.ghcXYC` and
-`haskell.packages.ghcXYC.ghc` are synonymous for the sake of convenience.
-
-## How to create a development environment
-
-### How to install a compiler
-
-A simple development environment consists of a Haskell compiler and one or both
-of the tools `cabal-install` and `stack`. We saw in section
-[How to install Haskell packages](#how-to-install-haskell-packages) how you can install those programs into your
-user profile:
-```shell
-nix-env -f "<nixpkgs>" -iA haskellPackages.ghc haskellPackages.cabal-install
-```
-
-Instead of the default package set `haskellPackages`, you can also use the more
-precise name `haskell.compiler.ghc7102`, which has the advantage that it refers
-to the same GHC version regardless of what Nixpkgs considers "default" at any
-given time.
-
-Once you've made those tools available in `$PATH`, it's possible to build
-Hackage packages the same way people without access to Nix do it all the time:
-```shell
-cabal get lens-4.11 && cd lens-4.11
-cabal install -j --dependencies-only
-cabal configure
-cabal build
-```
-
-If you enjoy working with Cabal sandboxes, then that's entirely possible too:
-just execute the command
-```shell
-cabal sandbox init
-```
-before installing the required dependencies.
-
-The `nix-shell` utility makes it easy to switch to a different compiler
-version; just enter the Nix shell environment with the command
-```shell
-nix-shell -p haskell.compiler.ghc784
-```
-to bring GHC 7.8.4 into `$PATH`. Alternatively, you can use Stack instead of
-`nix-shell` directly to select compiler versions and other build tools
-per-project. It uses `nix-shell` under the hood when Nix support is turned on.
-See [How to build a Haskell project using Stack](#how-to-build-a-haskell-project-using-stack).
-
-If you're using `cabal-install`, re-running `cabal configure` inside the spawned
-shell switches your build to use that compiler instead. If you're working on
-a project that doesn't depend on any additional system libraries outside of GHC,
-then it's even sufficient to just run the `cabal configure` command inside of
-the shell:
-```shell
-nix-shell -p haskell.compiler.ghc784 --command "cabal configure"
-```
-
-Afterwards, all other commands like `cabal build` work just fine in any shell
-environment, because the configure phase recorded the absolute paths to all
-required tools like GHC in its build configuration inside of the `dist/`
-directory. Please note, however, that `nix-collect-garbage` can break such an
-environment because the Nix store paths created by `nix-shell` aren't "alive"
-anymore once `nix-shell` has terminated. If you find that your Haskell builds
-no longer work after garbage collection, then you'll have to re-run `cabal
-configure` inside of a new `nix-shell` environment.
-
-### How to install a compiler with libraries
-
-GHC expects to find all installed libraries inside of its own `lib` directory.
-This approach works fine on traditional Unix systems, but it doesn't work for
-Nix, because GHC's store path is immutable once it's built. We cannot install
-additional libraries into that location. As a consequence, our copies of GHC
-don't know any packages except their own core libraries, like `base`,
-`containers`, `Cabal`, etc.
-
-We can register additional libraries to GHC, however, using a special build
-function called `ghcWithPackages`. That function expects one argument: a
-function that maps from an attribute set of Haskell packages to a list of
-packages, which determines the libraries known to that particular version of
-GHC. For example, the Nix expression `ghcWithPackages (pkgs: [pkgs.mtl])`
-generates a copy of GHC that has the `mtl` library registered in addition to
-its normal core packages:
-```
-$ nix-shell -p "haskellPackages.ghcWithPackages (pkgs: [pkgs.mtl])"
-
-[nix-shell:~]$ ghc-pkg list mtl
-/nix/store/zy79...-ghc-7.10.2/lib/ghc-7.10.2/package.conf.d:
-    mtl-2.2.1
-```
-
-This function allows users to define their own development environment by means
-of an override. After adding the following snippet to `~/.config/nixpkgs/config.nix`,
-```nix
-{
-  packageOverrides = super: let self = super.pkgs; in
-  {
-    myHaskellEnv = self.haskell.packages.ghc7102.ghcWithPackages
-                     (haskellPackages: with haskellPackages; [
-                       # libraries
-                       arrows async cgi criterion
-                       # tools
-                       cabal-install haskintex
-                     ]);
-  };
-}
-```
-it's possible to install that compiler with `nix-env -f "<nixpkgs>" -iA
-myHaskellEnv`. If you'd like to switch that development environment to a
-different version of GHC, just replace the `ghc7102` bit in the previous
-definition with the appropriate name. Of course, it's also possible to define
-any number of these development environments! (You can't install two of them
-into the same profile at the same time, though, because that would result in
-file conflicts.)
-
-The generated `ghc` program is a wrapper script that re-directs the real
-GHC executable to use a new `lib` directory --- one that we specifically
-constructed to contain all those packages the user requested:
-```
-$ cat $(type -p ghc)
-#! /nix/store/xlxj...-bash-4.3-p33/bin/bash -e
-export NIX_GHC=/nix/store/19sm...-ghc-7.10.2/bin/ghc
-export NIX_GHCPKG=/nix/store/19sm...-ghc-7.10.2/bin/ghc-pkg
-export NIX_GHC_DOCDIR=/nix/store/19sm...-ghc-7.10.2/share/doc/ghc/html
-export NIX_GHC_LIBDIR=/nix/store/19sm...-ghc-7.10.2/lib/ghc-7.10.2
-exec /nix/store/j50p...-ghc-7.10.2/bin/ghc "-B$NIX_GHC_LIBDIR" "$@"
-```
-
-The variables `$NIX_GHC`, `$NIX_GHCPKG`, etc. point to the *new* store path
-`ghcWithPackages` constructed specifically for this environment. The last line
-of the wrapper script then executes the real `ghc`, but passes the path to the
-new `lib` directory using GHC's `-B` flag.
-
-The purpose of those environment variables is to work around an impurity in the
-popular [ghc-paths](http://hackage.haskell.org/package/ghc-paths) library. That
-library promises to give its users access to GHC's installation paths. Only,
-the library can't possible know that path when it's compiled, because the path
-GHC considers its own is determined only much later, when the user configures
-it through `ghcWithPackages`. So we [patched
-ghc-paths](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/patches/ghc-paths-nix.patch)
-to return the paths found in those environment variables at run-time rather
-than trying to guess them at compile-time.
-
-To make sure that mechanism works properly all the time, we recommend that you
-set those variables to meaningful values in your shell environment, too, i.e.
-by adding the following code to your `~/.bashrc`:
-```bash
-if type >/dev/null 2>&1 -p ghc; then
-  eval "$(egrep ^export "$(type -p ghc)")"
-fi
-```
-
-If you are certain that you'll use only one GHC environment which is located in
-your user profile, then you can use the following code, too, which has the
-advantage that it doesn't contain any paths from the Nix store, i.e. those
-settings always remain valid even if a `nix-env -u` operation updates the GHC
-environment in your profile:
-```bash
-if [ -e ~/.nix-profile/bin/ghc ]; then
-  export NIX_GHC="$HOME/.nix-profile/bin/ghc"
-  export NIX_GHCPKG="$HOME/.nix-profile/bin/ghc-pkg"
-  export NIX_GHC_DOCDIR="$HOME/.nix-profile/share/doc/ghc/html"
-  export NIX_GHC_LIBDIR="$HOME/.nix-profile/lib/ghc-$($NIX_GHC --numeric-version)"
-fi
-```
-
-### How to install a compiler with libraries, hoogle and documentation indexes
-
-If you plan to use your environment for interactive programming, not just
-compiling random Haskell code, you might want to replace `ghcWithPackages` in
-all the listings above with `ghcWithHoogle`.
-
-This environment generator not only produces an environment with GHC and all
-the specified libraries, but also generates a `hoogle` and `haddock` indexes
-for all the packages, and provides a wrapper script around `hoogle` binary that
-uses all those things. A precise name for this thing would be
-"`ghcWithPackagesAndHoogleAndDocumentationIndexes`", which is, regrettably, too
-long and scary.
-
-For example, installing the following environment
-```nix
-{
-  packageOverrides = super: let self = super.pkgs; in
-  {
-    myHaskellEnv = self.haskellPackages.ghcWithHoogle
-                     (haskellPackages: with haskellPackages; [
-                       # libraries
-                       arrows async cgi criterion
-                       # tools
-                       cabal-install haskintex
-                     ]);
-  };
-}
-```
-allows one to browse module documentation index [not too dissimilar to
-this](https://downloads.haskell.org/~ghc/latest/docs/html/libraries/index.html)
-for all the specified packages and their dependencies by directing a browser of
-choice to `~/.nix-profile/share/doc/hoogle/index.html` (or
-`/run/current-system/sw/share/doc/hoogle/index.html` in case you put it in
-`environment.systemPackages` in NixOS).
-
-After you've marveled enough at that try adding the following to your
-`~/.ghc/ghci.conf`
-```
-:def hoogle \s -> return $ ":! hoogle search -cl --count=15 \"" ++ s ++ "\""
-:def doc \s -> return $ ":! hoogle search -cl --info \"" ++ s ++ "\""
-```
-and test it by typing into `ghci`:
-```
-:hoogle a -> a
-:doc a -> a
-```
-
-Be sure to note the links to `haddock` files in the output. With any modern and
-properly configured terminal emulator you can just click those links to
-navigate there.
-
-Finally, you can run
-```shell
-hoogle server --local -p 8080
-```
-and navigate to http://localhost:8080/ for your own local
-[Hoogle](https://www.haskell.org/hoogle/). The `--local` flag makes the hoogle
-server serve files from your nix store over http, without the flag it will use
-`file://` URIs. Note, however, that Firefox and possibly other browsers
-disallow navigation from `http://` to `file://` URIs for security reasons,
-which might be quite an inconvenience. Versions before v5 did not have this
-flag. See
-[this page](http://kb.mozillazine.org/Links_to_local_pages_do_not_work) for
-workarounds.
-
-For NixOS users there's a service which runs this exact command for you.
-Specify the `packages` you want documentation for and the `haskellPackages` set
-you want them to come from. Add the following to `configuration.nix`.
-
-```nix
-services.hoogle = {
-  enable = true;
-  packages = (hpkgs: with hpkgs; [text cryptonite]);
-  haskellPackages = pkgs.haskellPackages;
-};
-```
-
-### How to build a Haskell project using Stack
-
-[Stack](http://haskellstack.org) is a popular build tool for Haskell projects.
-It has first-class support for Nix. Stack can optionally use Nix to
-automatically select the right version of GHC and other build tools to build,
-test and execute apps in an existing project downloaded from somewhere on the
-Internet. Pass the `--nix` flag to any `stack` command to do so, e.g.
-```shell
-git clone --recurse-submodules https://github.com/yesodweb/wai.git
-cd wai
-stack --nix build
-```
-
-If you want `stack` to use Nix by default, you can add a `nix` section to the
-`stack.yaml` file, as explained in the [Stack documentation][stack-nix-doc]. For
-example:
-```yaml
-nix:
-  enable: true
-  packages: [pkgconfig zeromq zlib]
-```
-
-The example configuration snippet above tells Stack to create an ad hoc
-environment for `nix-shell` as in the below section, in which the `pkgconfig`,
-`zeromq` and `zlib` packages from Nixpkgs are available. All `stack` commands
-will implicitly be executed inside this ad hoc environment.
-
-Some projects have more sophisticated needs. For examples, some ad hoc
-environments might need to expose Nixpkgs packages compiled in a certain way, or
-with extra environment variables. In these cases, you'll need a `shell` field
-instead of `packages`:
-```yaml
-nix:
-  enable: true
-  shell-file: shell.nix
-```
-
-For more on how to write a `shell.nix` file see the below section. You'll need
-to express a derivation. Note that Nixpkgs ships with a convenience wrapper
-function around `mkDerivation` called `haskell.lib.buildStackProject` to help you
-create this derivation in exactly the way Stack expects. However for this to work
-you need to disable the sandbox, which you can do by using `--option sandbox relaxed`
-or `--option sandbox false` to the Nix command. All of the same inputs
-as `mkDerivation` can be provided. For example, to build a Stack project that
-including packages that link against a version of the R library compiled with
-special options turned on:
-```nix
-with (import <nixpkgs> { });
-
-let R = pkgs.R.override { enableStrictBarrier = true; };
-in
-haskell.lib.buildStackProject {
-  name = "HaskellR";
-  buildInputs = [ R zeromq zlib ];
-}
-```
-
-You can select a particular GHC version to compile with by setting the
-`ghc` attribute as an argument to `buildStackProject`. Better yet, let
-Stack choose what GHC version it wants based on the snapshot specified
-in `stack.yaml` (only works with Stack >= 1.1.3):
-```nix
-{nixpkgs ? import <nixpkgs> { }, ghc ? nixpkgs.ghc}:
-
-with nixpkgs;
-
-let R = pkgs.R.override { enableStrictBarrier = true; };
-in
-haskell.lib.buildStackProject {
-  name = "HaskellR";
-  buildInputs = [ R zeromq zlib ];
-  inherit ghc;
-}
-```
-
-[stack-nix-doc]: http://docs.haskellstack.org/en/stable/nix_integration.html
-
-### How to create ad hoc environments for `nix-shell`
-
-The easiest way to create an ad hoc development environment is to run
-`nix-shell` with the appropriate GHC environment given on the command-line:
-```shell
-nix-shell -p "haskellPackages.ghcWithPackages (pkgs: with pkgs; [mtl pandoc])"
-```
-
-For more sophisticated use-cases, however, it's more convenient to save the
-desired configuration in a file called `shell.nix` that looks like this:
-```nix
-{ nixpkgs ? import <nixpkgs> {}, compiler ? "ghc7102" }:
-let
-  inherit (nixpkgs) pkgs;
-  ghc = pkgs.haskell.packages.${compiler}.ghcWithPackages (ps: with ps; [
-          monad-par mtl
-        ]);
-in
-pkgs.stdenv.mkDerivation {
-  name = "my-haskell-env-0";
-  buildInputs = [ ghc ];
-  shellHook = "eval $(egrep ^export ${ghc}/bin/ghc)";
-}
-```
-
-Now run `nix-shell` --- or even `nix-shell --pure` --- to enter a shell
-environment that has the appropriate compiler in `$PATH`. If you use `--pure`,
-then add all other packages that your development environment needs into the
-`buildInputs` attribute. If you'd like to switch to a different compiler
-version, then pass an appropriate `compiler` argument to the expression, i.e.
-`nix-shell --argstr compiler ghc784`.
-
-If you need such an environment because you'd like to compile a Hackage package
-outside of Nix --- i.e. because you're hacking on the latest version from Git
----, then the package set provides suitable nix-shell environments for you
-already! Every Haskell package has an `env` attribute that provides a shell
-environment suitable for compiling that particular package. If you'd like to
-hack the `lens` library, for example, then you just have to check out the
-source code and enter the appropriate environment:
-```
-$ cabal get lens-4.11 && cd lens-4.11
-Downloading lens-4.11...
-Unpacking to lens-4.11/
-
-$ nix-shell "<nixpkgs>" -A haskellPackages.lens.env
-[nix-shell:/tmp/lens-4.11]$
-```
-
-At point, you can run `cabal configure`, `cabal build`, and all the other
-development commands. Note that you need `cabal-install` installed in your
-`$PATH` already to use it here --- the `nix-shell` environment does not provide
-it.
-
-## How to create Nix builds for your own private Haskell packages
-
-If your own Haskell packages have build instructions for Cabal, then you can
-convert those automatically into build instructions for Nix using the
-`cabal2nix` utility, which you can install into your profile by running
-`nix-env -i cabal2nix`.
-
-### How to build a stand-alone project
-
-For example, let's assume that you're working on a private project called
-`foo`. To generate a Nix build expression for it, change into the project's
-top-level directory and run the command:
-```shell
-cabal2nix . > foo.nix
-```
-Then write the following snippet into a file called `default.nix`:
-```nix
-{ nixpkgs ? import <nixpkgs> {}, compiler ? "ghc7102" }:
-nixpkgs.pkgs.haskell.packages.${compiler}.callPackage ./foo.nix { }
-```
-
-Finally, store the following code in a file called `shell.nix`:
-```nix
-{ nixpkgs ? import <nixpkgs> {}, compiler ? "ghc7102" }:
-(import ./default.nix { inherit nixpkgs compiler; }).env
-```
-
-At this point, you can run `nix-build` to have Nix compile your project and
-install it into a Nix store path. The local directory will contain a symlink
-called `result` after `nix-build` returns that points into that location. Of
-course, passing the flag `--argstr compiler ghc763` allows switching the build
-to any version of GHC currently supported.
-
-Furthermore, you can call `nix-shell` to enter an interactive development
-environment in which you can use `cabal configure` and `cabal build` to develop
-your code. That environment will automatically contain a proper GHC derivation
-with all the required libraries registered as well as all the system-level
-libraries your package might need.
-
-If your package does not depend on any system-level libraries, then it's
-sufficient to run
-```shell
-nix-shell --command "cabal configure"
-```
-once to set up your build. `cabal-install` determines the absolute paths to all
-resources required for the build and writes them into a config file in the
-`dist/` directory. Once that's done, you can run `cabal build` and any other
-command for that project even outside of the `nix-shell` environment. This
-feature is particularly nice for those of us who like to edit their code with
-an IDE, like Emacs' `haskell-mode`, because it's not necessary to start Emacs
-inside of nix-shell just to make it find out the necessary settings for
-building the project; `cabal-install` has already done that for us.
-
-If you want to do some quick-and-dirty hacking and don't want to bother setting
-up a `default.nix` and `shell.nix` file manually, then you can use the
-`--shell` flag offered by `cabal2nix` to have it generate a stand-alone
-`nix-shell` environment for you. With that feature, running
-```shell
-cabal2nix --shell . > shell.nix
-nix-shell --command "cabal configure"
-```
-is usually enough to set up a build environment for any given Haskell package.
-You can even use that generated file to run `nix-build`, too:
-```shell
-nix-build shell.nix
-```
-
-### How to build projects that depend on each other
-
-If you have multiple private Haskell packages that depend on each other, then
-you'll have to register those packages in the Nixpkgs set to make them visible
-for the dependency resolution performed by `callPackage`. First of all, change
-into each of your projects top-level directories and generate a `default.nix`
-file with `cabal2nix`:
-```shell
-cd ~/src/foo && cabal2nix . > default.nix
-cd ~/src/bar && cabal2nix . > default.nix
-```
-Then edit your `~/.config/nixpkgs/config.nix` file to register those builds in the
-default Haskell package set:
-```nix
-{
-  packageOverrides = super: let self = super.pkgs; in
-  {
-    haskellPackages = super.haskellPackages.override {
-      overrides = self: super: {
-        foo = self.callPackage ../src/foo {};
-        bar = self.callPackage ../src/bar {};
-      };
-    };
-  };
-}
-```
-Once that's accomplished, `nix-env -f "<nixpkgs>" -qA haskellPackages` will
-show your packages like any other package from Hackage, and you can build them
-```shell
-nix-build "<nixpkgs>" -A haskellPackages.foo
-```
-or enter an interactive shell environment suitable for building them:
-```shell
-nix-shell "<nixpkgs>" -A haskellPackages.bar.env
-```
-
-## Miscellaneous Topics
-
-### How to build with profiling enabled
-
-Every Haskell package set takes a function called `overrides` that you can use
-to manipulate the package as much as you please. One useful application of this
-feature is to replace the default `mkDerivation` function with one that enables
-library profiling for all packages. To accomplish that add the following
-snippet to your `~/.config/nixpkgs/config.nix` file:
-```nix
-{
-  packageOverrides = super: let self = super.pkgs; in
-  {
-    profiledHaskellPackages = self.haskellPackages.override {
-      overrides = self: super: {
-        mkDerivation = args: super.mkDerivation (args // {
-          enableLibraryProfiling = true;
-        });
-      };
-    };
-  };
-}
-```
-Then, replace instances of `haskellPackages` in the `cabal2nix`-generated
-`default.nix` or `shell.nix` files with `profiledHaskellPackages`.
-
-### How to override package versions in a compiler-specific package set
-
-Nixpkgs provides the latest version of
-[`ghc-events`](http://hackage.haskell.org/package/ghc-events), which is 0.4.4.0
-at the time of this writing. This is fine for users of GHC 7.10.x, but GHC
-7.8.4 cannot compile that binary. Now, one way to solve that problem is to
-register an older version of `ghc-events` in the 7.8.x-specific package set.
-The first step is to generate Nix build instructions with `cabal2nix`:
-```shell
-cabal2nix cabal://ghc-events-0.4.3.0 > ~/.nixpkgs/ghc-events-0.4.3.0.nix
-```
-Then add the override in `~/.config/nixpkgs/config.nix`:
-```nix
-{
-  packageOverrides = super: let self = super.pkgs; in
-  {
-    haskell = super.haskell // {
-      packages = super.haskell.packages // {
-        ghc784 = super.haskell.packages.ghc784.override {
-          overrides = self: super: {
-            ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {};
-          };
-        };
-      };
-    };
-  };
-}
-```
-
-This code is a little crazy, no doubt, but it's necessary because the intuitive
-version
-```nix
-{ # ...
-
-  haskell.packages.ghc784 = super.haskell.packages.ghc784.override {
-    overrides = self: super: {
-      ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {};
-    };
-  };
-}
-```
-doesn't do what we want it to: that code replaces the `haskell` package set in
-Nixpkgs with one that contains only one entry,`packages`, which contains only
-one entry `ghc784`. This override loses the `haskell.compiler` set, and it
-loses the `haskell.packages.ghcXYZ` sets for all compilers but GHC 7.8.4. To
-avoid that problem, we have to perform the convoluted little dance from above,
-iterating over each step in hierarchy.
-
-Once it's accomplished, however, we can install a variant of `ghc-events`
-that's compiled with GHC 7.8.4:
-```shell
-nix-env -f "<nixpkgs>" -iA haskell.packages.ghc784.ghc-events
-```
-Unfortunately, it turns out that this build fails again while executing the
-test suite! Apparently, the release archive on Hackage is missing some data
-files that the test suite requires, so we cannot run it. We accomplish that by
-re-generating the Nix expression with the `--no-check` flag:
-```shell
-cabal2nix --no-check cabal://ghc-events-0.4.3.0 > ~/.nixpkgs/ghc-events-0.4.3.0.nix
-```
-Now the builds succeeds.
-
-Of course, in the concrete example of `ghc-events` this whole exercise is not
-an ideal solution, because `ghc-events` can analyze the output emitted by any
-version of GHC later than 6.12 regardless of the compiler version that was used
-to build the `ghc-events` executable, so strictly speaking there's no reason to
-prefer one built with GHC 7.8.x in the first place. However, for users who
-cannot use GHC 7.10.x at all for some reason, the approach of downgrading to an
-older version might be useful.
-
-### How to override packages in all compiler-specific package sets
-
-In the previous section we learned how to override a package in a single
-compiler-specific package set. You may have some overrides defined that you want
-to use across multiple package sets. To accomplish this you could use the
-technique that we learned in the previous section by repeating the overrides for
-all the compiler-specific package sets. For example:
-
-```nix
-{
-  packageOverrides = super: let self = super.pkgs; in
-  {
-    haskell = super.haskell // {
-      packages = super.haskell.packages // {
-        ghc784 = super.haskell.packages.ghc784.override {
-          overrides = self: super: {
-            my-package = ...;
-            my-other-package = ...;
-          };
-        };
-        ghc822 = super.haskell.packages.ghc784.override {
-          overrides = self: super: {
-            my-package = ...;
-            my-other-package = ...;
-          };
-        };
-        ...
-      };
-    };
-  };
-}
-```
-
-However there's a more convenient way to override all compiler-specific package
-sets at once:
-
-```nix
-{
-  packageOverrides = super: let self = super.pkgs; in
-  {
-    haskell = super.haskell // {
-      packageOverrides = self: super: {
-        my-package = ...;
-        my-other-package = ...;
-      };
-    };
-  };
-}
-```
-
-### How to specify source overrides for your Haskell package
-
-When starting a Haskell project you can use `developPackage`
-to define a derivation for your package at the `root` path
-as well as source override versions for Hackage packages, like so:
-
-```nix
-# default.nix
-{ compilerVersion ? "ghc842" }:
-let
-  # pinning nixpkgs using new Nix 2.0 builtin `fetchGit`
-  pkgs = import (fetchGit (import ./version.nix)) { };
-  compiler = pkgs.haskell.packages."${compilerVersion}";
-  pkg = compiler.developPackage {
-    root = ./.;
-    source-overrides = {
-      # Let's say the GHC 8.4.2 haskellPackages uses 1.6.0.0 and your test suite is incompatible with >= 1.6.0.0
-      HUnit = "1.5.0.0";
-    };
-  };
-in pkg
-```
-
-This could be used in place of a simplified `stack.yaml` defining a Nix
-derivation for your Haskell package.
-
-As you can see this allows you to specify only the source version found on
-Hackage and nixpkgs will take care of the rest.
-
-You can also specify `buildInputs` for your Haskell derivation for packages
-that directly depend on external libraries like so:
-
-```nix
-# default.nix
-{ compilerVersion ? "ghc842" }:
-let
-  # pinning nixpkgs using new Nix 2.0 builtin `fetchGit`
-  pkgs = import (fetchGit (import ./version.nix)) { };
-  compiler = pkgs.haskell.packages."${compilerVersion}";
-  pkg = compiler.developPackage {
-    root = ./.;
-    source-overrides = {
-      HUnit = "1.5.0.0"; # Let's say the GHC 8.4.2 haskellPackages uses 1.6.0.0 and your test suite is incompatible with >= 1.6.0.0
-    };
-  };
-  # in case your package source depends on any libraries directly, not just transitively.
-  buildInputs = [ zlib ];
-in pkg.overrideAttrs(attrs: {
-  buildInputs = attrs.buildInputs ++ buildInputs;
-})
-```
-
-Notice that you will need to override (via `overrideAttrs` or similar) the
-derivation returned by the `developPackage` Nix lambda as there is no `buildInputs`
-named argument you can pass directly into the `developPackage` lambda.
-
-### How to recover from GHC's infamous non-deterministic library ID bug
-
-GHC and distributed build farms don't get along well:
-
-  - https://ghc.haskell.org/trac/ghc/ticket/4012
-
-When you see an error like this one
-```
-package foo-0.7.1.0 is broken due to missing package
-text-1.2.0.4-98506efb1b9ada233bb5c2b2db516d91
-```
-then you have to download and re-install `foo` and all its dependents from
-scratch:
-```shell
-nix-store -q --referrers /nix/store/*-haskell-text-1.2.0.4 \
-  | xargs -L 1 nix-store --repair-path
-```
-
-If you're using additional Hydra servers other than `hydra.nixos.org`, then it
-might be necessary to purge the local caches that store data from those
-machines to disable these binary channels for the duration of the previous
-command, i.e. by running:
-```shell
-rm ~/.cache/nix/binary-cache*.sqlite
-```
-
-### Builds on Darwin fail with `math.h` not found
-
-Users of GHC on Darwin have occasionally reported that builds fail, because the
-compiler complains about a missing include file:
-```
-fatal error: 'math.h' file not found
-```
-The issue has been discussed at length in [ticket
-6390](https://github.com/NixOS/nixpkgs/issues/6390), and so far no good
-solution has been proposed. As a work-around, users who run into this problem
-can configure the environment variables
-```shell
-export NIX_CFLAGS_COMPILE="-idirafter /usr/include"
-export NIX_CFLAGS_LINK="-L/usr/lib"
-```
-in their `~/.bashrc` file to avoid the compiler error.
-
-### Builds using Stack complain about missing system libraries
-
-```
---  While building package zlib-0.5.4.2 using:
-  runhaskell -package=Cabal-1.22.4.0 -clear-package-db [... lots of flags ...]
-Process exited with code: ExitFailure 1
-Logs have been written to: /home/foo/src/stack-ide/.stack-work/logs/zlib-0.5.4.2.log
-
-Configuring zlib-0.5.4.2...
-Setup.hs: Missing dependency on a foreign library:
-* Missing (or bad) header file: zlib.h
-This problem can usually be solved by installing the system package that
-provides this library (you may need the "-dev" version). If the library is
-already installed but in a non-standard location then you can use the flags
---extra-include-dirs= and --extra-lib-dirs= to specify where it is.
-If the header file does exist, it may contain errors that are caught by the C
-compiler at the preprocessing stage. In this case you can re-run configure
-with the verbosity flag -v3 to see the error messages.
-```
-
-When you run the build inside of the nix-shell environment, the system
-is configured to find `libz.so` without any special flags -- the compiler
-and linker "just know" how to find it. Consequently, Cabal won't record
-any search paths for `libz.so` in the package description, which means
-that the package works fine inside of nix-shell, but once you leave the
-shell the shared object can no longer be found. That issue is by no
-means specific to Stack: you'll have that problem with any other
-Haskell package that's built inside of nix-shell but run outside of that
-environment.
-
-You can remedy this issue in several ways. The easiest is to add a `nix` section
-to the `stack.yaml` like the following:
-```yaml
-nix:
-  enable: true
-  packages: [ zlib ]
-```
-
-Stack's Nix support knows to add `${zlib.out}/lib` and `${zlib.dev}/include`
-as an `--extra-lib-dirs` and `extra-include-dirs`, respectively.
-Alternatively, you can achieve the same effect by hand. First of all, run
-```
-$ nix-build --no-out-link "<nixpkgs>" -A zlib
-/nix/store/alsvwzkiw4b7ip38l4nlfjijdvg3fvzn-zlib-1.2.8
-```
-to find out the store path of the system's zlib library. Now, you can
-
-  1. add that path (plus a "/lib" suffix) to your `$LD_LIBRARY_PATH`
-    environment variable to make sure your system linker finds `libz.so`
-    automatically. It's no pretty solution, but it will work.
-
-  2. As a variant of (1), you can also install any number of system
-    libraries into your user's profile (or some other profile) and point
-    `$LD_LIBRARY_PATH` to that profile instead, so that you don't have to
-    list dozens of those store paths all over the place.
-
-  3. The solution I prefer is to call stack with an appropriate
-    --extra-lib-dirs flag like so:
-    ```shell
-    stack --extra-lib-dirs=/nix/store/alsvwzkiw4b7ip38l4nlfjijdvg3fvzn-zlib-1.2.8/lib build
-    ```
-
-Typically, you'll need `--extra-include-dirs` as well. It's possible
-to add those flag to the project's `stack.yaml` or your user's
-global `~/.stack/global/stack.yaml` file so that you don't have to
-specify them manually every time. But again, you're likely better off
-using Stack's Nix support instead.
-
-The same thing applies to `cabal configure`, of course, if you're
-building with `cabal-install` instead of Stack.
-
-### Creating statically linked binaries
-
-There are two levels of static linking. The first option is to configure the
-build with the Cabal flag `--disable-executable-dynamic`. In Nix expressions,
-this can be achieved by setting the attribute:
-```
-enableSharedExecutables = false;
-```
-That gives you a binary with statically linked Haskell libraries and
-dynamically linked system libraries.
-
-To link both Haskell libraries and system libraries statically, the additional
-flags `--ghc-option=-optl=-static --ghc-option=-optl=-pthread` need to be used.
-In Nix, this is accomplished with:
-```
-configureFlags = [ "--ghc-option=-optl=-static" "--ghc-option=-optl=-pthread" ];
-```
-
-It's important to realize, however, that most system libraries in Nix are
-built as shared libraries only, i.e. there is just no static library
-available that Cabal could link!
-
-### Building GHC with integer-simple
-
-By default GHC implements the Integer type using the
-[GNU Multiple Precision Arithmetic (GMP) library](https://gmplib.org/).
-The implementation can be found in the
-[integer-gmp](http://hackage.haskell.org/package/integer-gmp) package.
-
-A potential problem with this is that GMP is licensed under the
-[GNU Lesser General Public License (LGPL)](https://www.gnu.org/copyleft/lesser.html),
-a kind of "copyleft" license. According to the terms of the LGPL, paragraph 5,
-you may distribute a program that is designed to be compiled and dynamically
-linked with the library under the terms of your choice (i.e., commercially) but
-if your program incorporates portions of the library, if it is linked
-statically, then your program is a "derivative"--a "work based on the
-library"--and according to paragraph 2, section c, you "must cause the whole of
-the work to be licensed" under the terms of the LGPL (including for free).
-
-The LGPL licensing for GMP is a problem for the overall licensing of binary
-programs compiled with GHC because most distributions (and builds) of GHC use
-static libraries. (Dynamic libraries are currently distributed only for macOS.)
-The LGPL licensing situation may be worse: even though
-[The Glasgow Haskell Compiler License](https://www.haskell.org/ghc/license)
-is essentially a "free software" license (BSD3), according to
-paragraph 2 of the LGPL, GHC must be distributed under the terms of the LGPL!
-
-To work around these problems GHC can be build with a slower but LGPL-free
-alternative implementation for Integer called
-[integer-simple](http://hackage.haskell.org/package/integer-simple).
-
-To get a GHC compiler build with `integer-simple` instead of `integer-gmp` use
-the attribute: `haskell.compiler.integer-simple."${ghcVersion}"`.
-For example:
-```
-$ nix-build -E '(import <nixpkgs> {}).haskell.compiler.integer-simple.ghc802'
-...
-$ result/bin/ghc-pkg list | grep integer
-    integer-simple-0.1.1.1
-```
-The following command displays the complete list of GHC compilers build with `integer-simple`:
-```
-$ nix-env -f "<nixpkgs>" -qaP -A haskell.compiler.integer-simple
-haskell.compiler.integer-simple.ghc7102  ghc-7.10.2
-haskell.compiler.integer-simple.ghc7103  ghc-7.10.3
-haskell.compiler.integer-simple.ghc722   ghc-7.2.2
-haskell.compiler.integer-simple.ghc742   ghc-7.4.2
-haskell.compiler.integer-simple.ghc783   ghc-7.8.3
-haskell.compiler.integer-simple.ghc784   ghc-7.8.4
-haskell.compiler.integer-simple.ghc801   ghc-8.0.1
-haskell.compiler.integer-simple.ghc802   ghc-8.0.2
-haskell.compiler.integer-simple.ghcHEAD  ghc-8.1.20170106
-```
-
-To get a package set supporting `integer-simple` use the attribute:
-`haskell.packages.integer-simple."${ghcVersion}"`. For example
-use the following to get the `scientific` package build with `integer-simple`:
-```shell
-nix-build -A haskell.packages.integer-simple.ghc802.scientific
-```
-
-### Quality assurance
-
-The `haskell.lib` library includes a number of functions for checking for
-various imperfections in Haskell packages. It's useful to apply these functions
-to your own Haskell packages and integrate that in a Continuous Integration
-server like [hydra](https://nixos.org/hydra/) to assure your packages maintain a
-minimum level of quality. This section discusses some of these functions.
-
-#### failOnAllWarnings
-
-Applying `haskell.lib.failOnAllWarnings` to a Haskell package enables the
-`-Wall` and `-Werror` GHC options to turn all warnings into build failures.
-
-#### buildStrictly
-
-Applying `haskell.lib.buildStrictly` to a Haskell package calls
-`failOnAllWarnings` on the given package to turn all warnings into build
-failures. Additionally the source of your package is gotten from first invoking
-`cabal sdist` to ensure all needed files are listed in the Cabal file.
-
-#### checkUnusedPackages
-
-Applying `haskell.lib.checkUnusedPackages` to a Haskell package invokes
-the [packunused](http://hackage.haskell.org/package/packunused) tool on the
-package. `packunused` complains when it finds packages listed as build-depends
-in the Cabal file which are redundant. For example:
-
-```
-$ nix-build -E 'let pkgs = import <nixpkgs> {}; in pkgs.haskell.lib.checkUnusedPackages {} pkgs.haskellPackages.scientific'
-these derivations will be built:
-  /nix/store/3lc51cxj2j57y3zfpq5i69qbzjpvyci1-scientific-0.3.5.1.drv
-...
-detected package components
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
- - library
- - testsuite(s): test-scientific
- - benchmark(s): bench-scientific*
-
-(component names suffixed with '*' are not configured to be built)
-
-library
-~~~~~~~
-
-The following package dependencies seem redundant:
-
- - ghc-prim-0.5.0.0
-
-testsuite(test-scientific)
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-no redundant packages dependencies found
-
-builder for ‘/nix/store/3lc51cxj2j57y3zfpq5i69qbzjpvyci1-scientific-0.3.5.1.drv’ failed with exit code 1
-error: build of ‘/nix/store/3lc51cxj2j57y3zfpq5i69qbzjpvyci1-scientific-0.3.5.1.drv’ failed
-```
-
-As you can see, `packunused` finds out that although the testsuite component has
-no redundant dependencies the library component of `scientific-0.3.5.1` depends
-on `ghc-prim` which is unused in the library.
-
-### Using hackage2nix with nixpkgs
-
-Hackage package derivations are found in the
-[`hackage-packages.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/hackage-packages.nix)
-file within `nixpkgs` and are used as the initial package set for
-`haskellPackages`. The `hackage-packages.nix` file is not meant to be edited
-by hand, but rather autogenerated by [`hackage2nix`](https://github.com/NixOS/cabal2nix/tree/master/hackage2nix),
-which by default uses the [`configuration-hackage2nix.yaml`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/configuration-hackage2nix.yaml)
-file to generate all the derivations.
-
-To modify the contents `configuration-hackage2nix.yaml`, follow the
-instructions on [`hackage2nix`](https://github.com/NixOS/cabal2nix/tree/master/hackage2nix).
-
-## Other resources
-
-  - The Youtube video [Nix Loves Haskell](https://www.youtube.com/watch?v=BsBhi_r-OeE)
-    provides an introduction into Haskell NG aimed at beginners. The slides are
-    available at http://cryp.to/nixos-meetup-3-slides.pdf and also -- in a form
-    ready for cut & paste -- at
-    https://github.com/NixOS/cabal2nix/blob/master/doc/nixos-meetup-3-slides.md.
-
-  - Another Youtube video is [Escaping Cabal Hell with Nix](https://www.youtube.com/watch?v=mQd3s57n_2Y),
-    which discusses the subject of Haskell development with Nix but also provides
-    a basic introduction to Nix as well, i.e. it's suitable for viewers with
-    almost no prior Nix experience.
-
-  - Oliver Charles wrote a very nice [Tutorial how to develop Haskell packages with Nix](http://wiki.ocharles.org.uk/Nix).
-
-  - The *Journey into the Haskell NG infrastructure* series of postings
-    describe the new Haskell infrastructure in great detail:
-
-      - [Part 1](https://nixos.org/nix-dev/2015-January/015591.html)
-        explains the differences between the old and the new code and gives
-        instructions how to migrate to the new setup.
-
-      - [Part 2](https://nixos.org/nix-dev/2015-January/015608.html)
-        looks in-depth at how to tweak and configure your setup by means of
-        overrides.
-
-      - [Part 3](https://nixos.org/nix-dev/2015-April/016912.html)
-        describes the infrastructure that keeps the Haskell package set in Nixpkgs
-        up-to-date.
+The documentation for the Haskell infrastructure is published at
+<https://haskell4nix.readthedocs.io/>. The source code for that
+site lives in the `doc/` sub-directory of the
+[`cabal2nix` Git repository](https://github.com/NixOS/cabal2nix)
+and changes can be submitted there.
diff --git a/doc/languages-frameworks/hy.section.md b/doc/languages-frameworks/hy.section.md
new file mode 100644
index 00000000000..a851ff24dfc
--- /dev/null
+++ b/doc/languages-frameworks/hy.section.md
@@ -0,0 +1,31 @@
+# Hy {#sec-language-hy}
+
+## Installation {#ssec-hy-installation}
+
+### Installation without packages {#installation-without-packages}
+
+You can install `hy` via nix-env or by adding it to `configuration.nix` by reffering to it as a `hy` attribute. This kind of installation adds `hy` to your environment and it succesfully works with `python3`.
+
+::: {.caution}
+Packages that are installed with your python derivation, are not accesible by `hy` this way.
+:::
+
+### Installation with packages {#installation-with-packages}
+
+Creating `hy` derivation with custom `python` packages is really simple and similar to the way that python does it. Attribute `hy` provides function `withPackages` that creates custom `hy` derivation with specified packages.
+
+For example if you want to create shell with `matplotlib` and `numpy`, you can do it like so:
+
+```ShellSession
+$ nix-shell -p "hy.withPackages (ps: with ps; [ numpy matplotlib ])"
+```
+
+Or if you want to extend your `configuration.nix`:
+```nix
+{ # ...
+
+  environment.systemPackages = with pkgs; [
+    (hy.withPackages (py-packages: with py-packages; [ numpy matplotlib ]))
+  ];
+}
+```
diff --git a/doc/languages-frameworks/idris.section.md b/doc/languages-frameworks/idris.section.md
index f071b9ce178..ffdd706eb0b 100644
--- a/doc/languages-frameworks/idris.section.md
+++ b/doc/languages-frameworks/idris.section.md
@@ -1,10 +1,10 @@
-# Idris
+# Idris {#idris}
 
-## Installing Idris
+## Installing Idris {#installing-idris}
 
 The easiest way to get a working idris version is to install the `idris` attribute:
 
-```
+```ShellSession
 $ # On NixOS
 $ nix-env -i nixos.idris
 $ # On non-NixOS
@@ -21,7 +21,7 @@ self: super: {
 
 And then:
 
-```
+```ShellSession
 $ # On NixOS
 $ nix-env -iA nixos.myIdris
 $ # On non-NixOS
@@ -29,7 +29,8 @@ $ nix-env -iA nixpkgs.myIdris
 ```
 
 To see all available Idris packages:
-```
+
+```ShellSession
 $ # On NixOS
 $ nix-env -qaPA nixos.idrisPackages
 $ # On non-NixOS
@@ -37,22 +38,23 @@ $ nix-env -qaPA nixpkgs.idrisPackages
 ```
 
 Similarly, entering a `nix-shell`:
-```
+
+```ShellSession
 $ nix-shell -p 'idrisPackages.with-packages (with idrisPackages; [ contrib pruviloj ])'
 ```
 
-## Starting Idris with library support
+## Starting Idris with library support {#starting-idris-with-library-support}
 
 To have access to these libraries in idris, call it with an argument `-p <library name>` for each library:
 
-```
+```ShellSession
 $ nix-shell -p 'idrisPackages.with-packages (with idrisPackages; [ contrib pruviloj ])'
 [nix-shell:~]$ idris -p contrib -p pruviloj
 ```
 
 A listing of all available packages the Idris binary has access to is available via `--listlibs`:
 
-```
+```ShellSession
 $ idris --listlibs
 00prelude-idx.ibc
 pruviloj
@@ -64,16 +66,16 @@ prelude
 00contrib-idx.ibc
 ```
 
-## Building an Idris project with Nix
+## Building an Idris project with Nix {#building-an-idris-project-with-nix}
 
 As an example of how a Nix expression for an Idris package can be created, here is the one for `idrisPackages.yaml`:
 
 ```nix
-{ build-idris-package
+{ lib
+, build-idris-package
 , fetchFromGitHub
 , contrib
 , lightyear
-, lib
 }:
 build-idris-package  {
   name = "yaml";
@@ -94,18 +96,18 @@ build-idris-package  {
     sha256 = "1g4pi0swmg214kndj85hj50ccmckni7piprsxfdzdfhg87s0avw7";
   };
 
-  meta = {
+  meta = with lib; {
     description = "Idris YAML lib";
     homepage = "https://github.com/Heather/Idris.Yaml";
-    license = lib.licenses.mit;
-    maintainers = [ lib.maintainers.brainrape ];
+    license = licenses.mit;
+    maintainers = [ maintainers.brainrape ];
   };
 }
 ```
 
 Assuming this file is saved as `yaml.nix`, it's buildable using
 
-```
+```ShellSession
 $ nix-build -E '(import <nixpkgs> {}).idrisPackages.callPackage ./yaml.nix {}'
 ```
 
@@ -121,11 +123,11 @@ with import <nixpkgs> {};
 
 in another file (say `default.nix`) to be able to build it with
 
-```
+```ShellSession
 $ nix-build -A yaml
 ```
 
-## Passing options to `idris` commands
+## Passing options to `idris` commands {#passing-options-to-idris-commands}
 
 The `build-idris-package` function provides also optional input values to set additional options for the used `idris` commands.
 
@@ -133,7 +135,7 @@ Specifically, you can set `idrisBuildOptions`, `idrisTestOptions`, `idrisInstall
 
 For example you could set
 
-```
+```nix
 build-idris-package {
   idrisBuildOptions = [ "--log" "1" "--verbose" ]
 
diff --git a/doc/languages-frameworks/index.xml b/doc/languages-frameworks/index.xml
index 728a38c264a..516bddf67fd 100644
--- a/doc/languages-frameworks/index.xml
+++ b/doc/languages-frameworks/index.xml
@@ -7,28 +7,31 @@
  </para>
  <xi:include href="agda.section.xml" />
  <xi:include href="android.section.xml" />
- <xi:include href="beam.xml" />
- <xi:include href="bower.xml" />
- <xi:include href="coq.xml" />
+ <xi:include href="beam.section.xml" />
+ <xi:include href="bower.section.xml" />
+ <xi:include href="coq.section.xml" />
  <xi:include href="crystal.section.xml" />
+ <xi:include href="dhall.section.xml" />
  <xi:include href="emscripten.section.xml" />
- <xi:include href="gnome.xml" />
- <xi:include href="go.xml" />
+ <xi:include href="gnome.section.xml" />
+ <xi:include href="go.section.xml" />
  <xi:include href="haskell.section.xml" />
+ <xi:include href="hy.section.xml" />
  <xi:include href="idris.section.xml" />
  <xi:include href="ios.section.xml" />
- <xi:include href="java.xml" />
+ <xi:include href="java.section.xml" />
  <xi:include href="lua.section.xml" />
+ <xi:include href="maven.section.xml" />
  <xi:include href="node.section.xml" />
- <xi:include href="ocaml.xml" />
- <xi:include href="perl.xml" />
+ <xi:include href="ocaml.section.xml" />
+ <xi:include href="perl.section.xml" />
  <xi:include href="php.section.xml" />
  <xi:include href="python.section.xml" />
- <xi:include href="qt.xml" />
+ <xi:include href="qt.section.xml" />
  <xi:include href="r.section.xml" />
- <xi:include href="ruby.xml" />
+ <xi:include href="ruby.section.xml" />
  <xi:include href="rust.section.xml" />
- <xi:include href="texlive.xml" />
+ <xi:include href="texlive.section.xml" />
  <xi:include href="titanium.section.xml" />
  <xi:include href="vim.section.xml" />
 </chapter>
diff --git a/doc/languages-frameworks/ios.section.md b/doc/languages-frameworks/ios.section.md
index 768e0690b96..04b013be12e 100644
--- a/doc/languages-frameworks/ios.section.md
+++ b/doc/languages-frameworks/ios.section.md
@@ -1,9 +1,4 @@
----
-title: iOS
-author: Sander van der Burg
-date: 2019-11-10
----
-# iOS
+# iOS {#ios}
 
 This component is basically a wrapper/workaround that makes it possible to
 expose an Xcode installation as a Nix package by means of symlinking to the
@@ -25,8 +20,8 @@ Hydra.
 
 The Xcode build environment implements a number of features.
 
-Deploying a proxy component wrapper exposing Xcode
---------------------------------------------------
+## Deploying a proxy component wrapper exposing Xcode {#deploying-a-proxy-component-wrapper-exposing-xcode}
+
 The first use case is deploying a Nix package that provides symlinks to the Xcode
 installation on the host system. This package can be used as a build input to
 any build function implemented in the Nix expression language that requires
@@ -60,8 +55,8 @@ lrwxr-xr-x  1 sander  staff  61  1 jan  1970 xcodebuild -> /Applications/Xcode.a
 lrwxr-xr-x  1 sander  staff  14  1 jan  1970 xcrun -> /usr/bin/xcrun
 ```
 
-Building an iOS application
----------------------------
+## Building an iOS application {#building-an-ios-application}
+
 We can build an iOS app executable for the simulator, or an IPA/xcarchive file
 for release purposes, e.g. ad-hoc, enterprise or store installations, by
 executing the `xcodeenv.buildApp {}` function:
@@ -104,6 +99,7 @@ xcodeenv.buildApp {
 ```
 
 The above function takes a variety of parameters:
+
 * The `name` and `src` parameters are mandatory and specify the name of the app
   and the location where the source code resides
 * `sdkVersion` specifies which version of the iOS SDK to use.
@@ -156,8 +152,8 @@ the `xcodeenv.composeXcodeWrapper {}` function takes. For example, the
 `xcodeBaseDir` parameter can be overridden to refer to a different Xcode
 version.
 
-Spawning simulator instances
-----------------------------
+## Spawning simulator instances {#spawning-simulator-instances}
+
 In addition to building iOS apps, we can also automatically spawn simulator
 instances:
 
@@ -218,8 +214,8 @@ xcode.simulateApp {
 By providing the result of an `xcode.buildApp {}` function and configuring the
 app bundle id, the app gets deployed automatically and started.
 
-Troubleshooting
----------------
+## Troubleshooting {#troubleshooting}
+
 In some rare cases, it may happen that after a failure, changes are not picked
 up. Most likely, this is caused by a derived data cache that Xcode maintains.
 To wipe it you can run:
diff --git a/doc/languages-frameworks/java.section.md b/doc/languages-frameworks/java.section.md
new file mode 100644
index 00000000000..77919d43f74
--- /dev/null
+++ b/doc/languages-frameworks/java.section.md
@@ -0,0 +1,91 @@
+# Java {#sec-language-java}
+
+Ant-based Java packages are typically built from source as follows:
+
+```nix
+stdenv.mkDerivation {
+  name = "...";
+  src = fetchurl { ... };
+
+  nativeBuildInputs = [ jdk ant ];
+
+  buildPhase = "ant";
+}
+```
+
+Note that `jdk` is an alias for the OpenJDK (self-built where available,
+or pre-built via Zulu). Platforms with OpenJDK not (yet) in Nixpkgs
+(`Aarch32`, `Aarch64`) point to the (unfree) `oraclejdk`.
+
+JAR files that are intended to be used by other packages should be
+installed in `$out/share/java`. JDKs have a stdenv setup hook that add
+any JARs in the `share/java` directories of the build inputs to the
+`CLASSPATH` environment variable. For instance, if the package `libfoo`
+installs a JAR named `foo.jar` in its `share/java` directory, and
+another package declares the attribute
+
+```nix
+buildInputs = [ libfoo ];
+nativeBuildInputs = [ jdk ];
+```
+
+then `CLASSPATH` will be set to
+`/nix/store/...-libfoo/share/java/foo.jar`.
+
+Private JARs should be installed in a location like
+`$out/share/package-name`.
+
+If your Java package provides a program, you need to generate a wrapper
+script to run it using a JRE. You can use `makeWrapper` for this:
+
+```nix
+nativeBuildInputs = [ makeWrapper ];
+
+installPhase = ''
+  mkdir -p $out/bin
+  makeWrapper ${jre}/bin/java $out/bin/foo \
+    --add-flags "-cp $out/share/java/foo.jar org.foo.Main"
+'';
+```
+
+Since the introduction of the Java Platform Module System in Java 9,
+Java distributions typically no longer ship with a general-purpose JRE:
+instead, they allow generating a JRE with only the modules required for
+your application(s). Because we can't predict what modules will be
+needed on a general-purpose system, the default jre package is the full
+JDK. When building a minimal system/image, you can override the
+`modules` parameter on `jre_minimal` to build a JRE with only the
+modules relevant for you:
+
+```nix
+let
+  my_jre = pkgs.jre_minimal.override {
+    modules = [
+      # The modules used by 'something' and 'other' combined:
+      "java.base"
+      "java.logging"
+    ];
+  };
+  something = (pkgs.something.override { jre = my_jre; });
+  other = (pkgs.other.override { jre = my_jre; });
+in
+  ...
+```
+
+Note all JDKs passthru `home`, so if your application requires
+environment variables like `JAVA_HOME` being set, that can be done in a
+generic fashion with the `--set` argument of `makeWrapper`:
+
+```bash
+--set JAVA_HOME ${jdk.home}
+```
+
+It is possible to use a different Java compiler than `javac` from the
+OpenJDK. For instance, to use the GNU Java Compiler:
+
+```nix
+nativeBuildInputs = [ gcj ant ];
+```
+
+Here, Ant will automatically use `gij` (the GNU Java Runtime) instead of
+the OpenJRE.
diff --git a/doc/languages-frameworks/java.xml b/doc/languages-frameworks/java.xml
deleted file mode 100644
index bf0fc488392..00000000000
--- a/doc/languages-frameworks/java.xml
+++ /dev/null
@@ -1,63 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-language-java">
- <title>Java</title>
-
- <para>
-  Ant-based Java packages are typically built from source as follows:
-<programlisting>
-stdenv.mkDerivation {
-  name = "...";
-  src = fetchurl { ... };
-
-  nativeBuildInputs = [ jdk ant ];
-
-  buildPhase = "ant";
-}
-</programlisting>
-  Note that <varname>jdk</varname> is an alias for the OpenJDK (self-built where available, or pre-built via Zulu). Platforms with OpenJDK not (yet) in Nixpkgs (<literal>Aarch32</literal>, <literal>Aarch64</literal>) point to the (unfree) <literal>oraclejdk</literal>.
- </para>
-
- <para>
-  JAR files that are intended to be used by other packages should be installed in <filename>$out/share/java</filename>. JDKs have a stdenv setup hook that add any JARs in the <filename>share/java</filename> directories of the build inputs to the <envar>CLASSPATH</envar> environment variable. For instance, if the package <literal>libfoo</literal> installs a JAR named <filename>foo.jar</filename> in its <filename>share/java</filename> directory, and another package declares the attribute
-<programlisting>
-buildInputs = [ libfoo ];
-nativeBuildInputs = [ jdk ];
-</programlisting>
-  then <envar>CLASSPATH</envar> will be set to <filename>/nix/store/...-libfoo/share/java/foo.jar</filename>.
- </para>
-
- <para>
-  Private JARs should be installed in a location like <filename>$out/share/<replaceable>package-name</replaceable></filename>.
- </para>
-
- <para>
-  If your Java package provides a program, you need to generate a wrapper script to run it using the OpenJRE. You can use <literal>makeWrapper</literal> for this:
-<programlisting>
-nativeBuildInputs = [ makeWrapper ];
-
-installPhase =
-  ''
-    mkdir -p $out/bin
-    makeWrapper ${jre}/bin/java $out/bin/foo \
-      --add-flags "-cp $out/share/java/foo.jar org.foo.Main"
-  '';
-</programlisting>
-  Note the use of <literal>jre</literal>, which is the part of the OpenJDK package that contains the Java Runtime Environment. By using <literal>${jre}/bin/java</literal> instead of <literal>${jdk}/bin/java</literal>, you prevent your package from depending on the JDK at runtime.
- </para>
-
- <para>
-  Note all JDKs passthru <literal>home</literal>, so if your application requires environment variables like <envar>JAVA_HOME</envar> being set, that can be done in a generic fashion with the <literal>--set</literal> argument of <literal>makeWrapper</literal>:
-<programlisting>
---set JAVA_HOME ${jdk.home}
-</programlisting>
- </para>
-
- <para>
-  It is possible to use a different Java compiler than <command>javac</command> from the OpenJDK. For instance, to use the GNU Java Compiler:
-<programlisting>
-nativeBuildInputs = [ gcj ant ];
-</programlisting>
-  Here, Ant will automatically use <command>gij</command> (the GNU Java Runtime) instead of the OpenJRE.
- </para>
-</section>
diff --git a/doc/languages-frameworks/lua.section.md b/doc/languages-frameworks/lua.section.md
index a0e9917b8ec..ea893ce3a4a 100644
--- a/doc/languages-frameworks/lua.section.md
+++ b/doc/languages-frameworks/lua.section.md
@@ -1,14 +1,8 @@
----
-title: Lua
-author: Matthieu Coudron
-date: 2019-02-05
----
+# User’s Guide to Lua Infrastructure {#users-guide-to-lua-infrastructure}
 
-# User's Guide to Lua Infrastructure
+## Using Lua {#using-lua}
 
-## Using Lua
-
-### Overview of Lua
+### Overview of Lua {#overview-of-lua}
 
 Several versions of the Lua interpreter are available: luajit, lua 5.1, 5.2, 5.3.
 The attribute `lua` refers to the default interpreter, it is also possible to refer to specific versions, e.g. `lua5_2` refers to Lua 5.2.
@@ -23,27 +17,31 @@ The main package set contains aliases to these package sets, e.g.
 `luaPackages` refers to `lua5_1.pkgs` and `lua52Packages` to
 `lua5_2.pkgs`.
 
-### Installing Lua and packages
+### Installing Lua and packages {#installing-lua-and-packages}
 
-#### Lua environment defined in separate `.nix` file
+#### Lua environment defined in separate `.nix` file {#lua-environment-defined-in-separate-.nix-file}
 
 Create a file, e.g. `build.nix`, with the following expression
+
 ```nix
 with import <nixpkgs> {};
 
 lua5_2.withPackages (ps: with ps; [ busted luafilesystem ])
 ```
+
 and install it in your profile with
+
 ```shell
 nix-env -if build.nix
 ```
 Now you can use the Lua interpreter, as well as the extra packages (`busted`,
 `luafilesystem`) that you added to the environment.
 
-#### Lua environment defined in `~/.config/nixpkgs/config.nix`
+#### Lua environment defined in `~/.config/nixpkgs/config.nix` {#lua-environment-defined-in-.confignixpkgsconfig.nix}
 
 If you prefer to, you could also add the environment as a package override to the Nixpkgs set, e.g.
 using `config.nix`,
+
 ```nix
 { # ...
 
@@ -52,14 +50,16 @@ using `config.nix`,
   };
 }
 ```
+
 and install it in your profile with
+
 ```shell
 nix-env -iA nixpkgs.myLuaEnv
 ```
-The environment is is installed by referring to the attribute, and considering
+The environment is installed by referring to the attribute, and considering
 the `nixpkgs` channel was used.
 
-#### Lua environment defined in `/etc/nixos/configuration.nix`
+#### Lua environment defined in `/etc/nixos/configuration.nix` {#lua-environment-defined-in-etcnixosconfiguration.nix}
 
 For the sake of completeness, here's another example how to install the environment system-wide.
 
@@ -72,7 +72,7 @@ For the sake of completeness, here's another example how to install the environm
 }
 ```
 
-### How to override a Lua package using overlays?
+### How to override a Lua package using overlays? {#how-to-override-a-lua-package-using-overlays}
 
 Use the following overlay template:
 
@@ -93,18 +93,22 @@ final: prev:
 }
 ```
 
-### Temporary Lua environment with `nix-shell`
+### Temporary Lua environment with `nix-shell` {#temporary-lua-environment-with-nix-shell}
 
 
 There are two methods for loading a shell with Lua packages. The first and recommended method
 is to create an environment with `lua.buildEnv` or `lua.withPackages` and load that. E.g.
+
 ```sh
 $ nix-shell -p 'lua.withPackages(ps: with ps; [ busted luafilesystem ])'
 ```
+
 opens a shell from which you can launch the interpreter
+
 ```sh
 [nix-shell:~] lua
 ```
+
 The other method, which is not recommended, does not create an environment and requires you to list the packages directly,
 
 ```sh
@@ -114,7 +118,7 @@ Again, it is possible to launch the interpreter from the shell.
 The Lua interpreter has the attribute `pkgs` which contains all Lua libraries for that specific interpreter.
 
 
-## Developing with Lua
+## Developing with Lua {#developing-with-lua}
 
 Now that you know how to get a working Lua environment with Nix, it is time
 to go forward and start actually developing with Lua. There are two ways to
@@ -122,7 +126,7 @@ package lua software, either it is on luarocks and most of it can be taken care
 of by the luarocks2nix converter or the packaging has to be done manually.
 Let's present the luarocks way first and the manual one in a second time.
 
-### Packaging a library on luarocks
+### Packaging a library on luarocks {#packaging-a-library-on-luarocks}
 
 [Luarocks.org](www.luarocks.org) is the main repository of lua packages.
 The site proposes two types of packages, the rockspec and the src.rock
@@ -135,16 +139,17 @@ the whitelist maintainers/scripts/luarocks-packages.csv and updated by running m
 [luarocks2nix](https://github.com/nix-community/luarocks) is a tool capable of generating nix derivations from both rockspec and src.rock (and favors the src.rock).
 The automation only goes so far though and some packages need to be customized.
 These customizations go in `pkgs/development/lua-modules/overrides.nix`.
-For instance if the rockspec defines `external_dependencies`, these need to be manually added in in its rockspec file then it won't work.
+For instance if the rockspec defines `external_dependencies`, these need to be manually added in its rockspec file then it won't work.
 
 You can try converting luarocks packages to nix packages with the command `nix-shell -p luarocks-nix` and then `luarocks nix PKG_NAME`.
 Nix rely on luarocks to install lua packages, basically it runs:
 `luarocks make --deps-mode=none --tree $out`
 
-#### Packaging a library manually
+#### Packaging a library manually {#packaging-a-library-manually}
 
 You can develop your package as you usually would, just don't forget to wrap it
 within a `toLuaModule` call, for instance
+
 ```nix
 mynewlib = toLuaModule ( stdenv.mkDerivation { ... });
 ```
@@ -152,16 +157,15 @@ mynewlib = toLuaModule ( stdenv.mkDerivation { ... });
 There is also the `buildLuaPackage` function that can be used when lua modules
 are not packaged for luarocks. You can see a few examples at `pkgs/top-level/lua-packages.nix`.
 
-## Lua Reference
+## Lua Reference {#lua-reference}
 
-### Lua interpreters
+### Lua interpreters {#lua-interpreters}
 
 Versions 5.1, 5.2 and 5.3 of the lua interpreter are available as
 respectively `lua5_1`, `lua5_2` and `lua5_3`. Luajit is available too.
 The Nix expressions for the interpreters can be found in `pkgs/development/interpreters/lua-5`.
 
-
-#### Attributes on lua interpreters packages
+#### Attributes on lua interpreters packages {#attributes-on-lua-interpreters-packages}
 
 Each interpreter has the following attributes:
 
@@ -170,8 +174,7 @@ Each interpreter has the following attributes:
 - `withPackages`. Simpler interface to `buildEnv`.
 - `pkgs`. Set of Lua packages for that specific interpreter. The package set can be modified by overriding the interpreter and passing `packageOverrides`.
 
-
-#### `buildLuarocksPackage` function
+#### `buildLuarocksPackage` function {#buildluarockspackage-function}
 
 The `buildLuarocksPackage` function is implemented in `pkgs/development/interpreters/lua-5/build-lua-package.nix`
 The following is an example:
@@ -187,7 +190,7 @@ luaposix = buildLuarocksPackage {
   disabled = (luaOlder "5.1") || (luaAtLeast "5.4");
   propagatedBuildInputs = [ bit32 lua std_normalize ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/luaposix/luaposix/";
     description = "Lua bindings for POSIX";
     maintainers = with maintainers; [ vyp lblasc ];
@@ -211,16 +214,17 @@ install the package
 
 By default `meta.platforms` is set to the same value as the interpreter unless overridden otherwise.
 
-#### `buildLuaApplication` function
+#### `buildLuaApplication` function {#buildluaapplication-function}
 
 The `buildLuaApplication` function is practically the same as `buildLuaPackage`.
 The difference is that `buildLuaPackage` by default prefixes the names of the packages with the version of the interpreter.
 Because with an application we're not interested in multiple version the prefix is dropped.
 
-#### lua.withPackages function
+#### lua.withPackages function {#lua.withpackages-function}
 
 The `lua.withPackages` takes a function as an argument that is passed the set of lua packages and returns the list of packages to be included in the environment.
 Using the `withPackages` function, the previous example for the luafilesystem environment can be written like this:
+
 ```nix
 with import <nixpkgs> {};
 
@@ -229,6 +233,7 @@ lua.withPackages (ps: [ps.luafilesystem])
 
 `withPackages` passes the correct package set for the specific interpreter version as an argument to the function. In the above example, `ps` equals `luaPackages`.
 But you can also easily switch to using `lua5_2`:
+
 ```nix
 with import <nixpkgs> {};
 
@@ -237,16 +242,14 @@ lua5_2.withPackages (ps: [ps.lua])
 
 Now, `ps` is set to `lua52Packages`, matching the version of the interpreter.
 
-
-### Possible Todos
+### Possible Todos {#possible-todos}
 
 * export/use version specific variables such as `LUA_PATH_5_2`/`LUAROCKS_CONFIG_5_2`
 * let luarocks check for dependencies via exporting the different rocktrees in temporary config
 
-### Lua Contributing guidelines
+### Lua Contributing guidelines {#lua-contributing-guidelines}
 
 Following rules should be respected:
 
 * Make sure libraries build for all Lua interpreters.
 * Commit names of Lua libraries should reflect that they are Lua libraries, so write for example `luaPackages.luafilesystem: 1.11 -> 1.12`.
-
diff --git a/doc/languages-frameworks/maven.section.md b/doc/languages-frameworks/maven.section.md
new file mode 100644
index 00000000000..f53a6fa8ac2
--- /dev/null
+++ b/doc/languages-frameworks/maven.section.md
@@ -0,0 +1,351 @@
+# Maven {#maven}
+
+Maven is a well-known build tool for the Java ecosystem however it has some challenges when integrating into the Nix build system.
+
+The following provides a list of common patterns with how to package a Maven project (or any JVM language that can export to Maven) as a Nix package.
+
+For the purposes of this example let's consider a very basic Maven project with the following `pom.xml` with a single dependency on [emoji-java](https://github.com/vdurmont/emoji-java).
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>io.github.fzakaria</groupId>
+  <artifactId>maven-demo</artifactId>
+  <version>1.0</version>
+  <packaging>jar</packaging>
+  <name>NixOS Maven Demo</name>
+
+  <dependencies>
+    <dependency>
+        <groupId>com.vdurmont</groupId>
+        <artifactId>emoji-java</artifactId>
+        <version>5.1.1</version>
+      </dependency>
+  </dependencies>
+</project>
+```
+
+Our main class file will be very simple:
+
+```java
+import com.vdurmont.emoji.EmojiParser;
+
+public class Main {
+  public static void main(String[] args) {
+    String str = "NixOS :grinning: is super cool :smiley:!";
+    String result = EmojiParser.parseToUnicode(str);
+    System.out.println(result);
+  }
+}
+```
+
+You find this demo project at https://github.com/fzakaria/nixos-maven-example
+
+## Solving for dependencies {#solving-for-dependencies}
+
+### buildMaven with NixOS/mvn2nix-maven-plugin {#buildmaven-with-nixosmvn2nix-maven-plugin}
+
+> ⚠️ Although `buildMaven` is the "blessed" way within nixpkgs, as of 2020, it hasn't seen much activity in quite a while.
+
+`buildMaven` is an alternative method that tries to follow similar patterns of other programming languages by generating a lock file. It relies on the maven plugin [mvn2nix-maven-plugin](https://github.com/NixOS/mvn2nix-maven-plugin).
+
+First you generate a `project-info.json` file using the maven plugin.
+
+> This should be executed in the project's source repository or be told which `pom.xml` to execute with.
+
+```bash
+# run this step within the project's source repository
+❯ mvn org.nixos.mvn2nix:mvn2nix-maven-plugin:mvn2nix
+
+❯ cat project-info.json | jq | head
+{
+  "project": {
+    "artifactId": "maven-demo",
+    "groupId": "org.nixos",
+    "version": "1.0",
+    "classifier": "",
+    "extension": "jar",
+    "dependencies": [
+      {
+        "artifactId": "maven-resources-plugin",
+```
+
+This file is then given to the `buildMaven` function, and it returns 2 attributes.
+
+**`repo`**:
+    A Maven repository that is a symlink farm of all the dependencies found in the `project-info.json`
+
+
+**`build`**:
+    A simple derivation that runs through `mvn compile` & `mvn package` to build the JAR. You may use this as inspiration for more complicated derivations.
+
+Here is an [example](https://github.com/fzakaria/nixos-maven-example/blob/main/build-maven-repository.nix) of building the Maven repository
+
+```nix
+{ pkgs ? import <nixpkgs> { } }:
+with pkgs;
+(buildMaven ./project-info.json).repo
+```
+
+The benefit over the _double invocation_ as we will see below, is that the _/nix/store_ entry is a _linkFarm_ of every package, so that changes to your dependency set doesn't involve downloading everything from scratch.
+
+```bash
+❯ tree $(nix-build --no-out-link build-maven-repository.nix) | head
+/nix/store/g87va52nkc8jzbmi1aqdcf2f109r4dvn-maven-repository
+├── antlr
+│   └── antlr
+│       └── 2.7.2
+│           ├── antlr-2.7.2.jar -> /nix/store/d027c8f2cnmj5yrynpbq2s6wmc9cb559-antlr-2.7.2.jar
+│           └── antlr-2.7.2.pom -> /nix/store/mv42fc5gizl8h5g5vpywz1nfiynmzgp2-antlr-2.7.2.pom
+├── avalon-framework
+│   └── avalon-framework
+│       └── 4.1.3
+│           ├── avalon-framework-4.1.3.jar -> /nix/store/iv5fp3955w3nq28ff9xfz86wvxbiw6n9-avalon-framework-4.1.3.jar
+```
+
+### Double Invocation {#double-invocation}
+
+> ⚠️ This pattern is the simplest but may cause unnecessary rebuilds due to the output hash changing.
+
+The double invocation is a _simple_ way to get around the problem that `nix-build` may be sandboxed and have no Internet connectivity.
+
+It treats the entire Maven repository as a single source to be downloaded, relying on Maven's dependency resolution to satisfy the output hash. This is similar to fetchers like `fetchgit`, except it has to run a Maven build to determine what to download.
+
+The first step will be to build the Maven project as a fixed-output derivation in order to collect the Maven repository -- below is an [example](https://github.com/fzakaria/nixos-maven-example/blob/main/double-invocation-repository.nix).
+
+> Traditionally the Maven repository is at `~/.m2/repository`. We will override this to be the `$out` directory.
+
+```nix
+{ lib, stdenv, maven }:
+stdenv.mkDerivation {
+  name = "maven-repository";
+  buildInputs = [ maven ];
+  src = ./.; # or fetchFromGitHub, cleanSourceWith, etc
+  buildPhase = ''
+    mvn package -Dmaven.repo.local=$out
+  '';
+
+  # keep only *.{pom,jar,sha1,nbm} and delete all ephemeral files with lastModified timestamps inside
+  installPhase = ''
+    find $out -type f \
+      -name \*.lastUpdated -or \
+      -name resolver-status.properties -or \
+      -name _remote.repositories \
+      -delete
+  '';
+
+  # don't do any fixup
+  dontFixup = true;
+  outputHashAlgo = "sha256";
+  outputHashMode = "recursive";
+  # replace this with the correct SHA256
+  outputHash = lib.fakeSha256;
+}
+```
+
+The build will fail, and tell you the expected `outputHash` to place. When you've set the hash, the build will return with a `/nix/store` entry whose contents are the full Maven repository.
+
+> Some additional files are deleted that would cause the output hash to change potentially on subsequent runs.
+
+```bash
+❯ tree $(nix-build --no-out-link double-invocation-repository.nix) | head
+/nix/store/8kicxzp98j68xyi9gl6jda67hp3c54fq-maven-repository
+├── backport-util-concurrent
+│   └── backport-util-concurrent
+│       └── 3.1
+│           ├── backport-util-concurrent-3.1.pom
+│           └── backport-util-concurrent-3.1.pom.sha1
+├── classworlds
+│   └── classworlds
+│       ├── 1.1
+│       │   ├── classworlds-1.1.jar
+```
+
+If your package uses _SNAPSHOT_ dependencies or _version ranges_; there is a strong likelihood that over-time your output hash will change since the resolved dependencies may change. Hence this method is less recommended then using `buildMaven`.
+
+## Building a JAR {#building-a-jar}
+
+Regardless of which strategy is chosen above, the step to build the derivation is the same.
+
+```nix
+{ stdenv, maven, callPackage }:
+# pick a repository derivation, here we will use buildMaven
+let repository = callPackage ./build-maven-repository.nix { };
+in stdenv.mkDerivation rec {
+  pname = "maven-demo";
+  version = "1.0";
+
+  src = builtins.fetchTarball "https://github.com/fzakaria/nixos-maven-example/archive/main.tar.gz";
+  buildInputs = [ maven ];
+
+  buildPhase = ''
+    echo "Using repository ${repository}"
+    mvn --offline -Dmaven.repo.local=${repository} package;
+  '';
+
+  installPhase = ''
+    install -Dm644 target/${pname}-${version}.jar $out/share/java
+  '';
+}
+```
+
+> We place the library in `$out/share/java` since JDK package has a _stdenv setup hook_ that adds any JARs in the `share/java` directories of the build inputs to the CLASSPATH environment.
+
+```bash
+❯ tree $(nix-build --no-out-link build-jar.nix)
+/nix/store/7jw3xdfagkc2vw8wrsdv68qpsnrxgvky-maven-demo-1.0
+└── share
+    └── java
+        └── maven-demo-1.0.jar
+
+2 directories, 1 file
+```
+
+## Runnable JAR {#runnable-jar}
+
+The previous example builds a `jar` file but that's not a file one can run.
+
+You need to use it with `java -jar $out/share/java/output.jar` and make sure to provide the required dependencies on the classpath.
+
+The following explains how to use `makeWrapper` in order to make the derivation produce an executable that will run the JAR file you created.
+
+We will use the same repository we built above (either _double invocation_ or _buildMaven_) to setup a CLASSPATH for our JAR.
+
+The following two methods are more suited to Nix then building an [UberJar](https://imagej.net/Uber-JAR) which may be the more traditional approach.
+
+### CLASSPATH {#classpath}
+
+> This is ideal if you are providing a derivation for _nixpkgs_ and don't want to patch the project's `pom.xml`.
+
+We will read the Maven repository and flatten it to a single list. This list will then be concatenated with the _CLASSPATH_ separator to create the full classpath.
+
+We make sure to provide this classpath to the `makeWrapper`.
+
+```nix
+{ stdenv, maven, callPackage, makeWrapper, jre }:
+let
+  repository = callPackage ./build-maven-repository.nix { };
+in stdenv.mkDerivation rec {
+  pname = "maven-demo";
+  version = "1.0";
+
+  src = builtins.fetchTarball
+    "https://github.com/fzakaria/nixos-maven-example/archive/main.tar.gz";
+  buildInputs = [ maven makeWrapper ];
+
+  buildPhase = ''
+    echo "Using repository ${repository}"
+    mvn --offline -Dmaven.repo.local=${repository} package;
+  '';
+
+  installPhase = ''
+    mkdir -p $out/bin
+
+    classpath=$(find ${repository} -name "*.jar" -printf ':%h/%f');
+    install -Dm644 target/${pname}-${version}.jar $out/share/java
+    # create a wrapper that will automatically set the classpath
+    # this should be the paths from the dependency derivation
+    makeWrapper ${jre}/bin/java $out/bin/${pname} \
+          --add-flags "-classpath $out/share/java/${pname}-${version}.jar:''${classpath#:}" \
+          --add-flags "Main"
+  '';
+}
+```
+
+### MANIFEST file via Maven Plugin {#manifest-file-via-maven-plugin}
+
+> This is ideal if you are the project owner and want to change your `pom.xml` to set the CLASSPATH within it.
+
+Augment the `pom.xml` to create a JAR with the following manifest:
+
+```xml
+<build>
+  <plugins>
+    <plugin>
+        <artifactId>maven-jar-plugin</artifactId>
+        <configuration>
+            <archive>
+                <manifest>
+                    <addClasspath>true</addClasspath>
+                    <classpathPrefix>../../repository/</classpathPrefix>
+                    <classpathLayoutType>repository</classpathLayoutType>
+                    <mainClass>Main</mainClass>
+                </manifest>
+                <manifestEntries>
+                    <Class-Path>.</Class-Path>
+                </manifestEntries>
+            </archive>
+        </configuration>
+    </plugin>
+  </plugins>
+</build>
+```
+
+The above plugin instructs the JAR to look for the necessary dependencies in the `lib/` relative folder. The layout of the folder is also in the _maven repository_ style.
+
+```bash
+❯ unzip -q -c $(nix-build --no-out-link runnable-jar.nix)/share/java/maven-demo-1.0.jar META-INF/MANIFEST.MF
+
+Manifest-Version: 1.0
+Archiver-Version: Plexus Archiver
+Built-By: nixbld
+Class-Path: . ../../repository/com/vdurmont/emoji-java/5.1.1/emoji-jav
+ a-5.1.1.jar ../../repository/org/json/json/20170516/json-20170516.jar
+Created-By: Apache Maven 3.6.3
+Build-Jdk: 1.8.0_265
+Main-Class: Main
+```
+
+We will modify the derivation above to add a symlink to our repository so that it's accessible to our JAR during the `installPhase`.
+
+```nix
+{ stdenv, maven, callPackage, makeWrapper, jre }:
+# pick a repository derivation, here we will use buildMaven
+let repository = callPackage ./build-maven-repository.nix { };
+in stdenv.mkDerivation rec {
+  pname = "maven-demo";
+  version = "1.0";
+
+  src = builtins.fetchTarball
+    "https://github.com/fzakaria/nixos-maven-example/archive/main.tar.gz";
+  buildInputs = [ maven makeWrapper ];
+
+  buildPhase = ''
+    echo "Using repository ${repository}"
+    mvn --offline -Dmaven.repo.local=${repository} package;
+  '';
+
+  installPhase = ''
+    mkdir -p $out/bin
+
+    # create a symbolic link for the repository directory
+    ln -s ${repository} $out/repository
+
+    install -Dm644 target/${pname}-${version}.jar $out/share/java
+    # create a wrapper that will automatically set the classpath
+    # this should be the paths from the dependency derivation
+    makeWrapper ${jre}/bin/java $out/bin/${pname} \
+          --add-flags "-jar $out/share/java/${pname}-${version}.jar"
+  '';
+}
+```
+
+> Our script produces a dependency on `jre` rather than `jdk` to restrict the runtime closure necessary to run the application.
+
+This will give you an executable shell-script that launches your JAR with all the dependencies available.
+
+```bash
+❯ tree $(nix-build --no-out-link runnable-jar.nix)
+/nix/store/8d4c3ibw8ynsn01ibhyqmc1zhzz75s26-maven-demo-1.0
+├── bin
+│   └── maven-demo
+├── repository -> /nix/store/g87va52nkc8jzbmi1aqdcf2f109r4dvn-maven-repository
+└── share
+    └── java
+        └── maven-demo-1.0.jar
+
+❯ $(nix-build --no-out-link --option tarball-ttl 1 runnable-jar.nix)/bin/maven-demo
+NixOS 😀 is super cool 😃!
+```
diff --git a/doc/languages-frameworks/node.section.md b/doc/languages-frameworks/node.section.md
index c1f4294711a..847db22941f 100644
--- a/doc/languages-frameworks/node.section.md
+++ b/doc/languages-frameworks/node.section.md
@@ -1,5 +1,5 @@
-Node.js
-=======
+# Node.js {#node.js}
+
 The `pkgs/development/node-packages` folder contains a generated collection of
 [NPM packages](https://npmjs.com/) that can be installed with the Nix package
 manager.
@@ -25,12 +25,13 @@ build system it uses. Here are some examples:
 
 After you have identified the correct system, you need to override your package
 expression while adding in build system as a build input. For example, `dat`
-requires `node-gyp-build`, so we override its expression in `default.nix`:
+requires `node-gyp-build`, so [we override](https://github.com/NixOS/nixpkgs/blob/32f5e5da4a1b3f0595527f5195ac3a91451e9b56/pkgs/development/node-packages/default.nix#L37-L40) its expression in [`default.nix`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/node-packages/default.nix):
 
 ```nix
-dat = nodePackages.dat.override (oldAttrs: {
-  buildInputs = oldAttrs.buildInputs ++ [ nodePackages.node-gyp-build ];
-});
+    dat = super.dat.override {
+      buildInputs = [ self.node-gyp-build pkgs.libtool pkgs.autoconf pkgs.automake ];
+      meta.broken = since "12";
+    };
 ```
 
 To add a package from NPM to nixpkgs:
diff --git a/doc/languages-frameworks/ocaml.section.md b/doc/languages-frameworks/ocaml.section.md
new file mode 100644
index 00000000000..5ffc23173d6
--- /dev/null
+++ b/doc/languages-frameworks/ocaml.section.md
@@ -0,0 +1,93 @@
+# OCaml {#sec-language-ocaml}
+
+OCaml libraries should be installed in `$(out)/lib/ocaml/${ocaml.version}/site-lib/`. Such directories are automatically added to the `$OCAMLPATH` environment variable when building another package that depends on them or when opening a `nix-shell`.
+
+Given that most of the OCaml ecosystem is now built with dune, nixpkgs includes a convenience build support function called `buildDunePackage` that will build an OCaml package using dune, OCaml and findlib and any additional dependencies provided as `buildInputs` or `propagatedBuildInputs`.
+
+Here is a simple package example.
+
+- It defines an (optional) attribute `minimalOCamlVersion` that will be used to
+  throw a descriptive evaluation error if building with an older OCaml is
+  attempted.
+
+- It uses the `fetchFromGitHub` fetcher to get its source.
+
+- `useDune2 = true` ensures that the latest version of Dune is used for the
+  build (this may become the default value in a future release).
+
+- It sets the optional `doCheck` attribute such that tests will be run with
+  `dune runtest -p angstrom` after the build (`dune build -p angstrom`) is
+  complete, but only if the Ocaml version is at at least `"4.05"`.
+
+- It uses the package `ocaml-syntax-shims` as a build input, `alcotest` and
+  `ppx_let` as check inputs (because they are needed to run the tests), and
+  `bigstringaf` and `result` as propagated build inputs (thus they will also be
+  available to libraries depending on this library).
+
+- The library will be installed using the `angstrom.install` file that dune
+  generates.
+
+```nix
+{ lib,
+  fetchFromGitHub,
+  buildDunePackage,
+  ocaml,
+  ocaml-syntax-shims,
+  alcotest,
+  result,
+  bigstringaf,
+  ppx_let }:
+
+buildDunePackage rec {
+  pname = "angstrom";
+  version = "0.15.0";
+  useDune2 = true;
+
+  minimalOCamlVersion = "4.04";
+
+  src = fetchFromGitHub {
+    owner  = "inhabitedtype";
+    repo   = pname;
+    rev    = version;
+    sha256 = "1hmrkdcdlkwy7rxhngf3cv3sa61cznnd9p5lmqhx20664gx2ibrh";
+  };
+
+  checkInputs = [ alcotest ppx_let ];
+  buildInputs = [ ocaml-syntax-shims ];
+  propagatedBuildInputs = [ bigstringaf result ];
+  doCheck = lib.versionAtLeast ocaml.version "4.05";
+
+  meta = {
+    homepage = "https://github.com/inhabitedtype/angstrom";
+    description = "OCaml parser combinators built for speed and memory efficiency";
+    license = lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [ sternenseemann ];
+  };
+```
+
+Here is a second example, this time using a source archive generated with `dune-release`. It is a good idea to use this archive when it is available as it will usually contain substituted variables such as a `%%VERSION%%` field. This library does not depend on any other OCaml library and no tests are run after building it.
+
+```nix
+{ lib, fetchurl, buildDunePackage }:
+
+buildDunePackage rec {
+  pname = "wtf8";
+  version = "1.0.2";
+
+  useDune2 = true;
+
+  minimalOCamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/flowtype/ocaml-${pname}/releases/download/v${version}/${pname}-v${version}.tbz";
+    sha256 = "09ygcxxd5warkdzz17rgpidrd0pg14cy2svvnvy1hna080lzg7vp";
+  };
+
+  meta = with lib; {
+    homepage = "https://github.com/flowtype/ocaml-wtf8";
+    description = "WTF-8 is a superset of UTF-8 that allows unpaired surrogates.";
+    license = licenses.mit;
+    maintainers = [ maintainers.eqyiel ];
+  };
+}
+```
diff --git a/doc/languages-frameworks/ocaml.xml b/doc/languages-frameworks/ocaml.xml
deleted file mode 100644
index 3f72092ec15..00000000000
--- a/doc/languages-frameworks/ocaml.xml
+++ /dev/null
@@ -1,73 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-language-ocaml">
- <title>OCaml</title>
-
- <para>
-  OCaml libraries should be installed in <literal>$(out)/lib/ocaml/${ocaml.version}/site-lib/</literal>. Such directories are automatically added to the <literal>$OCAMLPATH</literal> environment variable when building another package that depends on them or when opening a <literal>nix-shell</literal>.
- </para>
-
- <para>
-  Given that most of the OCaml ecosystem is now built with dune, nixpkgs includes a convenience build support function called <literal>buildDunePackage</literal> that will build an OCaml package using dune, OCaml and findlib and any additional dependencies provided as <literal>buildInputs</literal> or <literal>propagatedBuildInputs</literal>.
- </para>
-
- <para>
-  Here is a simple package example. It defines an (optional) attribute <literal>minimumOCamlVersion</literal> that will be used to throw a descriptive evaluation error if building with an older OCaml is attempted. It uses the <literal>fetchFromGitHub</literal> fetcher to get its source. It sets the <literal>doCheck</literal> (optional) attribute to <literal>true</literal> which means that tests will be run with <literal>dune runtest -p angstrom</literal> after the build (<literal>dune build -p angstrom</literal>) is complete. It uses <literal>alcotest</literal> as a build input (because it is needed to run the tests) and <literal>bigstringaf</literal> and <literal>result</literal> as propagated build inputs (thus they will also be available to libraries depending on this library). The library will be installed using the <literal>angstrom.install</literal> file that dune generates.
- </para>
-
-<programlisting>
-{ stdenv, fetchFromGitHub, buildDunePackage, alcotest, result, bigstringaf }:
-
-buildDunePackage rec {
-  pname = "angstrom";
-  version = "0.10.0";
-
-  minimumOCamlVersion = "4.03";
-
-  src = fetchFromGitHub {
-    owner  = "inhabitedtype";
-    repo   = pname;
-    rev    = version;
-    sha256 = "0lh6024yf9ds0nh9i93r9m6p5psi8nvrqxl5x7jwl13zb0r9xfpw";
-  };
-
-  buildInputs = [ alcotest ];
-  propagatedBuildInputs = [ bigstringaf result ];
-  doCheck = true;
-
-  meta = {
-    homepage = "https://github.com/inhabitedtype/angstrom";
-    description = "OCaml parser combinators built for speed and memory efficiency";
-    license = stdenv.lib.licenses.bsd3;
-    maintainers = with stdenv.lib.maintainers; [ sternenseemann ];
-  };
-}
-</programlisting>
-
- <para>
-  Here is a second example, this time using a source archive generated with <literal>dune-release</literal>. It is a good idea to use this archive when it is available as it will usually contain substituted variables such as a <literal>%%VERSION%%</literal> field. This library does not depend on any other OCaml library and no tests are run after building it.
- </para>
-
-<programlisting>
-{ stdenv, fetchurl, buildDunePackage }:
-
-buildDunePackage rec {
-  pname = "wtf8";
-  version = "1.0.1";
-
-  minimumOCamlVersion = "4.01";
-
-  src = fetchurl {
-    url = "https://github.com/flowtype/ocaml-${pname}/releases/download/v${version}/${pname}-${version}.tbz";
-    sha256 = "1msg3vycd3k8qqj61sc23qks541cxpb97vrnrvrhjnqxsqnh6ygq";
-  };
-
-  meta = with stdenv.lib; {
-    homepage = "https://github.com/flowtype/ocaml-wtf8";
-    description = "WTF-8 is a superset of UTF-8 that allows unpaired surrogates.";
-    license = licenses.mit;
-    maintainers = [ maintainers.eqyiel ];
-  };
-}
-</programlisting>
-</section>
diff --git a/doc/languages-frameworks/perl.section.md b/doc/languages-frameworks/perl.section.md
new file mode 100644
index 00000000000..dcb7dcb77b6
--- /dev/null
+++ b/doc/languages-frameworks/perl.section.md
@@ -0,0 +1,163 @@
+# Perl {#sec-language-perl}
+
+## Running perl programs on the shell {#ssec-perl-running}
+
+When executing a Perl script, it is possible you get an error such as `./myscript.pl: bad interpreter: /usr/bin/perl: no such file or directory`. This happens when the script expects Perl to be installed at `/usr/bin/perl`, which is not the case when using Perl from nixpkgs. You can fix the script by changing the first line to:
+
+```perl
+#!/usr/bin/env perl
+```
+
+to take the Perl installation from the `PATH` environment variable, or invoke Perl directly with:
+
+```ShellSession
+$ perl ./myscript.pl
+```
+
+When the script is using a Perl library that is not installed globally, you might get an error such as `Can't locate DB_File.pm in @INC (you may need to install the DB_File module)`. In that case, you can use `nix-shell` to start an ad-hoc shell with that library installed, for instance:
+
+```ShellSession
+$ nix-shell -p perl perlPackages.DBFile --run ./myscript.pl
+```
+
+If you are always using the script in places where `nix-shell` is available, you can embed the `nix-shell` invocation in the shebang like this:
+
+```perl
+#!/usr/bin/env nix-shell
+#! nix-shell -i perl -p perl perlPackages.DBFile
+```
+
+## Packaging Perl programs {#ssec-perl-packaging}
+
+Nixpkgs provides a function `buildPerlPackage`, a generic package builder function for any Perl package that has a standard `Makefile.PL`. It’s implemented in [pkgs/development/perl-modules/generic](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/perl-modules/generic).
+
+Perl packages from CPAN are defined in [pkgs/top-level/perl-packages.nix](https://github.com/NixOS/nixpkgs/blob/master/pkgs/top-level/perl-packages.nix) rather than `pkgs/all-packages.nix`. Most Perl packages are so straight-forward to build that they are defined here directly, rather than having a separate function for each package called from `perl-packages.nix`. However, more complicated packages should be put in a separate file, typically in `pkgs/development/perl-modules`. Here is an example of the former:
+
+```nix
+ClassC3 = buildPerlPackage rec {
+  name = "Class-C3-0.21";
+  src = fetchurl {
+    url = "mirror://cpan/authors/id/F/FL/FLORA/${name}.tar.gz";
+    sha256 = "1bl8z095y4js66pwxnm7s853pi9czala4sqc743fdlnk27kq94gz";
+  };
+};
+```
+
+Note the use of `mirror://cpan/`, and the `${name}` in the URL definition to ensure that the name attribute is consistent with the source that we’re actually downloading. Perl packages are made available in `all-packages.nix` through the variable `perlPackages`. For instance, if you have a package that needs `ClassC3`, you would typically write
+
+```nix
+foo = import ../path/to/foo.nix {
+  inherit stdenv fetchurl ...;
+  inherit (perlPackages) ClassC3;
+};
+```
+
+in `all-packages.nix`. You can test building a Perl package as follows:
+
+```ShellSession
+$ nix-build -A perlPackages.ClassC3
+```
+
+`buildPerlPackage` adds `perl-` to the start of the name attribute, so the package above is actually called `perl-Class-C3-0.21`. So to install it, you can say:
+
+```ShellSession
+$ nix-env -i perl-Class-C3
+```
+
+(Of course you can also install using the attribute name: `nix-env -i -A perlPackages.ClassC3`.)
+
+So what does `buildPerlPackage` do? It does the following:
+
+1. In the configure phase, it calls `perl Makefile.PL` to generate a Makefile. You can set the variable `makeMakerFlags` to pass flags to `Makefile.PL`
+2. It adds the contents of the `PERL5LIB` environment variable to `#! .../bin/perl` line of Perl scripts as `-Idir` flags. This ensures that a script can find its dependencies. (This can cause this shebang line to become too long for Darwin to handle; see the note below.)
+3. In the fixup phase, it writes the propagated build inputs (`propagatedBuildInputs`) to the file `$out/nix-support/propagated-user-env-packages`. `nix-env` recursively installs all packages listed in this file when you install a package that has it. This ensures that a Perl package can find its dependencies.
+
+`buildPerlPackage` is built on top of `stdenv`, so everything can be customised in the usual way. For instance, the `BerkeleyDB` module has a `preConfigure` hook to generate a configuration file used by `Makefile.PL`:
+
+```nix
+{ buildPerlPackage, fetchurl, db }:
+
+buildPerlPackage rec {
+  name = "BerkeleyDB-0.36";
+
+  src = fetchurl {
+    url = "mirror://cpan/authors/id/P/PM/PMQS/${name}.tar.gz";
+    sha256 = "07xf50riarb60l1h6m2dqmql8q5dij619712fsgw7ach04d8g3z1";
+  };
+
+  preConfigure = ''
+    echo "LIB = ${db.out}/lib" > config.in
+    echo "INCLUDE = ${db.dev}/include" >> config.in
+  '';
+}
+```
+
+Dependencies on other Perl packages can be specified in the `buildInputs` and `propagatedBuildInputs` attributes. If something is exclusively a build-time dependency, use `buildInputs`; if it’s (also) a runtime dependency, use `propagatedBuildInputs`. For instance, this builds a Perl module that has runtime dependencies on a bunch of other modules:
+
+```nix
+ClassC3Componentised = buildPerlPackage rec {
+  name = "Class-C3-Componentised-1.0004";
+  src = fetchurl {
+    url = "mirror://cpan/authors/id/A/AS/ASH/${name}.tar.gz";
+    sha256 = "0xql73jkcdbq4q9m0b0rnca6nrlvf5hyzy8is0crdk65bynvs8q1";
+  };
+  propagatedBuildInputs = [
+    ClassC3 ClassInspector TestException MROCompat
+  ];
+};
+```
+
+On Darwin, if a script has too many `-Idir` flags in its first line (its “shebang line”), it will not run. This can be worked around by calling the `shortenPerlShebang` function from the `postInstall` phase:
+
+```nix
+{ lib, stdenv, buildPerlPackage, fetchurl, shortenPerlShebang }:
+
+ImageExifTool = buildPerlPackage {
+  pname = "Image-ExifTool";
+  version = "11.50";
+
+  src = fetchurl {
+    url = "https://www.sno.phy.queensu.ca/~phil/exiftool/Image-ExifTool-11.50.tar.gz";
+    sha256 = "0d8v48y94z8maxkmw1rv7v9m0jg2dc8xbp581njb6yhr7abwqdv3";
+  };
+
+  buildInputs = lib.optional stdenv.isDarwin shortenPerlShebang;
+  postInstall = lib.optional stdenv.isDarwin ''
+    shortenPerlShebang $out/bin/exiftool
+  '';
+};
+```
+
+This will remove the `-I` flags from the shebang line, rewrite them in the `use lib` form, and put them on the next line instead. This function can be given any number of Perl scripts as arguments; it will modify them in-place.
+
+### Generation from CPAN {#ssec-generation-from-CPAN}
+
+Nix expressions for Perl packages can be generated (almost) automatically from CPAN. This is done by the program `nix-generate-from-cpan`, which can be installed as follows:
+
+```ShellSession
+$ nix-env -i nix-generate-from-cpan
+```
+
+This program takes a Perl module name, looks it up on CPAN, fetches and unpacks the corresponding package, and prints a Nix expression on standard output. For example:
+
+```ShellSession
+$ nix-generate-from-cpan XML::Simple
+  XMLSimple = buildPerlPackage rec {
+    name = "XML-Simple-2.22";
+    src = fetchurl {
+      url = "mirror://cpan/authors/id/G/GR/GRANTM/${name}.tar.gz";
+      sha256 = "b9450ef22ea9644ae5d6ada086dc4300fa105be050a2030ebd4efd28c198eb49";
+    };
+    propagatedBuildInputs = [ XMLNamespaceSupport XMLSAX XMLSAXExpat ];
+    meta = {
+      description = "An API for simple XML files";
+      license = with lib.licenses; [ artistic1 gpl1Plus ];
+    };
+  };
+```
+
+The output can be pasted into `pkgs/top-level/perl-packages.nix` or wherever else you need it.
+
+### Cross-compiling modules {#ssec-perl-cross-compilation}
+
+Nixpkgs has experimental support for cross-compiling Perl modules. In many cases, it will just work out of the box, even for modules with native extensions. Sometimes, however, the Makefile.PL for a module may (indirectly) import a native module. In that case, you will need to make a stub for that module that will satisfy the Makefile.PL and install it into `lib/perl5/site_perl/cross_perl/${perl.version}`. See the `postInstall` for `DBI` for an example.
diff --git a/doc/languages-frameworks/perl.xml b/doc/languages-frameworks/perl.xml
deleted file mode 100644
index ff0f350e99c..00000000000
--- a/doc/languages-frameworks/perl.xml
+++ /dev/null
@@ -1,195 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-language-perl">
- <title>Perl</title>
-
- <section xml:id="ssec-perl-running">
-  <title>Running perl programs on the shell</title>
-
-  <para>
-   When executing a Perl script, it is possible you get an error such as <literal>./myscript.pl: bad interpreter: /usr/bin/perl: no such file or directory</literal>. This happens when the script expects Perl to be installed at <filename>/usr/bin/perl</filename>, which is not the case when using Perl from nixpkgs. You can fix the script by changing the first line to:
-  <programlisting>
-  #!/usr/bin/env perl
-  </programlisting>
-  to take the Perl installation from the <literal>PATH</literal> environment variable, or invoke Perl directly with:
-  <screen>
-  <prompt>$ </prompt>perl ./myscript.pl
-  </screen>
-  </para>
-
-  <para>
-   When the script is using a Perl library that is not installed globally, you might get an error such as <literal>Can't locate DB_File.pm in @INC (you may need to install the DB_File module)</literal>. In that case, you can use <command>nix-shell</command> to start an ad-hoc shell with that library installed, for instance:
-  <screen>
-  <prompt>$ </prompt>nix-shell -p perl perlPackages.DBFile --run ./myscript.pl
-  </screen>
-  </para>
-
-  <para>
-  If you are always using the script in places where <command>nix-shell</command> is available, you can embed the <command>nix-shell</command> invocation in the shebang like this:
-  <programlisting>
-  #!/usr/bin/env nix-shell
-  #! nix-shell -i perl -p perl perlPackages.DBFile
-  </programlisting>
-  </para>
- </section>
-
- <section xml:id="ssec-perl-packaging">
-  <title>Packaging Perl programs</title>
-
-  <para>
-   Nixpkgs provides a function <varname>buildPerlPackage</varname>, a generic package builder function for any Perl package that has a standard <varname>Makefile.PL</varname>. It’s implemented in <link
- xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/perl-modules/generic"><filename>pkgs/development/perl-modules/generic</filename></link>.
-  </para>
-
-  <para>
-   Perl packages from CPAN are defined in <link
- xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/top-level/perl-packages.nix"><filename>pkgs/top-level/perl-packages.nix</filename></link>, rather than <filename>pkgs/all-packages.nix</filename>. Most Perl packages are so straight-forward to build that they are defined here directly, rather than having a separate function for each package called from <filename>perl-packages.nix</filename>. However, more complicated packages should be put in a separate file, typically in <filename>pkgs/development/perl-modules</filename>. Here is an example of the former:
- <programlisting>
- ClassC3 = buildPerlPackage rec {
-   name = "Class-C3-0.21";
-   src = fetchurl {
-     url = "mirror://cpan/authors/id/F/FL/FLORA/${name}.tar.gz";
-     sha256 = "1bl8z095y4js66pwxnm7s853pi9czala4sqc743fdlnk27kq94gz";
-   };
- };
- </programlisting>
-   Note the use of <literal>mirror://cpan/</literal>, and the <literal>${name}</literal> in the URL definition to ensure that the name attribute is consistent with the source that we’re actually downloading. Perl packages are made available in <filename>all-packages.nix</filename> through the variable <varname>perlPackages</varname>. For instance, if you have a package that needs <varname>ClassC3</varname>, you would typically write
- <programlisting>
- foo = import ../path/to/foo.nix {
-   inherit stdenv fetchurl ...;
-   inherit (perlPackages) ClassC3;
- };
- </programlisting>
-   in <filename>all-packages.nix</filename>. You can test building a Perl package as follows:
- <screen>
- <prompt>$ </prompt>nix-build -A perlPackages.ClassC3
- </screen>
-   <varname>buildPerlPackage</varname> adds <literal>perl-</literal> to the start of the name attribute, so the package above is actually called <literal>perl-Class-C3-0.21</literal>. So to install it, you can say:
- <screen>
- <prompt>$ </prompt>nix-env -i perl-Class-C3
- </screen>
-   (Of course you can also install using the attribute name: <literal>nix-env -i -A perlPackages.ClassC3</literal>.)
-  </para>
-
-  <para>
-   So what does <varname>buildPerlPackage</varname> do? It does the following:
-   <orderedlist>
-    <listitem>
-     <para>
-      In the configure phase, it calls <literal>perl Makefile.PL</literal> to generate a Makefile. You can set the variable <varname>makeMakerFlags</varname> to pass flags to <filename>Makefile.PL</filename>
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      It adds the contents of the <envar>PERL5LIB</envar> environment variable to <literal>#! .../bin/perl</literal> line of Perl scripts as <literal>-I<replaceable>dir</replaceable></literal> flags. This ensures that a script can find its dependencies. (This can cause this shebang line to become too long for Darwin to handle; see the note below.)
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      In the fixup phase, it writes the propagated build inputs (<varname>propagatedBuildInputs</varname>) to the file <filename>$out/nix-support/propagated-user-env-packages</filename>. <command>nix-env</command> recursively installs all packages listed in this file when you install a package that has it. This ensures that a Perl package can find its dependencies.
-     </para>
-    </listitem>
-   </orderedlist>
-  </para>
-
-  <para>
-   <varname>buildPerlPackage</varname> is built on top of <varname>stdenv</varname>, so everything can be customised in the usual way. For instance, the <literal>BerkeleyDB</literal> module has a <varname>preConfigure</varname> hook to generate a configuration file used by <filename>Makefile.PL</filename>:
- <programlisting>
- { buildPerlPackage, fetchurl, db }:
-
- buildPerlPackage rec {
-   name = "BerkeleyDB-0.36";
-
-   src = fetchurl {
-     url = "mirror://cpan/authors/id/P/PM/PMQS/${name}.tar.gz";
-     sha256 = "07xf50riarb60l1h6m2dqmql8q5dij619712fsgw7ach04d8g3z1";
-   };
-
-   preConfigure = ''
-     echo "LIB = ${db.out}/lib" > config.in
-     echo "INCLUDE = ${db.dev}/include" >> config.in
-   '';
- }
- </programlisting>
-  </para>
-
-  <para>
-   Dependencies on other Perl packages can be specified in the <varname>buildInputs</varname> and <varname>propagatedBuildInputs</varname> attributes. If something is exclusively a build-time dependency, use <varname>buildInputs</varname>; if it’s (also) a runtime dependency, use <varname>propagatedBuildInputs</varname>. For instance, this builds a Perl module that has runtime dependencies on a bunch of other modules:
- <programlisting>
- ClassC3Componentised = buildPerlPackage rec {
-   name = "Class-C3-Componentised-1.0004";
-   src = fetchurl {
-     url = "mirror://cpan/authors/id/A/AS/ASH/${name}.tar.gz";
-     sha256 = "0xql73jkcdbq4q9m0b0rnca6nrlvf5hyzy8is0crdk65bynvs8q1";
-   };
-   propagatedBuildInputs = [
-     ClassC3 ClassInspector TestException MROCompat
-   ];
- };
- </programlisting>
-  </para>
-
-  <para>
-   On Darwin, if a script has too many <literal>-I<replaceable>dir</replaceable></literal> flags in its first line (its “shebang line”), it will not run. This can be worked around by calling the <literal>shortenPerlShebang</literal> function from the <literal>postInstall</literal> phase:
- <programlisting>
- { stdenv, buildPerlPackage, fetchurl, shortenPerlShebang }:
-
- ImageExifTool = buildPerlPackage {
-   pname = "Image-ExifTool";
-   version = "11.50";
-
-   src = fetchurl {
-     url = "https://www.sno.phy.queensu.ca/~phil/exiftool/Image-ExifTool-11.50.tar.gz";
-     sha256 = "0d8v48y94z8maxkmw1rv7v9m0jg2dc8xbp581njb6yhr7abwqdv3";
-   };
-
-   buildInputs = stdenv.lib.optional stdenv.isDarwin shortenPerlShebang;
-   postInstall = stdenv.lib.optional stdenv.isDarwin ''
-     shortenPerlShebang $out/bin/exiftool
-   '';
- };
- </programlisting>
-   This will remove the <literal>-I</literal> flags from the shebang line, rewrite them in the <literal>use lib</literal> form, and put them on the next line instead. This function can be given any number of Perl scripts as arguments; it will modify them in-place.
-  </para>
-
-  <section xml:id="ssec-generation-from-CPAN">
-   <title>Generation from CPAN</title>
-
-   <para>
-    Nix expressions for Perl packages can be generated (almost) automatically from CPAN. This is done by the program <command>nix-generate-from-cpan</command>, which can be installed as follows:
-   </para>
-
- <screen>
- <prompt>$ </prompt>nix-env -i nix-generate-from-cpan
- </screen>
-
-   <para>
-    This program takes a Perl module name, looks it up on CPAN, fetches and unpacks the corresponding package, and prints a Nix expression on standard output. For example:
- <screen>
- <prompt>$ </prompt>nix-generate-from-cpan XML::Simple
-   XMLSimple = buildPerlPackage rec {
-     name = "XML-Simple-2.22";
-     src = fetchurl {
-       url = "mirror://cpan/authors/id/G/GR/GRANTM/${name}.tar.gz";
-       sha256 = "b9450ef22ea9644ae5d6ada086dc4300fa105be050a2030ebd4efd28c198eb49";
-     };
-     propagatedBuildInputs = [ XMLNamespaceSupport XMLSAX XMLSAXExpat ];
-     meta = {
-       description = "An API for simple XML files";
-       license = with stdenv.lib.licenses; [ artistic1 gpl1Plus ];
-     };
-   };
- </screen>
-    The output can be pasted into <filename>pkgs/top-level/perl-packages.nix</filename> or wherever else you need it.
-   </para>
-  </section>
-
-  <section xml:id="ssec-perl-cross-compilation">
-   <title>Cross-compiling modules</title>
-
-   <para>
-    Nixpkgs has experimental support for cross-compiling Perl modules. In many cases, it will just work out of the box, even for modules with native extensions. Sometimes, however, the Makefile.PL for a module may (indirectly) import a native module. In that case, you will need to make a stub for that module that will satisfy the Makefile.PL and install it into <filename>lib/perl5/site_perl/cross_perl/${perl.version}</filename>. See the <varname>postInstall</varname> for <varname>DBI</varname> for an example.
-   </para>
-  </section>
- </section>
-</section>
diff --git a/doc/languages-frameworks/php.section.md b/doc/languages-frameworks/php.section.md
index 763beeb5935..5977363323f 100644
--- a/doc/languages-frameworks/php.section.md
+++ b/doc/languages-frameworks/php.section.md
@@ -135,3 +135,21 @@ Example of building `composer` with additional extensions:
   enabled ++ (with all; [ imagick redis ]))
 ).packages.composer
 ```
+
+### Overriding PHP packages {#ssec-php-user-guide-overriding-packages}
+
+`php-packages.nix` form a scope, allowing us to override the packages defined within. For example, to apply a patch to a `mysqlnd` extension, you can simply pass an overlay-style function to `php`’s `packageOverrides` argument:
+
+```nix
+php.override {
+  packageOverrides = final: prev: {
+    extensions = prev.extensions // {
+      mysqlnd = prev.extensions.mysqlnd.overrideAttrs (attrs: {
+        patches = attrs.patches or [] ++ [
+          …
+        ];
+      });
+    };
+  };
+}
+```
diff --git a/doc/languages-frameworks/python.section.md b/doc/languages-frameworks/python.section.md
index f189ce31448..53df328f8d4 100644
--- a/doc/languages-frameworks/python.section.md
+++ b/doc/languages-frameworks/python.section.md
@@ -1,14 +1,15 @@
-# Python
+# Python {#python}
 
-## User Guide
+## User Guide {#user-guide}
 
-### Using Python
+### Using Python {#using-python}
 
-#### Overview
+#### Overview {#overview}
 
 Several versions of the Python interpreter are available on Nix, as well as a
-high amount of packages. The attribute `python` refers to the default
-interpreter, which is currently CPython 2.7. It is also possible to refer to
+high amount of packages. The attribute `python3` refers to the default
+interpreter, which is currently CPython 3.9. The attribute `python` refers to
+CPython 2.7 for backwards-compatibility. It is also possible to refer to
 specific versions, e.g. `python38` refers to CPython 3.8, and `pypy` refers to
 the default PyPy interpreter.
 
@@ -30,7 +31,7 @@ The main package set contains aliases to these package sets, e.g.
 `pythonPackages` refers to `python.pkgs` and `python38Packages` to
 `python38.pkgs`.
 
-#### Installing Python and packages
+#### Installing Python and packages {#installing-python-and-packages}
 
 The Nix and NixOS manuals explain how packages are generally installed. In the
 case of Python and Nix, it is important to make a distinction between whether the
@@ -61,7 +62,7 @@ Philosphically, this should be familiar to users who are used to a `venv` style
 of development: individual projects create their own Python environments without
 impacting the global environment or each other.
 
-#### Ad-hoc temporary Python environment with `nix-shell`
+#### Ad-hoc temporary Python environment with `nix-shell` {#ad-hoc-temporary-python-environment-with-nix-shell}
 
 The simplest way to start playing with the way nix wraps and sets up Python
 environments is with `nix-shell` at the cmdline. These environments create a
@@ -78,7 +79,7 @@ $ nix-shell -p 'python38.withPackages(ps: with ps; [ numpy toolz ])'
 By default `nix-shell` will start a `bash` session with this interpreter in our
 `PATH`, so if we then run:
 
-```
+```Python console
 [nix-shell:~/src/nixpkgs]$ python3
 Python 3.8.1 (default, Dec 18 2019, 19:06:26)
 [GCC 9.2.0] on linux
@@ -89,7 +90,7 @@ Type "help", "copyright", "credits" or "license" for more information.
 Note that no other modules are in scope, even if they were imperatively
 installed into our user environment as a dependency of a Python application:
 
-```
+```Python console
 >>> import requests
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
@@ -130,7 +131,7 @@ arbitrary dependencies. This is a good way to get a feel for how the Python
 interpreter and dependencies work in Nix and NixOS, but to do some actual
 development, we'll want to make it a bit more persistent.
 
-##### Running Python scripts and using `nix-shell` as shebang
+##### Running Python scripts and using `nix-shell` as shebang {#running-python-scripts-and-using-nix-shell-as-shebang}
 
 Sometimes, we have a script whose header looks like this:
 
@@ -145,15 +146,15 @@ print(f"The dot product of {a} and {b} is: {np.dot(a, b)}")
 Executing this script requires a `python3` that has `numpy`. Using what we learned
 in the previous section, we could startup a shell and just run it like so:
 
-```
-nix-shell -p 'python38.withPackages(ps: with ps; [ numpy ])' --run 'python3 foo.py'
+```ShellSession
+$ nix-shell -p 'python38.withPackages(ps: with ps; [ numpy ])' --run 'python3 foo.py'
 The dot product of [1 2] and [3 4] is: 11
 ```
 
 But if we maintain the script ourselves, and if there are more dependencies, it
 may be nice to encode those dependencies in source to make the script re-usable
 without that bit of knowledge. That can be done by using `nix-shell` as a
-[shebang](https://en.wikipedia.org/wiki/Shebang_(Unix), like so:
+[shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)), like so:
 
 ```python
 #!/usr/bin/env nix-shell
@@ -202,7 +203,7 @@ of the package versions.
 This is also a great way to ensure the script executes identically on different
 servers.
 
-##### Load environment from `.nix` expression
+##### Load environment from `.nix` expression {#load-environment-from-.nix-expression}
 
 We've now seen how to create an ad-hoc temporary shell session, and how to
 create a single script with Python dependencies, but in the course of normal
@@ -244,7 +245,7 @@ let
     ps.toolz
   ]);
 in mkShell {
-  buildInputs = [
+  packages = [
     pythonEnv
 
     black
@@ -261,7 +262,7 @@ and its Python dependencies, but also tools like `black` or `mypy` and libraries
 like `libffi` the `openssl` in scope. This is generic and can span any number of
 tools or languages across the Nixpkgs ecosystem.
 
-##### Installing environments globally on the system
+##### Installing environments globally on the system {#installing-environments-globally-on-the-system}
 
 Up to now, we've been creating environments scoped to an ad-hoc shell session,
 or a single script, or a single project. This is generally advisable, as it
@@ -314,7 +315,7 @@ If you get a conflict or prefer to keep the setup clean, you can have `nix-env`
 atomically *uninstall* all other imperatively installed packages and replace
 your profile with just `myEnv` by using the `--replace` flag.
 
-##### Environment defined in `/etc/nixos/configuration.nix`
+##### Environment defined in `/etc/nixos/configuration.nix` {#environment-defined-in-etcnixosconfiguration.nix}
 
 For the sake of completeness, here's how to install the environment system-wide
 on NixOS.
@@ -328,16 +329,16 @@ on NixOS.
 }
 ```
 
-### Developing with Python
+### Developing with Python {#developing-with-python}
 
 Above, we were mostly just focused on use cases and what to do to get started
 creating working Python environments in nix.
 
 Now that you know the basics to be up and running, it is time to take a step
-back and take a deeper look at at how Python packages are packaged on Nix. Then,
+back and take a deeper look at how Python packages are packaged on Nix. Then,
 we will look at how you can use development mode with your code.
 
-#### Python library packages in Nixpkgs
+#### Python library packages in Nixpkgs {#python-library-packages-in-nixpkgs}
 
 With Nix all packages are built by functions. The main function in Nix for
 building Python libraries is `buildPythonPackage`. Let's see how we can build the
@@ -424,7 +425,7 @@ of `withPackages` we used a `let` expression. You can see that we used
 `toolz` from the Nixpkgs package set this time, but instead took our own version
 that we introduced with the `let` expression.
 
-#### Handling dependencies
+#### Handling dependencies {#handling-dependencies}
 
 Our example, `toolz`, does not have any dependencies on other Python packages or
 system libraries. According to the manual, `buildPythonPackage` uses the
@@ -438,7 +439,7 @@ The following example shows which arguments are given to `buildPythonPackage` in
 order to build [`datashape`](https://github.com/blaze/datashape).
 
 ```nix
-{ lib, buildPythonPackage, fetchPypi, numpy, multipledispatch, dateutil, pytest }:
+{ lib, buildPythonPackage, fetchPypi, numpy, multipledispatch, python-dateutil, pytest }:
 
 buildPythonPackage rec {
   pname = "datashape";
@@ -450,7 +451,7 @@ buildPythonPackage rec {
   };
 
   checkInputs = [ pytest ];
-  propagatedBuildInputs = [ numpy multipledispatch dateutil ];
+  propagatedBuildInputs = [ numpy multipledispatch python-dateutil ];
 
   meta = with lib; {
     homepage = "https://github.com/ContinuumIO/datashape";
@@ -462,7 +463,7 @@ buildPythonPackage rec {
 ```
 
 We can see several runtime dependencies, `numpy`, `multipledispatch`, and
-`dateutil`. Furthermore, we have one `checkInputs`, i.e. `pytest`. `pytest` is a
+`python-dateutil`. Furthermore, we have one `checkInputs`, i.e. `pytest`. `pytest` is a
 test runner and is only used during the `checkPhase` and is therefore not added
 to `propagatedBuildInputs`.
 
@@ -536,9 +537,10 @@ buildPythonPackage rec {
   };
 }
 ```
+
 Note also the line `doCheck = false;`, we explicitly disabled running the test-suite.
 
-#### Testing Python Packages
+#### Testing Python Packages {#testing-python-packages}
 
 It is highly encouraged to have testing as part of the package build. This
 helps to avoid situations where the package was able to build and install,
@@ -558,19 +560,21 @@ thus can cause issues when a test suite asserts on that behavior.
 as many tests should be enabled as possible. Failing tests can still be
 a good indication that the package is not in a valid state.
 
-#### Using pytest
+#### Using pytest {#using-pytest}
 
 Pytest is the most common test runner for python repositories. A trivial
 test run would be:
+
 ```
   checkInputs = [ pytest ];
   checkPhase = "pytest";
 ```
 
-However, many repositories' test suites do not translate well to nix's build 
+However, many repositories' test suites do not translate well to nix's build
 sandbox, and will generally need many tests to be disabled.
 
 To filter tests using pytest, one can do the following:
+
 ```
   checkInputs = [ pytest ];
   # avoid tests which need additional data or touch network
@@ -586,19 +590,20 @@ easier than having to create a new package.
 
 `-k` is used to define a predicate for test names. In this example, we are
 filtering out tests which contain `download` or `update` in their test case name.
-Only one `-k` argument is allows, and thus a long predicate should be concatenated
-with "\" and wrapped to the next line.
+Only one `-k` argument is allowed, and thus a long predicate should be concatenated
+with “\\” and wrapped to the next line.
 
-*NOTE:* In pytest==6.0.1, the use of "\" to continue a line (e.g. `-k 'not download \'`) has
+*NOTE:* In pytest==6.0.1, the use of “\\” to continue a line (e.g. `-k 'not download \'`) has
 been removed, in this case, it's recommended to use `pytestCheckHook`.
 
-#### Using pytestCheckHook
+#### Using pytestCheckHook {#using-pytestcheckhook}
 
 `pytestCheckHook` is a convenient hook which will substitute the setuptools
 `test` command for a checkPhase which runs `pytest`. This is also beneficial
 when a package may need many items disabled to run the test suite.
 
 Using the example above, the analagous pytestCheckHook usage would be:
+
 ```
   checkInputs = [ pytestCheckHook ];
 
@@ -610,6 +615,10 @@ Using the example above, the analagous pytestCheckHook usage would be:
     "download"
     "update"
   ];
+
+  disabledTestPaths = [
+    "tests/test_failing.py"
+  ];
 ```
 
 This is expecially useful when tests need to be conditionallydisabled,
@@ -632,9 +641,9 @@ Trying to concatenate the related strings to disable tests in a regular checkPha
 would be much harder to read. This also enables us to comment on why specific tests
 are disabled.
 
-#### Using pythonImportsCheck
+#### Using pythonImportsCheck {#using-pythonimportscheck}
 
-Although unit tests are highly prefered to valid correctness of a package. Not
+Although unit tests are highly prefered to validate correctness of a package, not
 all packages have test suites that can be ran easily, and some have none at all.
 To help ensure the package still works, `pythonImportsCheck` can attempt to import
 the listed modules.
@@ -654,7 +663,7 @@ However, this is done in it's own phase, and not dependent on whether `doCheck =
 This can also be useful in verifying that the package doesn't assume commonly
 present packages (e.g. `setuptools`)
 
-### Develop local package
+### Develop local package {#develop-local-package}
 
 As a Python developer you're likely aware of [development mode](http://setuptools.readthedocs.io/en/latest/setuptools.html#development-mode)
 (`python setup.py develop`); instead of installing the package this command
@@ -689,7 +698,7 @@ buildPythonPackage rec {
 It is important to note that due to how development mode is implemented on Nix
 it is not possible to have multiple packages simultaneously in development mode.
 
-### Organising your packages
+### Organising your packages {#organising-your-packages}
 
 So far we discussed how you can use Python on Nix, and how you can develop with
 it. We've looked at how you write expressions to package Python packages, and we
@@ -701,7 +710,7 @@ like to be able to use in different projects. In order to minimise unnecessary
 duplication we now look at how you can maintain a repository with your
 own packages. The important functions here are `import` and `callPackage`.
 
-### Including a derivation using `callPackage`
+### Including a derivation using `callPackage` {#including-a-derivation-using-callpackage}
 
 Earlier we created a Python environment using `withPackages`, and included the
 `toolz` package via a `let` expression.
@@ -751,28 +760,28 @@ don't explicitly define which `python` derivation should be used. In the above
 example we use `buildPythonPackage` that is part of the set `python38Packages`,
 and in this case the `python38` interpreter is automatically used.
 
-## Reference
+## Reference {#reference}
 
-### Interpreters
+### Interpreters {#interpreters}
 
-Versions 2.7, 3.6, 3.7 and 3.8 of the CPython interpreter are available as
-respectively `python27`, `python36`, `python37` and `python38`. The
+Versions 2.7, 3.6, 3.7, 3.8 and 3.9 of the CPython interpreter are available as
+respectively `python27`, `python36`, `python37`, `python38` and `python39`. The
 aliases `python2` and `python3` correspond to respectively `python27` and
-`python38`. The default interpreter, `python`, maps to `python2`. The PyPy
-interpreters compatible with Python 2.7 and 3 are available as `pypy27` and
-`pypy3`, with aliases `pypy2` mapping to `pypy27` and `pypy` mapping to `pypy2`.
-The Nix expressions for the interpreters can be found in
+`python39`. The attribute `python` maps to `python2`. The PyPy interpreters
+compatible with Python 2.7 and 3 are available as `pypy27` and `pypy3`, with
+aliases `pypy2` mapping to `pypy27` and `pypy` mapping to `pypy2`. The Nix
+expressions for the interpreters can be found in
 `pkgs/development/interpreters/python`.
 
 All packages depending on any Python interpreter get appended
 `out/{python.sitePackages}` to `$PYTHONPATH` if such directory
 exists.
 
-#### Missing `tkinter` module standard library
+#### Missing `tkinter` module standard library {#missing-tkinter-module-standard-library}
 
 To reduce closure size the `Tkinter`/`tkinter` is available as a separate package, `pythonPackages.tkinter`.
 
-#### Attributes on interpreters packages
+#### Attributes on interpreters packages {#attributes-on-interpreters-packages}
 
 Each interpreter has the following attributes:
 
@@ -784,7 +793,24 @@ Each interpreter has the following attributes:
 - `executable`. Name of the interpreter executable, e.g. `python3.8`.
 - `pkgs`. Set of Python packages for that specific interpreter. The package set can be modified by overriding the interpreter and passing `packageOverrides`.
 
-### Building packages and applications
+### Optimizations {#optimizations}
+
+The Python interpreters are by default not build with optimizations enabled, because
+the builds are in that case not reproducible. To enable optimizations, override the
+interpreter of interest, e.g using
+
+```
+let
+  pkgs = import ./. {};
+  mypython = pkgs.python3.override {
+    enableOptimizations = true;
+    reproducibleBuild = false;
+    self = mypython;
+  };
+in mypython
+```
+
+### Building packages and applications {#building-packages-and-applications}
 
 Python libraries and applications that use `setuptools` or
 `distutils` are typically built with respectively the `buildPythonPackage` and
@@ -813,10 +839,10 @@ sets are
 and the aliases
 
 * `pkgs.python2Packages` pointing to `pkgs.python27Packages`
-* `pkgs.python3Packages` pointing to `pkgs.python38Packages`
+* `pkgs.python3Packages` pointing to `pkgs.python39Packages`
 * `pkgs.pythonPackages` pointing to `pkgs.python2Packages`
 
-#### `buildPythonPackage` function
+#### `buildPythonPackage` function {#buildpythonpackage-function}
 
 The `buildPythonPackage` function is implemented in
 `pkgs/development/interpreters/python/mk-python-derivation`
@@ -825,7 +851,7 @@ using setup hooks.
 The following is an example:
 
 ```nix
-{ lib, buildPythonPackage, fetchPypi, hypothesis, setuptools_scm, attrs, py, setuptools, six, pluggy }:
+{ lib, buildPythonPackage, fetchPypi, hypothesis, setuptools-scm, attrs, py, setuptools, six, pluggy }:
 
 buildPythonPackage rec {
   pname = "pytest";
@@ -842,7 +868,7 @@ buildPythonPackage rec {
   '';
 
   checkInputs = [ hypothesis ];
-  nativeBuildInputs = [ setuptools_scm ];
+  nativeBuildInputs = [ setuptools-scm ];
   propagatedBuildInputs = [ attrs py setuptools six pluggy ];
 
   meta = with lib; {
@@ -868,7 +894,7 @@ e.g. the test runner, should be added to `checkInputs`.
 By default `meta.platforms` is set to the same value
 as the interpreter unless overridden otherwise.
 
-##### `buildPythonPackage` parameters
+##### `buildPythonPackage` parameters {#buildpythonpackage-parameters}
 
 All parameters from `stdenv.mkDerivation` function are still supported. The
 following are specific to `buildPythonPackage`:
@@ -914,7 +940,7 @@ because their behaviour is different:
 
 * `nativeBuildInputs ? []`: Build-time only dependencies. Typically executables
   as well as the items listed in `setup_requires`.
-* `buildInputs ? []`: Build and/or run-time dependencies that need to be be
+* `buildInputs ? []`: Build and/or run-time dependencies that need to be
   compiled for the host machine. Typically non-Python libraries which are being
   linked.
 * `checkInputs ? []`: Dependencies needed for running the `checkPhase`. These
@@ -924,7 +950,7 @@ because their behaviour is different:
   `buildPythonPackage` also injects code into and wraps executables with the
   paths included in this list. Items listed in `install_requires` go here.
 
-##### Overriding Python packages
+##### Overriding Python packages {#overriding-python-packages}
 
 The `buildPythonPackage` function has a `overridePythonAttrs` method that can be
 used to override the package. In the following example we create an environment
@@ -952,7 +978,7 @@ with import <nixpkgs> {};
 in python.withPackages(ps: [ps.blaze])).env
 ```
 
-#### `buildPythonApplication` function
+#### `buildPythonApplication` function {#buildpythonapplication-function}
 
 The `buildPythonApplication` function is practically the same as
 `buildPythonPackage`. The main purpose of this function is to build a Python
@@ -997,7 +1023,7 @@ luigi = callPackage ../applications/networking/cluster/luigi { };
 Since the package is an application, a consumer doesn't need to care about
 Python versions or modules, which is why they don't go in `pythonPackages`.
 
-#### `toPythonApplication` function
+#### `toPythonApplication` function {#topythonapplication-function}
 
 A distinction is made between applications and libraries, however, sometimes a
 package is used as both. In this case the package is added as a library to
@@ -1009,11 +1035,12 @@ The Nix expression shall use `buildPythonPackage` and be called from
 `python-packages.nix`. A reference shall be created from `all-packages.nix` to
 the attribute in `python-packages.nix`, and the `toPythonApplication` shall be
 applied to the reference:
+
 ```nix
 youtube-dl = with pythonPackages; toPythonApplication youtube-dl;
 ```
 
-#### `toPythonModule` function
+#### `toPythonModule` function {#topythonmodule-function}
 
 In some cases, such as bindings, a package is created using
 `stdenv.mkDerivation` and added as attribute in `all-packages.nix`. The Python
@@ -1030,7 +1057,7 @@ opencv = toPythonModule (pkgs.opencv.override {
 
 Do pay attention to passing in the right Python version!
 
-#### `python.buildEnv` function
+#### `python.buildEnv` function {#python.buildenv-function}
 
 Python environments can be created using the low-level `pkgs.buildEnv` function.
 This example shows how to create an environment that has the Pyramid Web Framework.
@@ -1068,8 +1095,8 @@ with import <nixpkgs> {};
 will drop you into a shell where Python will have the
 specified packages in its path.
 
+##### `python.buildEnv` arguments {#python.buildenv-arguments}
 
-##### `python.buildEnv` arguments
 
 * `extraLibs`: List of packages installed inside the environment.
 * `postBuild`: Shell command executed after the build of environment.
@@ -1077,7 +1104,7 @@ specified packages in its path.
 * `permitUserSite`: Skip setting the `PYTHONNOUSERSITE` environment variable in
   wrapped binaries in the environment.
 
-#### `python.withPackages` function
+#### `python.withPackages` function {#python.withpackages-function}
 
 The `python.withPackages` function provides a simpler interface to the `python.buildEnv` functionality.
 It takes a function as an argument that is passed the set of python packages and returns the list
@@ -1119,7 +1146,7 @@ need them, you have to use `python.buildEnv`.
 Python 2 namespace packages may provide `__init__.py` that collide. In that case
 `python.buildEnv` should be used with `ignoreCollisions = true`.
 
-#### Setup hooks
+#### Setup hooks {#setup-hooks}
 
 The following are setup hooks specifically for Python packages. Most of these
 are used in `buildPythonPackage`.
@@ -1144,7 +1171,7 @@ are used in `buildPythonPackage`.
 - `wheelUnpackHook` to move a wheel to the correct folder so it can be installed
   with the `pipInstallHook`.
 
-### Development mode
+### Development mode {#development-mode}
 
 Development or editable mode is supported. To develop Python packages
 `buildPythonPackage` has additional logic inside `shellPhase` to run `pip
@@ -1153,6 +1180,7 @@ install -e . --prefix $TMPDIR/`for the package.
 Warning: `shellPhase` is executed only if `setup.py` exists.
 
 Given a `default.nix`:
+
 ```nix
 with import <nixpkgs> {};
 
@@ -1175,7 +1203,7 @@ nix-shell -p pythonPackages.pyramid zlib libjpeg git
 
 Note: There is a boolean value `lib.inNixShell` set to `true` if nix-shell is invoked.
 
-### Tools
+### Tools {#tools}
 
 Packages inside nixpkgs are written by hand. However many tools exist in
 community to help save time. No tool is preferred at the moment.
@@ -1184,9 +1212,10 @@ community to help save time. No tool is preferred at the moment.
   expressions for your Python project. Note that [sharing derivations from
   pypi2nix with nixpkgs is possible but not
   encouraged](https://github.com/nix-community/pypi2nix/issues/222#issuecomment-443497376).
-- [python2nix](https://github.com/proger/python2nix) by Vladimir Kirillov.
+- [nixpkgs-pytools](https://github.com/nix-community/nixpkgs-pytools)
+- [poetry2nix](https://github.com/nix-community/poetry2nix)
 
-### Deterministic builds
+### Deterministic builds {#deterministic-builds}
 
 The Python interpreters are now built deterministically. Minor modifications had
 to be made to the interpreters in order to generate deterministic bytecode. This
@@ -1198,7 +1227,7 @@ have timestamp 1. The `buildPythonPackage` function sets `DETERMINISTIC_BUILD=1`
 and [PYTHONHASHSEED=0](https://docs.python.org/3.8/using/cmdline.html#envvar-PYTHONHASHSEED).
 Both are also exported in `nix-shell`.
 
-### Automatic tests
+### Automatic tests {#automatic-tests}
 
 It is recommended to test packages as part of the build process.
 Source distributions (`sdist`) often include test files, but not always.
@@ -1207,7 +1236,7 @@ By default the command `python setup.py test` is run as part of the
 `checkPhase`, but often it is necessary to pass a custom `checkPhase`. An
 example of such a situation is when `py.test` is used.
 
-#### Common issues
+#### Common issues {#common-issues}
 
 * Non-working tests can often be deselected. By default `buildPythonPackage`
   runs `python setup.py test`. Most Python modules follows the standard test
@@ -1224,18 +1253,19 @@ example of such a situation is when `py.test` is used.
     '';
   }
   ```
+
 * Tests that attempt to access `$HOME` can be fixed by using the following
   work-around before running tests (e.g. `preCheck`): `export HOME=$(mktemp -d)`
 
-## FAQ
+## FAQ {#faq}
 
-### How to solve circular dependencies?
+### How to solve circular dependencies? {#how-to-solve-circular-dependencies}
 
 Consider the packages `A` and `B` that depend on each other. When packaging `B`,
 a solution is to override package `A` not to depend on `B` as an input. The same
 should also be done when packaging `A`.
 
-### How to override a Python package?
+### How to override a Python package? {#how-to-override-a-python-package}
 
 We can override the interpreter and pass `packageOverrides`. In the following
 example we rename the `pandas` package and build it.
@@ -1293,7 +1323,7 @@ let
 in newpkgs.inkscape
 ```
 
-### `python setup.py bdist_wheel` cannot create .whl
+### `python setup.py bdist_wheel` cannot create .whl {#python-setup.py-bdist_wheel-cannot-create-.whl}
 
 Executing `python setup.py bdist_wheel` in a `nix-shell `fails with
 ```
@@ -1326,7 +1356,7 @@ or unset `SOURCE_DATE_EPOCH`:
 nix-shell --run "unset SOURCE_DATE_EPOCH; python3 setup.py bdist_wheel"
 ```
 
-### `install_data` / `data_files` problems
+### `install_data` / `data_files` problems {#install_data-data_files-problems}
 
 If you get the following error:
 
@@ -1346,7 +1376,7 @@ ${python.interpreter} setup.py install_data --install-dir=$out --root=$out
 sed -i '/ = data\_files/d' setup.py
 ```
 
-###  Rationale of non-existent global site-packages
+### Rationale of non-existent global site-packages {#rationale-of-non-existent-global-site-packages}
 
 On most operating systems a global `site-packages` is maintained. This however
 becomes problematic if you want to run multiple Python versions or have multiple
@@ -1361,7 +1391,7 @@ If you want to create a Python environment for development, then the recommended
 method is to use `nix-shell`, either with or without the `python.buildEnv`
 function.
 
-### How to consume Python modules using pip in a virtual environment like I am used to on other Operating Systems?
+### How to consume Python modules using pip in a virtual environment like I am used to on other Operating Systems? {#how-to-consume-python-modules-using-pip-in-a-virtual-environment-like-i-am-used-to-on-other-operating-systems}
 
 While this approach is not very idiomatic from Nix perspective, it can still be
 useful when dealing with pre-existing projects or in situations where it's not
@@ -1474,7 +1504,7 @@ is executed it will attempt to download the Python modules listed in
 requirements.txt. However these will be cached locally within the `virtualenv`
 folder and not downloaded again.
 
-### How to override a Python package from `configuration.nix`?
+### How to override a Python package from `configuration.nix`? {#how-to-override-a-python-package-from-configuration.nix}
 
 If you need to change a package's attribute(s) from `configuration.nix` you could do:
 
@@ -1482,11 +1512,12 @@ If you need to change a package's attribute(s) from `configuration.nix` you coul
   nixpkgs.config.packageOverrides = super: {
     python = super.python.override {
       packageOverrides = python-self: python-super: {
-        zerobin = python-super.zerobin.overrideAttrs (oldAttrs: {
-          src = super.fetchgit {
-            url = "https://github.com/sametmax/0bin";
-            rev = "a344dbb18fe7a855d0742b9a1cede7ce423b34ec";
-            sha256 = "16d769kmnrpbdr0ph0whyf4yff5df6zi4kmwx7sz1d3r6c8p6xji";
+        twisted = python-super.twisted.overrideAttrs (oldAttrs: {
+          src = super.fetchPipy {
+            pname = "twisted";
+            version = "19.10.0";
+            sha256 = "7394ba7f272ae722a74f3d969dcf599bc4ef093bc392038748a490f1724a515d";
+            extension = "tar.bz2";
           };
         });
       };
@@ -1494,9 +1525,11 @@ If you need to change a package's attribute(s) from `configuration.nix` you coul
   };
 ```
 
-`pythonPackages.zerobin` is now globally overridden. All packages and also the
-`zerobin` NixOS service use the new definition. Note that `python-super` refers
-to the old package set and `python-self` to the new, overridden version.
+`pythonPackages.twisted` is now globally overridden.
+All packages and also all NixOS services that reference `twisted`
+(such as `services.buildbot-worker`) now use the new definition.
+Note that `python-super` refers to the old package set and `python-self`
+to the new, overridden version.
 
 To modify only a Python package set instead of a whole Python derivation, use
 this snippet:
@@ -1504,12 +1537,12 @@ this snippet:
 ```nix
   myPythonPackages = pythonPackages.override {
     overrides = self: super: {
-      zerobin = ...;
+      twisted = ...;
     };
   }
 ```
 
-### How to override a Python package using overlays?
+### How to override a Python package using overlays? {#how-to-override-a-python-package-using-overlays}
 
 Use the following overlay template:
 
@@ -1517,11 +1550,12 @@ Use the following overlay template:
 self: super: {
   python = super.python.override {
     packageOverrides = python-self: python-super: {
-      zerobin = python-super.zerobin.overrideAttrs (oldAttrs: {
-        src = super.fetchgit {
-          url = "https://github.com/sametmax/0bin";
-          rev = "a344dbb18fe7a855d0742b9a1cede7ce423b34ec";
-          sha256 = "16d769kmnrpbdr0ph0whyf4yff5df6zi4kmwx7sz1d3r6c8p6xji";
+      twisted = python-super.twisted.overrideAttrs (oldAttrs: {
+        src = super.fetchPypi {
+          pname = "twisted";
+          version = "19.10.0";
+          sha256 = "7394ba7f272ae722a74f3d969dcf599bc4ef093bc392038748a490f1724a515d";
+          extension = "tar.bz2";
         };
       });
     };
@@ -1529,12 +1563,12 @@ self: super: {
 }
 ```
 
-### How to use Intel's MKL with numpy and scipy?
+### How to use Intel’s MKL with numpy and scipy? {#how-to-use-intels-mkl-with-numpy-and-scipy}
 
 MKL can be configured using an overlay. See the section "[Using overlays to
 configure alternatives](#sec-overlays-alternatives-blas-lapack)".
 
-### What inputs do `setup_requires`, `install_requires` and `tests_require` map to?
+### What inputs do `setup_requires`, `install_requires` and `tests_require` map to? {#what-inputs-do-setup_requires-install_requires-and-tests_require-map-to}
 
 In a `setup.py` or `setup.cfg` it is common to declare dependencies:
 
@@ -1542,17 +1576,15 @@ In a `setup.py` or `setup.cfg` it is common to declare dependencies:
 * `install_requires` corresponds to `propagatedBuildInputs`
 * `tests_require` corresponds to `checkInputs`
 
-## Contributing
+## Contributing {#contributing}
 
-### Contributing guidelines
+### Contributing guidelines {#contributing-guidelines}
 
-Following rules are desired to be respected:
+The following rules are desired to be respected:
 
 * Python libraries are called from `python-packages.nix` and packaged with
   `buildPythonPackage`. The expression of a library should be in
-  `pkgs/development/python-modules/<name>/default.nix`. Libraries in
-  `pkgs/top-level/python-packages.nix` are sorted quasi-alphabetically to avoid
-  merge conflicts.
+  `pkgs/development/python-modules/<name>/default.nix`.
 * Python applications live outside of `python-packages.nix` and are packaged
   with `buildPythonApplication`.
 * Make sure libraries build for all Python interpreters.
@@ -1562,7 +1594,11 @@ Following rules are desired to be respected:
   case, when you disable tests, leave a comment explaining why.
 * Commit names of Python libraries should reflect that they are Python
   libraries, so write for example `pythonPackages.numpy: 1.11 -> 1.12`.
-* Attribute names in `python-packages.nix` should be normalized according to
-  [PEP 0503](https://www.python.org/dev/peps/pep-0503/#normalized-names). This
-  means that characters should be converted to lowercase and `.` and `_` should
-  be replaced by a single `-` (foo-bar-baz instead of Foo__Bar.baz )
+* Attribute names in `python-packages.nix` as well as `pname`s should match the
+  library's name on PyPI, but be normalized according to [PEP
+  0503](https://www.python.org/dev/peps/pep-0503/#normalized-names). This means
+  that characters should be converted to lowercase and `.` and `_` should be
+  replaced by a single `-` (foo-bar-baz instead of Foo__Bar.baz).
+  If necessary, `pname` has to be given a different value within `fetchPypi`.
+* Attribute names in `python-packages.nix` should be sorted alphanumerically to
+  avoid merge conflicts and ease locating attributes.
diff --git a/doc/languages-frameworks/qt.section.md b/doc/languages-frameworks/qt.section.md
new file mode 100644
index 00000000000..986deeb0d4b
--- /dev/null
+++ b/doc/languages-frameworks/qt.section.md
@@ -0,0 +1,160 @@
+# Qt {#sec-language-qt}
+
+Writing Nix expressions for Qt libraries and applications is largely similar as for other C++ software.
+This section assumes some knowledge of the latter.
+There are two problems that the Nixpkgs Qt infrastructure addresses,
+which are not shared by other C++ software:
+
+1.  There are usually multiple supported versions of Qt in Nixpkgs.
+    All of a package's dependencies must be built with the same version of Qt.
+    This is similar to the version constraints imposed on interpreted languages like Python.
+2.  Qt makes extensive use of runtime dependency detection.
+    Runtime dependencies are made into build dependencies through wrappers.
+
+## Nix expression for a Qt package (default.nix) {#qt-default-nix}
+
+```{=docbook}
+<programlisting>
+{ stdenv, lib, qtbase, wrapQtAppsHook }: <co xml:id='qt-default-nix-co-1' />
+
+stdenv.mkDerivation {
+  pname = "myapp";
+  version = "1.0";
+
+  buildInputs = [ qtbase ];
+  nativeBuildInputs = [ wrapQtAppsHook ]; <co xml:id='qt-default-nix-co-2' />
+}
+</programlisting>
+
+ <calloutlist>
+  <callout arearefs='qt-default-nix-co-1'>
+   <para>
+    Import Qt modules directly, that is: <literal>qtbase</literal>, <literal>qtdeclarative</literal>, etc.
+    <emphasis>Do not</emphasis> import Qt package sets such as <literal>qt5</literal>
+    because the Qt versions of dependencies may not be coherent, causing build and runtime failures.
+   </para>
+  </callout>
+  <callout arearefs='qt-default-nix-co-2'>
+    <para>
+      All Qt packages must include <literal>wrapQtAppsHook</literal> in
+      <literal>nativeBuildInputs</literal>, or you must explicitly set
+      <literal>dontWrapQtApps</literal>.
+    </para>
+  </callout>
+ </calloutlist>
+```
+
+## Locating runtime dependencies {#qt-runtime-dependencies}
+
+Qt applications must be wrapped to find runtime dependencies.
+Include `wrapQtAppsHook` in `nativeBuildInputs`:
+
+```nix
+{ stdenv, wrapQtAppsHook }:
+
+stdenv.mkDerivation {
+  # ...
+  nativeBuildInputs = [ wrapQtAppsHook ];
+}
+```
+
+Add entries to `qtWrapperArgs` are to modify the wrappers created by
+`wrapQtAppsHook`:
+
+```nix
+{ stdenv, wrapQtAppsHook }:
+
+stdenv.mkDerivation {
+  # ...
+  nativeBuildInputs = [ wrapQtAppsHook ];
+  qtWrapperArgs = [ ''--prefix PATH : /path/to/bin'' ];
+}
+```
+
+The entries are passed as arguments to [wrapProgram](#fun-wrapProgram).
+
+Set `dontWrapQtApps` to stop applications from being wrapped automatically.
+Wrap programs manually with `wrapQtApp`, using the syntax of
+[wrapProgram](#fun-wrapProgram):
+
+```nix
+{ stdenv, lib, wrapQtAppsHook }:
+
+stdenv.mkDerivation {
+  # ...
+  nativeBuildInputs = [ wrapQtAppsHook ];
+  dontWrapQtApps = true;
+  preFixup = ''
+      wrapQtApp "$out/bin/myapp" --prefix PATH : /path/to/bin
+  '';
+}
+```
+
+::: {.note}
+`wrapQtAppsHook` ignores files that are non-ELF executables.
+This means that scripts won't be automatically wrapped so you'll need to manually wrap them as previously mentioned.
+An example of when you'd always need to do this is with Python applications that use PyQt.
+:::
+
+## Adding a library to Nixpkgs {#adding-a-library-to-nixpkgs}
+
+Add Qt libraries to `qt5-packages.nix` to make them available for every
+supported Qt version.
+
+### Example adding a Qt library {#qt-library-all-packages-nix}
+
+The following represents the contents of `qt5-packages.nix`.
+
+```nix
+{
+  # ...
+
+  mylib = callPackage ../path/to/mylib {};
+
+  # ...
+}
+```
+
+Libraries are built with every available version of Qt.
+Use the `meta.broken` attribute to disable the package for unsupported Qt versions:
+
+```nix
+{ stdenv, lib, qtbase }:
+
+stdenv.mkDerivation {
+  # ...
+  # Disable this library with Qt < 5.9.0
+  meta.broken = lib.versionOlder qtbase.version "5.9.0";
+}
+```
+
+## Adding an application to Nixpkgs {#adding-an-application-to-nixpkgs}
+
+Add Qt applications to `qt5-packages.nix`. Add an alias to `all-packages.nix`
+to select the Qt 5 version used for the application.
+
+### Example adding a Qt application {#qt-application-all-packages-nix}
+
+The following represents the contents of `qt5-packages.nix`.
+
+```nix
+{
+  # ...
+
+  myapp = callPackage ../path/to/myapp {};
+
+  # ...
+}
+```
+
+The following represents the contents of `all-packages.nix`.
+
+```nix
+{
+  # ...
+
+  myapp = libsForQt5.myapp;
+
+  # ...
+}
+```
diff --git a/doc/languages-frameworks/qt.xml b/doc/languages-frameworks/qt.xml
deleted file mode 100644
index 8d97de504ad..00000000000
--- a/doc/languages-frameworks/qt.xml
+++ /dev/null
@@ -1,149 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-language-qt">
- <title>Qt</title>
-
- <para>
-  This section describes the differences between Nix expressions for Qt libraries and applications and Nix expressions for other C++ software. Some knowledge of the latter is assumed. There are primarily two problems which the Qt infrastructure is designed to address: ensuring consistent versioning of all dependencies and finding dependencies at runtime.
- </para>
-
- <example xml:id='qt-default-nix'>
-  <title>Nix expression for a Qt package (<filename>default.nix</filename>)</title>
-<programlisting>
-{ mkDerivation, lib, qtbase }: <co xml:id='qt-default-nix-co-1' />
-
-mkDerivation { <co xml:id='qt-default-nix-co-2' />
-  pname = "myapp";
-  version = "1.0";
-
-  buildInputs = [ qtbase ]; <co xml:id='qt-default-nix-co-3' />
-}
-   </programlisting>
- </example>
-
- <calloutlist>
-  <callout arearefs='qt-default-nix-co-1'>
-   <para>
-    Import <literal>mkDerivation</literal> and Qt (such as <literal>qtbase</literal> modules directly. <emphasis>Do not</emphasis> import Qt package sets; the Qt versions of dependencies may not be coherent, causing build and runtime failures.
-   </para>
-  </callout>
-  <callout arearefs='qt-default-nix-co-2'>
-   <para>
-    Use <literal>mkDerivation</literal> instead of <literal>stdenv.mkDerivation</literal>. <literal>mkDerivation</literal> is a wrapper around <literal>stdenv.mkDerivation</literal> which applies some Qt-specific settings. This deriver accepts the same arguments as <literal>stdenv.mkDerivation</literal>; refer to <xref linkend='chap-stdenv' /> for details.
-   </para>
-   <para>
-    To use another deriver instead of <literal>stdenv.mkDerivation</literal>, use <literal>mkDerivationWith</literal>:
-<programlisting>
-mkDerivationWith myDeriver {
-  # ...
-}
-</programlisting>
-    If you cannot use <literal>mkDerivationWith</literal>, please refer to <xref linkend='qt-runtime-dependencies' />.
-   </para>
-  </callout>
-  <callout arearefs='qt-default-nix-co-3'>
-   <para>
-    <literal>mkDerivation</literal> accepts the same arguments as <literal>stdenv.mkDerivation</literal>, such as <literal>buildInputs</literal>.
-   </para>
-  </callout>
- </calloutlist>
-
- <formalpara xml:id='qt-runtime-dependencies'>
-  <title>Locating runtime dependencies</title>
-  <para>
-   Qt applications need to be wrapped to find runtime dependencies. If you cannot use <literal>mkDerivation</literal> or <literal>mkDerivationWith</literal> above, include <literal>wrapQtAppsHook</literal> in <literal>nativeBuildInputs</literal>:
-<programlisting>
-stdenv.mkDerivation {
-  # ...
-
-  nativeBuildInputs = [ wrapQtAppsHook ];
-}
-</programlisting>
-  </para>
- </formalpara>
-
- <para>
-  Entries added to <literal>qtWrapperArgs</literal> are used to modify the wrappers created by <literal>wrapQtAppsHook</literal>. The entries are passed as arguments to <xref linkend='fun-wrapProgram' />.
-<programlisting>
-mkDerivation {
-  # ...
-
-  qtWrapperArgs = [ ''--prefix PATH : /path/to/bin'' ];
-}
-</programlisting>
- </para>
-
- <para>
-  Set <literal>dontWrapQtApps</literal> to stop applications from being wrapped automatically. It is required to wrap applications manually with <literal>wrapQtApp</literal>, using the syntax of <xref linkend='fun-wrapProgram' />:
-<programlisting>
-mkDerivation {
-  # ...
-
-  dontWrapQtApps = true;
-  preFixup = ''
-      wrapQtApp "$out/bin/myapp" --prefix PATH : /path/to/bin
-  '';
-}
-</programlisting>
- </para>
-
- <note>
-  <para>
-   <literal>wrapQtAppsHook</literal> ignores files that are non-ELF executables. This means that scripts won't be automatically wrapped so you'll need to manually wrap them as previously mentioned. An example of when you'd always need to do this is with Python applications that use PyQT.
-  </para>
- </note>
-
- <para>
-  Libraries are built with every available version of Qt. Use the <literal>meta.broken</literal> attribute to disable the package for unsupported Qt versions:
-<programlisting>
-mkDerivation {
-  # ...
-
-  # Disable this library with Qt &lt; 5.9.0
-  meta.broken = builtins.compareVersions qtbase.version "5.9.0" &lt; 0;
-}
-</programlisting>
- </para>
-
- <formalpara>
-  <title>Adding a library to Nixpkgs</title>
-  <para>
-   Add a Qt library to <filename>all-packages.nix</filename> by adding it to the collection inside <literal>mkLibsForQt5</literal>. This ensures that the library is built with every available version of Qt as needed.
-   <example xml:id='qt-library-all-packages-nix'>
-    <title>Adding a Qt library to <filename>all-packages.nix</filename></title>
-<programlisting>
-{
-  # ...
-
-  mkLibsForQt5 = self: with self; {
-    # ...
-
-    mylib = callPackage ../path/to/mylib {};
-  };
-
-  # ...
-}
-</programlisting>
-   </example>
-  </para>
- </formalpara>
-
- <formalpara>
-  <title>Adding an application to Nixpkgs</title>
-  <para>
-   Add a Qt application to <filename>all-packages.nix</filename> using <literal>libsForQt5.callPackage</literal> instead of the usual <literal>callPackage</literal>. The former ensures that all dependencies are built with the same version of Qt.
-   <example xml:id='qt-application-all-packages-nix'>
-    <title>Adding a Qt application to <filename>all-packages.nix</filename></title>
-<programlisting>
-{
-  # ...
-
-  myapp = libsForQt5.callPackage ../path/to/myapp/ {};
-
-  # ...
-}
-</programlisting>
-   </example>
-  </para>
- </formalpara>
-</section>
diff --git a/doc/languages-frameworks/r.section.md b/doc/languages-frameworks/r.section.md
index d4e1617779c..56e3da64df2 100644
--- a/doc/languages-frameworks/r.section.md
+++ b/doc/languages-frameworks/r.section.md
@@ -1,7 +1,6 @@
-R
-=
+# R {#r}
 
-## Installation
+## Installation {#installation}
 
 Define an environment for R that contains all the libraries that you'd like to
 use by adding the following snippet to your $HOME/.config/nixpkgs/config.nix file:
@@ -32,15 +31,14 @@ output is the name that has to be passed to rWrapper in the code snipped above.
 However, if you'd like to add a file to your project source to make the
 environment available for other contributors, you can create a `default.nix`
 file like so:
+
 ```nix
-let
-  pkgs = import <nixpkgs> {};
-  stdenv = pkgs.stdenv;
-in with pkgs; {
+with import <nixpkgs> {};
+{
   myProject = stdenv.mkDerivation {
     name = "myProject";
     version = "1";
-    src = if pkgs.lib.inNixShell then null else nix;
+    src = if lib.inNixShell then null else nix;
 
     buildInputs = with rPackages; [
       R
@@ -53,7 +51,7 @@ in with pkgs; {
 and then run `nix-shell .` to be dropped into a shell with those packages
 available.
 
-## RStudio
+## RStudio {#rstudio}
 
 RStudio uses a standard set of packages and ignores any custom R
 environments or installed packages you may have.  To create a custom
@@ -96,7 +94,7 @@ Executing `nix-shell` will then drop you into an environment equivalent to the
 one above. If you need additional packages just add them to the list and
 re-enter the shell.
 
-## Updating the package set
+## Updating the package set {#updating-the-package-set}
 
 ```bash
 nix-shell generate-shell.nix
@@ -106,12 +104,17 @@ mv cran-packages.nix.new cran-packages.nix
 
 Rscript generate-r-packages.R bioc  > bioc-packages.nix.new
 mv bioc-packages.nix.new bioc-packages.nix
+
+Rscript generate-r-packages.R bioc-annotation > bioc-annotation-packages.nix.new
+mv bioc-annotation-packages.nix.new bioc-annotation-packages.nix
+
+Rscript generate-r-packages.R bioc-experiment > bioc-experiment-packages.nix.new
+mv bioc-experiment-packages.nix.new bioc-experiment-packages.nix
 ```
 
 `generate-r-packages.R <repo>` reads  `<repo>-packages.nix`, therefor the renaming.
 
-
-## Testing if the Nix-expression could be evaluated
+## Testing if the Nix-expression could be evaluated {#testing-if-the-nix-expression-could-be-evaluated}
 
 ```bash
 nix-build test-evaluation.nix --dry-run
diff --git a/doc/languages-frameworks/ruby.section.md b/doc/languages-frameworks/ruby.section.md
index e4c4ffce043..36b794458cb 100644
--- a/doc/languages-frameworks/ruby.section.md
+++ b/doc/languages-frameworks/ruby.section.md
@@ -1,74 +1,38 @@
----
-title: Ruby
-author: Michael Fellinger
-date: 2019-05-23
----
+# Ruby {#sec-language-ruby}
 
-# Ruby
+## Using Ruby {#using-ruby}
 
-## User Guide
+Several versions of Ruby interpreters are available on Nix, as well as over 250 gems and many applications written in Ruby. The attribute `ruby` refers to the default Ruby interpreter, which is currently MRI 2.6. It's also possible to refer to specific versions, e.g. `ruby_2_y`, `jruby`, or `mruby`.
 
-### Using Ruby
+In the Nixpkgs tree, Ruby packages can be found throughout, depending on what they do, and are called from the main package set. Ruby gems, however are separate sets, and there's one default set for each interpreter (currently MRI only).
 
-#### Overview
+There are two main approaches for using Ruby with gems. One is to use a specifically locked `Gemfile` for an application that has very strict dependencies. The other is to depend on the common gems, which we'll explain further down, and rely on them being updated regularly.
 
-Several versions of Ruby interpreters are available on Nix, as well as over 250 gems and many applications written in Ruby.
-The attribute `ruby` refers to the default Ruby interpreter, which is currently
-MRI 2.5. It's also possible to refer to specific versions, e.g. `ruby_2_6`, `jruby`, or `mruby`.
+The interpreters have common attributes, namely `gems`, and `withPackages`. So you can refer to `ruby.gems.nokogiri`, or `ruby_2_6.gems.nokogiri` to get the Nokogiri gem already compiled and ready to use.
 
-In the nixpkgs tree, Ruby packages can be found throughout, depending on what
-they do, and are called from the main package set. Ruby gems, however are
-separate sets, and there's one default set for each interpreter (currently MRI
-only).
+Since not all gems have executables like `nokogiri`, it's usually more convenient to use the `withPackages` function like this: `ruby.withPackages (p: with p; [ nokogiri ])`. This will also make sure that the Ruby in your environment will be able to find the gem and it can be used in your Ruby code (for example via `ruby` or `irb` executables) via `require "nokogiri"` as usual.
 
-There are two main approaches for using Ruby with gems.
-One is to use a specifically locked `Gemfile` for an application that has very strict dependencies.
-The other is to depend on the common gems, which we'll explain further down, and
-rely on them being updated regularly.
+### Temporary Ruby environment with `nix-shell` {#temporary-ruby-environment-with-nix-shell}
 
-The interpreters have common attributes, namely `gems`, and `withPackages`. So
-you can refer to `ruby.gems.nokogiri`, or `ruby_2_5.gems.nokogiri` to get the
-Nokogiri gem already compiled and ready to use.
+Rather than having a single Ruby environment shared by all Ruby development projects on a system, Nix allows you to create separate environments per project. `nix-shell` gives you the possibility to temporarily load another environment akin to a combined `chruby` or `rvm` and `bundle exec`.
 
-Since not all gems have executables like `nokogiri`, it's usually more
-convenient to use the `withPackages` function like this:
-`ruby.withPackages (p: with p; [ nokogiri ])`. This will also make sure that the
-Ruby in your environment will be able to find the gem and it can be used in your
-Ruby code (for example via `ruby` or `irb` executables) via `require "nokogiri"`
-as usual.
+There are two methods for loading a shell with Ruby packages. The first and recommended method is to create an environment with `ruby.withPackages` and load that.
 
-#### Temporary Ruby environment with `nix-shell`
-
-Rather than having a single Ruby environment shared by all Ruby
-development projects on a system, Nix allows you to create separate
-environments per project.  `nix-shell` gives you the possibility to
-temporarily load another environment akin to a combined `chruby` or
-`rvm` and `bundle exec`.
-
-There are two methods for loading a shell with Ruby packages. The first and
-recommended method is to create an environment with `ruby.withPackages` and load
-that.
-
-```shell
-nix-shell -p "ruby.withPackages (ps: with ps; [ nokogiri pry ])"
+```ShellSession
+$ nix-shell -p "ruby.withPackages (ps: with ps; [ nokogiri pry ])"
 ```
 
-The other method, which is not recommended, is to create an environment and list
-all the packages directly.
+The other method, which is not recommended, is to create an environment and list all the packages directly.
 
-```shell
-nix-shell -p ruby.gems.nokogiri ruby.gems.pry
+```ShellSession
+$ nix-shell -p ruby.gems.nokogiri ruby.gems.pry
 ```
 
-Again, it's possible to launch the interpreter from the shell. The Ruby
-interpreter has the attribute `gems` which contains all Ruby gems for that
-specific interpreter.
+Again, it's possible to launch the interpreter from the shell. The Ruby interpreter has the attribute `gems` which contains all Ruby gems for that specific interpreter.
 
-##### Load environment from `.nix` expression
+#### Load Ruby environment from `.nix` expression {#load-ruby-environment-from-.nix-expression}
 
-As explained in the Nix manual, `nix-shell` can also load an expression from a
-`.nix` file. Say we want to have Ruby 2.5, `nokogori`, and `pry`. Consider a
-`shell.nix` file with:
+As explained in the Nix manual, `nix-shell` can also load an expression from a `.nix` file. Say we want to have Ruby 2.6, `nokogori`, and `pry`. Consider a `shell.nix` file with:
 
 ```nix
 with import <nixpkgs> {};
@@ -77,43 +41,33 @@ ruby.withPackages (ps: with ps; [ nokogiri pry ])
 
 What's happening here?
 
-1. We begin with importing the Nix Packages collections. `import <nixpkgs>`
-   imports the `<nixpkgs>` function, `{}` calls it and the `with` statement
-   brings all attributes of `nixpkgs` in the local scope. These attributes form
-   the main package set.
+1. We begin with importing the Nix Packages collections. `import <nixpkgs>` imports the `<nixpkgs>` function, `{}` calls it and the `with` statement brings all attributes of `nixpkgs` in the local scope. These attributes form the main package set.
 2. Then we create a Ruby environment with the `withPackages` function.
-3. The `withPackages` function expects us to provide a function as an argument
-   that takes the set of all ruby gems and returns a list of packages to include
-   in the environment. Here, we select the packages `nokogiri` and `pry` from
-   the package set.
+3. The `withPackages` function expects us to provide a function as an argument that takes the set of all ruby gems and returns a list of packages to include in the environment. Here, we select the packages `nokogiri` and `pry` from the package set.
 
-##### Execute command with `--run`
+#### Execute command with `--run` {#execute-command-with---run}
 
-A convenient flag for `nix-shell` is `--run`. It executes a command in the
-`nix-shell`. We can e.g. directly open a `pry` REPL:
+A convenient flag for `nix-shell` is `--run`. It executes a command in the `nix-shell`. We can e.g. directly open a `pry` REPL:
 
-```shell
-nix-shell -p "ruby.withPackages (ps: with ps; [ nokogiri pry ])" --run "pry"
+```ShellSession
+$ nix-shell -p "ruby.withPackages (ps: with ps; [ nokogiri pry ])" --run "pry"
 ```
 
 Or immediately require `nokogiri` in pry:
 
-```shell
-nix-shell -p "ruby.withPackages (ps: with ps; [ nokogiri pry ])" --run "pry -rnokogiri"
+```ShellSession
+$ nix-shell -p "ruby.withPackages (ps: with ps; [ nokogiri pry ])" --run "pry -rnokogiri"
 ```
 
 Or run a script using this environment:
 
-```shell
-nix-shell -p "ruby.withPackages (ps: with ps; [ nokogiri pry ])" --run "ruby example.rb"
+```ShellSession
+$ nix-shell -p "ruby.withPackages (ps: with ps; [ nokogiri pry ])" --run "ruby example.rb"
 ```
 
-##### Using `nix-shell` as shebang
+#### Using `nix-shell` as shebang {#using-nix-shell-as-shebang}
 
-In fact, for the last case, there is a more convenient method. You can add a
-[shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)) to your script
-specifying which dependencies `nix-shell` needs. With the following shebang, you
-can just execute `./example.rb`, and it will run with all dependencies.
+In fact, for the last case, there is a more convenient method. You can add a [shebang](<https://en.wikipedia.org/wiki/Shebang_(Unix)>) to your script specifying which dependencies `nix-shell` needs. With the following shebang, you can just execute `./example.rb`, and it will run with all dependencies.
 
 ```ruby
 #! /usr/bin/env nix-shell
@@ -126,35 +80,24 @@ body = RestClient.get('http://example.com').body
 puts Nokogiri::HTML(body).at('h1').text
 ```
 
-### Developing with Ruby
+## Developing with Ruby {#developing-with-ruby}
 
-#### Using an existing Gemfile
+### Using an existing Gemfile {#using-an-existing-gemfile}
 
-In most cases, you'll already have a `Gemfile.lock` listing all your dependencies.
-This can be used to generate a `gemset.nix` which is used to fetch the gems and
-combine them into a single environment.
-The reason why you need to have a separate file for this, is that Nix requires
-you to have a checksum for each input to your build.
-Since the `Gemfile.lock` that `bundler` generates doesn't provide us with
-checksums, we have to first download each gem, calculate its SHA256, and store
-it in this separate file.
+In most cases, you'll already have a `Gemfile.lock` listing all your dependencies. This can be used to generate a `gemset.nix` which is used to fetch the gems and combine them into a single environment. The reason why you need to have a separate file for this, is that Nix requires you to have a checksum for each input to your build. Since the `Gemfile.lock` that `bundler` generates doesn't provide us with checksums, we have to first download each gem, calculate its SHA256, and store it in this separate file.
 
 So the steps from having just a `Gemfile` to a `gemset.nix` are:
 
-```shell
-bundle lock
-bundix
+```ShellSession
+$ bundle lock
+$ bundix
 ```
 
-If you already have a `Gemfile.lock`, you can simply run `bundix` and it will
-work the same.
+If you already have a `Gemfile.lock`, you can simply run `bundix` and it will work the same.
 
-To update the gems in your `Gemfile.lock`, you may use the `bundix -l` flag,
-which will create a new `Gemfile.lock` in case the `Gemfile` has a more recent
-time of modification.
+To update the gems in your `Gemfile.lock`, you may use the `bundix -l` flag, which will create a new `Gemfile.lock` in case the `Gemfile` has a more recent time of modification.
 
-Once the `gemset.nix` is generated, it can be used in a
-`bundlerEnv` derivation. Here is an example you could use for your `shell.nix`:
+Once the `gemset.nix` is generated, it can be used in a `bundlerEnv` derivation. Here is an example you could use for your `shell.nix`:
 
 ```nix
 # ...
@@ -163,44 +106,29 @@ let
     name = "gems-for-some-project";
     gemdir = ./.;
   };
-in mkShell { buildInputs = [ gems gems.wrappedRuby ]; }
+in mkShell { packages = [ gems gems.wrappedRuby ]; }
 ```
 
-With this file in your directory, you can run `nix-shell` to build and use the gems.
-The important parts here are `bundlerEnv` and `wrappedRuby`.
+With this file in your directory, you can run `nix-shell` to build and use the gems. The important parts here are `bundlerEnv` and `wrappedRuby`.
 
-The `bundlerEnv` is a wrapper over all the gems in your gemset. This means that
-all the `/lib` and `/bin` directories will be available, and the executables of
-all gems (even of indirect dependencies) will end up in your `$PATH`.
-The `wrappedRuby` provides you with all executables that come with Ruby itself,
-but wrapped so they can easily find the gems in your gemset.
+The `bundlerEnv` is a wrapper over all the gems in your gemset. This means that all the `/lib` and `/bin` directories will be available, and the executables of all gems (even of indirect dependencies) will end up in your `$PATH`. The `wrappedRuby` provides you with all executables that come with Ruby itself, but wrapped so they can easily find the gems in your gemset.
 
-One common issue that you might have is that you have Ruby 2.6, but also
-`bundler` in your gemset. That leads to a conflict for `/bin/bundle` and
-`/bin/bundler`. You can resolve this by wrapping either your Ruby or your gems
-in a `lowPrio` call. So in order to give the `bundler` from your gemset
-priority, it would be used like this:
+One common issue that you might have is that you have Ruby 2.6, but also `bundler` in your gemset. That leads to a conflict for `/bin/bundle` and `/bin/bundler`. You can resolve this by wrapping either your Ruby or your gems in a `lowPrio` call. So in order to give the `bundler` from your gemset priority, it would be used like this:
 
 ```nix
 # ...
 mkShell { buildInputs = [ gems (lowPrio gems.wrappedRuby) ]; }
 ```
 
+### Gem-specific configurations and workarounds {#gem-specific-configurations-and-workarounds}
 
-#### Gem-specific configurations and workarounds
-
-In some cases, especially if the gem has native extensions, you might need to
-modify the way the gem is built.
+In some cases, especially if the gem has native extensions, you might need to modify the way the gem is built.
 
-This is done via a common configuration file that includes all of the
-workarounds for each gem.
+This is done via a common configuration file that includes all of the workarounds for each gem.
 
-This file lives at `/pkgs/development/ruby-modules/gem-config/default.nix`,
-since it already contains a lot of entries, it should be pretty easy to add the
-modifications you need for your needs.
+This file lives at `/pkgs/development/ruby-modules/gem-config/default.nix`, since it already contains a lot of entries, it should be pretty easy to add the modifications you need for your needs.
 
-In the meanwhile, or if the modification is for a private gem, you can also add
-the configuration to only your own environment.
+In the meanwhile, or if the modification is for a private gem, you can also add the configuration to only your own environment.
 
 Two places that allow this modification are the `ruby` derivation, or `bundlerEnv`.
 
@@ -261,10 +189,9 @@ let
 in pkgs.ruby.withPackages (ps: with ps; [ pg ])
 ```
 
-Then we can get whichever postgresql version we desire and the `pg` gem will
-always reference it correctly:
+Then we can get whichever postgresql version we desire and the `pg` gem will always reference it correctly:
 
-```shell
+```ShellSession
 $ nix-shell --argstr pg_version 9_4 --run 'ruby -rpg -e "puts PG.library_version"'
 90421
 
@@ -272,24 +199,15 @@ $ nix-shell --run 'ruby -rpg -e "puts PG.library_version"'
 100007
 ```
 
-Of course for this use-case one could also use overlays since the configuration
-for `pg` depends on the `postgresql` alias, but for demonstration purposes this
-has to suffice.
+Of course for this use-case one could also use overlays since the configuration for `pg` depends on the `postgresql` alias, but for demonstration purposes this has to suffice.
 
-#### Adding a gem to the default gemset
+### Adding a gem to the default gemset {#adding-a-gem-to-the-default-gemset}
 
-Now that you know how to get a working Ruby environment with Nix, it's time to
-go forward and start actually developing with Ruby.
-We will first have a look at how Ruby gems are packaged on Nix. Then, we will
-look at how you can use development mode with your code.
+Now that you know how to get a working Ruby environment with Nix, it's time to go forward and start actually developing with Ruby. We will first have a look at how Ruby gems are packaged on Nix. Then, we will look at how you can use development mode with your code.
 
-All gems in the standard set are automatically generated from a single
-`Gemfile`. The dependency resolution is done with `bundler` and makes it more
-likely that all gems are compatible to each other.
+All gems in the standard set are automatically generated from a single `Gemfile`. The dependency resolution is done with `bundler` and makes it more likely that all gems are compatible to each other.
 
-In order to add a new gem to nixpkgs, you can put it into the
-`/pkgs/development/ruby-modules/with-packages/Gemfile` and run
-`./maintainers/scripts/update-ruby-packages`.
+In order to add a new gem to nixpkgs, you can put it into the `/pkgs/development/ruby-modules/with-packages/Gemfile` and run `./maintainers/scripts/update-ruby-packages`.
 
 To test that it works, you can then try using the gem with:
 
@@ -297,16 +215,11 @@ To test that it works, you can then try using the gem with:
 NIX_PATH=nixpkgs=$PWD nix-shell -p "ruby.withPackages (ps: with ps; [ name-of-your-gem ])"
 ```
 
-#### Packaging applications
+### Packaging applications {#packaging-applications}
 
-A common task is to add a ruby executable to nixpkgs, popular examples would be
-`chef`, `jekyll`, or `sass`. A good way to do that is to use the `bundlerApp`
-function, that allows you to make a package that only exposes the listed
-executables, otherwise the package may cause conflicts through common paths like
-`bin/rake` or `bin/bundler` that aren't meant to be used.
+A common task is to add a ruby executable to nixpkgs, popular examples would be `chef`, `jekyll`, or `sass`. A good way to do that is to use the `bundlerApp` function, that allows you to make a package that only exposes the listed executables, otherwise the package may cause conflicts through common paths like `bin/rake` or `bin/bundler` that aren't meant to be used.
 
-The absolute easiest way to do that is to write a
-`Gemfile` along these lines:
+The absolute easiest way to do that is to write a `Gemfile` along these lines:
 
 ```ruby
 source 'https://rubygems.org' do
@@ -314,15 +227,12 @@ source 'https://rubygems.org' do
 end
 ```
 
-If you want to package a specific version, you can use the standard Gemfile
-syntax for that, e.g. `gem 'mdl', '0.5.0'`, but if you want the latest stable
-version anyway, it's easier to update by simply running the `bundle lock` and
-`bundix` steps again.
+If you want to package a specific version, you can use the standard Gemfile syntax for that, e.g. `gem 'mdl', '0.5.0'`, but if you want the latest stable version anyway, it's easier to update by simply running the `bundle lock` and `bundix` steps again.
 
-Now you can also also make a `default.nix` that looks like this:
+Now you can also make a `default.nix` that looks like this:
 
 ```nix
-{ lib, bundlerApp }:
+{ bundlerApp }:
 
 bundlerApp {
   pname = "mdl";
@@ -331,20 +241,15 @@ bundlerApp {
 }
 ```
 
-All that's left to do is to generate the corresponding `Gemfile.lock` and
-`gemset.nix` as described above in the `Using an existing Gemfile` section.
+All that's left to do is to generate the corresponding `Gemfile.lock` and `gemset.nix` as described above in the `Using an existing Gemfile` section.
 
-##### Packaging executables that require wrapping
+#### Packaging executables that require wrapping {#packaging-executables-that-require-wrapping}
 
-Sometimes your app will depend on other executables at runtime, and tries to
-find it through the `PATH` environment variable.
+Sometimes your app will depend on other executables at runtime, and tries to find it through the `PATH` environment variable.
 
-In this case, you can provide a `postBuild` hook to `bundlerApp` that wraps the
-gem in another script that prefixes the `PATH`.
+In this case, you can provide a `postBuild` hook to `bundlerApp` that wraps the gem in another script that prefixes the `PATH`.
 
-Of course you could also make a custom `gemConfig` if you know exactly how to
-patch it, but it's usually much easier to maintain with a simple wrapper so the
-patch doesn't have to be adjusted for each version.
+Of course you could also make a custom `gemConfig` if you know exactly how to patch it, but it's usually much easier to maintain with a simple wrapper so the patch doesn't have to be adjusted for each version.
 
 Here's another example:
 
diff --git a/doc/languages-frameworks/ruby.xml b/doc/languages-frameworks/ruby.xml
deleted file mode 100644
index 9b36801fb96..00000000000
--- a/doc/languages-frameworks/ruby.xml
+++ /dev/null
@@ -1,108 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-language-ruby">
- <title>Ruby</title>
-
- <para>
-  There currently is support to bundle applications that are packaged as Ruby gems. The utility "bundix" allows you to write a <filename>Gemfile</filename>, let bundler create a <filename>Gemfile.lock</filename>, and then convert this into a nix expression that contains all Gem dependencies automatically.
- </para>
-
- <para>
-  For example, to package sensu, we did:
- </para>
-
-<screen>
-<![CDATA[$ cd pkgs/servers/monitoring
-$ mkdir sensu
-$ cd sensu
-$ cat > Gemfile
-source 'https://rubygems.org'
-gem 'sensu'
-$ $(nix-build '<nixpkgs>' -A bundix --no-out-link)/bin/bundix --magic
-$ cat > default.nix
-{ lib, bundlerEnv, ruby }:
-
-bundlerEnv rec {
-  name = "sensu-${version}";
-
-  version = (import gemset).sensu.version;
-  inherit ruby;
-  # expects Gemfile, Gemfile.lock and gemset.nix in the same directory
-  gemdir = ./.;
-
-  meta = with lib; {
-    description = "A monitoring framework that aims to be simple, malleable, and scalable";
-    homepage    = "http://sensuapp.org/";
-    license     = with licenses; mit;
-    maintainers = with maintainers; [ theuni ];
-    platforms   = platforms.unix;
-  };
-}]]>
-</screen>
-
- <para>
-  Please check in the <filename>Gemfile</filename>, <filename>Gemfile.lock</filename> and the <filename>gemset.nix</filename> so future updates can be run easily.
- </para>
-
- <para>
-  Updating Ruby packages can then be done like this:
- </para>
-
-<screen>
-<![CDATA[$ cd pkgs/servers/monitoring/sensu
-$ nix-shell -p bundler --run 'bundle lock --update'
-$ nix-shell -p bundix --run 'bundix'
-]]>
-</screen>
-
- <para>
-  For tools written in Ruby - i.e. where the desire is to install a package and then execute e.g. <command>rake</command> at the command line, there is an alternative builder called <literal>bundlerApp</literal>. Set up the <filename>gemset.nix</filename> the same way, and then, for example:
- </para>
-
-<screen>
-<![CDATA[{ lib, bundlerApp }:
-
-bundlerApp {
-  pname = "corundum";
-  gemdir = ./.;
-  exes = [ "corundum-skel" ];
-
-  meta = with lib; {
-    description = "Tool and libraries for maintaining Ruby gems.";
-    homepage    = "https://github.com/nyarly/corundum";
-    license     = licenses.mit;
-    maintainers = [ maintainers.nyarly ];
-    platforms   = platforms.unix;
-  };
-}]]>
-</screen>
-
- <para>
-  The chief advantage of <literal>bundlerApp</literal> over <literal>bundlerEnv</literal> is the executables introduced in the environment are precisely those selected in the <literal>exes</literal> list, as opposed to <literal>bundlerEnv</literal> which adds all the executables made available by gems in the gemset, which can mean e.g. <command>rspec</command> or <command>rake</command> in unpredictable versions available from various packages.
- </para>
-
- <para>
-  Resulting derivations for both builders also have two helpful attributes, <literal>env</literal> and <literal>wrappedRuby</literal>. The first one allows one to quickly drop into <command>nix-shell</command> with the specified environment present. E.g. <command>nix-shell -A sensu.env</command> would give you an environment with Ruby preset so it has all the libraries necessary for <literal>sensu</literal> in its paths. The second one can be used to make derivations from custom Ruby scripts which have <filename>Gemfile</filename>s with their dependencies specified. It is a derivation with <command>ruby</command> wrapped so it can find all the needed dependencies. For example, to make a derivation <literal>my-script</literal> for a <filename>my-script.rb</filename> (which should be placed in <filename>bin</filename>) you should run <command>bundix</command> as specified above and then use <literal>bundlerEnv</literal> like this:
- </para>
-
-<programlisting>
-<![CDATA[let env = bundlerEnv {
-  name = "my-script-env";
-
-  inherit ruby;
-  gemfile = ./Gemfile;
-  lockfile = ./Gemfile.lock;
-  gemset = ./gemset.nix;
-};
-
-in stdenv.mkDerivation {
-  name = "my-script";
-  buildInputs = [ env.wrappedRuby ];
-  script = ./my-script.rb;
-  buildCommand = ''
-    install -D -m755 $script $out/bin/my-script
-    patchShebangs $out/bin/my-script
-  '';
-}]]>
-</programlisting>
-</section>
diff --git a/doc/languages-frameworks/rust.section.md b/doc/languages-frameworks/rust.section.md
index 6c51da87cab..f5c664bec20 100644
--- a/doc/languages-frameworks/rust.section.md
+++ b/doc/languages-frameworks/rust.section.md
@@ -1,44 +1,41 @@
----
-title: Rust
-author: Matthias Beyer
-date: 2017-03-05
----
-
-# Rust
+# Rust {#rust}
 
 To install the rust compiler and cargo put
 
-```
-rustc
-cargo
+```nix
+environment.systemPackages = [
+  rustc
+  cargo
+];
 ```
 
-into the `environment.systemPackages` or bring them into
-scope with `nix-shell -p rustc cargo`.
+into your `configuration.nix` or bring them into scope with `nix-shell -p rustc cargo`.
 
-For daily builds (beta and nightly) use either rustup from
-nixpkgs or use the [Rust nightlies
-overlay](#using-the-rust-nightlies-overlay).
+For other versions such as daily builds (beta and nightly),
+use either `rustup` from nixpkgs (which will manage the rust installation in your home directory),
+or use Mozilla's [Rust nightlies overlay](#using-the-rust-nightlies-overlay).
 
-## Compiling Rust applications with Cargo
+## Compiling Rust applications with Cargo {#compiling-rust-applications-with-cargo}
 
 Rust applications are packaged by using the `buildRustPackage` helper from `rustPlatform`:
 
-```
+```nix
+{ lib, rustPlatform }:
+
 rustPlatform.buildRustPackage rec {
   pname = "ripgrep";
-  version = "11.0.2";
+  version = "12.1.1";
 
   src = fetchFromGitHub {
     owner = "BurntSushi";
     repo = pname;
     rev = version;
-    sha256 = "1iga3320mgi7m853la55xip514a3chqsdi1a1rwv25lr9b1p7vd3";
+    sha256 = "1hqps7l5qrjh9f914r5i6kmcz6f1yb951nv4lby0cjnp5l253kps";
   };
 
-  cargoSha256 = "17ldqr3asrdcsh4l29m3b5r37r5d0b3npq1lrgjmxb6vlx6a36qh";
+  cargoSha256 = "03wf9r2csi6jpa7v5sw5lpxkrk4wfzwmzx7k3991q3bdjzcwnnwp";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A fast line-oriented regex search tool, similar to ag and ack";
     homepage = "https://github.com/BurntSushi/ripgrep";
     license = licenses.unlicense;
@@ -47,34 +44,189 @@ rustPlatform.buildRustPackage rec {
 }
 ```
 
-`buildRustPackage` requires a `cargoSha256` attribute which is computed over
-all crate sources of this package. Currently it is obtained by inserting a
-fake checksum into the expression and building the package once. The correct
-checksum can be then take from the failed build.
+`buildRustPackage` requires either the `cargoSha256` or the
+`cargoHash` attribute which is computed over all crate sources of this
+package. `cargoHash256` is used for traditional Nix SHA-256 hashes,
+such as the one in the example above. `cargoHash` should instead be
+used for [SRI](https://www.w3.org/TR/SRI/) hashes. For example:
+
+```nix
+  cargoHash = "sha256-l1vL2ZdtDRxSGvP0X/l3nMw8+6WF67KPutJEzUROjg8=";
+```
+
+Both types of hashes are permitted when contributing to nixpkgs. The
+Cargo hash is obtained by inserting a fake checksum into the
+expression and building the package once. The correct checksum can
+then be taken from the failed build. A fake hash can be used for
+`cargoSha256` as follows:
+
+```nix
+  cargoSha256 = lib.fakeSha256;
+```
+
+For `cargoHash` you can use:
+
+```nix
+  cargoHash = lib.fakeHash;
+```
 
 Per the instructions in the [Cargo Book](https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html)
 best practices guide, Rust applications should always commit the `Cargo.lock`
 file in git to ensure a reproducible build. However, a few packages do not, and
-Nix depends on this file, so if it missing you can use `cargoPatches` to apply
-it in the `patchPhase`. Consider sending a PR upstream with a note to the
+Nix depends on this file, so if it is missing you can use `cargoPatches` to
+apply it in the `patchPhase`. Consider sending a PR upstream with a note to the
 maintainer describing why it's important to include in the application.
 
 The fetcher will verify that the `Cargo.lock` file is in sync with the `src`
 attribute, and fail the build if not. It will also will compress the vendor
 directory into a tar.gz archive.
 
-### Building a crate for a different target
+The tarball with vendored dependencies contains a directory with the
+package's `name`, which is normally composed of `pname` and
+`version`. This means that the vendored dependencies hash
+(`cargoSha256`/`cargoHash`) is dependent on the package name and
+version. The `cargoDepsName` attribute can be used to use another name
+for the directory of vendored dependencies. For example, the hash can
+be made invariant to the version by setting `cargoDepsName` to
+`pname`:
+
+```nix
+rustPlatform.buildRustPackage rec {
+  pname = "broot";
+  version = "1.2.0";
+
+  src = fetchCrate {
+    inherit pname version;
+    sha256 = "1mqaynrqaas82f5957lx31x80v74zwmwmjxxlbywajb61vh00d38";
+  };
+
+  cargoHash = "sha256-JmBZcDVYJaK1cK05cxx5BrnGWp4t8ca6FLUbvIot67s=";
+  cargoDepsName = pname;
+
+  # ...
+}
+```
+
+### Importing a `Cargo.lock` file {#importing-a-cargo.lock-file}
+
+Using `cargoSha256` or `cargoHash` is tedious when using
+`buildRustPackage` within a project, since it requires that the hash
+is updated after every change to `Cargo.lock`. Therefore,
+`buildRustPackage` also supports vendoring dependencies directly from
+a `Cargo.lock` file using the `cargoLock` argument. For example:
+
+```nix
+rustPlatform.buildRustPackage rec {
+  pname = "myproject";
+  version = "1.0.0";
+
+  cargoLock = {
+    lockFile = ./Cargo.lock;
+  }
+
+  # ...
+}
+```
+
+This will retrieve the dependencies using fixed-output derivations from
+the specified lockfile.
+
+The output hash of each dependency that uses a git source must be
+specified in the `outputHashes` attribute. For example:
+
+```nix
+rustPlatform.buildRustPackage rec {
+  pname = "myproject";
+  version = "1.0.0";
+
+  cargoLock = {
+    lockFile = ./Cargo.lock;
+    outputHashes = {
+      "finalfusion-0.14.0" = "17f4bsdzpcshwh74w5z119xjy2if6l2wgyjy56v621skr2r8y904";
+    };
+  }
+
+  # ...
+}
+```
+
+If you do not specify an output hash for a git dependency, building
+the package will fail and inform you of which crate needs to be
+added. To find the correct hash, you can first use `lib.fakeSha256` or
+`lib.fakeHash` as a stub hash. Building the package (and thus the
+vendored dependencies) will then inform you of the correct hash.
 
-To build your crate with a different cargo `--target` simply specify the `target` attribute:
+### Cross compilation {#cross-compilation}
+
+By default, Rust packages are compiled for the host platform, just like any
+other package is.  The `--target` passed to rust tools is computed from this.
+By default, it takes the `stdenv.hostPlatform.config` and replaces components
+where they are known to differ. But there are ways to customize the argument:
+
+ - To choose a different target by name, define
+   `stdenv.hostPlatform.rustc.config` as that name (a string), and that
+   name will be used instead.
+
+   For example:
+
+   ```nix
+   import <nixpkgs> {
+     crossSystem = (import <nixpkgs/lib>).systems.examples.armhf-embedded // {
+       rustc.config = "thumbv7em-none-eabi";
+     };
+   }
+   ```
+
+   will result in:
+
+   ```shell
+   --target thumbv7em-none-eabi
+   ```
+
+ - To pass a completely custom target, define
+   `stdenv.hostPlatform.rustc.config` with its name, and
+   `stdenv.hostPlatform.rustc.platform` with the value.  The value will be
+   serialized to JSON in a file called
+   `${stdenv.hostPlatform.rustc.config}.json`, and the path of that file
+   will be used instead.
+
+   For example:
+
+   ```nix
+   import <nixpkgs> {
+     crossSystem = (import <nixpkgs/lib>).systems.examples.armhf-embedded // {
+       rustc.config = "thumb-crazy";
+       rustc.platform = { foo = ""; bar = ""; };
+     };
+   }
+   ```
+
+   will result in:
+
+   ```shell
+   --target /nix/store/asdfasdfsadf-thumb-crazy.json # contains {"foo":"","bar":""}
+   ```
+
+Finally, as an ad-hoc escape hatch, a computed target (string or JSON file
+path) can be passed directly to `buildRustPackage`:
 
 ```nix
 pkgs.rustPlatform.buildRustPackage {
-  (...)
+  /* ... */
   target = "x86_64-fortanix-unknown-sgx";
 }
 ```
 
-### Running package tests
+This is useful to avoid rebuilding Rust tools, since they are actually target
+agnostic and don't need to be rebuilt. But in the future, we should always
+build the Rust tools and standard library crates separately so there is no
+reason not to take the `stdenv.hostPlatform.rustc`-modifying approach, and the
+ad-hoc escape hatch to `buildRustPackage` can be removed.
+
+Note that currently custom targets aren't compiled with `std`, so `cargo test`
+will fail. This can be ignored by adding `doCheck = false;` to your derivation.
+
+### Running package tests {#running-package-tests}
 
 When using `buildRustPackage`, the `checkPhase` is enabled by default and runs
 `cargo test` on the package to build. To make sure that we don't compile the
@@ -95,7 +247,14 @@ rustPlatform.buildRustPackage {
 Please note that the code will be compiled twice here: once in `release` mode
 for the `buildPhase`, and again in `debug` mode for the `checkPhase`.
 
-#### Tests relying on the structure of the `target/` directory
+Test flags, e.g., `--features xxx/yyy`, can be passed to `cargo test` via the
+`cargoTestFlags` attribute.
+
+Another attribute, called `checkFlags`, is used to pass arguments to the test
+binary itself, as stated
+(here)[https://doc.rust-lang.org/cargo/commands/cargo-test.html].
+
+#### Tests relying on the structure of the `target/` directory {#tests-relying-on-the-structure-of-the-target-directory}
 
 Some tests may rely on the structure of the `target/` directory. Those tests
 are likely to fail because we use `cargo --target` during the build. This means that
@@ -105,7 +264,7 @@ rather than in `target/release/`.
 
 This can only be worked around by patching the affected tests accordingly.
 
-#### Disabling package-tests
+#### Disabling package-tests {#disabling-package-tests}
 
 In some instances, it may be necessary to disable testing altogether (with `doCheck = false;`):
 
@@ -119,7 +278,19 @@ The above are just guidelines, and exceptions may be granted on a case-by-case b
 However, please check if it's possible to disable a problematic subset of the
 test suite and leave a comment explaining your reasoning.
 
-### Building a package in `debug` mode
+#### Setting `test-threads` {#setting-test-threads}
+
+`buildRustPackage` will use parallel test threads by default,
+sometimes it may be necessary to disable this so the tests run consecutively.
+
+```nix
+rustPlatform.buildRustPackage {
+  /* ... */
+  dontUseCargoParallelTests = true;
+}
+```
+
+### Building a package in `debug` mode {#building-a-package-in-debug-mode}
 
 By default, `buildRustPackage` will use `release` mode for builds. If a package
 should be built in `debug` mode, it can be configured like so:
@@ -133,22 +304,20 @@ rustPlatform.buildRustPackage {
 
 In this scenario, the `checkPhase` will be ran in `debug` mode as well.
 
-### Custom `build`/`install`-procedures
+### Custom `build`/`install`-procedures {#custom-buildinstall-procedures}
 
 Some packages may use custom scripts for building/installing, e.g. with a `Makefile`.
 In these cases, it's recommended to override the `buildPhase`/`installPhase`/`checkPhase`.
 
 Otherwise, some steps may fail because of the modified directory structure of `target/`.
 
-### Building a crate with an absent or out-of-date Cargo.lock file
+### Building a crate with an absent or out-of-date Cargo.lock file {#building-a-crate-with-an-absent-or-out-of-date-cargo.lock-file}
 
 `buildRustPackage` needs a `Cargo.lock` file to get all dependencies in the
 source code in a reproducible way. If it is missing or out-of-date one can use
 the `cargoPatches` attribute to update or add it.
 
-```
-{ lib, rustPlatform, fetchFromGitHub }:
-
+```nix
 rustPlatform.buildRustPackage rec {
   (...)
   cargoPatches = [
@@ -158,9 +327,233 @@ rustPlatform.buildRustPackage rec {
 }
 ```
 
-## Compiling Rust crates using Nix instead of Cargo
+## Compiling non-Rust packages that include Rust code {#compiling-non-rust-packages-that-include-rust-code}
+
+Several non-Rust packages incorporate Rust code for performance- or
+security-sensitive parts. `rustPlatform` exposes several functions and
+hooks that can be used to integrate Cargo in non-Rust packages.
+
+### Vendoring of dependencies {#vendoring-of-dependencies}
+
+Since network access is not allowed in sandboxed builds, Rust crate
+dependencies need to be retrieved using a fetcher. `rustPlatform`
+provides the `fetchCargoTarball` fetcher, which vendors all
+dependencies of a crate. For example, given a source path `src`
+containing `Cargo.toml` and `Cargo.lock`, `fetchCargoTarball`
+can be used as follows:
+
+```nix
+cargoDeps = rustPlatform.fetchCargoTarball {
+  inherit src;
+  hash = "sha256-BoHIN/519Top1NUBjpB/oEMqi86Omt3zTQcXFWqrek0=";
+};
+```
 
-### Simple operation
+The `src` attribute is required, as well as a hash specified through
+one of the `sha256` or `hash` attributes. The following optional
+attributes can also be used:
+
+* `name`: the name that is used for the dependencies tarball.  If
+  `name` is not specified, then the name `cargo-deps` will be used.
+* `sourceRoot`: when the `Cargo.lock`/`Cargo.toml` are in a
+  subdirectory, `sourceRoot` specifies the relative path to these
+  files.
+* `patches`: patches to apply before vendoring. This is useful when
+  the `Cargo.lock`/`Cargo.toml` files need to be patched before
+  vendoring.
+
+If a `Cargo.lock` file is available, you can alternatively use the
+`importCargoLock` function. In contrast to `fetchCargoTarball`, this
+function does not require a hash (unless git dependencies are used)
+and fetches every dependency as a separate fixed-output derivation.
+`importCargoLock` can be used as follows:
+
+```
+cargoDeps = rustPlatform.importCargoLock {
+  lockFile = ./Cargo.lock;
+};
+```
+
+If the `Cargo.lock` file includes git dependencies, then their output
+hashes need to be specified since they are not available through the
+lock file. For example:
+
+```
+cargoDeps = rustPlatform.importCargoLock {
+  lockFile = ./Cargo.lock;
+  outputHashes = {
+    "rand-0.8.3" = "0ya2hia3cn31qa8894s3av2s8j5bjwb6yq92k0jsnlx7jid0jwqa";
+  };
+};
+```
+
+If you do not specify an output hash for a git dependency, building
+`cargoDeps` will fail and inform you of which crate needs to be
+added. To find the correct hash, you can first use `lib.fakeSha256` or
+`lib.fakeHash` as a stub hash. Building `cargoDeps` will then inform
+you of the correct hash.
+
+### Hooks {#hooks}
+
+`rustPlatform` provides the following hooks to automate Cargo builds:
+
+* `cargoSetupHook`: configure Cargo to use depenencies vendored
+  through `fetchCargoTarball`. This hook uses the `cargoDeps`
+  environment variable to find the vendored dependencies. If a project
+  already vendors its dependencies, the variable `cargoVendorDir` can
+  be used instead. When the `Cargo.toml`/`Cargo.lock` files are not in
+  `sourceRoot`, then the optional `cargoRoot` is used to specify the
+  Cargo root directory relative to `sourceRoot`.
+* `cargoBuildHook`: use Cargo to build a crate. If the crate to be
+  built is a crate in e.g. a Cargo workspace, the relative path to the
+  crate to build can be set through the optional `buildAndTestSubdir`
+  environment variable. Additional Cargo build flags can be passed
+  through `cargoBuildFlags`.
+* `maturinBuildHook`: use [Maturin](https://github.com/PyO3/maturin)
+  to build a Python wheel. Similar to `cargoBuildHook`, the optional
+  variable `buildAndTestSubdir` can be used to build a crate in a
+  Cargo workspace. Additional maturin flags can be passed through
+  `maturinBuildFlags`.
+* `cargoCheckHook`: run tests using Cargo. The build type for checks
+  can be set using `cargoCheckType`. Additional flags can be passed to
+  the tests using `checkFlags` and `checkFlagsArray`. By default,
+  tests are run in parallel. This can be disabled by setting
+  `dontUseCargoParallelTests`.
+* `cargoInstallHook`: install binaries and static/shared libraries
+  that were built using `cargoBuildHook`.
+
+### Examples {#examples}
+
+#### Python package using `setuptools-rust` {#python-package-using-setuptools-rust}
+
+For Python packages using `setuptools-rust`, you can use
+`fetchCargoTarball` and `cargoSetupHook` to retrieve and set up Cargo
+dependencies. The build itself is then performed by
+`buildPythonPackage`.
+
+The following example outlines how the `tokenizers` Python package is
+built. Since the Python package is in the `source/bindings/python`
+directory of the *tokenizers* project's source archive, we use
+`sourceRoot` to point the tooling to this directory:
+
+```nix
+{ fetchFromGitHub
+, buildPythonPackage
+, rustPlatform
+, setuptools-rust
+}:
+
+buildPythonPackage rec {
+  pname = "tokenizers";
+  version = "0.10.0";
+
+  src = fetchFromGitHub {
+    owner = "huggingface";
+    repo = pname;
+    rev = "python-v${version}";
+    hash = "sha256-rQ2hRV52naEf6PvRsWVCTN7B1oXAQGmnpJw4iIdhamw=";
+  };
+
+  cargoDeps = rustPlatform.fetchCargoTarball {
+    inherit src sourceRoot;
+    name = "${pname}-${version}";
+    hash = "sha256-BoHIN/519Top1NUBjpB/oEMqi86Omt3zTQcXFWqrek0=";
+  };
+
+  sourceRoot = "source/bindings/python";
+
+  nativeBuildInputs = [ setuptools-rust ] ++ (with rustPlatform; [
+    cargoSetupHook
+    rust.cargo
+    rust.rustc
+  ]);
+
+  # ...
+}
+```
+
+In some projects, the Rust crate is not in the main Python source
+directory.  In such cases, the `cargoRoot` attribute can be used to
+specify the crate's directory relative to `sourceRoot`. In the
+following example, the crate is in `src/rust`, as specified in the
+`cargoRoot` attribute. Note that we also need to specify the correct
+path for `fetchCargoTarball`.
+
+```nix
+
+{ buildPythonPackage
+, fetchPypi
+, rustPlatform
+, setuptools-rust
+, openssl
+}:
+
+buildPythonPackage rec {
+  pname = "cryptography";
+  version = "3.4.2"; # Also update the hash in vectors.nix
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1i1mx5y9hkyfi9jrrkcw804hmkcglxi6rmf7vin7jfnbr2bf4q64";
+  };
+
+  cargoDeps = rustPlatform.fetchCargoTarball {
+    inherit src;
+    sourceRoot = "${pname}-${version}/${cargoRoot}";
+    name = "${pname}-${version}";
+    hash = "sha256-PS562W4L1NimqDV2H0jl5vYhL08H9est/pbIxSdYVfo=";
+  };
+
+  cargoRoot = "src/rust";
+
+  # ...
+}
+```
+
+#### Python package using `maturin` {#python-package-using-maturin}
+
+Python packages that use [Maturin](https://github.com/PyO3/maturin)
+can be built with `fetchCargoTarball`, `cargoSetupHook`, and
+`maturinBuildHook`. For example, the following (partial) derivation
+builds the `retworkx` Python package. `fetchCargoTarball` and
+`cargoSetupHook` are used to fetch and set up the crate dependencies.
+`maturinBuildHook` is used to perform the build.
+
+```nix
+{ lib
+, buildPythonPackage
+, rustPlatform
+, fetchFromGitHub
+}:
+
+buildPythonPackage rec {
+  pname = "retworkx";
+  version = "0.6.0";
+
+  src = fetchFromGitHub {
+    owner = "Qiskit";
+    repo = "retworkx";
+    rev = version;
+    sha256 = "11n30ldg3y3y6qxg3hbj837pnbwjkqw3nxq6frds647mmmprrd20";
+  };
+
+  cargoDeps = rustPlatform.fetchCargoTarball {
+    inherit src;
+    name = "${pname}-${version}";
+    hash = "sha256-heOBK8qi2nuc/Ib+I/vLzZ1fUUD/G/KTw9d7M4Hz5O0=";
+  };
+
+  format = "pyproject";
+
+  nativeBuildInputs = with rustPlatform; [ cargoSetupHook maturinBuildHook ];
+
+  # ...
+}
+```
+
+## Compiling Rust crates using Nix instead of Cargo {#compiling-rust-crates-using-nix-instead-of-cargo}
+
+### Simple operation {#simple-operation}
 
 When run, `cargo build` produces a file called `Cargo.lock`,
 containing pinned versions of all dependencies. Nixpkgs contains a
@@ -171,20 +564,21 @@ That Nix expression calls `rustc` directly (hence bypassing Cargo),
 and can be used to compile a crate and all its dependencies. Here is
 an example for a minimal `hello` crate:
 
-
-    $ cargo new hello
-    $ cd hello
-    $ cargo build
+```ShellSession
+$ cargo new hello
+$ cd hello
+$ cargo build
      Compiling hello v0.1.0 (file:///tmp/hello)
-      Finished dev [unoptimized + debuginfo] target(s) in 0.20 secs
-    $ carnix -o hello.nix --src ./. Cargo.lock --standalone
-    $ nix-build hello.nix -A hello_0_1_0
+     Finished dev [unoptimized + debuginfo] target(s) in 0.20 secs
+$ carnix -o hello.nix --src ./. Cargo.lock --standalone
+$ nix-build hello.nix -A hello_0_1_0
+```
 
 Now, the file produced by the call to `carnix`, called `hello.nix`, looks like:
 
-```
+```nix
 # Generated by carnix 0.6.5: carnix -o hello.nix --src ./. Cargo.lock --standalone
-{ lib, stdenv, buildRustCrate, fetchgit }:
+{ stdenv, buildRustCrate, fetchgit }:
 let kernel = stdenv.buildPlatform.parsed.kernel.name;
     # ... (content skipped)
 in
@@ -211,9 +605,9 @@ dependencies, for instance by adding a single line `libc="*"` to our
 `Cargo.lock`. Then, `carnix` needs to be run again, and produces the
 following nix file:
 
-```
+```nix
 # Generated by carnix 0.6.5: carnix -o hello.nix --src ./. Cargo.lock --standalone
-{ lib, stdenv, buildRustCrate, fetchgit }:
+{ stdenv, buildRustCrate, fetchgit }:
 let kernel = stdenv.buildPlatform.parsed.kernel.name;
     # ... (content skipped)
 in
@@ -257,7 +651,7 @@ Here, the `libc` crate has no `src` attribute, so `buildRustCrate`
 will fetch it from [crates.io](https://crates.io). A `sha256`
 attribute is still needed for Nix purity.
 
-### Handling external dependencies
+### Handling external dependencies {#handling-external-dependencies}
 
 Some crates require external libraries. For crates from
 [crates.io](https://crates.io), such libraries can be specified in
@@ -266,7 +660,7 @@ Some crates require external libraries. For crates from
 Starting from that file, one can add more overrides, to add features
 or build inputs by overriding the hello crate in a seperate file.
 
-```
+```nix
 with import <nixpkgs> {};
 ((import ./hello.nix).hello {}).override {
   crateOverrides = defaultCrateOverrides // {
@@ -286,7 +680,7 @@ derivation depend on the crate's version, the `attrs` argument of
 the override above can be read, as in the following example, which
 patches the derivation:
 
-```
+```nix
 with import <nixpkgs> {};
 ((import ./hello.nix).hello {}).override {
   crateOverrides = defaultCrateOverrides // {
@@ -307,7 +701,7 @@ dependencies. For instance, to override the build inputs for crate
 `libc` in the example above, where `libc` is a dependency of the main
 crate, we could do:
 
-```
+```nix
 with import <nixpkgs> {};
 ((import hello.nix).hello {}).override {
   crateOverrides = defaultCrateOverrides // {
@@ -316,34 +710,34 @@ with import <nixpkgs> {};
 }
 ```
 
-### Options and phases configuration
+### Options and phases configuration {#options-and-phases-configuration}
 
 Actually, the overrides introduced in the previous section are more
 general. A number of other parameters can be overridden:
 
 - The version of rustc used to compile the crate:
 
-  ```
+  ```nix
   (hello {}).override { rust = pkgs.rust; };
   ```
 
 - Whether to build in release mode or debug mode (release mode by
   default):
 
-  ```
+  ```nix
   (hello {}).override { release = false; };
   ```
 
 - Whether to print the commands sent to rustc when building
   (equivalent to `--verbose` in cargo:
 
-  ```
+  ```nix
   (hello {}).override { verbose = false; };
   ```
 
 - Extra arguments to be passed to `rustc`:
 
-  ```
+  ```nix
   (hello {}).override { extraRustcOpts = "-Z debuginfo=2"; };
   ```
 
@@ -355,7 +749,7 @@ general. A number of other parameters can be overridden:
   `postInstall`. As an example, here is how to create a new module
   before running the build script:
 
-  ```
+  ```nix
   (hello {}).override {
     preConfigure = ''
        echo "pub const PATH=\"${hi.out}\";" >> src/path.rs"
@@ -363,13 +757,13 @@ general. A number of other parameters can be overridden:
   };
   ```
 
-### Features
+### Features {#features}
 
 One can also supply features switches. For example, if we want to
 compile `diesel_cli` only with the `postgres` feature, and no default
 features, we would write:
 
-```
+```nix
 (callPackage ./diesel.nix {}).diesel {
   default = false;
   postgres = true;
@@ -378,21 +772,22 @@ features, we would write:
 
 Where `diesel.nix` is the file generated by Carnix, as explained above.
 
+## Setting Up `nix-shell` {#setting-up-nix-shell}
 
-## Setting Up `nix-shell`
 Oftentimes you want to develop code from within `nix-shell`. Unfortunately
 `buildRustCrate` does not support common `nix-shell` operations directly
 (see [this issue](https://github.com/NixOS/nixpkgs/issues/37945))
 so we will use `stdenv.mkDerivation` instead.
 
 Using the example `hello` project above, we want to do the following:
+
 - Have access to `cargo` and `rustc`
 - Have the `openssl` library available to a crate through it's _normal_
   compilation mechanism (`pkg-config`).
 
 A typical `shell.nix` might look like:
 
-```
+```nix
 with import <nixpkgs> {};
 
 stdenv.mkDerivation {
@@ -401,7 +796,7 @@ stdenv.mkDerivation {
     rustc cargo
 
     # Example Build-time Additional Dependencies
-    pkgconfig
+    pkg-config
   ];
   buildInputs = [
     # Example Run-time Additional Dependencies
@@ -414,17 +809,19 @@ stdenv.mkDerivation {
 ```
 
 You should now be able to run the following:
-```
+
+```ShellSession
 $ nix-shell --pure
 $ cargo build
 $ cargo test
 ```
 
-### Controlling Rust Version Inside `nix-shell`
+### Controlling Rust Version Inside `nix-shell` {#controlling-rust-version-inside-nix-shell}
+
 To control your rust version (i.e. use nightly) from within `shell.nix` (or
 other nix expressions) you can use the following `shell.nix`
 
-```
+```nix
 # Latest Nightly
 with import <nixpkgs> {};
 let src = fetchFromGitHub {
@@ -439,11 +836,11 @@ with import "${src.out}/rust-overlay.nix" pkgs pkgs;
 stdenv.mkDerivation {
   name = "rust-env";
   buildInputs = [
-    # Note: to use use stable, just replace `nightly` with `stable`
+    # Note: to use stable, just replace `nightly` with `stable`
     latest.rustChannels.nightly.rust
 
     # Add some extra dependencies from `pkgs`
-    pkgconfig openssl
+    pkg-config openssl
   ];
 
   # Set Environment Variables
@@ -452,38 +849,80 @@ stdenv.mkDerivation {
 ```
 
 Now run:
-```
+
+```ShellSession
 $ rustc --version
 rustc 1.26.0-nightly (188e693b3 2018-03-26)
 ```
 
 To see that you are using nightly.
 
-
-## Using the Rust nightlies overlay
+## Using the Rust nightlies overlay {#using-the-rust-nightlies-overlay}
 
 Mozilla provides an overlay for nixpkgs to bring a nightly version of Rust into scope.
 This overlay can _also_ be used to install recent unstable or stable versions
 of Rust, if desired.
 
-To use this overlay, clone
-[nixpkgs-mozilla](https://github.com/mozilla/nixpkgs-mozilla),
+### Rust overlay installation {#rust-overlay-installation}
+
+You can use this overlay by either changing your local nixpkgs configuration,
+or by adding the overlay declaratively in a nix expression,  e.g. in `configuration.nix`.
+For more information see [the manual on installing overlays](#sec-overlays-install).
+
+#### Imperative rust overlay installation {#imperative-rust-overlay-installation}
+
+Clone [nixpkgs-mozilla](https://github.com/mozilla/nixpkgs-mozilla),
 and create a symbolic link to the file
 [rust-overlay.nix](https://github.com/mozilla/nixpkgs-mozilla/blob/master/rust-overlay.nix)
 in the `~/.config/nixpkgs/overlays` directory.
 
-    $ git clone https://github.com/mozilla/nixpkgs-mozilla.git
-    $ mkdir -p ~/.config/nixpkgs/overlays
-    $ ln -s $(pwd)/nixpkgs-mozilla/rust-overlay.nix ~/.config/nixpkgs/overlays/rust-overlay.nix
+```ShellSession
+$ git clone https://github.com/mozilla/nixpkgs-mozilla.git
+$ mkdir -p ~/.config/nixpkgs/overlays
+$ ln -s $(pwd)/nixpkgs-mozilla/rust-overlay.nix ~/.config/nixpkgs/overlays/rust-overlay.nix
+```
+
+### Declarative rust overlay installation {#declarative-rust-overlay-installation}
+
+Add the following to your `configuration.nix`, `home-configuration.nix`, `shell.nix`, or similar:
 
-The latest version can be installed with the following command:
+```nix
+{ pkgs ? import <nixpkgs> {
+    overlays = [
+      (import (builtins.fetchTarball https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz))
+      # Further overlays go here
+    ];
+  };
+};
+```
+
+Note that this will fetch the latest overlay version when rebuilding your system.
+
+### Rust overlay usage {#rust-overlay-usage}
+
+The overlay contains attribute sets corresponding to different versions of the rust toolchain, such as:
 
-    $ nix-env -Ai nixos.latest.rustChannels.stable.rust
+* `latest.rustChannels.stable`
+* `latest.rustChannels.nightly`
+* a function `rustChannelOf`, called as `(rustChannelOf { date = "2018-04-11"; channel = "nightly"; })`, or...
+* `(nixpkgs.rustChannelOf { rustToolchain = ./rust-toolchain; })` if you have a local `rust-toolchain` file (see https://github.com/mozilla/nixpkgs-mozilla#using-in-nix-expressions for an example)
+
+Each of these contain packages such as `rust`, which contains your usual rust development tools with the respective toolchain chosen.
+For example, you might want to add `latest.rustChannels.stable.rust` to the list of packages in your configuration.
+
+Imperatively, the latest stable version can be installed with the following command:
+
+```ShellSession
+$ nix-env -Ai nixpkgs.latest.rustChannels.stable.rust
+```
 
 Or using the attribute with nix-shell:
 
-    $ nix-shell -p nixos.latest.rustChannels.stable.rust
+```ShellSession
+$ nix-shell -p nixpkgs.latest.rustChannels.stable.rust
+```
 
+Substitute the `nixpkgs` prefix with `nixos` on NixOS.
 To install the beta or nightly channel, "stable" should be substituted by
 "nightly" or "beta", or
 use the function provided by this overlay to pull a version based on a
diff --git a/doc/languages-frameworks/texlive.section.md b/doc/languages-frameworks/texlive.section.md
new file mode 100644
index 00000000000..6b505cefcc9
--- /dev/null
+++ b/doc/languages-frameworks/texlive.section.md
@@ -0,0 +1,129 @@
+# TeX Live {#sec-language-texlive}
+
+Since release 15.09 there is a new TeX Live packaging that lives entirely under attribute `texlive`.
+
+## User's guide {#sec-language-texlive-user-guide}
+
+- For basic usage just pull `texlive.combined.scheme-basic` for an environment with basic LaTeX support.
+
+- It typically won't work to use separately installed packages together. Instead, you can build a custom set of packages like this:
+
+  ```nix
+  texlive.combine {
+    inherit (texlive) scheme-small collection-langkorean algorithms cm-super;
+  }
+  ```
+
+- There are all the schemes, collections and a few thousand packages, as defined upstream (perhaps with tiny differences).
+
+- By default you only get executables and files needed during runtime, and a little documentation for the core packages. To change that, you need to add `pkgFilter` function to `combine`.
+
+  ```nix
+  texlive.combine {
+    # inherit (texlive) whatever-you-want;
+    pkgFilter = pkg:
+      pkg.tlType == "run" || pkg.tlType == "bin" || pkg.pname == "cm-super";
+    # elem tlType [ "run" "bin" "doc" "source" ]
+    # there are also other attributes: version, name
+  }
+  ```
+
+- You can list packages e.g. by `nix repl`.
+
+  ```ShellSession
+  $ nix repl
+  nix-repl> :l <nixpkgs>
+  nix-repl> texlive.collection-[TAB]
+  ```
+
+- Note that the wrapper assumes that the result has a chance to be useful. For example, the core executables should be present, as well as some core data files. The supported way of ensuring this is by including some scheme, for example `scheme-basic`, into the combination.
+
+## Custom packages {#sec-language-texlive-custom-packages}
+
+
+You may find that you need to use an external TeX package. A derivation for such package has to provide contents of the "texmf" directory in its output and provide the `tlType` attribute. Here is a (very verbose) example:
+
+```nix
+with import <nixpkgs> {};
+
+let
+  foiltex_run = stdenvNoCC.mkDerivation {
+    pname = "latex-foiltex";
+    version = "2.1.4b";
+    passthru.tlType = "run";
+
+    srcs = [
+      (fetchurl {
+        url = "http://mirrors.ctan.org/macros/latex/contrib/foiltex/foiltex.dtx";
+        sha256 = "07frz0krpz7kkcwlayrwrj2a2pixmv0icbngyw92srp9fp23cqpz";
+      })
+      (fetchurl {
+        url = "http://mirrors.ctan.org/macros/latex/contrib/foiltex/foiltex.ins";
+        sha256 = "09wkyidxk3n3zvqxfs61wlypmbhi1pxmjdi1kns9n2ky8ykbff99";
+      })
+    ];
+
+    unpackPhase = ''
+      runHook preUnpack
+
+      for _src in $srcs; do
+        cp "$_src" $(stripHash "$_src")
+      done
+
+      runHook postUnpack
+    '';
+
+    nativeBuildInputs = [ texlive.combined.scheme-small ];
+
+    dontConfigure = true;
+
+    buildPhase = ''
+      runHook preBuild
+
+      # Generate the style files
+      latex foiltex.ins
+
+      runHook postBuild
+    '';
+
+    installPhase = ''
+      runHook preInstall
+
+      path="$out/tex/latex/foiltex"
+      mkdir -p "$path"
+      cp *.{cls,def,clo} "$path/"
+
+      runHook postInstall
+    '';
+
+    meta = with lib; {
+      description = "A LaTeX2e class for overhead transparencies";
+      license = licenses.unfreeRedistributable;
+      maintainers = with maintainers; [ veprbl ];
+      platforms = platforms.all;
+    };
+  };
+  foiltex = { pkgs = [ foiltex_run ]; };
+
+  latex_with_foiltex = texlive.combine {
+    inherit (texlive) scheme-small;
+    inherit foiltex;
+  };
+in
+  runCommand "test.pdf" {
+    nativeBuildInputs = [ latex_with_foiltex ];
+  } ''
+cat >test.tex <<EOF
+\documentclass{foils}
+
+\title{Presentation title}
+\date{}
+
+\begin{document}
+\maketitle
+\end{document}
+EOF
+  pdflatex test.tex
+  cp test.pdf $out
+''
+```
diff --git a/doc/languages-frameworks/texlive.xml b/doc/languages-frameworks/texlive.xml
deleted file mode 100644
index a581ec5911c..00000000000
--- a/doc/languages-frameworks/texlive.xml
+++ /dev/null
@@ -1,152 +0,0 @@
-<section xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="sec-language-texlive">
- <title>TeX Live</title>
-
- <para>
-  Since release 15.09 there is a new TeX Live packaging that lives entirely under attribute <varname>texlive</varname>.
- </para>
-
- <section xml:id="sec-language-texlive-users-guide">
-  <title>User's guide</title>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     For basic usage just pull <varname>texlive.combined.scheme-basic</varname> for an environment with basic LaTeX support.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     It typically won't work to use separately installed packages together. Instead, you can build a custom set of packages like this:
-<programlisting>
-texlive.combine {
-  inherit (texlive) scheme-small collection-langkorean algorithms cm-super;
-}
-</programlisting>
-     There are all the schemes, collections and a few thousand packages, as defined upstream (perhaps with tiny differences).
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     By default you only get executables and files needed during runtime, and a little documentation for the core packages. To change that, you need to add <varname>pkgFilter</varname> function to <varname>combine</varname>.
-<programlisting>
-texlive.combine {
-  # inherit (texlive) whatever-you-want;
-  pkgFilter = pkg:
-    pkg.tlType == "run" || pkg.tlType == "bin" || pkg.pname == "cm-super";
-  # elem tlType [ "run" "bin" "doc" "source" ]
-  # there are also other attributes: version, name
-}
-</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     You can list packages e.g. by <command>nix repl</command>.
-<programlisting><![CDATA[
-$ nix repl
-nix-repl> :l <nixpkgs>
-nix-repl> texlive.collection-<TAB>
-]]></programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     Note that the wrapper assumes that the result has a chance to be useful. For example, the core executables should be present, as well as some core data files. The supported way of ensuring this is by including some scheme, for example <varname>scheme-basic</varname>, into the combination.
-    </para>
-   </listitem>
-  </itemizedlist>
- </section>
-
- <section xml:id="sec-language-texlive-custom-packages">
-  <title>Custom packages</title>
-  <para>
-    You may find that you need to use an external TeX package. A derivation for such package has to provide contents of the "texmf" directory in its output and provide the <varname>tlType</varname> attribute. Here is a (very verbose) example:
-<programlisting><![CDATA[
-with import <nixpkgs> {};
-
-let
-  foiltex_run = stdenvNoCC.mkDerivation {
-    pname = "latex-foiltex";
-    version = "2.1.4b";
-    passthru.tlType = "run";
-
-    srcs = [
-      (fetchurl {
-        url = "http://mirrors.ctan.org/macros/latex/contrib/foiltex/foiltex.dtx";
-        sha256 = "07frz0krpz7kkcwlayrwrj2a2pixmv0icbngyw92srp9fp23cqpz";
-      })
-      (fetchurl {
-        url = "http://mirrors.ctan.org/macros/latex/contrib/foiltex/foiltex.ins";
-        sha256 = "09wkyidxk3n3zvqxfs61wlypmbhi1pxmjdi1kns9n2ky8ykbff99";
-      })
-    ];
-
-    unpackPhase = ''
-      runHook preUnpack
-
-      for _src in $srcs; do
-        cp "$_src" $(stripHash "$_src")
-      done
-
-      runHook postUnpack
-    '';
-
-    nativeBuildInputs = [ texlive.combined.scheme-small ];
-
-    dontConfigure = true;
-
-    buildPhase = ''
-      runHook preBuild
-
-      # Generate the style files
-      latex foiltex.ins
-
-      runHook postBuild
-    '';
-
-    installPhase = ''
-      runHook preInstall
-
-      path="$out/tex/latex/foiltex"
-      mkdir -p "$path"
-      cp *.{cls,def,clo} "$path/"
-
-      runHook postInstall
-    '';
-
-    meta = with lib; {
-      description = "A LaTeX2e class for overhead transparencies";
-      license = licenses.unfreeRedistributable;
-      maintainers = with maintainers; [ veprbl ];
-      platforms = platforms.all;
-    };
-  };
-  foiltex = { pkgs = [ foiltex_run ]; };
-
-  latex_with_foiltex = texlive.combine {
-    inherit (texlive) scheme-small;
-    inherit foiltex;
-  };
-in
-  runCommand "test.pdf" {
-    nativeBuildInputs = [ latex_with_foiltex ];
-  } ''
-cat >test.tex <<EOF
-\documentclass{foils}
-
-\title{Presentation title}
-\date{}
-
-\begin{document}
-\maketitle
-\end{document}
-EOF
-  pdflatex test.tex
-  cp test.pdf $out
-''
-]]></programlisting>
-  </para>
- </section>
-</section>
diff --git a/doc/languages-frameworks/titanium.section.md b/doc/languages-frameworks/titanium.section.md
index 7a97664ec59..306ad866276 100644
--- a/doc/languages-frameworks/titanium.section.md
+++ b/doc/languages-frameworks/titanium.section.md
@@ -1,9 +1,4 @@
----
-title: Titanium
-author: Sander van der Burg
-date: 2018-11-18
----
-# Titanium
+# Titanium {#titanium}
 
 The Nixpkgs repository contains facilities to deploy a variety of versions of
 the [Titanium SDK](https://www.appcelerator.com) versions, a cross-platform
@@ -14,8 +9,8 @@ applications for Android and iOS devices from source code.
 Not all Titanium features supported -- currently, it can only be used to build
 Android and iOS apps.
 
-Building a Titanium app
------------------------
+## Building a Titanium app {#building-a-titanium-app}
+
 We can build a Titanium app from source for Android or iOS and for debugging or
 release purposes by invoking the `titaniumenv.buildApp {}` function:
 
@@ -108,8 +103,8 @@ When `enableWirelessDistribution` has been enabled, you must also provide the
 path of the PHP script (`installURL`) (that is included with the iOS build
 environment) to enable wireless ad-hoc installations.
 
-Emulating or simulating the app
--------------------------------
+## Emulating or simulating the app {#emulating-or-simulating-the-app}
+
 It is also possible to simulate the correspond iOS simulator build by using
 `xcodeenv.simulateApp {}` and emulate an Android APK by using
 `androidenv.emulateApp {}`.
diff --git a/doc/languages-frameworks/vim.section.md b/doc/languages-frameworks/vim.section.md
index 4911509212e..26a01a89aa5 100644
--- a/doc/languages-frameworks/vim.section.md
+++ b/doc/languages-frameworks/vim.section.md
@@ -1,9 +1,4 @@
----
-title: User's Guide for Vim in Nixpkgs
-author: Marc Weber
-date: 2016-06-25
----
-# Vim
+# Vim {#vim}
 
 Both Neovim and Vim can be configured to include your favorite plugins
 and additional libraries.
@@ -17,7 +12,7 @@ At the moment we support three different methods for managing plugins:
 - Pathogen
 - vim-plug
 
-## Custom configuration
+## Custom configuration {#custom-configuration}
 
 Adding custom .vimrc lines can be done using the following code:
 
@@ -61,7 +56,7 @@ neovim-qt.override {
 }
 ```
 
-## Managing plugins with Vim packages
+## Managing plugins with Vim packages {#managing-plugins-with-vim-packages}
 
 To store you plugins in Vim packages (the native Vim plugin manager, see `:help packages`) the following example can be used:
 
@@ -121,7 +116,72 @@ The resulting package can be added to `packageOverrides` in `~/.nixpkgs/config.n
 
 After that you can install your special grafted `myVim` or `myNeovim` packages.
 
-## Managing plugins with vim-plug
+### What if your favourite Vim plugin isn’t already packaged? {#what-if-your-favourite-vim-plugin-isnt-already-packaged}
+
+If one of your favourite plugins isn't packaged, you can package it yourself:
+
+```nix
+{ config, pkgs, ... }:
+
+let
+  easygrep = pkgs.vimUtils.buildVimPlugin {
+    name = "vim-easygrep";
+    src = pkgs.fetchFromGitHub {
+      owner = "dkprice";
+      repo = "vim-easygrep";
+      rev = "d0c36a77cc63c22648e792796b1815b44164653a";
+      sha256 = "0y2p5mz0d5fhg6n68lhfhl8p4mlwkb82q337c22djs4w5zyzggbc";
+    };
+  };
+in
+{
+  environment.systemPackages = [
+    (
+      pkgs.neovim.override {
+        configure = {
+          packages.myPlugins = with pkgs.vimPlugins; {
+          start = [
+            vim-go # already packaged plugin
+            easygrep # custom package
+          ];
+          opt = [];
+        };
+        # ...
+      };
+     }
+    )
+  ];
+}
+```
+
+### Specificities for some plugins
+#### Tree sitter
+
+By default `nvim-treesitter` encourages you to download, compile and install
+the required tree-sitter grammars at run time with `:TSInstall`. This works
+poorly on NixOS.  Instead, to install the `nvim-treesitter` plugins with a set
+of precompiled grammars, you can use `nvim-treesitter.withPlugins` function:
+
+```nix
+(pkgs.neovim.override {
+  configure = {
+    packages.myPlugins = with pkgs.vimPlugins; {
+      start = [
+        (nvim-treesitter.withPlugins (
+          plugins: with plugins; [
+            tree-sitter-nix
+            tree-sitter-python
+          ]
+        ))
+      ];
+    };
+  };
+})
+```
+
+To enable all grammars packaged in nixpkgs, use `(pkgs.vimPlugins.nvim-treesitter.withPlugins (plugins: pkgs.tree-sitter.allGrammars))`.
+
+## Managing plugins with vim-plug {#managing-plugins-with-vim-plug}
 
 To use [vim-plug](https://github.com/junegunn/vim-plug) to manage your Vim
 plugins the following example can be used:
@@ -150,18 +210,18 @@ neovim.override {
 }
 ```
 
-## Managing plugins with VAM
+## Managing plugins with VAM {#managing-plugins-with-vam}
 
-### Handling dependencies of Vim plugins
+### Handling dependencies of Vim plugins {#handling-dependencies-of-vim-plugins}
 
 VAM introduced .json files supporting dependencies without versioning
 assuming that "using latest version" is ok most of the time.
 
-### Example
+### Example {#example}
 
 First create a vim-scripts file having one plugin name per line. Example:
 
-```
+```vim
 "tlib"
 {'name': 'vim-addon-sql'}
 {'filetype_regex': '\%(vim)$', 'names': ['reload', 'vim-dev-plugin']}
@@ -202,7 +262,7 @@ nix-shell -p vimUtils.vim_with_vim2nix --command "vim -c 'source generate.vim'"
 You should get a Vim buffer with the nix derivations (output1) and vam.pluginDictionaries (output2).
 You can add your Vim to your system's configuration file like this and start it by "vim-my":
 
-```
+```nix
 my-vim =
   let plugins = let inherit (vimUtils) buildVimPluginFrom2Nix; in {
     copy paste output1 here
@@ -222,7 +282,7 @@ my-vim =
 
 Sample output1:
 
-```
+```nix
 "reload" = buildVimPluginFrom2Nix { # created by nix#NixDerivation
   name = "reload";
   src = fetchgit {
@@ -247,13 +307,13 @@ Sample output2:
 ]
 ```
 
-## Adding new plugins to nixpkgs
+## Adding new plugins to nixpkgs {#adding-new-plugins-to-nixpkgs}
 
 Nix expressions for Vim plugins are stored in [pkgs/misc/vim-plugins](/pkgs/misc/vim-plugins). For the vast majority of plugins, Nix expressions are automatically generated by running [`./update.py`](/pkgs/misc/vim-plugins/update.py). This creates a [generated.nix](/pkgs/misc/vim-plugins/generated.nix) file based on the plugins listed in [vim-plugin-names](/pkgs/misc/vim-plugins/vim-plugin-names). Plugins are listed in alphabetical order in `vim-plugin-names` using the format `[github username]/[repository]`. For example https://github.com/scrooloose/nerdtree becomes `scrooloose/nerdtree`.
 
 Some plugins require overrides in order to function properly. Overrides are placed in [overrides.nix](/pkgs/misc/vim-plugins/overrides.nix). Overrides are most often required when a plugin requires some dependencies, or extra steps are required during the build process. For example `deoplete-fish` requires both `deoplete-nvim` and `vim-fish`, and so the following override was added:
 
-```
+```nix
 deoplete-fish = super.deoplete-fish.overrideAttrs(old: {
   dependencies = with super; [ deoplete-nvim vim-fish ];
 });
@@ -263,7 +323,23 @@ Sometimes plugins require an override that must be changed when the plugin is up
 
 To add a new plugin, run `./update.py --add "[owner]/[name]"`. **NOTE**: This script automatically commits to your git repository. Be sure to check out a fresh branch before running.
 
-## Important repositories
+Finally, there are some plugins that are also packaged in nodePackages because they have Javascript-related build steps, such as running webpack. Those plugins are not listed in `vim-plugin-names` or managed by `update.py` at all, and are included separately in `overrides.nix`. Currently, all these plugins are related to the `coc.nvim` ecosystem of Language Server Protocol integration with vim/neovim.
+
+## Updating plugins in nixpkgs {#updating-plugins-in-nixpkgs}
+
+Run the update script with a GitHub API token that has at least `public_repo` access. Running the script without the token is likely to result in rate-limiting (429 errors). For steps on creating an API token, please refer to [GitHub's token documentation](https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/creating-a-personal-access-token).
+
+```sh
+GITHUB_API_TOKEN=my_token ./pkgs/misc/vim-plugins/update.py
+```
+
+Alternatively, set the number of processes to a lower count to avoid rate-limiting.
+
+```sh
+./pkgs/misc/vim-plugins/update.py --proc 1
+```
+
+## Important repositories {#important-repositories}
 
 - [vim-pi](https://bitbucket.org/vimcommunity/vim-pi) is a plugin repository
   from VAM plugin manager meant to be used by others as well used by
diff --git a/doc/manual.xml b/doc/manual.xml
index 1f69872d2a7..b43021d85ca 100644
--- a/doc/manual.xml
+++ b/doc/manual.xml
@@ -1,30 +1,30 @@
 <book xmlns="http://docbook.org/ns/docbook"
       xmlns:xi="http://www.w3.org/2001/XInclude">
  <info>
-  <title>Nixpkgs Users and Contributors Guide</title>
+  <title>Nixpkgs Manual</title>
   <subtitle>Version <xi:include href=".version" parse="text" />
   </subtitle>
  </info>
  <xi:include href="preface.chapter.xml" />
  <part>
   <title>Using Nixpkgs</title>
-  <xi:include href="using/configuration.xml" />
-  <xi:include href="using/overlays.xml" />
-  <xi:include href="using/overrides.xml" />
+  <xi:include href="using/configuration.chapter.xml" />
+  <xi:include href="using/overlays.chapter.xml" />
+  <xi:include href="using/overrides.chapter.xml" />
   <xi:include href="functions.xml" />
  </part>
  <part>
   <title>Standard environment</title>
-  <xi:include href="stdenv/stdenv.xml" />
-  <xi:include href="stdenv/meta.xml" />
-  <xi:include href="stdenv/multiple-output.xml" />
-  <xi:include href="stdenv/cross-compilation.xml" />
-  <xi:include href="stdenv/platform-notes.xml" />
+  <xi:include href="stdenv/stdenv.chapter.xml" />
+  <xi:include href="stdenv/meta.chapter.xml" />
+  <xi:include href="stdenv/multiple-output.chapter.xml" />
+  <xi:include href="stdenv/cross-compilation.chapter.xml" />
+  <xi:include href="stdenv/platform-notes.chapter.xml" />
  </part>
  <part>
   <title>Builders</title>
-  <xi:include href="builders/fetchers.xml" />
-  <xi:include href="builders/trivial-builders.xml" />
+  <xi:include href="builders/fetchers.chapter.xml" />
+  <xi:include href="builders/trivial-builders.chapter.xml" />
   <xi:include href="builders/special.xml" />
   <xi:include href="builders/images.xml" />
   <xi:include href="languages-frameworks/index.xml" />
@@ -32,10 +32,11 @@
  </part>
  <part>
   <title>Contributing to Nixpkgs</title>
-  <xi:include href="contributing/quick-start.xml" />
-  <xi:include href="contributing/coding-conventions.xml" />
-  <xi:include href="contributing/submitting-changes.xml" />
-  <xi:include href="contributing/reviewing-contributions.xml" />
-  <xi:include href="contributing/contributing-to-documentation.xml" />
+  <xi:include href="contributing/quick-start.chapter.xml" />
+  <xi:include href="contributing/coding-conventions.chapter.xml" />
+  <xi:include href="contributing/submitting-changes.chapter.xml" />
+  <xi:include href="contributing/vulnerability-roundup.chapter.xml" />
+  <xi:include href="contributing/reviewing-contributions.chapter.xml" />
+  <xi:include href="contributing/contributing-to-documentation.chapter.xml" />
  </part>
 </book>
diff --git a/doc/preface.chapter.md b/doc/preface.chapter.md
index 549e42de7aa..16f228272b3 100644
--- a/doc/preface.chapter.md
+++ b/doc/preface.chapter.md
@@ -1,10 +1,4 @@
----
-title: Preface
-author: Frederik Rietdijk
-date: 2015-11-25
----
-
-# Preface
+# Preface {#preface}
 
 The Nix Packages collection (Nixpkgs) is a set of thousands of packages for the
 [Nix package manager](https://nixos.org/nix/), released under a
@@ -18,7 +12,7 @@ Nixpkgs. If you like to learn more about the Nix package manager and the Nix
 expression language, then you are kindly referred to the [Nix manual](https://nixos.org/nix/manual/).
 The NixOS distribution is documented in the [NixOS manual](https://nixos.org/nixos/manual/).
 
-## Overview of Nixpkgs
+## Overview of Nixpkgs {#overview-of-nixpkgs}
 
 Nix expressions describe how to build packages from source and are collected in
 the [nixpkgs repository](https://github.com/NixOS/nixpkgs). Also included in the
diff --git a/doc/shell.nix b/doc/shell.nix
index 8ac2019f9d6..5fa2b442489 100644
--- a/doc/shell.nix
+++ b/doc/shell.nix
@@ -1,5 +1,3 @@
-{ pkgs ? import ../. {} }:
-(import ./default.nix {}).overrideAttrs (x: {
-  buildInputs = x.buildInputs ++ [ pkgs.xmloscopy pkgs.ruby ];
-
-})
+{ pkgs ? import ../. { } }:
+(import ./default.nix { }).overrideAttrs
+(x: { buildInputs = (x.buildInputs or [ ]) ++ [ pkgs.xmloscopy pkgs.ruby ]; })
diff --git a/doc/stdenv/cross-compilation.chapter.md b/doc/stdenv/cross-compilation.chapter.md
new file mode 100644
index 00000000000..53522962a5c
--- /dev/null
+++ b/doc/stdenv/cross-compilation.chapter.md
@@ -0,0 +1,211 @@
+# Cross-compilation {#chap-cross}
+
+## Introduction {#sec-cross-intro}
+
+"Cross-compilation" means compiling a program on one machine for another type of machine. For example, a typical use of cross-compilation is to compile programs for embedded devices. These devices often don't have the computing power and memory to compile their own programs. One might think that cross-compilation is a fairly niche concern. However, there are significant advantages to rigorously distinguishing between build-time and run-time environments! Significant, because the benefits apply even when one is developing and deploying on the same machine. Nixpkgs is increasingly adopting the opinion that packages should be written with cross-compilation in mind, and Nixpkgs should evaluate in a similar way (by minimizing cross-compilation-specific special cases) whether or not one is cross-compiling.
+
+This chapter will be organized in three parts. First, it will describe the basics of how to package software in a way that supports cross-compilation. Second, it will describe how to use Nixpkgs when cross-compiling. Third, it will describe the internal infrastructure supporting cross-compilation.
+
+## Packaging in a cross-friendly manner {#sec-cross-packaging}
+
+### Platform parameters {#ssec-cross-platform-parameters}
+
+Nixpkgs follows the [conventions of GNU autoconf](https://gcc.gnu.org/onlinedocs/gccint/Configure-Terms.html). We distinguish between 3 types of platforms when building a derivation: _build_, _host_, and _target_. In summary, _build_ is the platform on which a package is being built, _host_ is the platform on which it will run. The third attribute, _target_, is relevant only for certain specific compilers and build tools.
+
+In Nixpkgs, these three platforms are defined as attribute sets under the names `buildPlatform`, `hostPlatform`, and `targetPlatform`. They are always defined as attributes in the standard environment. That means one can access them like:
+
+```nix
+{ stdenv, fooDep, barDep, ... }: ...stdenv.buildPlatform...
+```
+
+`buildPlatform`
+
+: The "build platform" is the platform on which a package is built. Once someone has a built package, or pre-built binary package, the build platform should not matter and can be ignored.
+
+`hostPlatform`
+
+: The "host platform" is the platform on which a package will be run. This is the simplest platform to understand, but also the one with the worst name.
+
+`targetPlatform`
+
+: The "target platform" attribute is, unlike the other two attributes, not actually fundamental to the process of building software. Instead, it is only relevant for compatibility with building certain specific compilers and build tools. It can be safely ignored for all other packages.
+
+: The build process of certain compilers is written in such a way that the compiler resulting from a single build can itself only produce binaries for a single platform. The task of specifying this single "target platform" is thus pushed to build time of the compiler. The root cause of this is that the compiler (which will be run on the host) and the standard library/runtime (which will be run on the target) are built by a single build process.
+
+: There is no fundamental need to think about a single target ahead of time like this. If the tool supports modular or pluggable backends, both the need to specify the target at build time and the constraint of having only a single target disappear. An example of such a tool is LLVM.
+
+: Although the existence of a "target platform" is arguably a historical mistake, it is a common one: examples of tools that suffer from it are GCC, Binutils, GHC and Autoconf. Nixpkgs tries to avoid sharing in the mistake where possible. Still, because the concept of a target platform is so ingrained, it is best to support it as is.
+
+The exact schema these fields follow is a bit ill-defined due to a long and convoluted evolution, but this is slowly being cleaned up. You can see examples of ones used in practice in `lib.systems.examples`; note how they are not all very consistent. For now, here are few fields can count on them containing:
+
+`system`
+
+: This is a two-component shorthand for the platform. Examples of this would be "x86_64-darwin" and "i686-linux"; see `lib.systems.doubles` for more. The first component corresponds to the CPU architecture of the platform and the second to the operating system of the platform (`[cpu]-[os]`). This format has built-in support in Nix, such as the `builtins.currentSystem` impure string.
+
+`config`
+
+: This is a 3- or 4- component shorthand for the platform. Examples of this would be `x86_64-unknown-linux-gnu` and `aarch64-apple-darwin14`. This is a standard format called the "LLVM target triple", as they are pioneered by LLVM. In the 4-part form, this corresponds to `[cpu]-[vendor]-[os]-[abi]`. This format is strictly more informative than the "Nix host double", as the previous format could analogously be termed. This needs a better name than `config`!
+
+`parsed`
+
+: This is a Nix representation of a parsed LLVM target triple with white-listed components. This can be specified directly, or actually parsed from the `config`. See `lib.systems.parse` for the exact representation.
+
+`libc`
+
+: This is a string identifying the standard C library used. Valid identifiers include "glibc" for GNU libc, "libSystem" for Darwin's Libsystem, and "uclibc" for µClibc. It should probably be refactored to use the module system, like `parse`.
+
+`is*`
+
+: These predicates are defined in `lib.systems.inspect`, and slapped onto every platform. They are superior to the ones in `stdenv` as they force the user to be explicit about which platform they are inspecting. Please use these instead of those.
+
+`platform`
+
+: This is, quite frankly, a dumping ground of ad-hoc settings (it's an attribute set). See `lib.systems.platforms` for examples—there's hopefully one in there that will work verbatim for each platform that is working. Please help us triage these flags and give them better homes!
+
+### Theory of dependency categorization {#ssec-cross-dependency-categorization}
+
+::: {.note}
+This is a rather philosophical description that isn't very Nixpkgs-specific. For an overview of all the relevant attributes given to `mkDerivation`, see [](#ssec-stdenv-dependencies). For a description of how everything is implemented, see [](#ssec-cross-dependency-implementation).
+:::
+
+In this section we explore the relationship between both runtime and build-time dependencies and the 3 Autoconf platforms.
+
+A run time dependency between two packages requires that their host platforms match. This is directly implied by the meaning of "host platform" and "runtime dependency": The package dependency exists while both packages are running on a single host platform.
+
+A build time dependency, however, has a shift in platforms between the depending package and the depended-on package. "build time dependency" means that to build the depending package we need to be able to run the depended-on's package. The depending package's build platform is therefore equal to the depended-on package's host platform.
+
+If both the dependency and depending packages aren't compilers or other machine-code-producing tools, we're done. And indeed `buildInputs` and `nativeBuildInputs` have covered these simpler cases for many years. But if the dependency does produce machine code, we might need to worry about its target platform too. In principle, that target platform might be any of the depending package's build, host, or target platforms, but we prohibit dependencies from a "later" platform to an earlier platform to limit confusion because we've never seen a legitimate use for them.
+
+Finally, if the depending package is a compiler or other machine-code-producing tool, it might need dependencies that run at "emit time". This is for compilers that (regrettably) insist on being built together with their source languages' standard libraries. Assuming build != host != target, a run-time dependency of the standard library cannot be run at the compiler's build time or run time, but only at the run time of code emitted by the compiler.
+
+Putting this all together, that means we have dependencies in the form "host → target", in at most the following six combinations:
+
+#### Possible dependency types {#possible-dependency-types}
+
+| Dependency’s host platform | Dependency’s target platform |
+|----------------------------|------------------------------|
+| build                      | build                        |
+| build                      | host                         |
+| build                      | target                       |
+| host                       | host                         |
+| host                       | target                       |
+| target                     | target                       |
+
+
+Some examples will make this table clearer. Suppose there's some package that is being built with a `(build, host, target)` platform triple of `(foo, bar, baz)`. If it has a build-time library dependency, that would be a "host → build" dependency with a triple of `(foo, foo, *)` (the target platform is irrelevant). If it needs a compiler to be built, that would be a "build → host" dependency with a triple of `(foo, foo, *)` (the target platform is irrelevant). That compiler, would be built with another compiler, also "build → host" dependency, with a triple of `(foo, foo, foo)`.
+
+### Cross packaging cookbook {#ssec-cross-cookbook}
+
+Some frequently encountered problems when packaging for cross-compilation should be answered here. Ideally, the information above is exhaustive, so this section cannot provide any new information, but it is ludicrous and cruel to expect everyone to spend effort working through the interaction of many features just to figure out the same answer to the same common problem. Feel free to add to this list!
+
+#### My package fails to find a binutils command (`cc`/`ar`/`ld` etc.) {#cross-qa-fails-to-find-binutils}
+Many packages assume that an unprefixed binutils (`cc`/`ar`/`ld` etc.) is available, but Nix doesn't provide one. It only provides a prefixed one, just as it only does for all the other binutils programs. It may be necessary to patch the package to fix the build system to use a prefix. For instance, instead of `cc`, use `${stdenv.cc.targetPrefix}cc`.
+
+```nix
+makeFlags = [ "CC=${stdenv.cc.targetPrefix}cc" ];
+```
+
+#### How do I avoid compiling a GCC cross-compiler from source? {#cross-qa-avoid-compiling-gcc-cross-compiler}
+On less powerful machines, it can be inconvenient to cross-compile a package only to find out that GCC has to be compiled from source, which could take up to several hours. Nixpkgs maintains a limited [cross-related jobset on Hydra](https://hydra.nixos.org/jobset/nixpkgs/cross-trunk), which tests cross-compilation to various platforms from build platforms "x86\_64-darwin", "x86\_64-linux", and "aarch64-linux".  See `pkgs/top-level/release-cross.nix` for the full list of target platforms and packages.  For instance, the following invocation fetches the pre-built cross-compiled GCC for `armv6l-unknown-linux-gnueabihf` and builds GNU Hello from source.
+
+```ShellSession
+$ nix-build '<nixpkgs>' -A pkgsCross.raspberryPi.hello
+```
+
+#### What if my package’s build system needs to build a C program to be run under the build environment? {#cross-qa-build-c-program-in-build-environment}
+
+Add the following to your `mkDerivation` invocation.
+
+```nix
+depsBuildBuild = [ buildPackages.stdenv.cc ];
+```
+
+#### My package’s testsuite needs to run host platform code. {#cross-testsuite-runs-host-code}
+
+Add the following to your `mkDerivation` invocation.
+
+```nix
+doCheck = stdenv.hostPlatform == stdenv.buildPlatform;
+```
+
+## Cross-building packages {#sec-cross-usage}
+
+Nixpkgs can be instantiated with `localSystem` alone, in which case there is no cross-compiling and everything is built by and for that system, or also with `crossSystem`, in which case packages run on the latter, but all building happens on the former. Both parameters take the same schema as the 3 (build, host, and target) platforms defined in the previous section. As mentioned above, `lib.systems.examples` has some platforms which are used as arguments for these parameters in practice. You can use them programmatically, or on the command line:
+
+```ShellSession
+$ nix-build '<nixpkgs>' --arg crossSystem '(import <nixpkgs/lib>).systems.examples.fooBarBaz' -A whatever
+```
+
+::: {.note}
+Eventually we would like to make these platform examples an unnecessary convenience so that
+
+```ShellSession
+$ nix-build '<nixpkgs>' --arg crossSystem '{ config = "<arch>-<os>-<vendor>-<abi>"; }' -A whatever
+```
+
+works in the vast majority of cases. The problem today is dependencies on other sorts of configuration which aren't given proper defaults. We rely on the examples to crudely to set those configuration parameters in some vaguely sane manner on the users behalf. Issue [\#34274](https://github.com/NixOS/nixpkgs/issues/34274) tracks this inconvenience along with its root cause in crufty configuration options.
+:::
+
+While one is free to pass both parameters in full, there's a lot of logic to fill in missing fields. As discussed in the previous section, only one of `system`, `config`, and `parsed` is needed to infer the other two. Additionally, `libc` will be inferred from `parse`. Finally, `localSystem.system` is also _impurely_ inferred based on the platform evaluation occurs. This means it is often not necessary to pass `localSystem` at all, as in the command-line example in the previous paragraph.
+
+::: {.note}
+Many sources (manual, wiki, etc) probably mention passing `system`, `platform`, along with the optional `crossSystem` to Nixpkgs: `import <nixpkgs> { system = ..; platform = ..; crossSystem = ..; }`. Passing those two instead of `localSystem` is still supported for compatibility, but is discouraged. Indeed, much of the inference we do for these parameters is motivated by compatibility as much as convenience.
+:::
+
+One would think that `localSystem` and `crossSystem` overlap horribly with the three `*Platforms` (`buildPlatform`, `hostPlatform,` and `targetPlatform`; see `stage.nix` or the manual). Actually, those identifiers are purposefully not used here to draw a subtle but important distinction: While the granularity of having 3 platforms is necessary to properly *build* packages, it is overkill for specifying the user's *intent* when making a build plan or package set. A simple "build vs deploy" dichotomy is adequate: the sliding window principle described in the previous section shows how to interpolate between the these two "end points" to get the 3 platform triple for each bootstrapping stage. That means for any package a given package set, even those not bound on the top level but only reachable via dependencies or `buildPackages`, the three platforms will be defined as one of `localSystem` or `crossSystem`, with the former replacing the latter as one traverses build-time dependencies. A last simple difference is that `crossSystem` should be null when one doesn't want to cross-compile, while the `*Platform`s are always non-null. `localSystem` is always non-null.
+
+## Cross-compilation infrastructure {#sec-cross-infra}
+
+### Implementation of dependencies {#ssec-cross-dependency-implementation}
+
+The categories of dependencies developed in [](#ssec-cross-dependency-categorization) are specified as lists of derivations given to `mkDerivation`, as documented in [](#ssec-stdenv-dependencies). In short, each list of dependencies for "host → target" of "foo → bar" is called `depsFooBar`, with exceptions for backwards compatibility that `depsBuildHost` is instead called `nativeBuildInputs` and `depsHostTarget` is instead called `buildInputs`. Nixpkgs is now structured so that each `depsFooBar` is automatically taken from `pkgsFooBar`. (These `pkgsFooBar`s are quite new, so there is no special case for `nativeBuildInputs` and `buildInputs`.) For example, `pkgsBuildHost.gcc` should be used at build-time, while `pkgsHostTarget.gcc` should be used at run-time.
+
+Now, for most of Nixpkgs's history, there were no `pkgsFooBar` attributes, and most packages have not been refactored to use it explicitly. Prior to those, there were just `buildPackages`, `pkgs`, and `targetPackages`. Those are now redefined as aliases to `pkgsBuildHost`, `pkgsHostTarget`, and `pkgsTargetTarget`. It is acceptable, even recommended, to use them for libraries to show that the host platform is irrelevant.
+
+But before that, there was just `pkgs`, even though both `buildInputs` and `nativeBuildInputs` existed. \[Cross barely worked, and those were implemented with some hacks on `mkDerivation` to override dependencies.\] What this means is the vast majority of packages do not use any explicit package set to populate their dependencies, just using whatever `callPackage` gives them even if they do correctly sort their dependencies into the multiple lists described above. And indeed, asking that users both sort their dependencies, _and_ take them from the right attribute set, is both too onerous and redundant, so the recommended approach (for now) is to continue just categorizing by list and not using an explicit package set.
+
+To make this work, we "splice" together the six `pkgsFooBar` package sets and have `callPackage` actually take its arguments from that. This is currently implemented in `pkgs/top-level/splice.nix`. `mkDerivation` then, for each dependency attribute, pulls the right derivation out from the splice. This splicing can be skipped when not cross-compiling as the package sets are the same, but still is a bit slow for cross-compiling. We'd like to do something better, but haven't come up with anything yet.
+
+### Bootstrapping {#ssec-bootstrapping}
+
+Each of the package sets described above come from a single bootstrapping stage. While `pkgs/top-level/default.nix`, coordinates the composition of stages at a high level, `pkgs/top-level/stage.nix` "ties the knot" (creates the fixed point) of each stage. The package sets are defined per-stage however, so they can be thought of as edges between stages (the nodes) in a graph. Compositions like `pkgsBuildTarget.targetPackages` can be thought of as paths to this graph.
+
+While there are many package sets, and thus many edges, the stages can also be arranged in a linear chain. In other words, many of the edges are redundant as far as connectivity is concerned. This hinges on the type of bootstrapping we do. Currently for cross it is:
+
+1.  `(native, native, native)`
+
+2.  `(native, native, foreign)`
+
+3.  `(native, foreign, foreign)`
+
+In each stage, `pkgsBuildHost` refers to the previous stage, `pkgsBuildBuild` refers to the one before that, and `pkgsHostTarget` refers to the current one, and `pkgsTargetTarget` refers to the next one. When there is no previous or next stage, they instead refer to the current stage. Note how all the invariants regarding the mapping between dependency and depending packages' build host and target platforms are preserved. `pkgsBuildTarget` and `pkgsHostHost` are more complex in that the stage fitting the requirements isn't always a fixed chain of "prevs" and "nexts" away (modulo the "saturating" self-references at the ends). We just special case each instead. All the primary edges are implemented is in `pkgs/stdenv/booter.nix`, and secondarily aliases in `pkgs/top-level/stage.nix`.
+
+::: {.note}
+The native stages are bootstrapped in legacy ways that predate the current cross implementation. This is why the bootstrapping stages leading up to the final stages are ignored in the previous paragraph.
+:::
+
+If one looks at the 3 platform triples, one can see that they overlap such that one could put them together into a chain like:
+```
+(native, native, native, foreign, foreign)
+```
+
+If one imagines the saturating self references at the end being replaced with infinite stages, and then overlays those platform triples, one ends up with the infinite tuple:
+```
+(native..., native, native, native, foreign, foreign, foreign...)
+```
+One can then imagine any sequence of platforms such that there are bootstrap stages with their 3 platforms determined by "sliding a window" that is the 3 tuple through the sequence. This was the original model for bootstrapping. Without a target platform (assume a better world where all compilers are multi-target and all standard libraries are built in their own derivation), this is sufficient. Conversely if one wishes to cross compile "faster", with a "Canadian Cross" bootstrapping stage where `build != host != target`, more bootstrapping stages are needed since no sliding window provides the pesky `pkgsBuildTarget` package set since it skips the Canadian cross stage's "host".
+
+
+::: {.note}
+It is much better to refer to `buildPackages` than `targetPackages`, or more broadly package sets that do not mention “target”. There are three reasons for this.
+
+First, it is because bootstrapping stages do not have a unique `targetPackages`. For example a `(x86-linux, x86-linux, arm-linux)` and `(x86-linux, x86-linux, x86-windows)` package set both have a `(x86-linux, x86-linux, x86-linux)` package set. Because there is no canonical `targetPackages` for such a native (`build == host == target`) package set, we set their `targetPackages`
+
+Second, it is because this is a frequent source of hard-to-follow "infinite recursions" / cycles. When only package sets that don't mention target are used, the package set forms a directed acyclic graph. This means that all cycles that exist are confined to one stage. This means they are a lot smaller, and easier to follow in the code or a backtrace. It also means they are present in native and cross builds alike, and so more likely to be caught by CI and other users.
+
+Thirdly, it is because everything target-mentioning only exists to accommodate compilers with lousy build systems that insist on the compiler itself and standard library being built together. Of course that is bad because bigger derivations means longer rebuilds. It is also problematic because it tends to make the standard libraries less like other libraries than they could be, complicating code and build systems alike. Because of the other problems, and because of these innate disadvantages, compilers ought to be packaged another way where possible.
+:::
+
+::: {.note}
+If one explores Nixpkgs, they will see derivations with names like `gccCross`. Such `*Cross` derivations is a holdover from before we properly distinguished between the host and target platforms—the derivation with “Cross” in the name covered the `build = host != target` case, while the other covered the `host = target`, with build platform the same or not based on whether one was using its `.nativeDrv` or `.crossDrv`. This ugliness will disappear soon.
+:::
diff --git a/doc/stdenv/cross-compilation.xml b/doc/stdenv/cross-compilation.xml
deleted file mode 100644
index 690578b78c6..00000000000
--- a/doc/stdenv/cross-compilation.xml
+++ /dev/null
@@ -1,394 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-cross">
- <title>Cross-compilation</title>
- <section xml:id="sec-cross-intro">
-  <title>Introduction</title>
-
-  <para>
-   "Cross-compilation" means compiling a program on one machine for another type of machine. For example, a typical use of cross-compilation is to compile programs for embedded devices. These devices often don't have the computing power and memory to compile their own programs. One might think that cross-compilation is a fairly niche concern. However, there are significant advantages to rigorously distinguishing between build-time and run-time environments! Significant, because the benefits apply even when one is developing and deploying on the same machine. Nixpkgs is increasingly adopting the opinion that packages should be written with cross-compilation in mind, and nixpkgs should evaluate in a similar way (by minimizing cross-compilation-specific special cases) whether or not one is cross-compiling.
-  </para>
-
-  <para>
-   This chapter will be organized in three parts. First, it will describe the basics of how to package software in a way that supports cross-compilation. Second, it will describe how to use Nixpkgs when cross-compiling. Third, it will describe the internal infrastructure supporting cross-compilation.
-  </para>
- </section>
-<!--============================================================-->
- <section xml:id="sec-cross-packaging">
-  <title>Packaging in a cross-friendly manner</title>
-
-  <section xml:id="ssec-cross-platform-parameters">
-   <title>Platform parameters</title>
-
-   <para>
-    Nixpkgs follows the <link
-     xlink:href="https://gcc.gnu.org/onlinedocs/gccint/Configure-Terms.html">conventions of GNU autoconf</link>. We distinguish between 3 types of platforms when building a derivation: <wordasword>build</wordasword>, <wordasword>host</wordasword>, and <wordasword>target</wordasword>. In summary, <wordasword>build</wordasword> is the platform on which a package is being built, <wordasword>host</wordasword> is the platform on which it will run. The third attribute, <wordasword>target</wordasword>, is relevant only for certain specific compilers and build tools.
-   </para>
-
-   <para>
-    In Nixpkgs, these three platforms are defined as attribute sets under the names <literal>buildPlatform</literal>, <literal>hostPlatform</literal>, and <literal>targetPlatform</literal>. They are always defined as attributes in the standard environment. That means one can access them like:
-<programlisting>{ stdenv, fooDep, barDep, .. }: ...stdenv.buildPlatform...</programlisting>
-    .
-   </para>
-
-   <variablelist>
-    <varlistentry>
-     <term>
-      <varname>buildPlatform</varname>
-     </term>
-     <listitem>
-      <para>
-       The "build platform" is the platform on which a package is built. Once someone has a built package, or pre-built binary package, the build platform should not matter and can be ignored.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>hostPlatform</varname>
-     </term>
-     <listitem>
-      <para>
-       The "host platform" is the platform on which a package will be run. This is the simplest platform to understand, but also the one with the worst name.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>targetPlatform</varname>
-     </term>
-     <listitem>
-      <para>
-       The "target platform" attribute is, unlike the other two attributes, not actually fundamental to the process of building software. Instead, it is only relevant for compatibility with building certain specific compilers and build tools. It can be safely ignored for all other packages.
-      </para>
-      <para>
-       The build process of certain compilers is written in such a way that the compiler resulting from a single build can itself only produce binaries for a single platform. The task of specifying this single "target platform" is thus pushed to build time of the compiler. The root cause of this is that the compiler (which will be run on the host) and the standard library/runtime (which will be run on the target) are built by a single build process.
-      </para>
-      <para>
-       There is no fundamental need to think about a single target ahead of time like this. If the tool supports modular or pluggable backends, both the need to specify the target at build time and the constraint of having only a single target disappear. An example of such a tool is LLVM.
-      </para>
-      <para>
-       Although the existence of a "target platfom" is arguably a historical mistake, it is a common one: examples of tools that suffer from it are GCC, Binutils, GHC and Autoconf. Nixpkgs tries to avoid sharing in the mistake where possible. Still, because the concept of a target platform is so ingrained, it is best to support it as is.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-
-   <para>
-    The exact schema these fields follow is a bit ill-defined due to a long and convoluted evolution, but this is slowly being cleaned up. You can see examples of ones used in practice in <literal>lib.systems.examples</literal>; note how they are not all very consistent. For now, here are few fields can count on them containing:
-   </para>
-
-   <variablelist>
-    <varlistentry>
-     <term>
-      <varname>system</varname>
-     </term>
-     <listitem>
-      <para>
-       This is a two-component shorthand for the platform. Examples of this would be "x86_64-darwin" and "i686-linux"; see <literal>lib.systems.doubles</literal> for more. The first component corresponds to the CPU architecture of the platform and the second to the operating system of the platform (<literal>[cpu]-[os]</literal>). This format has built-in support in Nix, such as the <varname>builtins.currentSystem</varname> impure string.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>config</varname>
-     </term>
-     <listitem>
-      <para>
-       This is a 3- or 4- component shorthand for the platform. Examples of this would be <literal>x86_64-unknown-linux-gnu</literal> and <literal>aarch64-apple-darwin14</literal>. This is a standard format called the "LLVM target triple", as they are pioneered by LLVM. In the 4-part form, this corresponds to <literal>[cpu]-[vendor]-[os]-[abi]</literal>. This format is strictly more informative than the "Nix host double", as the previous format could analogously be termed. This needs a better name than <varname>config</varname>!
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>parsed</varname>
-     </term>
-     <listitem>
-      <para>
-       This is a Nix representation of a parsed LLVM target triple with white-listed components. This can be specified directly, or actually parsed from the <varname>config</varname>. See <literal>lib.systems.parse</literal> for the exact representation.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>libc</varname>
-     </term>
-     <listitem>
-      <para>
-       This is a string identifying the standard C library used. Valid identifiers include "glibc" for GNU libc, "libSystem" for Darwin's Libsystem, and "uclibc" for µClibc. It should probably be refactored to use the module system, like <varname>parse</varname>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>is*</varname>
-     </term>
-     <listitem>
-      <para>
-       These predicates are defined in <literal>lib.systems.inspect</literal>, and slapped onto every platform. They are superior to the ones in <varname>stdenv</varname> as they force the user to be explicit about which platform they are inspecting. Please use these instead of those.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>platform</varname>
-     </term>
-     <listitem>
-      <para>
-       This is, quite frankly, a dumping ground of ad-hoc settings (it's an attribute set). See <literal>lib.systems.platforms</literal> for examples—there's hopefully one in there that will work verbatim for each platform that is working. Please help us triage these flags and give them better homes!
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
-
-  <section xml:id="ssec-cross-dependency-categorization">
-   <title>Theory of dependency categorization</title>
-
-   <note>
-    <para>
-     This is a rather philosophical description that isn't very Nixpkgs-specific. For an overview of all the relevant attributes given to <varname>mkDerivation</varname>, see <xref
-     linkend="ssec-stdenv-dependencies"/>. For a description of how everything is implemented, see <xref linkend="ssec-cross-dependency-implementation" />.
-    </para>
-   </note>
-
-   <para>
-    In this section we explore the relationship between both runtime and build-time dependencies and the 3 Autoconf platforms.
-   </para>
-
-   <para>
-    A run time dependency between two packages requires that their host platforms match. This is directly implied by the meaning of "host platform" and "runtime dependency": The package dependency exists while both packages are running on a single host platform.
-   </para>
-
-   <para>
-    A build time dependency, however, has a shift in platforms between the depending package and the depended-on package. "build time dependency" means that to build the depending package we need to be able to run the depended-on's package. The depending package's build platform is therefore equal to the depended-on package's host platform.
-   </para>
-
-   <para>
-    If both the dependency and depending packages aren't compilers or other machine-code-producing tools, we're done. And indeed <varname>buildInputs</varname> and <varname>nativeBuildInputs</varname> have covered these simpler build-time and run-time (respectively) changes for many years. But if the dependency does produce machine code, we might need to worry about its target platform too. In principle, that target platform might be any of the depending package's build, host, or target platforms, but we prohibit dependencies from a "later" platform to an earlier platform to limit confusion because we've never seen a legitimate use for them.
-   </para>
-
-   <para>
-    Finally, if the depending package is a compiler or other machine-code-producing tool, it might need dependencies that run at "emit time". This is for compilers that (regrettably) insist on being built together with their source langauges' standard libraries. Assuming build != host != target, a run-time dependency of the standard library cannot be run at the compiler's build time or run time, but only at the run time of code emitted by the compiler.
-   </para>
-
-   <para>
-    Putting this all together, that means we have dependencies in the form "host → target", in at most the following six combinations:
-    <table>
-     <caption>Possible dependency types</caption>
-     <thead>
-      <tr>
-       <th>Dependency's host platform</th>
-       <th>Dependency's target platform</th>
-      </tr>
-     </thead>
-     <tbody>
-      <tr>
-       <td>build</td>
-       <td>build</td>
-      </tr>
-      <tr>
-       <td>build</td>
-       <td>host</td>
-      </tr>
-      <tr>
-       <td>build</td>
-       <td>target</td>
-      </tr>
-      <tr>
-       <td>host</td>
-       <td>host</td>
-      </tr>
-      <tr>
-       <td>host</td>
-       <td>target</td>
-      </tr>
-      <tr>
-       <td>target</td>
-       <td>target</td>
-      </tr>
-     </tbody>
-    </table>
-   </para>
-
-   <para>
-    Some examples will make this table clearer. Suppose there's some package that is being built with a <literal>(build, host, target)</literal> platform triple of <literal>(foo, bar, baz)</literal>. If it has a build-time library dependency, that would be a "host → build" dependency with a triple of <literal>(foo, foo, *)</literal> (the target platform is irrelevant). If it needs a compiler to be built, that would be a "build → host" dependency with a triple of <literal>(foo, foo, *)</literal> (the target platform is irrelevant). That compiler, would be built with another compiler, also "build → host" dependency, with a triple of <literal>(foo, foo, foo)</literal>.
-   </para>
-  </section>
-
-  <section xml:id="ssec-cross-cookbook">
-   <title>Cross packaging cookbook</title>
-
-   <para>
-    Some frequently encountered problems when packaging for cross-compilation should be answered here. Ideally, the information above is exhaustive, so this section cannot provide any new information, but it is ludicrous and cruel to expect everyone to spend effort working through the interaction of many features just to figure out the same answer to the same common problem. Feel free to add to this list!
-   </para>
-
-   <qandaset>
-    <qandaentry xml:id="cross-qa-build-c-program-in-build-environment">
-     <question>
-      <para>
-       What if my package's build system needs to build a C program to be run under the build environment?
-      </para>
-     </question>
-     <answer>
-      <para>
-<programlisting>depsBuildBuild = [ buildPackages.stdenv.cc ];</programlisting>
-       Add it to your <function>mkDerivation</function> invocation.
-      </para>
-     </answer>
-    </qandaentry>
-    <qandaentry xml:id="cross-qa-fails-to-find-ar">
-     <question>
-      <para>
-       My package fails to find <command>ar</command>.
-      </para>
-     </question>
-     <answer>
-      <para>
-       Many packages assume that an unprefixed <command>ar</command> is available, but Nix doesn't provide one. It only provides a prefixed one, just as it only does for all the other binutils programs. It may be necessary to patch the package to fix the build system to use a prefixed <command>ar</command>.
-      </para>
-     </answer>
-    </qandaentry>
-    <qandaentry xml:id="cross-testsuite-runs-host-code">
-     <question>
-      <para>
-       My package's testsuite needs to run host platform code.
-      </para>
-     </question>
-     <answer>
-      <para>
-<programlisting>doCheck = stdenv.hostPlatform == stdenv.buildPlatfrom;</programlisting>
-       Add it to your <function>mkDerivation</function> invocation.
-      </para>
-     </answer>
-    </qandaentry>
-   </qandaset>
-  </section>
- </section>
-<!--============================================================-->
- <section xml:id="sec-cross-usage">
-  <title>Cross-building packages</title>
-
-  <para>
-   Nixpkgs can be instantiated with <varname>localSystem</varname> alone, in which case there is no cross-compiling and everything is built by and for that system, or also with <varname>crossSystem</varname>, in which case packages run on the latter, but all building happens on the former. Both parameters take the same schema as the 3 (build, host, and target) platforms defined in the previous section. As mentioned above, <literal>lib.systems.examples</literal> has some platforms which are used as arguments for these parameters in practice. You can use them programmatically, or on the command line:
-<programlisting>
-nix-build '&lt;nixpkgs&gt;' --arg crossSystem '(import &lt;nixpkgs/lib&gt;).systems.examples.fooBarBaz' -A whatever</programlisting>
-  </para>
-
-  <note>
-   <para>
-    Eventually we would like to make these platform examples an unnecessary convenience so that
-<programlisting>
-nix-build '&lt;nixpkgs&gt;' --arg crossSystem '{ config = "&lt;arch&gt;-&lt;os&gt;-&lt;vendor&gt;-&lt;abi&gt;"; }' -A whatever</programlisting>
-    works in the vast majority of cases. The problem today is dependencies on other sorts of configuration which aren't given proper defaults. We rely on the examples to crudely to set those configuration parameters in some vaguely sane manner on the users behalf. Issue <link xlink:href="https://github.com/NixOS/nixpkgs/issues/34274">#34274</link> tracks this inconvenience along with its root cause in crufty configuration options.
-   </para>
-  </note>
-
-  <para>
-   While one is free to pass both parameters in full, there's a lot of logic to fill in missing fields. As discussed in the previous section, only one of <varname>system</varname>, <varname>config</varname>, and <varname>parsed</varname> is needed to infer the other two. Additionally, <varname>libc</varname> will be inferred from <varname>parse</varname>. Finally, <literal>localSystem.system</literal> is also <emphasis>impurely</emphasis> inferred based on the platform evaluation occurs. This means it is often not necessary to pass <varname>localSystem</varname> at all, as in the command-line example in the previous paragraph.
-  </para>
-
-  <note>
-   <para>
-    Many sources (manual, wiki, etc) probably mention passing <varname>system</varname>, <varname>platform</varname>, along with the optional <varname>crossSystem</varname> to nixpkgs: <literal>import &lt;nixpkgs&gt; { system = ..; platform = ..; crossSystem = ..; }</literal>. Passing those two instead of <varname>localSystem</varname> is still supported for compatibility, but is discouraged. Indeed, much of the inference we do for these parameters is motivated by compatibility as much as convenience.
-   </para>
-  </note>
-
-  <para>
-   One would think that <varname>localSystem</varname> and <varname>crossSystem</varname> overlap horribly with the three <varname>*Platforms</varname> (<varname>buildPlatform</varname>, <varname>hostPlatform,</varname> and <varname>targetPlatform</varname>; see <varname>stage.nix</varname> or the manual). Actually, those identifiers are purposefully not used here to draw a subtle but important distinction: While the granularity of having 3 platforms is necessary to properly *build* packages, it is overkill for specifying the user's *intent* when making a build plan or package set. A simple "build vs deploy" dichotomy is adequate: the sliding window principle described in the previous section shows how to interpolate between the these two "end points" to get the 3 platform triple for each bootstrapping stage. That means for any package a given package set, even those not bound on the top level but only reachable via dependencies or <varname>buildPackages</varname>, the three platforms will be defined as one of <varname>localSystem</varname> or <varname>crossSystem</varname>, with the former replacing the latter as one traverses build-time dependencies. A last simple difference is that <varname>crossSystem</varname> should be null when one doesn't want to cross-compile, while the <varname>*Platform</varname>s are always non-null. <varname>localSystem</varname> is always non-null.
-  </para>
- </section>
-<!--============================================================-->
- <section xml:id="sec-cross-infra">
-  <title>Cross-compilation infrastructure</title>
-
-  <section xml:id="ssec-cross-dependency-implementation">
-   <title>Implementation of dependencies</title>
-
-   <para>
-    The categorizes of dependencies developed in <xref
-    linkend="ssec-cross-dependency-categorization"/> are specified as lists of derivations given to <varname>mkDerivation</varname>, as documented in <xref linkend="ssec-stdenv-dependencies"/>. In short, each list of dependencies for "host → target" of "foo → bar" is called <varname>depsFooBar</varname>, with exceptions for backwards compatibility that <varname>depsBuildHost</varname> is instead called <varname>nativeBuildInputs</varname> and <varname>depsHostTarget</varname> is instead called <varname>buildInputs</varname>. Nixpkgs is now structured so that each <varname>depsFooBar</varname> is automatically taken from <varname>pkgsFooBar</varname>. (These <varname>pkgsFooBar</varname>s are quite new, so there is no special case for <varname>nativeBuildInputs</varname> and <varname>buildInputs</varname>.) For example, <varname>pkgsBuildHost.gcc</varname> should be used at build-time, while <varname>pkgsHostTarget.gcc</varname> should be used at run-time.
-   </para>
-
-   <para>
-    Now, for most of Nixpkgs's history, there were no <varname>pkgsFooBar</varname> attributes, and most packages have not been refactored to use it explicitly. Prior to those, there were just <varname>buildPackages</varname>, <varname>pkgs</varname>, and <varname>targetPackages</varname>. Those are now redefined as aliases to <varname>pkgsBuildHost</varname>, <varname>pkgsHostTarget</varname>, and <varname>pkgsTargetTarget</varname>. It is acceptable, even recommended, to use them for libraries to show that the host platform is irrelevant.
-   </para>
-
-   <para>
-    But before that, there was just <varname>pkgs</varname>, even though both <varname>buildInputs</varname> and <varname>nativeBuildInputs</varname> existed. [Cross barely worked, and those were implemented with some hacks on <varname>mkDerivation</varname> to override dependencies.] What this means is the vast majority of packages do not use any explicit package set to populate their dependencies, just using whatever <varname>callPackage</varname> gives them even if they do correctly sort their dependencies into the multiple lists described above. And indeed, asking that users both sort their dependencies, <emphasis>and</emphasis> take them from the right attribute set, is both too onerous and redundant, so the recommended approach (for now) is to continue just categorizing by list and not using an explicit package set.
-   </para>
-
-   <para>
-    To make this work, we "splice" together the six <varname>pkgsFooBar</varname> package sets and have <varname>callPackage</varname> actually take its arguments from that. This is currently implemented in <filename>pkgs/top-level/splice.nix</filename>. <varname>mkDerivation</varname> then, for each dependency attribute, pulls the right derivation out from the splice. This splicing can be skipped when not cross-compiling as the package sets are the same, but still is a bit slow for cross-compiling. We'd like to do something better, but haven't come up with anything yet.
-   </para>
-  </section>
-
-  <section xml:id="ssec-bootstrapping">
-   <title>Bootstrapping</title>
-
-   <para>
-    Each of the package sets described above come from a single bootstrapping stage. While <filename>pkgs/top-level/default.nix</filename>, coordinates the composition of stages at a high level, <filename>pkgs/top-level/stage.nix</filename> "ties the knot" (creates the fixed point) of each stage. The package sets are defined per-stage however, so they can be thought of as edges between stages (the nodes) in a graph. Compositions like <literal>pkgsBuildTarget.targetPackages</literal> can be thought of as paths to this graph.
-   </para>
-
-   <para>
-    While there are many package sets, and thus many edges, the stages can also be arranged in a linear chain. In other words, many of the edges are redundant as far as connectivity is concerned. This hinges on the type of bootstrapping we do. Currently for cross it is:
-    <orderedlist>
-     <listitem>
-      <para>
-       <literal>(native, native, native)</literal>
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       <literal>(native, native, foreign)</literal>
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       <literal>(native, foreign, foreign)</literal>
-      </para>
-     </listitem>
-    </orderedlist>
-    In each stage, <varname>pkgsBuildHost</varname> refers to the previous stage, <varname>pkgsBuildBuild</varname> refers to the one before that, and <varname>pkgsHostTarget</varname> refers to the current one, and <varname>pkgsTargetTarget</varname> refers to the next one. When there is no previous or next stage, they instead refer to the current stage. Note how all the invariants regarding the mapping between dependency and depending packages' build host and target platforms are preserved. <varname>pkgsBuildTarget</varname> and <varname>pkgsHostHost</varname> are more complex in that the stage fitting the requirements isn't always a fixed chain of "prevs" and "nexts" away (modulo the "saturating" self-references at the ends). We just special case each instead. All the primary edges are implemented is in <filename>pkgs/stdenv/booter.nix</filename>, and secondarily aliases in <filename>pkgs/top-level/stage.nix</filename>.
-   </para>
-
-   <note>
-    <para>
-     Note the native stages are bootstrapped in legacy ways that predate the current cross implementation. This is why the bootstrapping stages leading up to the final stages are ignored inthe previous paragraph.
-    </para>
-   </note>
-
-   <para>
-    If one looks at the 3 platform triples, one can see that they overlap such that one could put them together into a chain like:
-<programlisting>
-(native, native, native, foreign, foreign)
-</programlisting>
-    If one imagines the saturating self references at the end being replaced with infinite stages, and then overlays those platform triples, one ends up with the infinite tuple:
-<programlisting>
-(native..., native, native, native, foreign, foreign, foreign...)
-</programlisting>
-    On can then imagine any sequence of platforms such that there are bootstrap stages with their 3 platforms determined by "sliding a window" that is the 3 tuple through the sequence. This was the original model for bootstrapping. Without a target platform (assume a better world where all compilers are multi-target and all standard libraries are built in their own derivation), this is sufficient. Conversely if one wishes to cross compile "faster", with a "Canadian Cross" bootstraping stage where <literal>build != host != target</literal>, more bootstrapping stages are needed since no sliding window providess the pesky <varname>pkgsBuildTarget</varname> package set since it skips the Canadian cross stage's "host".
-   </para>
-
-   <note>
-    <para>
-     It is much better to refer to <varname>buildPackages</varname> than <varname>targetPackages</varname>, or more broadly package sets that do not mention "target". There are three reasons for this.
-    </para>
-    <para>
-     First, it is because bootstrapping stages do not have a unique <varname>targetPackages</varname>. For example a <literal>(x86-linux, x86-linux, arm-linux)</literal> and <literal>(x86-linux, x86-linux, x86-windows)</literal> package set both have a <literal>(x86-linux, x86-linux, x86-linux)</literal> package set. Because there is no canonical <varname>targetPackages</varname> for such a native (<literal>build == host == target</literal>) package set, we set their <varname>targetPackages</varname>
-    </para>
-    <para>
-     Second, it is because this is a frequent source of hard-to-follow "infinite recursions" / cycles. When only package sets that don't mention target are used, the package set forms a directed acyclic graph. This means that all cycles that exist are confined to one stage. This means they are a lot smaller, and easier to follow in the code or a backtrace. It also means they are present in native and cross builds alike, and so more likely to be caught by CI and other users.
-    </para>
-    <para>
-     Thirdly, it is because everything target-mentioning only exists to accommodate compilers with lousy build systems that insist on the compiler itself and standard library being built together. Of course that is bad because bigger derivations means longer rebuilds. It is also problematic because it tends to make the standard libraries less like other libraries than they could be, complicating code and build systems alike. Because of the other problems, and because of these innate disadvantages, compilers ought to be packaged another way where possible.
-    </para>
-   </note>
-
-   <note>
-    <para>
-     If one explores Nixpkgs, they will see derivations with names like <literal>gccCross</literal>. Such <literal>*Cross</literal> derivations is a holdover from before we properly distinguished between the host and target platforms—the derivation with "Cross" in the name covered the <literal>build = host != target</literal> case, while the other covered the <literal>host = target</literal>, with build platform the same or not based on whether one was using its <literal>.nativeDrv</literal> or <literal>.crossDrv</literal>. This ugliness will disappear soon.
-    </para>
-   </note>
-  </section>
- </section>
-</chapter>
diff --git a/doc/stdenv/meta.chapter.md b/doc/stdenv/meta.chapter.md
new file mode 100644
index 00000000000..f226a725480
--- /dev/null
+++ b/doc/stdenv/meta.chapter.md
@@ -0,0 +1,194 @@
+# Meta-attributes {#chap-meta}
+
+Nix packages can declare *meta-attributes* that contain information about a package such as a description, its homepage, its license, and so on. For instance, the GNU Hello package has a `meta` declaration like this:
+
+```nix
+meta = with lib; {
+  description = "A program that produces a familiar, friendly greeting";
+  longDescription = ''
+    GNU Hello is a program that prints "Hello, world!" when you run it.
+    It is fully customizable.
+  '';
+  homepage = "https://www.gnu.org/software/hello/manual/";
+  license = licenses.gpl3Plus;
+  maintainers = [ maintainers.eelco ];
+  platforms = platforms.all;
+};
+```
+
+Meta-attributes are not passed to the builder of the package. Thus, a change to a meta-attribute doesn’t trigger a recompilation of the package. The value of a meta-attribute must be a string.
+
+The meta-attributes of a package can be queried from the command-line using `nix-env`:
+
+```ShellSession
+$ nix-env -qa hello --json
+{
+    "hello": {
+        "meta": {
+            "description": "A program that produces a familiar, friendly greeting",
+            "homepage": "https://www.gnu.org/software/hello/manual/",
+            "license": {
+                "fullName": "GNU General Public License version 3 or later",
+                "shortName": "GPLv3+",
+                "url": "http://www.fsf.org/licensing/licenses/gpl.html"
+            },
+            "longDescription": "GNU Hello is a program that prints \"Hello, world!\" when you run it.\nIt is fully customizable.\n",
+            "maintainers": [
+                "Ludovic Court\u00e8s <ludo@gnu.org>"
+            ],
+            "platforms": [
+                "i686-linux",
+                "x86_64-linux",
+                "armv5tel-linux",
+                "armv7l-linux",
+                "mips32-linux",
+                "x86_64-darwin",
+                "i686-cygwin",
+                "i686-freebsd",
+                "x86_64-freebsd",
+                "i686-openbsd",
+                "x86_64-openbsd"
+            ],
+            "position": "/home/user/dev/nixpkgs/pkgs/applications/misc/hello/default.nix:14"
+        },
+        "name": "hello-2.9",
+        "system": "x86_64-linux"
+    }
+}
+```
+
+`nix-env` knows about the `description` field specifically:
+
+```ShellSession
+$ nix-env -qa hello --description
+hello-2.3  A program that produces a familiar, friendly greeting
+```
+
+## Standard meta-attributes {#sec-standard-meta-attributes}
+
+It is expected that each meta-attribute is one of the following:
+
+### `description` {#var-meta-description}
+
+A short (one-line) description of the package. This is shown by `nix-env -q --description` and also on the Nixpkgs release pages.
+
+Don’t include a period at the end. Don’t include newline characters. Capitalise the first character. For brevity, don’t repeat the name of package --- just describe what it does.
+
+Wrong: `"libpng is a library that allows you to decode PNG images."`
+
+Right: `"A library for decoding PNG images"`
+
+### `longDescription` {#var-meta-longDescription}
+
+An arbitrarily long description of the package.
+
+### `branch` {#var-meta-branch}
+
+Release branch. Used to specify that a package is not going to receive updates that are not in this branch; for example, Linux kernel 3.0 is supposed to be updated to 3.0.X, not 3.1.
+
+### `homepage` {#var-meta-homepage}
+
+The package’s homepage. Example: `https://www.gnu.org/software/hello/manual/`
+
+### `downloadPage` {#var-meta-downloadPage}
+
+The page where a link to the current version can be found. Example: `https://ftp.gnu.org/gnu/hello/`
+
+### `changelog` {#var-meta-changelog}
+
+A link or a list of links to the location of Changelog for a package. A link may use expansion to refer to the correct changelog version. Example: `"https://git.savannah.gnu.org/cgit/hello.git/plain/NEWS?h=v${version}"`
+
+### `license` {#var-meta-license}
+
+The license, or licenses, for the package. One from the attribute set defined in [`nixpkgs/lib/licenses.nix`](https://github.com/NixOS/nixpkgs/blob/master/lib/licenses.nix). At this moment using both a list of licenses and a single license is valid. If the license field is in the form of a list representation, then it means that parts of the package are licensed differently. Each license should preferably be referenced by their attribute. The non-list attribute value can also be a space delimited string representation of the contained attribute `shortNames` or `spdxIds`. The following are all valid examples:
+
+- Single license referenced by attribute (preferred) `lib.licenses.gpl3Only`.
+- Single license referenced by its attribute shortName (frowned upon) `"gpl3Only"`.
+- Single license referenced by its attribute spdxId (frowned upon) `"GPL-3.0-only"`.
+- Multiple licenses referenced by attribute (preferred) `with lib.licenses; [ asl20 free ofl ]`.
+- Multiple licenses referenced as a space delimited string of attribute shortNames (frowned upon) `"asl20 free ofl"`.
+
+For details, see [Licenses](#sec-meta-license).
+
+### `maintainers` {#var-meta-maintainers}
+
+A list of the maintainers of this Nix expression. Maintainers are defined in [`nixpkgs/maintainers/maintainer-list.nix`](https://github.com/NixOS/nixpkgs/blob/master/maintainers/maintainer-list.nix). There is no restriction to becoming a maintainer, just add yourself to that list in a separate commit titled “maintainers: add alice”, and reference maintainers with `maintainers = with lib.maintainers; [ alice bob ]`.
+
+### `priority` {#var-meta-priority}
+
+The *priority* of the package, used by `nix-env` to resolve file name conflicts between packages. See the Nix manual page for `nix-env` for details. Example: `"10"` (a low-priority package).
+
+### `platforms` {#var-meta-platforms}
+
+The list of Nix platform types on which the package is supported. Hydra builds packages according to the platform specified. If no platform is specified, the package does not have prebuilt binaries. An example is:
+
+```nix
+meta.platforms = lib.platforms.linux;
+```
+
+Attribute Set `lib.platforms` defines [various common lists](https://github.com/NixOS/nixpkgs/blob/master/lib/systems/doubles.nix) of platforms types.
+
+### `tests` {#var-meta-tests}
+
+::: {.warning}
+This attribute is special in that it is not actually under the `meta` attribute set but rather under the `passthru` attribute set. This is due to how `meta` attributes work, and the fact that they are supposed to contain only metadata, not derivations.
+:::
+
+An attribute set with as values tests. A test is a derivation, which builds successfully when the test passes, and fails to build otherwise. A derivation that is a test needs to have `meta.timeout` defined.
+
+The NixOS tests are available as `nixosTests` in parameters of derivations. For instance, the OpenSMTPD derivation includes lines similar to:
+
+```nix
+{ /* ... */, nixosTests }:
+{
+  # ...
+  passthru.tests = {
+    basic-functionality-and-dovecot-integration = nixosTests.opensmtpd;
+  };
+}
+```
+
+### `timeout` {#var-meta-timeout}
+
+A timeout (in seconds) for building the derivation. If the derivation takes longer than this time to build, it can fail due to breaking the timeout. However, all computers do not have the same computing power, hence some builders may decide to apply a multiplicative factor to this value. When filling this value in, try to keep it approximately consistent with other values already present in `nixpkgs`.
+
+### `hydraPlatforms` {#var-meta-hydraPlatforms}
+
+The list of Nix platform types for which the Hydra instance at `hydra.nixos.org` will build the package. (Hydra is the Nix-based continuous build system.) It defaults to the value of `meta.platforms`. Thus, the only reason to set `meta.hydraPlatforms` is if you want `hydra.nixos.org` to build the package on a subset of `meta.platforms`, or not at all, e.g.
+
+```nix
+meta.platforms = lib.platforms.linux;
+meta.hydraPlatforms = [];
+```
+
+### `broken` {#var-meta-broken}
+
+If set to `true`, the package is marked as "broken", meaning that it won’t show up in `nix-env -qa`, and cannot be built or installed. Such packages should be removed from Nixpkgs eventually unless they are fixed.
+
+### `updateWalker` {#var-meta-updateWalker}
+
+If set to `true`, the package is tested to be updated correctly by the `update-walker.sh` script without additional settings. Such packages have `meta.version` set and their homepage (or the page specified by `meta.downloadPage`) contains a direct link to the package tarball.
+
+## Licenses {#sec-meta-license}
+
+The `meta.license` attribute should preferably contain a value from `lib.licenses` defined in [`nixpkgs/lib/licenses.nix`](https://github.com/NixOS/nixpkgs/blob/master/lib/licenses.nix), or in-place license description of the same format if the license is unlikely to be useful in another expression.
+
+Although it’s typically better to indicate the specific license, a few generic options are available:
+
+### `lib.licenses.free`, `"free"` {#lib.licenses.free-free}
+
+Catch-all for free software licenses not listed above.
+
+### `lib.licenses.unfreeRedistributable`, `"unfree-redistributable"` {#lib.licenses.unfreeredistributable-unfree-redistributable}
+
+Unfree package that can be redistributed in binary form. That is, it’s legal to redistribute the *output* of the derivation. This means that the package can be included in the Nixpkgs channel.
+
+Sometimes proprietary software can only be redistributed unmodified. Make sure the builder doesn’t actually modify the original binaries; otherwise we’re breaking the license. For instance, the NVIDIA X11 drivers can be redistributed unmodified, but our builder applies `patchelf` to make them work. Thus, its license is `"unfree"` and it cannot be included in the Nixpkgs channel.
+
+### `lib.licenses.unfree`, `"unfree"` {#lib.licenses.unfree-unfree}
+
+Unfree package that cannot be redistributed. You can build it yourself, but you cannot redistribute the output of the derivation. Thus it cannot be included in the Nixpkgs channel.
+
+### `lib.licenses.unfreeRedistributableFirmware`, `"unfree-redistributable-firmware"` {#lib.licenses.unfreeredistributablefirmware-unfree-redistributable-firmware}
+
+This package supplies unfree, redistributable firmware. This is a separate value from `unfree-redistributable` because not everybody cares whether firmware is free.
diff --git a/doc/stdenv/meta.xml b/doc/stdenv/meta.xml
deleted file mode 100644
index 9cef9360002..00000000000
--- a/doc/stdenv/meta.xml
+++ /dev/null
@@ -1,350 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-meta">
- <title>Meta-attributes</title>
- <para>
-  Nix packages can declare <emphasis>meta-attributes</emphasis> that contain information about a package such as a description, its homepage, its license, and so on. For instance, the GNU Hello package has a <varname>meta</varname> declaration like this:
-<programlisting>
-meta = with stdenv.lib; {
-  description = "A program that produces a familiar, friendly greeting";
-  longDescription = ''
-    GNU Hello is a program that prints "Hello, world!" when you run it.
-    It is fully customizable.
-  '';
-  homepage = "https://www.gnu.org/software/hello/manual/";
-  license = licenses.gpl3Plus;
-  maintainers = [ maintainers.eelco ];
-  platforms = platforms.all;
-};
-</programlisting>
- </para>
- <para>
-  Meta-attributes are not passed to the builder of the package. Thus, a change to a meta-attribute doesn’t trigger a recompilation of the package. The value of a meta-attribute must be a string.
- </para>
- <para>
-  The meta-attributes of a package can be queried from the command-line using <command>nix-env</command>:
-<screen>
-<prompt>$ </prompt>nix-env -qa hello --json
-{
-    "hello": {
-        "meta": {
-            "description": "A program that produces a familiar, friendly greeting",
-            "homepage": "https://www.gnu.org/software/hello/manual/",
-            "license": {
-                "fullName": "GNU General Public License version 3 or later",
-                "shortName": "GPLv3+",
-                "url": "http://www.fsf.org/licensing/licenses/gpl.html"
-            },
-            "longDescription": "GNU Hello is a program that prints \"Hello, world!\" when you run it.\nIt is fully customizable.\n",
-            "maintainers": [
-                "Ludovic Court\u00e8s &lt;ludo@gnu.org>"
-            ],
-            "platforms": [
-                "i686-linux",
-                "x86_64-linux",
-                "armv5tel-linux",
-                "armv7l-linux",
-                "mips32-linux",
-                "x86_64-darwin",
-                "i686-cygwin",
-                "i686-freebsd",
-                "x86_64-freebsd",
-                "i686-openbsd",
-                "x86_64-openbsd"
-            ],
-            "position": "/home/user/dev/nixpkgs/pkgs/applications/misc/hello/default.nix:14"
-        },
-        "name": "hello-2.9",
-        "system": "x86_64-linux"
-    }
-}
-
-
-</screen>
-  <command>nix-env</command> knows about the <varname>description</varname> field specifically:
-<screen>
-<prompt>$ </prompt>nix-env -qa hello --description
-hello-2.3  A program that produces a familiar, friendly greeting
-</screen>
- </para>
- <section xml:id="sec-standard-meta-attributes">
-  <title>Standard meta-attributes</title>
-
-  <para>
-   It is expected that each meta-attribute is one of the following:
-  </para>
-
-  <variablelist>
-   <varlistentry>
-    <term>
-     <varname>description</varname>
-    </term>
-    <listitem>
-     <para>
-      A short (one-line) description of the package. This is shown by <command>nix-env -q --description</command> and also on the Nixpkgs release pages.
-     </para>
-     <para>
-      Don’t include a period at the end. Don’t include newline characters. Capitalise the first character. For brevity, don’t repeat the name of package — just describe what it does.
-     </para>
-     <para>
-      Wrong: <literal>"libpng is a library that allows you to decode PNG images."</literal>
-     </para>
-     <para>
-      Right: <literal>"A library for decoding PNG images"</literal>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>longDescription</varname>
-    </term>
-    <listitem>
-     <para>
-      An arbitrarily long description of the package.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>branch</varname>
-    </term>
-    <listitem>
-     <para>
-      Release branch. Used to specify that a package is not going to receive updates that are not in this branch; for example, Linux kernel 3.0 is supposed to be updated to 3.0.X, not 3.1.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>homepage</varname>
-    </term>
-    <listitem>
-     <para>
-      The package’s homepage. Example: <literal>https://www.gnu.org/software/hello/manual/</literal>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>downloadPage</varname>
-    </term>
-    <listitem>
-     <para>
-      The page where a link to the current version can be found. Example: <literal>https://ftp.gnu.org/gnu/hello/</literal>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>changelog</varname>
-    </term>
-    <listitem>
-     <para>
-      A link or a list of links to the location of Changelog for a package. A link may use expansion to refer to the correct changelog version. Example: <literal>"https://git.savannah.gnu.org/cgit/hello.git/plain/NEWS?h=v${version}"</literal>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>license</varname>
-    </term>
-    <listitem>
-     <para>
-      The license, or licenses, for the package. One from the attribute set defined in <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/lib/licenses.nix"> <filename>nixpkgs/lib/licenses.nix</filename></link>. At this moment using both a list of licenses and a single license is valid. If the license field is in the form of a list representation, then it means that parts of the package are licensed differently. Each license should preferably be referenced by their attribute. The non-list attribute value can also be a space delimited string representation of the contained attribute shortNames or spdxIds. The following are all valid examples:
-      <itemizedlist>
-       <listitem>
-        <para>
-         Single license referenced by attribute (preferred) <literal>stdenv.lib.licenses.gpl3Only</literal>.
-        </para>
-       </listitem>
-       <listitem>
-        <para>
-         Single license referenced by its attribute shortName (frowned upon) <literal>"gpl3Only"</literal>.
-        </para>
-       </listitem>
-       <listitem>
-        <para>
-         Single license referenced by its attribute spdxId (frowned upon) <literal>"GPL-3.0-only"</literal>.
-        </para>
-       </listitem>
-       <listitem>
-        <para>
-         Multiple licenses referenced by attribute (preferred) <literal>with stdenv.lib.licenses; [ asl20 free ofl ]</literal>.
-        </para>
-       </listitem>
-       <listitem>
-        <para>
-         Multiple licenses referenced as a space delimited string of attribute shortNames (frowned upon) <literal>"asl20 free ofl"</literal>.
-        </para>
-       </listitem>
-      </itemizedlist>
-      For details, see <xref linkend='sec-meta-license'/>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>maintainers</varname>
-    </term>
-    <listitem>
-     <para>
-      A list of names and e-mail addresses of the maintainers of this Nix expression. If you would like to be a maintainer of a package, you may want to add yourself to <link
-    xlink:href="https://github.com/NixOS/nixpkgs/blob/master/maintainers/maintainer-list.nix"><filename>nixpkgs/maintainers/maintainer-list.nix</filename></link> and write something like <literal>[ stdenv.lib.maintainers.alice stdenv.lib.maintainers.bob ]</literal>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>priority</varname>
-    </term>
-    <listitem>
-     <para>
-      The <emphasis>priority</emphasis> of the package, used by <command>nix-env</command> to resolve file name conflicts between packages. See the Nix manual page for <command>nix-env</command> for details. Example: <literal>"10"</literal> (a low-priority package).
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>platforms</varname>
-    </term>
-    <listitem>
-     <para>
-      The list of Nix platform types on which the package is supported. Hydra builds packages according to the platform specified. If no platform is specified, the package does not have prebuilt binaries. An example is:
-<programlisting>
-meta.platforms = stdenv.lib.platforms.linux;
-</programlisting>
-      Attribute Set <varname>stdenv.lib.platforms</varname> defines <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/lib/systems/doubles.nix"> various common lists</link> of platforms types.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>tests</varname>
-    </term>
-    <listitem>
-     <warning>
-      <para>
-       This attribute is special in that it is not actually under the <literal>meta</literal> attribute set but rather under the <literal>passthru</literal> attribute set. This is due to how <literal>meta</literal> attributes work, and the fact that they are supposed to contain only metadata, not derivations.
-      </para>
-     </warning>
-     <para>
-      An attribute set with as values tests. A test is a derivation, which builds successfully when the test passes, and fails to build otherwise. A derivation that is a test needs to have <literal>meta.timeout</literal> defined.
-     </para>
-     <para>
-      The NixOS tests are available as <literal>nixosTests</literal> in parameters of derivations. For instance, the OpenSMTPD derivation includes lines similar to:
-<programlisting>
-{ /* ... */, nixosTests }:
-{
-  # ...
-  passthru.tests = {
-    basic-functionality-and-dovecot-integration = nixosTests.opensmtpd;
-  };
-}
-</programlisting>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>timeout</varname>
-    </term>
-    <listitem>
-     <para>
-      A timeout (in seconds) for building the derivation. If the derivation takes longer than this time to build, it can fail due to breaking the timeout. However, all computers do not have the same computing power, hence some builders may decide to apply a multiplicative factor to this value. When filling this value in, try to keep it approximately consistent with other values already present in <literal>nixpkgs</literal>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>hydraPlatforms</varname>
-    </term>
-    <listitem>
-     <para>
-      The list of Nix platform types for which the Hydra instance at <literal>hydra.nixos.org</literal> will build the package. (Hydra is the Nix-based continuous build system.) It defaults to the value of <varname>meta.platforms</varname>. Thus, the only reason to set <varname>meta.hydraPlatforms</varname> is if you want <literal>hydra.nixos.org</literal> to build the package on a subset of <varname>meta.platforms</varname>, or not at all, e.g.
-<programlisting>
-meta.platforms = stdenv.lib.platforms.linux;
-meta.hydraPlatforms = [];
-</programlisting>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>broken</varname>
-    </term>
-    <listitem>
-     <para>
-      If set to <literal>true</literal>, the package is marked as “broken”, meaning that it won’t show up in <literal>nix-env -qa</literal>, and cannot be built or installed. Such packages should be removed from Nixpkgs eventually unless they are fixed.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>updateWalker</varname>
-    </term>
-    <listitem>
-     <para>
-      If set to <literal>true</literal>, the package is tested to be updated correctly by the <literal>update-walker.sh</literal> script without additional settings. Such packages have <varname>meta.version</varname> set and their homepage (or the page specified by <varname>meta.downloadPage</varname>) contains a direct link to the package tarball.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
- </section>
- <section xml:id="sec-meta-license">
-  <title>Licenses</title>
-
-  <para>
-   The <varname>meta.license</varname> attribute should preferrably contain a value from <varname>stdenv.lib.licenses</varname> defined in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/lib/licenses.nix"> <filename>nixpkgs/lib/licenses.nix</filename></link>, or in-place license description of the same format if the license is unlikely to be useful in another expression.
-  </para>
-
-  <para>
-   Although it's typically better to indicate the specific license, a few generic options are available:
-   <variablelist>
-    <varlistentry>
-     <term>
-      <varname>stdenv.lib.licenses.free</varname>, <varname>"free"</varname>
-     </term>
-     <listitem>
-      <para>
-       Catch-all for free software licenses not listed above.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>stdenv.lib.licenses.unfreeRedistributable</varname>, <varname>"unfree-redistributable"</varname>
-     </term>
-     <listitem>
-      <para>
-       Unfree package that can be redistributed in binary form. That is, it’s legal to redistribute the <emphasis>output</emphasis> of the derivation. This means that the package can be included in the Nixpkgs channel.
-      </para>
-      <para>
-       Sometimes proprietary software can only be redistributed unmodified. Make sure the builder doesn’t actually modify the original binaries; otherwise we’re breaking the license. For instance, the NVIDIA X11 drivers can be redistributed unmodified, but our builder applies <command>patchelf</command> to make them work. Thus, its license is <varname>"unfree"</varname> and it cannot be included in the Nixpkgs channel.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>stdenv.lib.licenses.unfree</varname>, <varname>"unfree"</varname>
-     </term>
-     <listitem>
-      <para>
-       Unfree package that cannot be redistributed. You can build it yourself, but you cannot redistribute the output of the derivation. Thus it cannot be included in the Nixpkgs channel.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>stdenv.lib.licenses.unfreeRedistributableFirmware</varname>, <varname>"unfree-redistributable-firmware"</varname>
-     </term>
-     <listitem>
-      <para>
-       This package supplies unfree, redistributable firmware. This is a separate value from <varname>unfree-redistributable</varname> because not everybody cares whether firmware is free.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </para>
- </section>
-</chapter>
diff --git a/doc/stdenv/multiple-output.chapter.md b/doc/stdenv/multiple-output.chapter.md
new file mode 100644
index 00000000000..d04f83302ac
--- /dev/null
+++ b/doc/stdenv/multiple-output.chapter.md
@@ -0,0 +1,128 @@
+# Multiple-output packages {#chap-multiple-output}
+
+## Introduction {#sec-multiple-outputs-introduction}
+
+The Nix language allows a derivation to produce multiple outputs, which is similar to what is utilized by other Linux distribution packaging systems. The outputs reside in separate Nix store paths, so they can be mostly handled independently of each other, including passing to build inputs, garbage collection or binary substitution. The exception is that building from source always produces all the outputs.
+
+The main motivation is to save disk space by reducing runtime closure sizes; consequently also sizes of substituted binaries get reduced. Splitting can be used to have more granular runtime dependencies, for example the typical reduction is to split away development-only files, as those are typically not needed during runtime. As a result, closure sizes of many packages can get reduced to a half or even much less.
+
+::: {.note}
+The reduction effects could be instead achieved by building the parts in completely separate derivations. That would often additionally reduce build-time closures, but it tends to be much harder to write such derivations, as build systems typically assume all parts are being built at once. This compromise approach of single source package producing multiple binary packages is also utilized often by rpm and deb.
+:::
+
+A number of attributes can be used to work with a derivation with multiple outputs. The attribute `outputs` is a list of strings, which are the names of the outputs. For each of these names, an identically named attribute is created, corresponding to that output. The attribute `meta.outputsToInstall` is used to determine the default set of outputs to install when using the derivation name unqualified.
+
+## Installing a split package {#sec-multiple-outputs-installing}
+
+When installing a package with multiple outputs, the package’s `meta.outputsToInstall` attribute determines which outputs are actually installed. `meta.outputsToInstall` is a list whose [default installs binaries and the associated man pages](https://github.com/NixOS/nixpkgs/blob/f1680774340d5443a1409c3421ced84ac1163ba9/pkgs/stdenv/generic/make-derivation.nix#L310-L320). The following sections describe ways to install different outputs.
+
+### Selecting outputs to install via NixOS {#sec-multiple-outputs-installing-nixos}
+
+NixOS provides two ways to select the outputs to install for packages listed in `environment.systemPackages`:
+
+- The configuration option `environment.extraOutputsToInstall` is appended to each package’s `meta.outputsToInstall` attribute to determine the outputs to install. It can for example be used to install `info` documentation or debug symbols for all packages.
+
+- The outputs can be listed as packages in `environment.systemPackages`. For example, the `"out"` and `"info"` outputs for the `coreutils` package can be installed by including `coreutils` and `coreutils.info` in `environment.systemPackages`.
+
+### Selecting outputs to install via `nix-env` {#sec-multiple-outputs-installing-nix-env}
+
+`nix-env` lacks an easy way to select the outputs to install. When installing a package, `nix-env` always installs the outputs listed in `meta.outputsToInstall`, even when the user explicitly selects an output.
+
+::: {.warning}
+`nix-env` silenty disregards the outputs selected by the user, and instead installs the outputs from `meta.outputsToInstall`. For example,
+
+```ShellSession
+$ nix-env -iA nixpkgs.coreutils.info
+```
+
+installs the `"out"` output (`coreutils.meta.outputsToInstall` is `[ "out" ]`) instead of the requested `"info"`.
+:::
+
+The only recourse to select an output with `nix-env` is to override the package’s `meta.outputsToInstall`, using the functions described in [](#chap-overrides). For example, the following overlay adds the `"info"` output for the `coreutils` package:
+
+```nix
+self: super:
+{
+  coreutils = super.coreutils.overrideAttrs (oldAttrs: {
+    meta = oldAttrs.meta // { outputsToInstall = oldAttrs.meta.outputsToInstall or [ "out" ] ++ [ "info" ]; };
+  });
+}
+```
+
+## Using a split package {#sec-multiple-outputs-using-split-packages}
+
+In the Nix language the individual outputs can be reached explicitly as attributes, e.g. `coreutils.info`, but the typical case is just using packages as build inputs.
+
+When a multiple-output derivation gets into a build input of another derivation, the `dev` output is added if it exists, otherwise the first output is added. In addition to that, `propagatedBuildOutputs` of that package which by default contain `$outputBin` and `$outputLib` are also added. (See [](#multiple-output-file-type-groups).)
+
+In some cases it may be desirable to combine different outputs under a single store path. A function `symlinkJoin` can be used to do this. (Note that it may negate some closure size benefits of using a multiple-output package.)
+
+## Writing a split derivation {#sec-multiple-outputs-}
+
+Here you find how to write a derivation that produces multiple outputs.
+
+In nixpkgs there is a framework supporting multiple-output derivations. It tries to cover most cases by default behavior. You can find the source separated in `<nixpkgs/pkgs/build-support/setup-hooks/multiple-outputs.sh>`; it’s relatively well-readable. The whole machinery is triggered by defining the `outputs` attribute to contain the list of desired output names (strings).
+
+```nix
+outputs = [ "bin" "dev" "out" "doc" ];
+```
+
+Often such a single line is enough. For each output an equally named environment variable is passed to the builder and contains the path in nix store for that output. Typically you also want to have the main `out` output, as it catches any files that didn’t get elsewhere.
+
+::: {.note}
+There is a special handling of the `debug` output, described at [](#stdenv-separateDebugInfo).
+:::
+
+### “Binaries first” {#multiple-output-file-binaries-first-convention}
+
+A commonly adopted convention in `nixpkgs` is that executables provided by the package are contained within its first output. This convention allows the dependent packages to reference the executables provided by packages in a uniform manner. For instance, provided with the knowledge that the `perl` package contains a `perl` executable it can be referenced as `${pkgs.perl}/bin/perl` within a Nix derivation that needs to execute a Perl script.
+
+The `glibc` package is a deliberate single exception to the “binaries first” convention. The `glibc` has `libs` as its first output allowing the libraries provided by `glibc` to be referenced directly (e.g. `${stdenv.glibc}/lib/ld-linux-x86-64.so.2`). The executables provided by `glibc` can be accessed via its `bin` attribute (e.g. `${stdenv.glibc.bin}/bin/ldd`).
+
+The reason for why `glibc` deviates from the convention is because referencing a library provided by `glibc` is a very common operation among Nix packages. For instance, third-party executables packaged by Nix are typically patched and relinked with the relevant version of `glibc` libraries from Nix packages (please see the documentation on [patchelf](https://github.com/NixOS/patchelf/blob/master/README) for more details).
+
+### File type groups {#multiple-output-file-type-groups}
+
+The support code currently recognizes some particular kinds of outputs and either instructs the build system of the package to put files into their desired outputs or it moves the files during the fixup phase. Each group of file types has an `outputFoo` variable specifying the output name where they should go. If that variable isn’t defined by the derivation writer, it is guessed – a default output name is defined, falling back to other possibilities if the output isn’t defined.
+
+#### `$outputDev` {#outputdev}
+
+is for development-only files. These include C(++) headers (`include/`), pkg-config (`lib/pkgconfig/`), cmake (`lib/cmake/`) and aclocal files (`share/aclocal/`). They go to `dev` or `out` by default.
+
+#### `$outputBin` {#outputbin}
+
+is meant for user-facing binaries, typically residing in `bin/`. They go to `bin` or `out` by default.
+
+#### `$outputLib` {#outputlib}
+
+is meant for libraries, typically residing in `lib/` and `libexec/`. They go to `lib` or `out` by default.
+
+#### `$outputDoc` {#outputdoc}
+
+is for user documentation, typically residing in `share/doc/`. It goes to `doc` or `out` by default.
+
+#### `$outputDevdoc` {#outputdevdoc}
+
+is for _developer_ documentation. Currently we count gtk-doc and devhelp books, typically residing in `share/gtk-doc/` and `share/devhelp/`, in there. It goes to `devdoc` or is removed (!) by default. This is because e.g. gtk-doc tends to be rather large and completely unused by nixpkgs users.
+
+#### `$outputMan` {#outputman}
+
+is for man pages (except for section 3), typically residing in `share/man/man[0-9]/`. They go to `man` or `$outputBin` by default.
+
+#### `$outputDevman` {#outputdevman}
+
+is for section 3 man pages, typically residing in `share/man/man[0-9]/`. They go to `devman` or `$outputMan` by default.
+
+#### `$outputInfo` {#outputinfo}
+
+is for info pages, typically residing in `share/info/`. They go to `info` or `$outputBin` by default.
+
+### Common caveats {#sec-multiple-outputs-caveats}
+
+- Some configure scripts don’t like some of the parameters passed by default by the framework, e.g. `--docdir=/foo/bar`. You can disable this by setting `setOutputFlags = false;`.
+
+- The outputs of a single derivation can retain references to each other, but note that circular references are not allowed. (And each strongly-connected component would act as a single output anyway.)
+
+- Most of split packages contain their core functionality in libraries. These libraries tend to refer to various kind of data that typically gets into `out`, e.g. locale strings, so there is often no advantage in separating the libraries into `lib`, as keeping them in `out` is easier.
+
+- Some packages have hidden assumptions on install paths, which complicates splitting.
diff --git a/doc/stdenv/multiple-output.xml b/doc/stdenv/multiple-output.xml
deleted file mode 100644
index 51e1cc2e024..00000000000
--- a/doc/stdenv/multiple-output.xml
+++ /dev/null
@@ -1,232 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE chapter [
-  <!ENTITY ndash "&#x2013;"> <!-- @vcunat likes to use this one ;-) -->
-]>
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-multiple-output">
- <title>Multiple-output packages</title>
- <section xml:id="sec-multiple-outputs-introduction">
-  <title>Introduction</title>
-
-  <para>
-   The Nix language allows a derivation to produce multiple outputs, which is similar to what is utilized by other Linux distribution packaging systems. The outputs reside in separate Nix store paths, so they can be mostly handled independently of each other, including passing to build inputs, garbage collection or binary substitution. The exception is that building from source always produces all the outputs.
-  </para>
-
-  <para>
-   The main motivation is to save disk space by reducing runtime closure sizes; consequently also sizes of substituted binaries get reduced. Splitting can be used to have more granular runtime dependencies, for example the typical reduction is to split away development-only files, as those are typically not needed during runtime. As a result, closure sizes of many packages can get reduced to a half or even much less.
-  </para>
-
-  <note>
-   <para>
-    The reduction effects could be instead achieved by building the parts in completely separate derivations. That would often additionally reduce build-time closures, but it tends to be much harder to write such derivations, as build systems typically assume all parts are being built at once. This compromise approach of single source package producing multiple binary packages is also utilized often by rpm and deb.
-   </para>
-  </note>
- </section>
- <section xml:id="sec-multiple-outputs-installing">
-  <title>Installing a split package</title>
-
-  <para>
-   When installing a package via <varname>systemPackages</varname> or <command>nix-env</command> you have several options:
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     You can install particular outputs explicitly, as each is available in the Nix language as an attribute of the package. The <varname>outputs</varname> attribute contains a list of output names.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     You can let it use the default outputs. These are handled by <varname>meta.outputsToInstall</varname> attribute that contains a list of output names.
-    </para>
-    <para>
-     TODO: more about tweaking the attribute, etc.
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     NixOS provides configuration option <varname>environment.extraOutputsToInstall</varname> that allows adding extra outputs of <varname>environment.systemPackages</varname> atop the default ones. It's mainly meant for documentation and debug symbols, and it's also modified by specific options.
-    </para>
-    <note>
-     <para>
-      At this moment there is no similar configurability for packages installed by <command>nix-env</command>. You can still use approach from <xref linkend="sec-modify-via-packageOverrides" /> to override <varname>meta.outputsToInstall</varname> attributes, but that's a rather inconvenient way.
-     </para>
-    </note>
-   </listitem>
-  </itemizedlist>
- </section>
- <section xml:id="sec-multiple-outputs-using-split-packages">
-  <title>Using a split package</title>
-
-  <para>
-   In the Nix language the individual outputs can be reached explicitly as attributes, e.g. <varname>coreutils.info</varname>, but the typical case is just using packages as build inputs.
-  </para>
-
-  <para>
-   When a multiple-output derivation gets into a build input of another derivation, the <varname>dev</varname> output is added if it exists, otherwise the first output is added. In addition to that, <varname>propagatedBuildOutputs</varname> of that package which by default contain <varname>$outputBin</varname> and <varname>$outputLib</varname> are also added. (See <xref linkend="multiple-output-file-type-groups" />.)
-  </para>
-
-  <para>
-   In some cases it may be desirable to combine different outputs under a single store path. A function <literal>symlinkJoin</literal> can be used to do this. (Note that it may negate some closure size benefits of using a multiple-output package.)
-  </para>
- </section>
- <section xml:id="sec-multiple-outputs-">
-  <title>Writing a split derivation</title>
-
-  <para>
-   Here you find how to write a derivation that produces multiple outputs.
-  </para>
-
-  <para>
-   In nixpkgs there is a framework supporting multiple-output derivations. It tries to cover most cases by default behavior. You can find the source separated in &lt;<filename>nixpkgs/pkgs/build-support/setup-hooks/multiple-outputs.sh</filename>&gt;; it's relatively well-readable. The whole machinery is triggered by defining the <varname>outputs</varname> attribute to contain the list of desired output names (strings).
-  </para>
-
-<programlisting>outputs = [ "bin" "dev" "out" "doc" ];</programlisting>
-
-  <para>
-   Often such a single line is enough. For each output an equally named environment variable is passed to the builder and contains the path in nix store for that output. Typically you also want to have the main <varname>out</varname> output, as it catches any files that didn't get elsewhere.
-  </para>
-
-  <note>
-   <para>
-    There is a special handling of the <varname>debug</varname> output, described at <xref linkend="stdenv-separateDebugInfo" />.
-   </para>
-  </note>
-
-  <section xml:id="multiple-output-file-binaries-first-convention">
-   <title><quote>Binaries first</quote></title>
-
-   <para>
-    A commonly adopted convention in <literal>nixpkgs</literal> is that executables provided by the package are contained within its first output. This convention allows the dependent packages to reference the executables provided by packages in a uniform manner. For instance, provided with the knowledge that the <literal>perl</literal> package contains a <literal>perl</literal> executable it can be referenced as <literal>${pkgs.perl}/bin/perl</literal> within a Nix derivation that needs to execute a Perl script.
-   </para>
-
-   <para>
-    The <literal>glibc</literal> package is a deliberate single exception to the <quote>binaries first</quote> convention. The <literal>glibc</literal> has <literal>libs</literal> as its first output allowing the libraries provided by <literal>glibc</literal> to be referenced directly (e.g. <literal>${stdenv.glibc}/lib/ld-linux-x86-64.so.2</literal>). The executables provided by <literal>glibc</literal> can be accessed via its <literal>bin</literal> attribute (e.g. <literal>${stdenv.glibc.bin}/bin/ldd</literal>).
-   </para>
-
-   <para>
-    The reason for why <literal>glibc</literal> deviates from the convention is because referencing a library provided by <literal>glibc</literal> is a very common operation among Nix packages. For instance, third-party executables packaged by Nix are typically patched and relinked with the relevant version of <literal>glibc</literal> libraries from Nix packages (please see the documentation on <link xlink:href="https://github.com/NixOS/patchelf/blob/master/README">patchelf</link> for more details).
-   </para>
-  </section>
-
-  <section xml:id="multiple-output-file-type-groups">
-   <title>File type groups</title>
-
-   <para>
-    The support code currently recognizes some particular kinds of outputs and either instructs the build system of the package to put files into their desired outputs or it moves the files during the fixup phase. Each group of file types has an <varname>outputFoo</varname> variable specifying the output name where they should go. If that variable isn't defined by the derivation writer, it is guessed &ndash; a default output name is defined, falling back to other possibilities if the output isn't defined.
-   </para>
-
-   <variablelist>
-    <varlistentry>
-     <term>
-      <varname> $outputDev</varname>
-     </term>
-     <listitem>
-      <para>
-       is for development-only files. These include C(++) headers, pkg-config, cmake and aclocal files. They go to <varname>dev</varname> or <varname>out</varname> by default.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname> $outputBin</varname>
-     </term>
-     <listitem>
-      <para>
-       is meant for user-facing binaries, typically residing in bin/. They go to <varname>bin</varname> or <varname>out</varname> by default.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname> $outputLib</varname>
-     </term>
-     <listitem>
-      <para>
-       is meant for libraries, typically residing in <filename>lib/</filename> and <filename>libexec/</filename>. They go to <varname>lib</varname> or <varname>out</varname> by default.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname> $outputDoc</varname>
-     </term>
-     <listitem>
-      <para>
-       is for user documentation, typically residing in <filename>share/doc/</filename>. It goes to <varname>doc</varname> or <varname>out</varname> by default.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname> $outputDevdoc</varname>
-     </term>
-     <listitem>
-      <para>
-       is for <emphasis>developer</emphasis> documentation. Currently we count gtk-doc and devhelp books in there. It goes to <varname>devdoc</varname> or is removed (!) by default. This is because e.g. gtk-doc tends to be rather large and completely unused by nixpkgs users.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname> $outputMan</varname>
-     </term>
-     <listitem>
-      <para>
-       is for man pages (except for section 3). They go to <varname>man</varname> or <varname>$outputBin</varname> by default.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname> $outputDevman</varname>
-     </term>
-     <listitem>
-      <para>
-       is for section 3 man pages. They go to <varname>devman</varname> or <varname>$outputMan</varname> by default.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname> $outputInfo</varname>
-     </term>
-     <listitem>
-      <para>
-       is for info pages. They go to <varname>info</varname> or <varname>$outputBin</varname> by default.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
-
-  <section xml:id="sec-multiple-outputs-caveats">
-   <title>Common caveats</title>
-
-   <itemizedlist>
-    <listitem>
-     <para>
-      Some configure scripts don't like some of the parameters passed by default by the framework, e.g. <literal>--docdir=/foo/bar</literal>. You can disable this by setting <literal>setOutputFlags = false;</literal>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      The outputs of a single derivation can retain references to each other, but note that circular references are not allowed. (And each strongly-connected component would act as a single output anyway.)
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      Most of split packages contain their core functionality in libraries. These libraries tend to refer to various kind of data that typically gets into <varname>out</varname>, e.g. locale strings, so there is often no advantage in separating the libraries into <varname>lib</varname>, as keeping them in <varname>out</varname> is easier.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      Some packages have hidden assumptions on install paths, which complicates splitting.
-     </para>
-    </listitem>
-   </itemizedlist>
-  </section>
- </section>
-<!--Writing a split derivation-->
-</chapter>
diff --git a/doc/stdenv/platform-notes.chapter.md b/doc/stdenv/platform-notes.chapter.md
new file mode 100644
index 00000000000..03e61e333f8
--- /dev/null
+++ b/doc/stdenv/platform-notes.chapter.md
@@ -0,0 +1,62 @@
+# Platform Notes {#chap-platform-notes}
+
+## Darwin (macOS) {#sec-darwin}
+
+Some common issues when packaging software for Darwin:
+
+- The Darwin `stdenv` uses clang instead of gcc. When referring to the compiler `$CC` or `cc` will work in both cases. Some builds hardcode gcc/g++ in their build scripts, that can usually be fixed with using something like `makeFlags = [ "CC=cc" ];` or by patching the build scripts.
+
+  ```nix
+  stdenv.mkDerivation {
+    name = "libfoo-1.2.3";
+    # ...
+    buildPhase = ''
+      $CC -o hello hello.c
+    '';
+  }
+  ```
+
+- On Darwin, libraries are linked using absolute paths, libraries are resolved by their `install_name` at link time. Sometimes packages won’t set this correctly causing the library lookups to fail at runtime. This can be fixed by adding extra linker flags or by running `install_name_tool -id` during the `fixupPhase`.
+
+  ```nix
+  stdenv.mkDerivation {
+    name = "libfoo-1.2.3";
+    # ...
+    makeFlags = lib.optional stdenv.isDarwin "LDFLAGS=-Wl,-install_name,$(out)/lib/libfoo.dylib";
+  }
+  ```
+
+- Even if the libraries are linked using absolute paths and resolved via their `install_name` correctly, tests can sometimes fail to run binaries. This happens because the `checkPhase` runs before the libraries are installed.
+
+  This can usually be solved by running the tests after the `installPhase` or alternatively by using `DYLD_LIBRARY_PATH`. More information about this variable can be found in the *dyld(1)* manpage.
+
+  ```
+  dyld: Library not loaded: /nix/store/7hnmbscpayxzxrixrgxvvlifzlxdsdir-jq-1.5-lib/lib/libjq.1.dylib
+  Referenced from: /private/tmp/nix-build-jq-1.5.drv-0/jq-1.5/tests/../jq
+  Reason: image not found
+  ./tests/jqtest: line 5: 75779 Abort trap: 6
+  ```
+
+  ```nix
+  stdenv.mkDerivation {
+    name = "libfoo-1.2.3";
+    # ...
+    doInstallCheck = true;
+    installCheckTarget = "check";
+  }
+  ```
+
+- Some packages assume xcode is available and use `xcrun` to resolve build tools like `clang`, etc. This causes errors like `xcode-select: error: no developer tools were found at '/Applications/Xcode.app'` while the build doesn’t actually depend on xcode.
+
+  ```nix
+  stdenv.mkDerivation {
+    name = "libfoo-1.2.3";
+    # ...
+    prePatch = ''
+      substituteInPlace Makefile \
+          --replace '/usr/bin/xcrun clang' clang
+    '';
+  }
+  ```
+
+  The package `xcbuild` can be used to build projects that really depend on Xcode. However, this replacement is not 100% compatible with Xcode and can occasionally cause issues.
diff --git a/doc/stdenv/platform-notes.xml b/doc/stdenv/platform-notes.xml
deleted file mode 100644
index 5a266fdc0ee..00000000000
--- a/doc/stdenv/platform-notes.xml
+++ /dev/null
@@ -1,83 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-platform-notes">
- <title>Platform Notes</title>
- <section xml:id="sec-darwin">
-  <title>Darwin (macOS)</title>
-
-  <para>
-   Some common issues when packaging software for Darwin:
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     The Darwin <literal>stdenv</literal> uses clang instead of gcc. When referring to the compiler <varname>$CC</varname> or <command>cc</command> will work in both cases. Some builds hardcode gcc/g++ in their build scripts, that can usually be fixed with using something like <literal>makeFlags = [ "CC=cc" ];</literal> or by patching the build scripts.
-    </para>
-<programlisting>
-stdenv.mkDerivation {
-  name = "libfoo-1.2.3";
-  # ...
-  buildPhase = ''
-    $CC -o hello hello.c
-  '';
-}
-</programlisting>
-   </listitem>
-   <listitem>
-    <para>
-     On Darwin, libraries are linked using absolute paths, libraries are resolved by their <literal>install_name</literal> at link time. Sometimes packages won't set this correctly causing the library lookups to fail at runtime. This can be fixed by adding extra linker flags or by running <command>install_name_tool -id</command> during the <function>fixupPhase</function>.
-    </para>
-<programlisting>
-stdenv.mkDerivation {
-  name = "libfoo-1.2.3";
-  # ...
-  makeFlags = stdenv.lib.optional stdenv.isDarwin "LDFLAGS=-Wl,-install_name,$(out)/lib/libfoo.dylib";
-}
-</programlisting>
-   </listitem>
-   <listitem>
-    <para>
-     Even if the libraries are linked using absolute paths and resolved via their <literal>install_name</literal> correctly, tests can sometimes fail to run binaries. This happens because the <varname>checkPhase</varname> runs before the libraries are installed.
-    </para>
-    <para>
-     This can usually be solved by running the tests after the <varname>installPhase</varname> or alternatively by using <varname>DYLD_LIBRARY_PATH</varname>. More information about this variable can be found in the <citerefentry>
-     <refentrytitle>dyld</refentrytitle>
-     <manvolnum>1</manvolnum></citerefentry> manpage.
-    </para>
-<programlisting>
-dyld: Library not loaded: /nix/store/7hnmbscpayxzxrixrgxvvlifzlxdsdir-jq-1.5-lib/lib/libjq.1.dylib
-Referenced from: /private/tmp/nix-build-jq-1.5.drv-0/jq-1.5/tests/../jq
-Reason: image not found
-./tests/jqtest: line 5: 75779 Abort trap: 6
-</programlisting>
-<programlisting>
-stdenv.mkDerivation {
-  name = "libfoo-1.2.3";
-  # ...
-  doInstallCheck = true;
-  installCheckTarget = "check";
-}
-</programlisting>
-   </listitem>
-   <listitem>
-    <para>
-     Some packages assume xcode is available and use <command>xcrun</command> to resolve build tools like <command>clang</command>, etc. This causes errors like <code>xcode-select: error: no developer tools were found at '/Applications/Xcode.app'</code> while the build doesn't actually depend on xcode.
-    </para>
-<programlisting>
-stdenv.mkDerivation {
-  name = "libfoo-1.2.3";
-  # ...
-  prePatch = ''
-    substituteInPlace Makefile \
-        --replace '/usr/bin/xcrun clang' clang
-  '';
-}
-</programlisting>
-    <para>
-     The package <literal>xcbuild</literal> can be used to build projects that really depend on Xcode. However, this replacement is not 100% compatible with Xcode and can occasionally cause issues.
-    </para>
-   </listitem>
-  </itemizedlist>
- </section>
-</chapter>
diff --git a/doc/stdenv/stdenv.chapter.md b/doc/stdenv/stdenv.chapter.md
new file mode 100644
index 00000000000..e3e7b4c850b
--- /dev/null
+++ b/doc/stdenv/stdenv.chapter.md
@@ -0,0 +1,1232 @@
+# The Standard Environment {#chap-stdenv}
+
+The standard build environment in the Nix Packages collection provides an environment for building Unix packages that does a lot of common build tasks automatically. In fact, for Unix packages that use the standard `./configure; make; make install` build interface, you don’t need to write a build script at all; the standard environment does everything automatically. If `stdenv` doesn’t do what you need automatically, you can easily customise or override the various build phases.
+
+## Using `stdenv` {#sec-using-stdenv}
+
+To build a package with the standard environment, you use the function `stdenv.mkDerivation`, instead of the primitive built-in function `derivation`, e.g.
+
+```nix
+stdenv.mkDerivation {
+  name = "libfoo-1.2.3";
+  src = fetchurl {
+    url = "http://example.org/libfoo-1.2.3.tar.bz2";
+    sha256 = "0x2g1jqygyr5wiwg4ma1nd7w4ydpy82z9gkcv8vh2v8dn3y58v5m";
+  };
+}
+```
+
+(`stdenv` needs to be in scope, so if you write this in a separate Nix expression from `pkgs/all-packages.nix`, you need to pass it as a function argument.) Specifying a `name` and a `src` is the absolute minimum Nix requires. For convenience, you can also use `pname` and `version` attributes and `mkDerivation` will automatically set `name` to `"${pname}-${version}"` by default. Since [RFC 0035](https://github.com/NixOS/rfcs/pull/35), this is preferred for packages in Nixpkgs, as it allows us to reuse the version easily:
+
+```nix
+stdenv.mkDerivation rec {
+  pname = "libfoo";
+  version = "1.2.3";
+  src = fetchurl {
+    url = "http://example.org/libfoo-source-${version}.tar.bz2";
+    sha256 = "0x2g1jqygyr5wiwg4ma1nd7w4ydpy82z9gkcv8vh2v8dn3y58v5m";
+  };
+}
+```
+
+Many packages have dependencies that are not provided in the standard environment. It’s usually sufficient to specify those dependencies in the `buildInputs` attribute:
+
+```nix
+stdenv.mkDerivation {
+  name = "libfoo-1.2.3";
+  ...
+  buildInputs = [libbar perl ncurses];
+}
+```
+
+This attribute ensures that the `bin` subdirectories of these packages appear in the `PATH` environment variable during the build, that their `include` subdirectories are searched by the C compiler, and so on. (See [](#ssec-setup-hooks) for details.)
+
+Often it is necessary to override or modify some aspect of the build. To make this easier, the standard environment breaks the package build into a number of *phases*, all of which can be overridden or modified individually: unpacking the sources, applying patches, configuring, building, and installing. (There are some others; see [](#sec-stdenv-phases).) For instance, a package that doesn’t supply a makefile but instead has to be compiled "manually" could be handled like this:
+
+```nix
+stdenv.mkDerivation {
+  name = "fnord-4.5";
+  ...
+  buildPhase = ''
+    gcc foo.c -o foo
+  '';
+  installPhase = ''
+    mkdir -p $out/bin
+    cp foo $out/bin
+  '';
+}
+```
+
+(Note the use of `''`-style string literals, which are very convenient for large multi-line script fragments because they don’t need escaping of `"` and `\`, and because indentation is intelligently removed.)
+
+There are many other attributes to customise the build. These are listed in [](#ssec-stdenv-attributes).
+
+While the standard environment provides a generic builder, you can still supply your own build script:
+
+```nix
+stdenv.mkDerivation {
+  name = "libfoo-1.2.3";
+  ...
+  builder = ./builder.sh;
+}
+```
+
+where the builder can do anything it wants, but typically starts with
+
+```bash
+source $stdenv/setup
+```
+
+to let `stdenv` set up the environment (e.g., process the `buildInputs`). If you want, you can still use `stdenv`’s generic builder:
+
+```bash
+source $stdenv/setup
+
+buildPhase() {
+  echo "... this is my custom build phase ..."
+  gcc foo.c -o foo
+}
+
+installPhase() {
+  mkdir -p $out/bin
+  cp foo $out/bin
+}
+
+genericBuild
+```
+
+## Tools provided by `stdenv` {#sec-tools-of-stdenv}
+
+The standard environment provides the following packages:
+
+- The GNU C Compiler, configured with C and C++ support.
+- GNU coreutils (contains a few dozen standard Unix commands).
+- GNU findutils (contains `find`).
+- GNU diffutils (contains `diff`, `cmp`).
+- GNU `sed`.
+- GNU `grep`.
+- GNU `awk`.
+- GNU `tar`.
+- `gzip`, `bzip2` and `xz`.
+- GNU Make.
+- Bash. This is the shell used for all builders in the Nix Packages collection. Not using `/bin/sh` removes a large source of portability problems.
+- The `patch` command.
+
+On Linux, `stdenv` also includes the `patchelf` utility.
+
+## Specifying dependencies {#ssec-stdenv-dependencies}
+
+As described in the Nix manual, almost any `*.drv` store path in a derivation’s attribute set will induce a dependency on that derivation. `mkDerivation`, however, takes a few attributes intended to, between them, include all the dependencies of a package. This is done both for structure and consistency, but also so that certain other setup can take place. For example, certain dependencies need their bin directories added to the `PATH`. That is built-in, but other setup is done via a pluggable mechanism that works in conjunction with these dependency attributes. See [](#ssec-setup-hooks) for details.
+
+Dependencies can be broken down along three axes: their host and target platforms relative to the new derivation’s, and whether they are propagated. The platform distinctions are motivated by cross compilation; see [](#chap-cross) for exactly what each platform means. [^footnote-stdenv-ignored-build-platform] But even if one is not cross compiling, the platforms imply whether or not the dependency is needed at run-time or build-time, a concept that makes perfect sense outside of cross compilation. By default, the run-time/build-time distinction is just a hint for mental clarity, but with `strictDeps` set it is mostly enforced even in the native case.
+
+The extension of `PATH` with dependencies, alluded to above, proceeds according to the relative platforms alone. The process is carried out only for dependencies whose host platform matches the new derivation’s build platform i.e. dependencies which run on the platform where the new derivation will be built. [^footnote-stdenv-native-dependencies-in-path] For each dependency \<dep\> of those dependencies, `dep/bin`, if present, is added to the `PATH` environment variable.
+
+The dependency is propagated when it forces some of its other-transitive (non-immediate) downstream dependencies to also take it on as an immediate dependency. Nix itself already takes a package’s transitive dependencies into account, but this propagation ensures nixpkgs-specific infrastructure like setup hooks (mentioned above) also are run as if the propagated dependency.
+
+It is important to note that dependencies are not necessarily propagated as the same sort of dependency that they were before, but rather as the corresponding sort so that the platform rules still line up. The exact rules for dependency propagation can be given by assigning to each dependency two integers based one how its host and target platforms are offset from the depending derivation’s platforms. Those offsets are given below in the descriptions of each dependency list attribute. Algorithmically, we traverse propagated inputs, accumulating every propagated dependency’s propagated dependencies and adjusting them to account for the “shift in perspective” described by the current dependency’s platform offsets. This results in sort a transitive closure of the dependency relation, with the offsets being approximately summed when two dependency links are combined. We also prune transitive dependencies whose combined offsets go out-of-bounds, which can be viewed as a filter over that transitive closure removing dependencies that are blatantly absurd.
+
+We can define the process precisely with [Natural Deduction](https://en.wikipedia.org/wiki/Natural_deduction) using the inference rules. This probably seems a bit obtuse, but so is the bash code that actually implements it! [^footnote-stdenv-find-inputs-location] They’re confusing in very different ways so… hopefully if something doesn’t make sense in one presentation, it will in the other!
+
+```
+let mapOffset(h, t, i) = i + (if i <= 0 then h else t - 1)
+
+propagated-dep(h0, t0, A, B)
+propagated-dep(h1, t1, B, C)
+h0 + h1 in {-1, 0, 1}
+h0 + t1 in {-1, 0, 1}
+-------------------------------------- Transitive property
+propagated-dep(mapOffset(h0, t0, h1),
+               mapOffset(h0, t0, t1),
+               A, C)
+```
+
+```
+let mapOffset(h, t, i) = i + (if i <= 0 then h else t - 1)
+
+dep(h0, _, A, B)
+propagated-dep(h1, t1, B, C)
+h0 + h1 in {-1, 0, 1}
+h0 + t1 in {-1, 0, -1}
+----------------------------- Take immediate dependencies' propagated dependencies
+propagated-dep(mapOffset(h0, t0, h1),
+               mapOffset(h0, t0, t1),
+               A, C)
+```
+
+```
+propagated-dep(h, t, A, B)
+----------------------------- Propagated dependencies count as dependencies
+dep(h, t, A, B)
+```
+
+Some explanation of this monstrosity is in order. In the common case, the target offset of a dependency is the successor to the target offset: `t = h + 1`. That means that:
+
+```
+let f(h, t, i) = i + (if i <= 0 then h else t - 1)
+let f(h, h + 1, i) = i + (if i <= 0 then h else (h + 1) - 1)
+let f(h, h + 1, i) = i + (if i <= 0 then h else h)
+let f(h, h + 1, i) = i + h
+```
+
+This is where “sum-like” comes in from above: We can just sum all of the host offsets to get the host offset of the transitive dependency. The target offset is the transitive dependency is simply the host offset + 1, just as it was with the dependencies composed to make this transitive one; it can be ignored as it doesn’t add any new information.
+
+Because of the bounds checks, the uncommon cases are `h = t` and `h + 2 = t`. In the former case, the motivation for `mapOffset` is that since its host and target platforms are the same, no transitive dependency of it should be able to “discover” an offset greater than its reduced target offsets. `mapOffset` effectively “squashes” all its transitive dependencies’ offsets so that none will ever be greater than the target offset of the original `h = t` package. In the other case, `h + 1` is skipped over between the host and target offsets. Instead of squashing the offsets, we need to “rip” them apart so no transitive dependencies’ offset is that one.
+
+Overall, the unifying theme here is that propagation shouldn’t be introducing transitive dependencies involving platforms the depending package is unaware of. \[One can imagine the dependending package asking for dependencies with the platforms it knows about; other platforms it doesn’t know how to ask for. The platform description in that scenario is a kind of unforagable capability.\] The offset bounds checking and definition of `mapOffset` together ensure that this is the case. Discovering a new offset is discovering a new platform, and since those platforms weren’t in the derivation “spec” of the needing package, they cannot be relevant. From a capability perspective, we can imagine that the host and target platforms of a package are the capabilities a package requires, and the depending package must provide the capability to the dependency.
+
+### Variables specifying dependencies {#variables-specifying-dependencies}
+
+#### `depsBuildBuild` {#var-stdenv-depsBuildBuild}
+
+A list of dependencies whose host and target platforms are the new derivation’s build platform. This means a `-1` host and `-1` target offset from the new derivation’s platforms. These are programs and libraries used at build time that produce programs and libraries also used at build time. If the dependency doesn’t care about the target platform (i.e. isn’t a compiler or similar tool), put it in `nativeBuildInputs` instead. The most common use of this `buildPackages.stdenv.cc`, the default C compiler for this role. That example crops up more than one might think in old commonly used C libraries.
+
+Since these packages are able to be run at build-time, they are always added to the `PATH`, as described above. But since these packages are only guaranteed to be able to run then, they shouldn’t persist as run-time dependencies. This isn’t currently enforced, but could be in the future.
+
+#### `nativeBuildInputs` {#var-stdenv-nativeBuildInputs}
+
+A list of dependencies whose host platform is the new derivation’s build platform, and target platform is the new derivation’s host platform. This means a `-1` host offset and `0` target offset from the new derivation’s platforms. These are programs and libraries used at build-time that, if they are a compiler or similar tool, produce code to run at run-time—i.e. tools used to build the new derivation. If the dependency doesn’t care about the target platform (i.e. isn’t a compiler or similar tool), put it here, rather than in `depsBuildBuild` or `depsBuildTarget`. This could be called `depsBuildHost` but `nativeBuildInputs` is used for historical continuity.
+
+Since these packages are able to be run at build-time, they are added to the `PATH`, as described above. But since these packages are only guaranteed to be able to run then, they shouldn’t persist as run-time dependencies. This isn’t currently enforced, but could be in the future.
+
+#### `depsBuildTarget` {#var-stdenv-depsBuildTarget}
+
+A list of dependencies whose host platform is the new derivation’s build platform, and target platform is the new derivation’s target platform. This means a `-1` host offset and `1` target offset from the new derivation’s platforms. These are programs used at build time that produce code to run with code produced by the depending package. Most commonly, these are tools used to build the runtime or standard library that the currently-being-built compiler will inject into any code it compiles. In many cases, the currently-being-built-compiler is itself employed for that task, but when that compiler won’t run (i.e. its build and host platform differ) this is not possible. Other times, the compiler relies on some other tool, like binutils, that is always built separately so that the dependency is unconditional.
+
+This is a somewhat confusing concept to wrap one’s head around, and for good reason. As the only dependency type where the platform offsets are not adjacent integers, it requires thinking of a bootstrapping stage *two* away from the current one. It and its use-case go hand in hand and are both considered poor form: try to not need this sort of dependency, and try to avoid building standard libraries and runtimes in the same derivation as the compiler produces code using them. Instead strive to build those like a normal library, using the newly-built compiler just as a normal library would. In short, do not use this attribute unless you are packaging a compiler and are sure it is needed.
+
+Since these packages are able to run at build time, they are added to the `PATH`, as described above. But since these packages are only guaranteed to be able to run then, they shouldn’t persist as run-time dependencies. This isn’t currently enforced, but could be in the future.
+
+#### `depsHostHost` {#var-stdenv-depsHostHost}
+
+A list of dependencies whose host and target platforms match the new derivation’s host platform. This means a `0` host offset and `0` target offset from the new derivation’s host platform. These are packages used at run-time to generate code also used at run-time. In practice, this would usually be tools used by compilers for macros or a metaprogramming system, or libraries used by the macros or metaprogramming code itself. It’s always preferable to use a `depsBuildBuild` dependency in the derivation being built over a `depsHostHost` on the tool doing the building for this purpose.
+
+#### `buildInputs` {#var-stdenv-buildInputs}
+
+A list of dependencies whose host platform and target platform match the new derivation’s. This means a `0` host offset and a `1` target offset from the new derivation’s host platform. This would be called `depsHostTarget` but for historical continuity. If the dependency doesn’t care about the target platform (i.e. isn’t a compiler or similar tool), put it here, rather than in `depsBuildBuild`.
+
+These are often programs and libraries used by the new derivation at *run*-time, but that isn’t always the case. For example, the machine code in a statically-linked library is only used at run-time, but the derivation containing the library is only needed at build-time. Even in the dynamic case, the library may also be needed at build-time to appease the linker.
+
+#### `depsTargetTarget` {#var-stdenv-depsTargetTarget}
+
+A list of dependencies whose host platform matches the new derivation’s target platform. This means a `1` offset from the new derivation’s platforms. These are packages that run on the target platform, e.g. the standard library or run-time deps of standard library that a compiler insists on knowing about. It’s poor form in almost all cases for a package to depend on another from a future stage \[future stage corresponding to positive offset\]. Do not use this attribute unless you are packaging a compiler and are sure it is needed.
+
+#### `depsBuildBuildPropagated` {#var-stdenv-depsBuildBuildPropagated}
+
+The propagated equivalent of `depsBuildBuild`. This perhaps never ought to be used, but it is included for consistency \[see below for the others\].
+
+#### `propagatedNativeBuildInputs` {#var-stdenv-propagatedNativeBuildInputs}
+
+The propagated equivalent of `nativeBuildInputs`. This would be called `depsBuildHostPropagated` but for historical continuity. For example, if package `Y` has `propagatedNativeBuildInputs = [X]`, and package `Z` has `buildInputs = [Y]`, then package `Z` will be built as if it included package `X` in its `nativeBuildInputs`. If instead, package `Z` has `nativeBuildInputs = [Y]`, then `Z` will be built as if it included `X` in the `depsBuildBuild` of package `Z`, because of the sum of the two `-1` host offsets.
+
+#### `depsBuildTargetPropagated` {#var-stdenv-depsBuildTargetPropagated}
+
+The propagated equivalent of `depsBuildTarget`. This is prefixed for the same reason of alerting potential users.
+
+#### `depsHostHostPropagated` {#var-stdenv-depsHostHostPropagated}
+
+The propagated equivalent of `depsHostHost`.
+
+#### `propagatedBuildInputs` {#var-stdenv-propagatedBuildInputs}
+
+The propagated equivalent of `buildInputs`. This would be called `depsHostTargetPropagated` but for historical continuity.
+
+#### `depsTargetTargetPropagated` {#var-stdenv-depsTargetTargetPropagated}
+
+The propagated equivalent of `depsTargetTarget`. This is prefixed for the same reason of alerting potential users.
+
+## Attributes {#ssec-stdenv-attributes}
+
+### Variables affecting `stdenv` initialisation {#variables-affecting-stdenv-initialisation}
+
+#### `NIX_DEBUG` {#var-stdenv-NIX_DEBUG}
+
+A natural number indicating how much information to log. If set to 1 or higher, `stdenv` will print moderate debugging information during the build. In particular, the `gcc` and `ld` wrapper scripts will print out the complete command line passed to the wrapped tools. If set to 6 or higher, the `stdenv` setup script will be run with `set -x` tracing. If set to 7 or higher, the `gcc` and `ld` wrapper scripts will also be run with `set -x` tracing.
+
+### Attributes affecting build properties {#attributes-affecting-build-properties}
+
+#### `enableParallelBuilding` {#var-stdenv-enableParallelBuilding}
+
+If set to `true`, `stdenv` will pass specific flags to `make` and other build tools to enable parallel building with up to `build-cores` workers.
+
+Unless set to `false`, some build systems with good support for parallel building including `cmake`, `meson`, and `qmake` will set it to `true`.
+
+### Special variables {#special-variables}
+
+#### `passthru` {#var-stdenv-passthru}
+
+This is an attribute set which can be filled with arbitrary values. For example:
+
+```nix
+passthru = {
+  foo = "bar";
+  baz = {
+    value1 = 4;
+    value2 = 5;
+  };
+}
+```
+
+Values inside it are not passed to the builder, so you can change them without triggering a rebuild. However, they can be accessed outside of a derivation directly, as if they were set inside a derivation itself, e.g. `hello.baz.value1`. We don’t specify any usage or schema of `passthru` - it is meant for values that would be useful outside the derivation in other parts of a Nix expression (e.g. in other derivations). An example would be to convey some specific dependency of your derivation which contains a program with plugins support. Later, others who make derivations with plugins can use passed-through dependency to ensure that their plugin would be binary-compatible with built program.
+
+#### `passthru.updateScript` {#var-passthru-updateScript}
+
+A script to be run by `maintainers/scripts/update.nix` when the package is matched. It needs to be an executable file, either on the file system:
+
+```nix
+passthru.updateScript = ./update.sh;
+```
+
+or inside the expression itself:
+
+```nix
+passthru.updateScript = writeScript "update-zoom-us" ''
+  #!/usr/bin/env nix-shell
+  #!nix-shell -i bash -p curl pcre common-updater-scripts
+
+  set -eu -o pipefail
+
+  version="$(curl -sI https://zoom.us/client/latest/zoom_x86_64.tar.xz | grep -Fi 'Location:' | pcregrep -o1 '/(([0-9]\.?)+)/')"
+  update-source-version zoom-us "$version"
+'';
+```
+
+The attribute can also contain a list, a script followed by arguments to be passed to it:
+
+```nix
+passthru.updateScript = [ ../../update.sh pname "--requested-release=unstable" ];
+```
+
+The script will be run with `UPDATE_NIX_ATTR_PATH` environment variable set to the attribute path it is supposed to update.
+
+::: {.note}
+The script will be usually run from the root of the Nixpkgs repository but you should not rely on that. Also note that the update scripts will be run in parallel by default; you should avoid running `git commit` or any other commands that cannot handle that.
+:::
+
+For information about how to run the updates, execute `nix-shell maintainers/scripts/update.nix`.
+
+## Phases {#sec-stdenv-phases}
+
+The generic builder has a number of *phases*. Package builds are split into phases to make it easier to override specific parts of the build (e.g., unpacking the sources or installing the binaries). Furthermore, it allows a nicer presentation of build logs in the Nix build farm.
+
+Each phase can be overridden in its entirety either by setting the environment variable `namePhase` to a string containing some shell commands to be executed, or by redefining the shell function `namePhase`. The former is convenient to override a phase from the derivation, while the latter is convenient from a build script. However, typically one only wants to *add* some commands to a phase, e.g. by defining `postInstall` or `preFixup`, as skipping some of the default actions may have unexpected consequences. The default script for each phase is defined in the file `pkgs/stdenv/generic/setup.sh`.
+
+### Controlling phases {#ssec-controlling-phases}
+
+There are a number of variables that control what phases are executed and in what order:
+
+#### Variables affecting phase control {#variables-affecting-phase-control}
+
+##### `phases` {#var-stdenv-phases}
+
+Specifies the phases. You can change the order in which phases are executed, or add new phases, by setting this variable. If it’s not set, the default value is used, which is `$prePhases unpackPhase patchPhase $preConfigurePhases configurePhase $preBuildPhases buildPhase checkPhase $preInstallPhases installPhase fixupPhase installCheckPhase $preDistPhases distPhase $postPhases`.
+
+Usually, if you just want to add a few phases, it’s more convenient to set one of the variables below (such as `preInstallPhases`), as you then don’t specify all the normal phases.
+
+##### `prePhases` {#var-stdenv-prePhases}
+
+Additional phases executed before any of the default phases.
+
+##### `preConfigurePhases` {#var-stdenv-preConfigurePhases}
+
+Additional phases executed just before the configure phase.
+
+##### `preBuildPhases` {#var-stdenv-preBuildPhases}
+
+Additional phases executed just before the build phase.
+
+##### `preInstallPhases` {#var-stdenv-preInstallPhases}
+
+Additional phases executed just before the install phase.
+
+##### `preFixupPhases` {#var-stdenv-preFixupPhases}
+
+Additional phases executed just before the fixup phase.
+
+##### `preDistPhases` {#var-stdenv-preDistPhases}
+
+Additional phases executed just before the distribution phase.
+
+##### `postPhases` {#var-stdenv-postPhases}
+
+Additional phases executed after any of the default phases.
+
+### The unpack phase {#ssec-unpack-phase}
+
+The unpack phase is responsible for unpacking the source code of the package. The default implementation of `unpackPhase` unpacks the source files listed in the `src` environment variable to the current directory. It supports the following files by default:
+
+#### Tar files {#tar-files}
+
+These can optionally be compressed using `gzip` (`.tar.gz`, `.tgz` or `.tar.Z`), `bzip2` (`.tar.bz2`, `.tbz2` or `.tbz`) or `xz` (`.tar.xz`, `.tar.lzma` or `.txz`).
+
+#### Zip files {#zip-files}
+
+Zip files are unpacked using `unzip`. However, `unzip` is not in the standard environment, so you should add it to `nativeBuildInputs` yourself.
+
+#### Directories in the Nix store {#directories-in-the-nix-store}
+
+These are simply copied to the current directory. The hash part of the file name is stripped, e.g. `/nix/store/1wydxgby13cz...-my-sources` would be copied to `my-sources`.
+
+Additional file types can be supported by setting the `unpackCmd` variable (see below).
+
+#### Variables controlling the unpack phase {#variables-controlling-the-unpack-phase}
+
+##### `srcs` / `src` {#var-stdenv-src}
+
+The list of source files or directories to be unpacked or copied. One of these must be set.
+
+##### `sourceRoot` {#var-stdenv-sourceRoot}
+
+After running `unpackPhase`, the generic builder changes the current directory to the directory created by unpacking the sources. If there are multiple source directories, you should set `sourceRoot` to the name of the intended directory.
+
+##### `setSourceRoot` {#var-stdenv-setSourceRoot}
+
+Alternatively to setting `sourceRoot`, you can set `setSourceRoot` to a shell command to be evaluated by the unpack phase after the sources have been unpacked. This command must set `sourceRoot`.
+
+##### `preUnpack` {#var-stdenv-preUnpack}
+
+Hook executed at the start of the unpack phase.
+
+##### `postUnpack` {#var-stdenv-postUnpack}
+
+Hook executed at the end of the unpack phase.
+
+##### `dontUnpack` {#var-stdenv-dontUnpack}
+
+Set to true to skip the unpack phase.
+
+##### `dontMakeSourcesWritable` {#var-stdenv-dontMakeSourcesWritable}
+
+If set to `1`, the unpacked sources are *not* made writable. By default, they are made writable to prevent problems with read-only sources. For example, copied store directories would be read-only without this.
+
+##### `unpackCmd` {#var-stdenv-unpackCmd}
+
+The unpack phase evaluates the string `$unpackCmd` for any unrecognised file. The path to the current source file is contained in the `curSrc` variable.
+
+### The patch phase {#ssec-patch-phase}
+
+The patch phase applies the list of patches defined in the `patches` variable.
+
+#### Variables controlling the patch phase {#variables-controlling-the-patch-phase}
+
+##### `dontPatch` {#var-stdenv-dontPatch}
+
+Set to true to skip the patch phase.
+
+##### `patches` {#var-stdenv-patches}
+
+The list of patches. They must be in the format accepted by the `patch` command, and may optionally be compressed using `gzip` (`.gz`), `bzip2` (`.bz2`) or `xz` (`.xz`).
+
+##### `patchFlags` {#var-stdenv-patchFlags}
+
+Flags to be passed to `patch`. If not set, the argument `-p1` is used, which causes the leading directory component to be stripped from the file names in each patch.
+
+##### `prePatch` {#var-stdenv-prePatch}
+
+Hook executed at the start of the patch phase.
+
+##### `postPatch` {#var-stdenv-postPatch}
+
+Hook executed at the end of the patch phase.
+
+### The configure phase {#ssec-configure-phase}
+
+The configure phase prepares the source tree for building. The default `configurePhase` runs `./configure` (typically an Autoconf-generated script) if it exists.
+
+#### Variables controlling the configure phase {#variables-controlling-the-configure-phase}
+
+##### `configureScript` {#var-stdenv-configureScript}
+
+The name of the configure script. It defaults to `./configure` if it exists; otherwise, the configure phase is skipped. This can actually be a command (like `perl ./Configure.pl`).
+
+##### `configureFlags` {#var-stdenv-configureFlags}
+
+A list of strings passed as additional arguments to the configure script.
+
+##### `dontConfigure` {#var-stdenv-dontConfigure}
+
+Set to true to skip the configure phase.
+
+##### `configureFlagsArray` {#var-stdenv-configureFlagsArray}
+
+A shell array containing additional arguments passed to the configure script. You must use this instead of `configureFlags` if the arguments contain spaces.
+
+##### `dontAddPrefix` {#var-stdenv-dontAddPrefix}
+
+By default, the flag `--prefix=$prefix` is added to the configure flags. If this is undesirable, set this variable to true.
+
+##### `prefix` {#var-stdenv-prefix}
+
+The prefix under which the package must be installed, passed via the `--prefix` option to the configure script. It defaults to `$out`.
+
+##### `prefixKey` {#var-stdenv-prefixKey}
+
+The key to use when specifying the prefix. By default, this is set to `--prefix=` as that is used by the majority of packages.
+
+##### `dontAddStaticConfigureFlags`
+
+By default, when building statically, stdenv will try to add build system appropriate configure flags to try to enable static builds.
+
+If this is undesirable, set this variable to true.
+
+##### `dontAddDisableDepTrack` {#var-stdenv-dontAddDisableDepTrack}
+
+By default, the flag `--disable-dependency-tracking` is added to the configure flags to speed up Automake-based builds. If this is undesirable, set this variable to true.
+
+##### `dontFixLibtool` {#var-stdenv-dontFixLibtool}
+
+By default, the configure phase applies some special hackery to all files called `ltmain.sh` before running the configure script in order to improve the purity of Libtool-based packages [^footnote-stdenv-sys-lib-search-path] . If this is undesirable, set this variable to true.
+
+##### `dontDisableStatic` {#var-stdenv-dontDisableStatic}
+
+By default, when the configure script has `--enable-static`, the option `--disable-static` is added to the configure flags.
+
+If this is undesirable, set this variable to true.  It is automatically set to true when building statically, for example through `pkgsStatic`.
+
+##### `configurePlatforms` {#var-stdenv-configurePlatforms}
+
+By default, when cross compiling, the configure script has `--build=...` and `--host=...` passed. Packages can instead pass `[ "build" "host" "target" ]` or a subset to control exactly which platform flags are passed. Compilers and other tools can use this to also pass the target platform. [^footnote-stdenv-build-time-guessing-impurity]
+
+##### `preConfigure` {#var-stdenv-preConfigure}
+
+Hook executed at the start of the configure phase.
+
+##### `postConfigure` {#var-stdenv-postConfigure}
+
+Hook executed at the end of the configure phase.
+
+### The build phase {#build-phase}
+
+The build phase is responsible for actually building the package (e.g. compiling it). The default `buildPhase` simply calls `make` if a file named `Makefile`, `makefile` or `GNUmakefile` exists in the current directory (or the `makefile` is explicitly set); otherwise it does nothing.
+
+#### Variables controlling the build phase {#variables-controlling-the-build-phase}
+
+##### `dontBuild` {#var-stdenv-dontBuild}
+
+Set to true to skip the build phase.
+
+##### `makefile` {#var-stdenv-makefile}
+
+The file name of the Makefile.
+
+##### `makeFlags` {#var-stdenv-makeFlags}
+
+A list of strings passed as additional flags to `make`. These flags are also used by the default install and check phase. For setting make flags specific to the build phase, use `buildFlags` (see below).
+
+```nix
+makeFlags = [ "PREFIX=$(out)" ];
+```
+
+::: {.note}
+The flags are quoted in bash, but environment variables can be specified by using the make syntax.
+:::
+
+##### `makeFlagsArray` {#var-stdenv-makeFlagsArray}
+
+A shell array containing additional arguments passed to `make`. You must use this instead of `makeFlags` if the arguments contain spaces, e.g.
+
+```nix
+preBuild = ''
+  makeFlagsArray+=(CFLAGS="-O0 -g" LDFLAGS="-lfoo -lbar")
+'';
+```
+
+Note that shell arrays cannot be passed through environment variables, so you cannot set `makeFlagsArray` in a derivation attribute (because those are passed through environment variables): you have to define them in shell code.
+
+##### `buildFlags` / `buildFlagsArray` {#var-stdenv-buildFlags}
+
+A list of strings passed as additional flags to `make`. Like `makeFlags` and `makeFlagsArray`, but only used by the build phase.
+
+##### `preBuild` {#var-stdenv-preBuild}
+
+Hook executed at the start of the build phase.
+
+##### `postBuild` {#var-stdenv-postBuild}
+
+Hook executed at the end of the build phase.
+
+You can set flags for `make` through the `makeFlags` variable.
+
+Before and after running `make`, the hooks `preBuild` and `postBuild` are called, respectively.
+
+### The check phase {#ssec-check-phase}
+
+The check phase checks whether the package was built correctly by running its test suite. The default `checkPhase` calls `make check`, but only if the `doCheck` variable is enabled.
+
+#### Variables controlling the check phase {#variables-controlling-the-check-phase}
+
+##### `doCheck` {#var-stdenv-doCheck}
+
+Controls whether the check phase is executed. By default it is skipped, but if `doCheck` is set to true, the check phase is usually executed. Thus you should set
+
+```nix
+doCheck = true;
+```
+
+in the derivation to enable checks. The exception is cross compilation. Cross compiled builds never run tests, no matter how `doCheck` is set, as the newly-built program won’t run on the platform used to build it.
+
+##### `makeFlags` / `makeFlagsArray` / `makefile` {#makeflags-makeflagsarray-makefile}
+
+See the [build phase](#var-stdenv-makeFlags) for details.
+
+##### `checkTarget` {#var-stdenv-checkTarget}
+
+The make target that runs the tests. Defaults to `check`.
+
+##### `checkFlags` / `checkFlagsArray` {#var-stdenv-checkFlags}
+
+A list of strings passed as additional flags to `make`. Like `makeFlags` and `makeFlagsArray`, but only used by the check phase.
+
+##### `checkInputs` {#var-stdenv-checkInputs}
+
+A list of dependencies used by the phase. This gets included in `nativeBuildInputs` when `doCheck` is set.
+
+##### `preCheck` {#var-stdenv-preCheck}
+
+Hook executed at the start of the check phase.
+
+##### `postCheck` {#var-stdenv-postCheck}
+
+Hook executed at the end of the check phase.
+
+### The install phase {#ssec-install-phase}
+
+The install phase is responsible for installing the package in the Nix store under `out`. The default `installPhase` creates the directory `$out` and calls `make install`.
+
+#### Variables controlling the install phase {#variables-controlling-the-install-phase}
+
+##### `dontInstall` {#var-stdenv-dontInstall}
+
+Set to true to skip the install phase.
+
+##### `makeFlags` / `makeFlagsArray` / `makefile` {#makeflags-makeflagsarray-makefile-1}
+
+See the [build phase](#var-stdenv-makeFlags) for details.
+
+##### `installTargets` {#var-stdenv-installTargets}
+
+The make targets that perform the installation. Defaults to `install`. Example:
+
+```nix
+installTargets = "install-bin install-doc";
+```
+
+##### `installFlags` / `installFlagsArray` {#var-stdenv-installFlags}
+
+A list of strings passed as additional flags to `make`. Like `makeFlags` and `makeFlagsArray`, but only used by the install phase.
+
+##### `preInstall` {#var-stdenv-preInstall}
+
+Hook executed at the start of the install phase.
+
+##### `postInstall` {#var-stdenv-postInstall}
+
+Hook executed at the end of the install phase.
+
+### The fixup phase {#ssec-fixup-phase}
+
+The fixup phase performs some (Nix-specific) post-processing actions on the files installed under `$out` by the install phase. The default `fixupPhase` does the following:
+
+- It moves the `man/`, `doc/` and `info/` subdirectories of `$out` to `share/`.
+- It strips libraries and executables of debug information.
+- On Linux, it applies the `patchelf` command to ELF executables and libraries to remove unused directories from the `RPATH` in order to prevent unnecessary runtime dependencies.
+- It rewrites the interpreter paths of shell scripts to paths found in `PATH`. E.g., `/usr/bin/perl` will be rewritten to `/nix/store/some-perl/bin/perl` found in `PATH`.
+
+#### Variables controlling the fixup phase {#variables-controlling-the-fixup-phase}
+
+##### `dontFixup` {#var-stdenv-dontFixup}
+
+Set to true to skip the fixup phase.
+
+##### `dontStrip` {#var-stdenv-dontStrip}
+
+If set, libraries and executables are not stripped. By default, they are.
+
+##### `dontStripHost` {#var-stdenv-dontStripHost}
+
+Like `dontStrip`, but only affects the `strip` command targetting the package’s host platform. Useful when supporting cross compilation, but otherwise feel free to ignore.
+
+##### `dontStripTarget` {#var-stdenv-dontStripTarget}
+
+Like `dontStrip`, but only affects the `strip` command targetting the packages’ target platform. Useful when supporting cross compilation, but otherwise feel free to ignore.
+
+##### `dontMoveSbin` {#var-stdenv-dontMoveSbin}
+
+If set, files in `$out/sbin` are not moved to `$out/bin`. By default, they are.
+
+##### `stripAllList` {#var-stdenv-stripAllList}
+
+List of directories to search for libraries and executables from which *all* symbols should be stripped. By default, it’s empty. Stripping all symbols is risky, since it may remove not just debug symbols but also ELF information necessary for normal execution.
+
+##### `stripAllFlags` {#var-stdenv-stripAllFlags}
+
+Flags passed to the `strip` command applied to the files in the directories listed in `stripAllList`. Defaults to `-s` (i.e. `--strip-all`).
+
+##### `stripDebugList` {#var-stdenv-stripDebugList}
+
+List of directories to search for libraries and executables from which only debugging-related symbols should be stripped. It defaults to `lib lib32 lib64 libexec bin sbin`.
+
+##### `stripDebugFlags` {#var-stdenv-stripDebugFlags}
+
+Flags passed to the `strip` command applied to the files in the directories listed in `stripDebugList`. Defaults to `-S` (i.e. `--strip-debug`).
+
+##### `dontPatchELF` {#var-stdenv-dontPatchELF}
+
+If set, the `patchelf` command is not used to remove unnecessary `RPATH` entries. Only applies to Linux.
+
+##### `dontPatchShebangs` {#var-stdenv-dontPatchShebangs}
+
+If set, scripts starting with `#!` do not have their interpreter paths rewritten to paths in the Nix store.
+
+##### `dontPruneLibtoolFiles` {#var-stdenv-dontPruneLibtoolFiles}
+
+If set, libtool `.la` files associated with shared libraries won’t have their `dependency_libs` field cleared.
+
+##### `forceShare` {#var-stdenv-forceShare}
+
+The list of directories that must be moved from `$out` to `$out/share`. Defaults to `man doc info`.
+
+##### `setupHook` {#var-stdenv-setupHook}
+
+A package can export a [setup hook](#ssec-setup-hooks) by setting this variable. The setup hook, if defined, is copied to `$out/nix-support/setup-hook`. Environment variables are then substituted in it using `substituteAll`.
+
+##### `preFixup` {#var-stdenv-preFixup}
+
+Hook executed at the start of the fixup phase.
+
+##### `postFixup` {#var-stdenv-postFixup}
+
+Hook executed at the end of the fixup phase.
+
+##### `separateDebugInfo` {#stdenv-separateDebugInfo}
+
+If set to `true`, the standard environment will enable debug information in C/C++ builds. After installation, the debug information will be separated from the executables and stored in the output named `debug`. (This output is enabled automatically; you don’t need to set the `outputs` attribute explicitly.) To be precise, the debug information is stored in `debug/lib/debug/.build-id/XX/YYYY…`, where \<XXYYYY…\> is the \<build ID\> of the binary — a SHA-1 hash of the contents of the binary. Debuggers like GDB use the build ID to look up the separated debug information.
+
+For example, with GDB, you can add
+
+```
+set debug-file-directory ~/.nix-profile/lib/debug
+```
+
+to `~/.gdbinit`. GDB will then be able to find debug information installed via `nix-env -i`.
+
+### The installCheck phase {#ssec-installCheck-phase}
+
+The installCheck phase checks whether the package was installed correctly by running its test suite against the installed directories. The default `installCheck` calls `make installcheck`.
+
+#### Variables controlling the installCheck phase {#variables-controlling-the-installcheck-phase}
+
+##### `doInstallCheck` {#var-stdenv-doInstallCheck}
+
+Controls whether the installCheck phase is executed. By default it is skipped, but if `doInstallCheck` is set to true, the installCheck phase is usually executed. Thus you should set
+
+```nix
+doInstallCheck = true;
+```
+
+in the derivation to enable install checks. The exception is cross compilation. Cross compiled builds never run tests, no matter how `doInstallCheck` is set, as the newly-built program won’t run on the platform used to build it.
+
+##### `installCheckTarget` {#var-stdenv-installCheckTarget}
+
+The make target that runs the install tests. Defaults to `installcheck`.
+
+##### `installCheckFlags` / `installCheckFlagsArray` {#var-stdenv-installCheckFlags}
+
+A list of strings passed as additional flags to `make`. Like `makeFlags` and `makeFlagsArray`, but only used by the installCheck phase.
+
+##### `installCheckInputs` {#var-stdenv-installCheckInputs}
+
+A list of dependencies used by the phase. This gets included in `nativeBuildInputs` when `doInstallCheck` is set.
+
+##### `preInstallCheck` {#var-stdenv-preInstallCheck}
+
+Hook executed at the start of the installCheck phase.
+
+##### `postInstallCheck` {#var-stdenv-postInstallCheck}
+
+Hook executed at the end of the installCheck phase.
+
+### The distribution phase {#ssec-distribution-phase}
+
+The distribution phase is intended to produce a source distribution of the package. The default `distPhase` first calls `make dist`, then it copies the resulting source tarballs to `$out/tarballs/`. This phase is only executed if the attribute `doDist` is set.
+
+#### Variables controlling the distribution phase {#variables-controlling-the-distribution-phase}
+
+##### `distTarget` {#var-stdenv-distTarget}
+
+The make target that produces the distribution. Defaults to `dist`.
+
+##### `distFlags` / `distFlagsArray` {#var-stdenv-distFlags}
+
+Additional flags passed to `make`.
+
+##### `tarballs` {#var-stdenv-tarballs}
+
+The names of the source distribution files to be copied to `$out/tarballs/`. It can contain shell wildcards. The default is `*.tar.gz`.
+
+##### `dontCopyDist` {#var-stdenv-dontCopyDist}
+
+If set, no files are copied to `$out/tarballs/`.
+
+##### `preDist` {#var-stdenv-preDist}
+
+Hook executed at the start of the distribution phase.
+
+##### `postDist` {#var-stdenv-postDist}
+
+Hook executed at the end of the distribution phase.
+
+## Shell functions {#ssec-stdenv-functions}
+
+The standard environment provides a number of useful functions.
+
+### `makeWrapper` \<executable\> \<wrapperfile\> \<args\> {#fun-makeWrapper}
+
+Constructs a wrapper for a program with various possible arguments. For example:
+
+```bash
+# adds `FOOBAR=baz` to `$out/bin/foo`’s environment
+makeWrapper $out/bin/foo $wrapperfile --set FOOBAR baz
+
+# prefixes the binary paths of `hello` and `git`
+# Be advised that paths often should be patched in directly
+# (via string replacements or in `configurePhase`).
+makeWrapper $out/bin/foo $wrapperfile --prefix PATH : ${lib.makeBinPath [ hello git ]}
+```
+
+There’s many more kinds of arguments, they are documented in `nixpkgs/pkgs/build-support/setup-hooks/make-wrapper.sh`.
+
+`wrapProgram` is a convenience function you probably want to use most of the time.
+
+### `substitute` \<infile\> \<outfile\> \<subs\> {#fun-substitute}
+
+Performs string substitution on the contents of \<infile\>, writing the result to \<outfile\>. The substitutions in \<subs\> are of the following form:
+
+#### `--replace` \<s1\> \<s2\>
+
+Replace every occurrence of the string \<s1\> by \<s2\>.
+
+#### `--subst-var` \<varName\>
+
+Replace every occurrence of `@varName@` by the contents of the environment variable \<varName\>. This is useful for generating files from templates, using `@...@` in the template as placeholders.
+
+#### `--subst-var-by` \<varName\> \<s\>
+
+Replace every occurrence of `@varName@` by the string \<s\>.
+
+Example:
+
+```shell
+substitute ./foo.in ./foo.out \
+    --replace /usr/bin/bar $bar/bin/bar \
+    --replace "a string containing spaces" "some other text" \
+    --subst-var someVar
+```
+
+### `substituteInPlace` \<file\> \<subs\> {#fun-substituteInPlace}
+
+Like `substitute`, but performs the substitutions in place on the file \<file\>.
+
+### `substituteAll` \<infile\> \<outfile\> {#fun-substituteAll}
+
+Replaces every occurrence of `@varName@`, where \<varName\> is any environment variable, in \<infile\>, writing the result to \<outfile\>. For instance, if \<infile\> has the contents
+
+```bash
+#! @bash@/bin/sh
+PATH=@coreutils@/bin
+echo @foo@
+```
+
+and the environment contains `bash=/nix/store/bmwp0q28cf21...-bash-3.2-p39` and `coreutils=/nix/store/68afga4khv0w...-coreutils-6.12`, but does not contain the variable `foo`, then the output will be
+
+```bash
+#! /nix/store/bmwp0q28cf21...-bash-3.2-p39/bin/sh
+PATH=/nix/store/68afga4khv0w...-coreutils-6.12/bin
+echo @foo@
+```
+
+That is, no substitution is performed for undefined variables.
+
+Environment variables that start with an uppercase letter or an underscore are filtered out, to prevent global variables (like `HOME`) or private variables (like `__ETC_PROFILE_DONE`) from accidentally getting substituted. The variables also have to be valid bash "names", as defined in the bash manpage (alphanumeric or `_`, must not start with a number).
+
+### `substituteAllInPlace` \<file\> {#fun-substituteAllInPlace}
+
+Like `substituteAll`, but performs the substitutions in place on the file \<file\>.
+
+### `stripHash` \<path\> {#fun-stripHash}
+
+Strips the directory and hash part of a store path, outputting the name part to `stdout`. For example:
+
+```bash
+# prints coreutils-8.24
+stripHash "/nix/store/9s9r019176g7cvn2nvcw41gsp862y6b4-coreutils-8.24"
+```
+
+If you wish to store the result in another variable, then the following idiom may be useful:
+
+```bash
+name="/nix/store/9s9r019176g7cvn2nvcw41gsp862y6b4-coreutils-8.24"
+someVar=$(stripHash $name)
+```
+
+### `wrapProgram` \<executable\> \<makeWrapperArgs\> {#fun-wrapProgram}
+
+Convenience function for `makeWrapper` that automatically creates a sane wrapper file. It takes all the same arguments as `makeWrapper`, except for `--argv0`.
+
+It cannot be applied multiple times, since it will overwrite the wrapper file.
+
+## Package setup hooks {#ssec-setup-hooks}
+
+Nix itself considers a build-time dependency as merely something that should previously be built and accessible at build time—packages themselves are on their own to perform any additional setup. In most cases, that is fine, and the downstream derivation can deal with its own dependencies. But for a few common tasks, that would result in almost every package doing the same sort of setup work—depending not on the package itself, but entirely on which dependencies were used.
+
+In order to alleviate this burden, the setup hook mechanism was written, where any package can include a shell script that \[by convention rather than enforcement by Nix\], any downstream reverse-dependency will source as part of its build process. That allows the downstream dependency to merely specify its dependencies, and lets those dependencies effectively initialize themselves. No boilerplate mirroring the list of dependencies is needed.
+
+The setup hook mechanism is a bit of a sledgehammer though: a powerful feature with a broad and indiscriminate area of effect. The combination of its power and implicit use may be expedient, but isn’t without costs. Nix itself is unchanged, but the spirit of added dependencies being effect-free is violated even if the letter isn’t. For example, if a derivation path is mentioned more than once, Nix itself doesn’t care and simply makes sure the dependency derivation is already built just the same—depending is just needing something to exist, and needing is idempotent. However, a dependency specified twice will have its setup hook run twice, and that could easily change the build environment (though a well-written setup hook will therefore strive to be idempotent so this is in fact not observable). More broadly, setup hooks are anti-modular in that multiple dependencies, whether the same or different, should not interfere and yet their setup hooks may well do so.
+
+The most typical use of the setup hook is actually to add other hooks which are then run (i.e. after all the setup hooks) on each dependency. For example, the C compiler wrapper’s setup hook feeds itself flags for each dependency that contains relevant libraries and headers. This is done by defining a bash function, and appending its name to one of `envBuildBuildHooks`, `envBuildHostHooks`, `envBuildTargetHooks`, `envHostHostHooks`, `envHostTargetHooks`, or `envTargetTargetHooks`. These 6 bash variables correspond to the 6 sorts of dependencies by platform (there’s 12 total but we ignore the propagated/non-propagated axis).
+
+Packages adding a hook should not hard code a specific hook, but rather choose a variable *relative* to how they are included. Returning to the C compiler wrapper example, if the wrapper itself is an `n` dependency, then it only wants to accumulate flags from `n + 1` dependencies, as only those ones match the compiler’s target platform. The `hostOffset` variable is defined with the current dependency’s host offset `targetOffset` with its target offset, before its setup hook is sourced. Additionally, since most environment hooks don’t care about the target platform, that means the setup hook can append to the right bash array by doing something like
+
+```bash
+addEnvHooks "$hostOffset" myBashFunction
+```
+
+The *existence* of setups hooks has long been documented and packages inside Nixpkgs are free to use this mechanism. Other packages, however, should not rely on these mechanisms not changing between Nixpkgs versions. Because of the existing issues with this system, there’s little benefit from mandating it be stable for any period of time.
+
+First, let’s cover some setup hooks that are part of Nixpkgs default stdenv. This means that they are run for every package built using `stdenv.mkDerivation`. Some of these are platform specific, so they may run on Linux but not Darwin or vice-versa.
+
+### `move-docs.sh` {#move-docs.sh}
+
+This setup hook moves any installed documentation to the `/share` subdirectory directory. This includes the man, doc and info directories. This is needed for legacy programs that do not know how to use the `share` subdirectory.
+
+### `compress-man-pages.sh` {#compress-man-pages.sh}
+
+This setup hook compresses any man pages that have been installed. The compression is done using the gzip program. This helps to reduce the installed size of packages.
+
+### `strip.sh` {#strip.sh}
+
+This runs the strip command on installed binaries and libraries. This removes unnecessary information like debug symbols when they are not needed. This also helps to reduce the installed size of packages.
+
+### `patch-shebangs.sh` {#patch-shebangs.sh}
+
+This setup hook patches installed scripts to use the full path to the shebang interpreter. A shebang interpreter is the first commented line of a script telling the operating system which program will run the script (e.g `#!/bin/bash`). In Nix, we want an exact path to that interpreter to be used. This often replaces `/bin/sh` with a path in the Nix store.
+
+### `audit-tmpdir.sh` {#audit-tmpdir.sh}
+
+This verifies that no references are left from the install binaries to the directory used to build those binaries. This ensures that the binaries do not need things outside the Nix store. This is currently supported in Linux only.
+
+### `multiple-outputs.sh` {#multiple-outputs.sh}
+
+This setup hook adds configure flags that tell packages to install files into any one of the proper outputs listed in `outputs`. This behavior can be turned off by setting `setOutputFlags` to false in the derivation environment. See [](#chap-multiple-output) for more information.
+
+### `move-sbin.sh` {#move-sbin.sh}
+
+This setup hook moves any binaries installed in the `sbin/` subdirectory into `bin/`. In addition, a link is provided from `sbin/` to `bin/` for compatibility.
+
+### `move-lib64.sh` {#move-lib64.sh}
+
+This setup hook moves any libraries installed in the `lib64/` subdirectory into `lib/`. In addition, a link is provided from `lib64/` to `lib/` for compatibility.
+
+### `move-systemd-user-units.sh` {#move-systemd-user-units.sh}
+
+This setup hook moves any systemd user units installed in the `lib/` subdirectory into `share/`. In addition, a link is provided from `share/` to `lib/` for compatibility. This is needed for systemd to find user services when installed into the user profile.
+
+### `set-source-date-epoch-to-latest.sh` {#set-source-date-epoch-to-latest.sh}
+
+This sets `SOURCE_DATE_EPOCH` to the modification time of the most recent file.
+
+### Bintools Wrapper {#bintools-wrapper}
+
+The Bintools Wrapper wraps the binary utilities for a bunch of miscellaneous purposes. These are GNU Binutils when targetting Linux, and a mix of cctools and GNU binutils for Darwin. \[The “Bintools” name is supposed to be a compromise between “Binutils” and “cctools” not denoting any specific implementation.\] Specifically, the underlying bintools package, and a C standard library (glibc or Darwin’s libSystem, just for the dynamic loader) are all fed in, and dependency finding, hardening (see below), and purity checks for each are handled by the Bintools Wrapper. Packages typically depend on CC Wrapper, which in turn (at run time) depends on the Bintools Wrapper.
+
+The Bintools Wrapper was only just recently split off from CC Wrapper, so the division of labor is still being worked out. For example, it shouldn’t care about the C standard library, but just take a derivation with the dynamic loader (which happens to be the glibc on linux). Dependency finding however is a task both wrappers will continue to need to share, and probably the most important to understand. It is currently accomplished by collecting directories of host-platform dependencies (i.e. `buildInputs` and `nativeBuildInputs`) in environment variables. The Bintools Wrapper’s setup hook causes any `lib` and `lib64` subdirectories to be added to `NIX_LDFLAGS`. Since the CC Wrapper and the Bintools Wrapper use the same strategy, most of the Bintools Wrapper code is sparsely commented and refers to the CC Wrapper. But the CC Wrapper’s code, by contrast, has quite lengthy comments. The Bintools Wrapper merely cites those, rather than repeating them, to avoid falling out of sync.
+
+A final task of the setup hook is defining a number of standard environment variables to tell build systems which executables fulfill which purpose. They are defined to just be the base name of the tools, under the assumption that the Bintools Wrapper’s binaries will be on the path. Firstly, this helps poorly-written packages, e.g. ones that look for just `gcc` when `CC` isn’t defined yet `clang` is to be used. Secondly, this helps packages not get confused when cross-compiling, in which case multiple Bintools Wrappers may simultaneously be in use. [^footnote-stdenv-per-platform-wrapper] `BUILD_`- and `TARGET_`-prefixed versions of the normal environment variable are defined for additional Bintools Wrappers, properly disambiguating them.
+
+A problem with this final task is that the Bintools Wrapper is honest and defines `LD` as `ld`. Most packages, however, firstly use the C compiler for linking, secondly use `LD` anyways, defining it as the C compiler, and thirdly, only so define `LD` when it is undefined as a fallback. This triple-threat means Bintools Wrapper will break those packages, as LD is already defined as the actual linker which the package won’t override yet doesn’t want to use. The workaround is to define, just for the problematic package, `LD` as the C compiler. A good way to do this would be `preConfigure = "LD=$CC"`.
+
+### CC Wrapper {#cc-wrapper}
+
+The CC Wrapper wraps a C toolchain for a bunch of miscellaneous purposes. Specifically, a C compiler (GCC or Clang), wrapped binary tools, and a C standard library (glibc or Darwin’s libSystem, just for the dynamic loader) are all fed in, and dependency finding, hardening (see below), and purity checks for each are handled by the CC Wrapper. Packages typically depend on the CC Wrapper, which in turn (at run-time) depends on the Bintools Wrapper.
+
+Dependency finding is undoubtedly the main task of the CC Wrapper. This works just like the Bintools Wrapper, except that any `include` subdirectory of any relevant dependency is added to `NIX_CFLAGS_COMPILE`. The setup hook itself contains some lengthy comments describing the exact convoluted mechanism by which this is accomplished.
+
+Similarly, the CC Wrapper follows the Bintools Wrapper in defining standard environment variables with the names of the tools it wraps, for the same reasons described above. Importantly, while it includes a `cc` symlink to the c compiler for portability, the `CC` will be defined using the compiler’s “real name” (i.e. `gcc` or `clang`). This helps lousy build systems that inspect on the name of the compiler rather than run it.
+
+Here are some more packages that provide a setup hook. Since the list of hooks is extensible, this is not an exhaustive list. The mechanism is only to be used as a last resort, so it might cover most uses.
+
+### Perl {#setup-hook-perl}
+
+Adds the `lib/site_perl` subdirectory of each build input to the `PERL5LIB` environment variable. For instance, if `buildInputs` contains Perl, then the `lib/site_perl` subdirectory of each input is added to the `PERL5LIB` environment variable.
+
+### Python {#setup-hook-python}
+
+Adds the `lib/${python.libPrefix}/site-packages` subdirectory of each build input to the `PYTHONPATH` environment variable.
+
+### pkg-config {#setup-hook-pkg-config}
+
+Adds the `lib/pkgconfig` and `share/pkgconfig` subdirectories of each build input to the `PKG_CONFIG_PATH` environment variable.
+
+### Automake {#setup-hook-automake}
+
+Adds the `share/aclocal` subdirectory of each build input to the `ACLOCAL_PATH` environment variable.
+
+### Autoconf {#setup-hook-autoconf}
+
+The `autoreconfHook` derivation adds `autoreconfPhase`, which runs autoreconf, libtoolize and automake, essentially preparing the configure script in autotools-based builds. Most autotools-based packages come with the configure script pre-generated, but this hook is necessary for a few packages and when you need to patch the package’s configure scripts.
+
+### libxml2 {#setup-hook-libxml2}
+
+Adds every file named `catalog.xml` found under the `xml/dtd` and `xml/xsl` subdirectories of each build input to the `XML_CATALOG_FILES` environment variable.
+
+### teTeX / TeX Live {#tetex-tex-live}
+
+Adds the `share/texmf-nix` subdirectory of each build input to the `TEXINPUTS` environment variable.
+
+### Qt 4 {#qt-4}
+
+Sets the `QTDIR` environment variable to Qt’s path.
+
+### gdk-pixbuf {#setup-hook-gdk-pixbuf}
+
+Exports `GDK_PIXBUF_MODULE_FILE` environment variable to the builder. Add librsvg package to `buildInputs` to get svg support. See also the [setup hook description in GNOME platform docs](#ssec-gnome-hooks-gdk-pixbuf).
+
+### GHC {#ghc}
+
+Creates a temporary package database and registers every Haskell build input in it (TODO: how?).
+
+### GNOME platform {#gnome-platform}
+
+Hooks related to GNOME platform and related libraries like GLib, GTK and GStreamer are described in [](#sec-language-gnome).
+
+### autoPatchelfHook {#setup-hook-autopatchelfhook}
+
+This is a special setup hook which helps in packaging proprietary software in that it automatically tries to find missing shared library dependencies of ELF files based on the given `buildInputs` and `nativeBuildInputs`.
+
+You can also specify a `runtimeDependencies` variable which lists dependencies to be unconditionally added to rpath of all executables. This is useful for programs that use dlopen 3 to load libraries at runtime.
+
+In certain situations you may want to run the main command (`autoPatchelf`) of the setup hook on a file or a set of directories instead of unconditionally patching all outputs. This can be done by setting the `dontAutoPatchelf` environment variable to a non-empty value.
+
+By default `autoPatchelf` will fail as soon as any ELF file requires a dependency which cannot be resolved via the given build inputs. In some situations you might prefer to just leave missing dependencies unpatched and continue to patch the rest. This can be achieved by setting the `autoPatchelfIgnoreMissingDeps` environment variable to a non-empty value.
+
+The `autoPatchelf` command also recognizes a `--no-recurse` command line flag, which prevents it from recursing into subdirectories.
+
+### breakpointHook {#breakpointhook}
+
+This hook will make a build pause instead of stopping when a failure happens. It prevents nix from cleaning up the build environment immediately and allows the user to attach to a build environment using the `cntr` command. Upon build error it will print instructions on how to use `cntr`, which can be used to enter the environment for debugging. Installing cntr and running the command will provide shell access to the build sandbox of failed build. At `/var/lib/cntr` the sandboxed filesystem is mounted. All commands and files of the system are still accessible within the shell. To execute commands from the sandbox use the cntr exec subcommand. `cntr` is only supported on Linux-based platforms. To use it first add `cntr` to your `environment.systemPackages` on NixOS or alternatively to the root user on non-NixOS systems. Then in the package that is supposed to be inspected, add `breakpointHook` to `nativeBuildInputs`.
+
+```nix
+nativeBuildInputs = [ breakpointHook ];
+```
+
+When a build failure happens there will be an instruction printed that shows how to attach with `cntr` to the build sandbox.
+
+::: {.note}
+::: {.title}
+Caution with remote builds
+:::
+
+This won’t work with remote builds as the build environment is on a different machine and can’t be accessed by `cntr`. Remote builds can be turned off by setting `--option builders ''` for `nix-build` or `--builders ''` for `nix build`.
+:::
+
+### installShellFiles {#installshellfiles}
+
+This hook helps with installing manpages and shell completion files. It exposes 2 shell functions `installManPage` and `installShellCompletion` that can be used from your `postInstall` hook.
+
+The `installManPage` function takes one or more paths to manpages to install. The manpages must have a section suffix, and may optionally be compressed (with `.gz` suffix). This function will place them into the correct directory.
+
+The `installShellCompletion` function takes one or more paths to shell completion files. By default it will autodetect the shell type from the completion file extension, but you may also specify it by passing one of `--bash`, `--fish`, or `--zsh`. These flags apply to all paths listed after them (up until another shell flag is given). Each path may also have a custom installation name provided by providing a flag `--name NAME` before the path. If this flag is not provided, zsh completions will be renamed automatically such that `foobar.zsh` becomes `_foobar`. A root name may be provided for all paths using the flag `--cmd NAME`; this synthesizes the appropriate name depending on the shell (e.g. `--cmd foo` will synthesize the name `foo.bash` for bash and `_foo` for zsh). The path may also be a fifo or named fd (such as produced by `<(cmd)`), in which case the shell and name must be provided.
+
+```nix
+nativeBuildInputs = [ installShellFiles ];
+postInstall = ''
+  installManPage doc/foobar.1 doc/barfoo.3
+  # explicit behavior
+  installShellCompletion --bash --name foobar.bash share/completions.bash
+  installShellCompletion --fish --name foobar.fish share/completions.fish
+  installShellCompletion --zsh --name _foobar share/completions.zsh
+  # implicit behavior
+  installShellCompletion share/completions/foobar.{bash,fish,zsh}
+  # using named fd
+  installShellCompletion --cmd foobar \
+    --bash <($out/bin/foobar --bash-completion) \
+    --fish <($out/bin/foobar --fish-completion) \
+    --zsh <($out/bin/foobar --zsh-completion)
+'';
+```
+
+### libiconv, libintl {#libiconv-libintl}
+
+A few libraries automatically add to `NIX_LDFLAGS` their library, making their symbols automatically available to the linker. This includes libiconv and libintl (gettext). This is done to provide compatibility between GNU Linux, where libiconv and libintl are bundled in, and other systems where that might not be the case. Sometimes, this behavior is not desired. To disable this behavior, set `dontAddExtraLibs`.
+
+### validatePkgConfig {#validatepkgconfig}
+
+The `validatePkgConfig` hook validates all pkg-config (`.pc`) files in a package. This helps catching some common errors in pkg-config files, such as undefined variables.
+
+### cmake {#cmake}
+
+Overrides the default configure phase to run the CMake command. By default, we use the Make generator of CMake. In addition, dependencies are added automatically to CMAKE_PREFIX_PATH so that packages are correctly detected by CMake. Some additional flags are passed in to give similar behavior to configure-based packages. You can disable this hook’s behavior by setting configurePhase to a custom value, or by setting dontUseCmakeConfigure. cmakeFlags controls flags passed only to CMake. By default, parallel building is enabled as CMake supports parallel building almost everywhere. When Ninja is also in use, CMake will detect that and use the ninja generator.
+
+### xcbuildHook {#xcbuildhook}
+
+Overrides the build and install phases to run the "xcbuild" command. This hook is needed when a project only comes with build files for the XCode build system. You can disable this behavior by setting buildPhase and configurePhase to a custom value. xcbuildFlags controls flags passed only to xcbuild.
+
+### Meson {#meson}
+
+Overrides the configure phase to run meson to generate Ninja files. To run these files, you should accompany Meson with ninja. By default, `enableParallelBuilding` is enabled as Meson supports parallel building almost everywhere.
+
+#### Variables controlling Meson {#variables-controlling-meson}
+
+##### `mesonFlags` {#mesonflags}
+
+Controls the flags passed to meson.
+
+##### `mesonBuildType` {#mesonbuildtype}
+
+Which [`--buildtype`](https://mesonbuild.com/Builtin-options.html#core-options) to pass to Meson. We default to `plain`.
+
+##### `mesonAutoFeatures` {#mesonautofeatures}
+
+What value to set [`-Dauto_features=`](https://mesonbuild.com/Builtin-options.html#core-options) to. We default to `enabled`.
+
+##### `mesonWrapMode` {#mesonwrapmode}
+
+What value to set [`-Dwrap_mode=`](https://mesonbuild.com/Builtin-options.html#core-options) to. We default to `nodownload` as we disallow network access.
+
+##### `dontUseMesonConfigure` {#dontusemesonconfigure}
+
+Disables using Meson’s `configurePhase`.
+
+### ninja {#ninja}
+
+Overrides the build, install, and check phase to run ninja instead of make. You can disable this behavior with the `dontUseNinjaBuild`, `dontUseNinjaInstall`, and `dontUseNinjaCheck`, respectively. Parallel building is enabled by default in Ninja.
+
+### unzip {#unzip}
+
+This setup hook will allow you to unzip .zip files specified in `$src`. There are many similar packages like `unrar`, `undmg`, etc.
+
+### wafHook {#wafhook}
+
+Overrides the configure, build, and install phases. This will run the “waf” script used by many projects. If `wafPath` (default `./waf`) doesn’t exist, it will copy the version of waf available in Nixpkgs. `wafFlags` can be used to pass flags to the waf script.
+
+### scons {#scons}
+
+Overrides the build, install, and check phases. This uses the scons build system as a replacement for make. scons does not provide a configure phase, so everything is managed at build and install time.
+
+## Purity in Nixpkgs {#sec-purity-in-nixpkgs}
+
+*Measures taken to prevent dependencies on packages outside the store, and what you can do to prevent them.*
+
+GCC doesn’t search in locations such as `/usr/include`. In fact, attempts to add such directories through the `-I` flag are filtered out. Likewise, the linker (from GNU binutils) doesn’t search in standard locations such as `/usr/lib`. Programs built on Linux are linked against a GNU C Library that likewise doesn’t search in the default system locations.
+
+## Hardening in Nixpkgs {#sec-hardening-in-nixpkgs}
+
+There are flags available to harden packages at compile or link-time. These can be toggled using the `stdenv.mkDerivation` parameters `hardeningDisable` and `hardeningEnable`.
+
+Both parameters take a list of flags as strings. The special `"all"` flag can be passed to `hardeningDisable` to turn off all hardening. These flags can also be used as environment variables for testing or development purposes.
+
+For more in-depth information on these hardening flags and hardening in general, refer to the [Debian Wiki](https://wiki.debian.org/Hardening), [Ubuntu Wiki](https://wiki.ubuntu.com/Security/Features), [Gentoo Wiki](https://wiki.gentoo.org/wiki/Project:Hardened), and the [Arch Wiki](https://wiki.archlinux.org/title/Security).
+
+### Hardening flags enabled by default {#sec-hardening-flags-enabled-by-default}
+
+The following flags are enabled by default and might require disabling with `hardeningDisable` if the program to package is incompatible.
+
+#### `format` {#format}
+
+Adds the `-Wformat -Wformat-security -Werror=format-security` compiler options. At present, this warns about calls to `printf` and `scanf` functions where the format string is not a string literal and there are no format arguments, as in `printf(foo);`. This may be a security hole if the format string came from untrusted input and contains `%n`.
+
+This needs to be turned off or fixed for errors similar to:
+
+```
+/tmp/nix-build-zynaddsubfx-2.5.2.drv-0/zynaddsubfx-2.5.2/src/UI/guimain.cpp:571:28: error: format not a string literal and no format arguments [-Werror=format-security]
+         printf(help_message);
+                            ^
+cc1plus: some warnings being treated as errors
+```
+
+#### `stackprotector` {#stackprotector}
+
+Adds the `-fstack-protector-strong --param ssp-buffer-size=4` compiler options. This adds safety checks against stack overwrites rendering many potential code injection attacks into aborting situations. In the best case this turns code injection vulnerabilities into denial of service or into non-issues (depending on the application).
+
+This needs to be turned off or fixed for errors similar to:
+
+```
+bin/blib.a(bios_console.o): In function `bios_handle_cup':
+/tmp/nix-build-ipxe-20141124-5cbdc41.drv-0/ipxe-5cbdc41/src/arch/i386/firmware/pcbios/bios_console.c:86: undefined reference to `__stack_chk_fail'
+```
+
+#### `fortify` {#fortify}
+
+Adds the `-O2 -D_FORTIFY_SOURCE=2` compiler options. During code generation the compiler knows a great deal of information about buffer sizes (where possible), and attempts to replace insecure unlimited length buffer function calls with length-limited ones. This is especially useful for old, crufty code. Additionally, format strings in writable memory that contain `%n` are blocked. If an application depends on such a format string, it will need to be worked around.
+
+Additionally, some warnings are enabled which might trigger build failures if compiler warnings are treated as errors in the package build. In this case, set `NIX_CFLAGS_COMPILE` to `-Wno-error=warning-type`.
+
+This needs to be turned off or fixed for errors similar to:
+
+```
+malloc.c:404:15: error: return type is an incomplete type
+malloc.c:410:19: error: storage size of 'ms' isn't known
+
+strdup.h:22:1: error: expected identifier or '(' before '__extension__'
+
+strsep.c:65:23: error: register name not specified for 'delim'
+
+installwatch.c:3751:5: error: conflicting types for '__open_2'
+
+fcntl2.h:50:4: error: call to '__open_missing_mode' declared with attribute error: open with O_CREAT or O_TMPFILE in second argument needs 3 arguments
+```
+
+#### `pic` {#pic}
+
+Adds the `-fPIC` compiler options. This options adds support for position independent code in shared libraries and thus making ASLR possible.
+
+Most notably, the Linux kernel, kernel modules and other code not running in an operating system environment like boot loaders won’t build with PIC enabled. The compiler will is most cases complain that PIC is not supported for a specific build.
+
+This needs to be turned off or fixed for assembler errors similar to:
+
+```
+ccbLfRgg.s: Assembler messages:
+ccbLfRgg.s:33: Error: missing or invalid displacement expression `private_key_len@GOTOFF'
+```
+
+#### `strictoverflow` {#strictoverflow}
+
+Signed integer overflow is undefined behaviour according to the C standard. If it happens, it is an error in the program as it should check for overflow before it can happen, not afterwards. GCC provides built-in functions to perform arithmetic with overflow checking, which are correct and faster than any custom implementation. As a workaround, the option `-fno-strict-overflow` makes gcc behave as if signed integer overflows were defined.
+
+This flag should not trigger any build or runtime errors.
+
+#### `relro` {#relro}
+
+Adds the `-z relro` linker option. During program load, several ELF memory sections need to be written to by the linker, but can be turned read-only before turning over control to the program. This prevents some GOT (and .dtors) overwrite attacks, but at least the part of the GOT used by the dynamic linker (.got.plt) is still vulnerable.
+
+This flag can break dynamic shared object loading. For instance, the module systems of Xorg and OpenCV are incompatible with this flag. In almost all cases the `bindnow` flag must also be disabled and incompatible programs typically fail with similar errors at runtime.
+
+#### `bindnow` {#bindnow}
+
+Adds the `-z bindnow` linker option. During program load, all dynamic symbols are resolved, allowing for the complete GOT to be marked read-only (due to `relro`). This prevents GOT overwrite attacks. For very large applications, this can incur some performance loss during initial load while symbols are resolved, but this shouldn’t be an issue for daemons.
+
+This flag can break dynamic shared object loading. For instance, the module systems of Xorg and PHP are incompatible with this flag. Programs incompatible with this flag often fail at runtime due to missing symbols, like:
+
+```
+intel_drv.so: undefined symbol: vgaHWFreeHWRec
+```
+
+### Hardening flags disabled by default {#sec-hardening-flags-disabled-by-default}
+
+The following flags are disabled by default and should be enabled with `hardeningEnable` for packages that take untrusted input like network services.
+
+#### `pie` {#pie}
+
+This flag is disabled by default for normal `glibc` based NixOS package builds, but enabled by default for `musl` based package builds.
+
+Adds the `-fPIE` compiler and `-pie` linker options. Position Independent Executables are needed to take advantage of Address Space Layout Randomization, supported by modern kernel versions. While ASLR can already be enforced for data areas in the stack and heap (brk and mmap), the code areas must be compiled as position-independent. Shared libraries already do this with the `pic` flag, so they gain ASLR automatically, but binary .text regions need to be build with `pie` to gain ASLR. When this happens, ROP attacks are much harder since there are no static locations to bounce off of during a memory corruption attack.
+
+Static libraries need to be compiled with `-fPIE` so that executables can link them in with the `-pie` linker option.
+If the libraries lack `-fPIE`, you will get the error `recompile with -fPIE`.
+
+[^footnote-stdenv-ignored-build-platform]: The build platform is ignored because it is a mere implementation detail of the package satisfying the dependency: As a general programming principle, dependencies are always *specified* as interfaces, not concrete implementation.
+[^footnote-stdenv-native-dependencies-in-path]: Currently, this means for native builds all dependencies are put on the `PATH`. But in the future that may not be the case for sake of matching cross: the platforms would be assumed to be unique for native and cross builds alike, so only the `depsBuild*` and `nativeBuildInputs` would be added to the `PATH`.
+[^footnote-stdenv-find-inputs-location]: The `findInputs` function, currently residing in `pkgs/stdenv/generic/setup.sh`, implements the propagation logic.
+[^footnote-stdenv-sys-lib-search-path]: It clears the `sys_lib_*search_path` variables in the Libtool script to prevent Libtool from using libraries in `/usr/lib` and such.
+[^footnote-stdenv-build-time-guessing-impurity]: Eventually these will be passed building natively as well, to improve determinism: build-time guessing, as is done today, is a risk of impurity.
+[^footnote-stdenv-per-platform-wrapper]: Each wrapper targets a single platform, so if binaries for multiple platforms are needed, the underlying binaries must be wrapped multiple times. As this is a property of the wrapper itself, the multiple wrappings are needed whether or not the same underlying binaries can target multiple platforms.
diff --git a/doc/stdenv/stdenv.xml b/doc/stdenv/stdenv.xml
deleted file mode 100644
index f97c2a145af..00000000000
--- a/doc/stdenv/stdenv.xml
+++ /dev/null
@@ -1,2406 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-stdenv">
- <title>The Standard Environment</title>
- <para>
-  The standard build environment in the Nix Packages collection provides an environment for building Unix packages that does a lot of common build tasks automatically. In fact, for Unix packages that use the standard <literal>./configure; make; make install</literal> build interface, you don’t need to write a build script at all; the standard environment does everything automatically. If <literal>stdenv</literal> doesn’t do what you need automatically, you can easily customise or override the various build phases.
- </para>
- <section xml:id="sec-using-stdenv">
-  <title>Using <literal>stdenv</literal></title>
-
-  <para>
-   To build a package with the standard environment, you use the function <varname>stdenv.mkDerivation</varname>, instead of the primitive built-in function <varname>derivation</varname>, e.g.
-<programlisting>
-stdenv.mkDerivation {
-  name = "libfoo-1.2.3";
-  src = fetchurl {
-    url = "http://example.org/libfoo-1.2.3.tar.bz2";
-    sha256 = "0x2g1jqygyr5wiwg4ma1nd7w4ydpy82z9gkcv8vh2v8dn3y58v5m";
-  };
-}</programlisting>
-   (<varname>stdenv</varname> needs to be in scope, so if you write this in a separate Nix expression from <filename>pkgs/all-packages.nix</filename>, you need to pass it as a function argument.) Specifying a <varname>name</varname> and a <varname>src</varname> is the absolute minimum Nix requires. For convenience, you can also use <varname>pname</varname> and <varname>version</varname> attributes and <literal>mkDerivation</literal> will automatically set <varname>name</varname> to <literal>"${pname}-${version}"</literal> by default. Since <link xlink:href="https://github.com/NixOS/rfcs/pull/35">RFC 0035</link>, this is preferred for packages in Nixpkgs, as it allows us to reuse the version easily:
-<programlisting>
-stdenv.mkDerivation rec {
-  pname = "libfoo";
-  version = "1.2.3";
-  src = fetchurl {
-    url = "http://example.org/libfoo-source-${version}.tar.bz2";
-    sha256 = "0x2g1jqygyr5wiwg4ma1nd7w4ydpy82z9gkcv8vh2v8dn3y58v5m";
-  };
-}</programlisting>
-  </para>
-
-  <para>
-   Many packages have dependencies that are not provided in the standard environment. It’s usually sufficient to specify those dependencies in the <varname>buildInputs</varname> attribute:
-<programlisting>
-stdenv.mkDerivation {
-  name = "libfoo-1.2.3";
-  ...
-  buildInputs = [libbar perl ncurses];
-}</programlisting>
-   This attribute ensures that the <filename>bin</filename> subdirectories of these packages appear in the <envar>PATH</envar> environment variable during the build, that their <filename>include</filename> subdirectories are searched by the C compiler, and so on. (See <xref linkend="ssec-setup-hooks"/> for details.)
-  </para>
-
-  <para>
-   Often it is necessary to override or modify some aspect of the build. To make this easier, the standard environment breaks the package build into a number of <emphasis>phases</emphasis>, all of which can be overridden or modified individually: unpacking the sources, applying patches, configuring, building, and installing. (There are some others; see <xref linkend="sec-stdenv-phases"/>.) For instance, a package that doesn’t supply a makefile but instead has to be compiled “manually” could be handled like this:
-<programlisting>
-stdenv.mkDerivation {
-  name = "fnord-4.5";
-  ...
-  buildPhase = ''
-    gcc foo.c -o foo
-  '';
-  installPhase = ''
-    mkdir -p $out/bin
-    cp foo $out/bin
-  '';
-}</programlisting>
-   (Note the use of <literal>''</literal>-style string literals, which are very convenient for large multi-line script fragments because they don’t need escaping of <literal>"</literal> and <literal>\</literal>, and because indentation is intelligently removed.)
-  </para>
-
-  <para>
-   There are many other attributes to customise the build. These are listed in <xref linkend="ssec-stdenv-attributes"/>.
-  </para>
-
-  <para>
-   While the standard environment provides a generic builder, you can still supply your own build script:
-<programlisting>
-stdenv.mkDerivation {
-  name = "libfoo-1.2.3";
-  ...
-  builder = ./builder.sh;
-}</programlisting>
-   where the builder can do anything it wants, but typically starts with
-<programlisting>
-source $stdenv/setup
-</programlisting>
-   to let <literal>stdenv</literal> set up the environment (e.g., process the <varname>buildInputs</varname>). If you want, you can still use <literal>stdenv</literal>’s generic builder:
-<programlisting>
-source $stdenv/setup
-
-buildPhase() {
-  echo "... this is my custom build phase ..."
-  gcc foo.c -o foo
-}
-
-installPhase() {
-  mkdir -p $out/bin
-  cp foo $out/bin
-}
-
-genericBuild
-</programlisting>
-  </para>
- </section>
- <section xml:id="sec-tools-of-stdenv">
-  <title>Tools provided by <literal>stdenv</literal></title>
-
-  <para>
-   The standard environment provides the following packages:
-   <itemizedlist>
-    <listitem>
-     <para>
-      The GNU C Compiler, configured with C and C++ support.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      GNU coreutils (contains a few dozen standard Unix commands).
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      GNU findutils (contains <command>find</command>).
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      GNU diffutils (contains <command>diff</command>, <command>cmp</command>).
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      GNU <command>sed</command>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      GNU <command>grep</command>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      GNU <command>awk</command>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      GNU <command>tar</command>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      <command>gzip</command>, <command>bzip2</command> and <command>xz</command>.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      GNU Make.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      Bash. This is the shell used for all builders in the Nix Packages collection. Not using <command>/bin/sh</command> removes a large source of portability problems.
-     </para>
-    </listitem>
-    <listitem>
-     <para>
-      The <command>patch</command> command.
-     </para>
-    </listitem>
-   </itemizedlist>
-  </para>
-
-  <para>
-   On Linux, <literal>stdenv</literal> also includes the <command>patchelf</command> utility.
-  </para>
- </section>
- <section xml:id="ssec-stdenv-dependencies">
-  <title>Specifying dependencies</title>
-
-  <para>
-   As described in the Nix manual, almost any <filename>*.drv</filename> store path in a derivation's attribute set will induce a dependency on that derivation. <varname>mkDerivation</varname>, however, takes a few attributes intended to, between them, include all the dependencies of a package. This is done both for structure and consistency, but also so that certain other setup can take place. For example, certain dependencies need their bin directories added to the <envar>PATH</envar>. That is built-in, but other setup is done via a pluggable mechanism that works in conjunction with these dependency attributes. See <xref linkend="ssec-setup-hooks"/> for details.
-  </para>
-
-  <para>
-   Dependencies can be broken down along three axes: their host and target platforms relative to the new derivation's, and whether they are propagated. The platform distinctions are motivated by cross compilation; see <xref linkend="chap-cross"/> for exactly what each platform means.
-   <footnote xml:id="footnote-stdenv-ignored-build-platform">
-    <para>
-     The build platform is ignored because it is a mere implementation detail of the package satisfying the dependency: As a general programming principle, dependencies are always <emphasis>specified</emphasis> as interfaces, not concrete implementation.
-    </para>
-   </footnote>
-   But even if one is not cross compiling, the platforms imply whether or not the dependency is needed at run-time or build-time, a concept that makes perfect sense outside of cross compilation. By default, the run-time/build-time distinction is just a hint for mental clarity, but with <varname>strictDeps</varname> set it is mostly enforced even in the native case.
-  </para>
-
-  <para>
-   The extension of <envar>PATH</envar> with dependencies, alluded to above, proceeds according to the relative platforms alone. The process is carried out only for dependencies whose host platform matches the new derivation's build platform i.e. dependencies which run on the platform where the new derivation will be built.
-   <footnote xml:id="footnote-stdenv-native-dependencies-in-path">
-    <para>
-     Currently, this means for native builds all dependencies are put on the <envar>PATH</envar>. But in the future that may not be the case for sake of matching cross: the platforms would be assumed to be unique for native and cross builds alike, so only the <varname>depsBuild*</varname> and <varname>nativeBuildInputs</varname> would be added to the <envar>PATH</envar>.
-    </para>
-   </footnote>
-   For each dependency <replaceable>dep</replaceable> of those dependencies, <filename><replaceable>dep</replaceable>/bin</filename>, if present, is added to the <envar>PATH</envar> environment variable.
-  </para>
-
-  <para>
-   The dependency is propagated when it forces some of its other-transitive (non-immediate) downstream dependencies to also take it on as an immediate dependency. Nix itself already takes a package's transitive dependencies into account, but this propagation ensures nixpkgs-specific infrastructure like setup hooks (mentioned above) also are run as if the propagated dependency.
-  </para>
-
-  <para>
-   It is important to note that dependencies are not necessarily propagated as the same sort of dependency that they were before, but rather as the corresponding sort so that the platform rules still line up. The exact rules for dependency propagation can be given by assigning to each dependency two integers based one how its host and target platforms are offset from the depending derivation's platforms. Those offsets are given below in the descriptions of each dependency list attribute. Algorithmically, we traverse propagated inputs, accumulating every propagated dependency's propagated dependencies and adjusting them to account for the "shift in perspective" described by the current dependency's platform offsets. This results in sort a transitive closure of the dependency relation, with the offsets being approximately summed when two dependency links are combined. We also prune transitive dependencies whose combined offsets go out-of-bounds, which can be viewed as a filter over that transitive closure removing dependencies that are blatantly absurd.
-  </para>
-
-  <para>
-   We can define the process precisely with <link xlink:href="https://en.wikipedia.org/wiki/Natural_deduction">Natural Deduction</link> using the inference rules. This probably seems a bit obtuse, but so is the bash code that actually implements it!
-   <footnote xml:id="footnote-stdenv-find-inputs-location">
-    <para>
-     The <function>findInputs</function> function, currently residing in <filename>pkgs/stdenv/generic/setup.sh</filename>, implements the propagation logic.
-    </para>
-   </footnote>
-   They're confusing in very different ways so... hopefully if something doesn't make sense in one presentation, it will in the other!
-<programlisting>
-let mapOffset(h, t, i) = i + (if i &lt;= 0 then h else t - 1)
-
-propagated-dep(h0, t0, A, B)
-propagated-dep(h1, t1, B, C)
-h0 + h1 in {-1, 0, 1}
-h0 + t1 in {-1, 0, 1}
--------------------------------------- Transitive property
-propagated-dep(mapOffset(h0, t0, h1),
-               mapOffset(h0, t0, t1),
-               A, C)</programlisting>
-<programlisting>
-let mapOffset(h, t, i) = i + (if i &lt;= 0 then h else t - 1)
-
-dep(h0, _, A, B)
-propagated-dep(h1, t1, B, C)
-h0 + h1 in {-1, 0, 1}
-h0 + t1 in {-1, 0, -1}
------------------------------ Take immediate dependencies' propagated dependencies
-propagated-dep(mapOffset(h0, t0, h1),
-               mapOffset(h0, t0, t1),
-               A, C)</programlisting>
-<programlisting>
-propagated-dep(h, t, A, B)
------------------------------ Propagated dependencies count as dependencies
-dep(h, t, A, B)</programlisting>
-   Some explanation of this monstrosity is in order. In the common case, the target offset of a dependency is the successor to the target offset: <literal>t = h + 1</literal>. That means that:
-<programlisting>
-let f(h, t, i) = i + (if i &lt;= 0 then h else t - 1)
-let f(h, h + 1, i) = i + (if i &lt;= 0 then h else (h + 1) - 1)
-let f(h, h + 1, i) = i + (if i &lt;= 0 then h else h)
-let f(h, h + 1, i) = i + h
-</programlisting>
-   This is where "sum-like" comes in from above: We can just sum all of the host offsets to get the host offset of the transitive dependency. The target offset is the transitive dependency is simply the host offset + 1, just as it was with the dependencies composed to make this transitive one; it can be ignored as it doesn't add any new information.
-  </para>
-
-  <para>
-   Because of the bounds checks, the uncommon cases are <literal>h = t</literal> and <literal>h + 2 = t</literal>. In the former case, the motivation for <function>mapOffset</function> is that since its host and target platforms are the same, no transitive dependency of it should be able to "discover" an offset greater than its reduced target offsets. <function>mapOffset</function> effectively "squashes" all its transitive dependencies' offsets so that none will ever be greater than the target offset of the original <literal>h = t</literal> package. In the other case, <literal>h + 1</literal> is skipped over between the host and target offsets. Instead of squashing the offsets, we need to "rip" them apart so no transitive dependencies' offset is that one.
-  </para>
-
-  <para>
-   Overall, the unifying theme here is that propagation shouldn't be introducing transitive dependencies involving platforms the depending package is unaware of. [One can imagine the dependending package asking for dependencies with the platforms it knows about; other platforms it doesn't know how to ask for. The platform description in that scenario is a kind of unforagable capability.] The offset bounds checking and definition of <function>mapOffset</function> together ensure that this is the case. Discovering a new offset is discovering a new platform, and since those platforms weren't in the derivation "spec" of the needing package, they cannot be relevant. From a capability perspective, we can imagine that the host and target platforms of a package are the capabilities a package requires, and the depending package must provide the capability to the dependency.
-  </para>
-
-  <variablelist>
-   <title>Variables specifying dependencies</title>
-   <varlistentry xml:id="var-stdenv-depsBuildBuild">
-    <term>
-     <varname>depsBuildBuild</varname>
-    </term>
-    <listitem>
-     <para>
-      A list of dependencies whose host and target platforms are the new derivation's build platform. This means a <literal>-1</literal> host and <literal>-1</literal> target offset from the new derivation's platforms. These are programs and libraries used at build time that produce programs and libraries also used at build time. If the dependency doesn't care about the target platform (i.e. isn't a compiler or similar tool), put it in <varname>nativeBuildInputs</varname> instead. The most common use of this <literal>buildPackages.stdenv.cc</literal>, the default C compiler for this role. That example crops up more than one might think in old commonly used C libraries.
-     </para>
-     <para>
-      Since these packages are able to be run at build-time, they are always added to the <envar>PATH</envar>, as described above. But since these packages are only guaranteed to be able to run then, they shouldn't persist as run-time dependencies. This isn't currently enforced, but could be in the future.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-nativeBuildInputs">
-    <term>
-     <varname>nativeBuildInputs</varname>
-    </term>
-    <listitem>
-     <para>
-      A list of dependencies whose host platform is the new derivation's build platform, and target platform is the new derivation's host platform. This means a <literal>-1</literal> host offset and <literal>0</literal> target offset from the new derivation's platforms. These are programs and libraries used at build-time that, if they are a compiler or similar tool, produce code to run at run-time—i.e. tools used to build the new derivation. If the dependency doesn't care about the target platform (i.e. isn't a compiler or similar tool), put it here, rather than in <varname>depsBuildBuild</varname> or <varname>depsBuildTarget</varname>. This could be called <varname>depsBuildHost</varname> but <varname>nativeBuildInputs</varname> is used for historical continuity.
-     </para>
-     <para>
-      Since these packages are able to be run at build-time, they are added to the <envar>PATH</envar>, as described above. But since these packages are only guaranteed to be able to run then, they shouldn't persist as run-time dependencies. This isn't currently enforced, but could be in the future.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-depsBuildTarget">
-    <term>
-     <varname>depsBuildTarget</varname>
-    </term>
-    <listitem>
-     <para>
-      A list of dependencies whose host platform is the new derivation's build platform, and target platform is the new derivation's target platform. This means a <literal>-1</literal> host offset and <literal>1</literal> target offset from the new derivation's platforms. These are programs used at build time that produce code to run with code produced by the depending package. Most commonly, these are tools used to build the runtime or standard library that the currently-being-built compiler will inject into any code it compiles. In many cases, the currently-being-built-compiler is itself employed for that task, but when that compiler won't run (i.e. its build and host platform differ) this is not possible. Other times, the compiler relies on some other tool, like binutils, that is always built separately so that the dependency is unconditional.
-     </para>
-     <para>
-      This is a somewhat confusing concept to wrap one’s head around, and for good reason. As the only dependency type where the platform offsets are not adjacent integers, it requires thinking of a bootstrapping stage <emphasis>two</emphasis> away from the current one. It and its use-case go hand in hand and are both considered poor form: try to not need this sort of dependency, and try to avoid building standard libraries and runtimes in the same derivation as the compiler produces code using them. Instead strive to build those like a normal library, using the newly-built compiler just as a normal library would. In short, do not use this attribute unless you are packaging a compiler and are sure it is needed.
-     </para>
-     <para>
-      Since these packages are able to run at build time, they are added to the <envar>PATH</envar>, as described above. But since these packages are only guaranteed to be able to run then, they shouldn't persist as run-time dependencies. This isn't currently enforced, but could be in the future.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-depsHostHost">
-    <term>
-     <varname>depsHostHost</varname>
-    </term>
-    <listitem>
-     <para>
-      A list of dependencies whose host and target platforms match the new derivation's host platform. This means a <literal>0</literal> host offset and <literal>0</literal> target offset from the new derivation's host platform. These are packages used at run-time to generate code also used at run-time. In practice, this would usually be tools used by compilers for macros or a metaprogramming system, or libraries used by the macros or metaprogramming code itself. It's always preferable to use a <varname>depsBuildBuild</varname> dependency in the derivation being built over a <varname>depsHostHost</varname> on the tool doing the building for this purpose.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-buildInputs">
-    <term>
-     <varname>buildInputs</varname>
-    </term>
-    <listitem>
-     <para>
-      A list of dependencies whose host platform and target platform match the new derivation's. This means a <literal>0</literal> host offset and a <literal>1</literal> target offset from the new derivation's host platform. This would be called <varname>depsHostTarget</varname> but for historical continuity. If the dependency doesn't care about the target platform (i.e. isn't a compiler or similar tool), put it here, rather than in <varname>depsBuildBuild</varname>.
-     </para>
-     <para>
-      These are often programs and libraries used by the new derivation at <emphasis>run</emphasis>-time, but that isn't always the case. For example, the machine code in a statically-linked library is only used at run-time, but the derivation containing the library is only needed at build-time. Even in the dynamic case, the library may also be needed at build-time to appease the linker.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-depsTargetTarget">
-    <term>
-     <varname>depsTargetTarget</varname>
-    </term>
-    <listitem>
-     <para>
-      A list of dependencies whose host platform matches the new derivation's target platform. This means a <literal>1</literal> offset from the new derivation's platforms. These are packages that run on the target platform, e.g. the standard library or run-time deps of standard library that a compiler insists on knowing about. It's poor form in almost all cases for a package to depend on another from a future stage [future stage corresponding to positive offset]. Do not use this attribute unless you are packaging a compiler and are sure it is needed.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-depsBuildBuildPropagated">
-    <term>
-     <varname>depsBuildBuildPropagated</varname>
-    </term>
-    <listitem>
-     <para>
-      The propagated equivalent of <varname>depsBuildBuild</varname>. This perhaps never ought to be used, but it is included for consistency [see below for the others].
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-propagatedNativeBuildInputs">
-    <term>
-     <varname>propagatedNativeBuildInputs</varname>
-    </term>
-    <listitem>
-     <para>
-      The propagated equivalent of <varname>nativeBuildInputs</varname>. This would be called <varname>depsBuildHostPropagated</varname> but for historical continuity. For example, if package <varname>Y</varname> has <literal>propagatedNativeBuildInputs = [X]</literal>, and package <varname>Z</varname> has <literal>buildInputs = [Y]</literal>, then package <varname>Z</varname> will be built as if it included package <varname>X</varname> in its <varname>nativeBuildInputs</varname>. If instead, package <varname>Z</varname> has <literal>nativeBuildInputs = [Y]</literal>, then <varname>Z</varname> will be built as if it included <varname>X</varname> in the <varname>depsBuildBuild</varname> of package <varname>Z</varname>, because of the sum of the two <literal>-1</literal> host offsets.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-depsBuildTargetPropagated">
-    <term>
-     <varname>depsBuildTargetPropagated</varname>
-    </term>
-    <listitem>
-     <para>
-      The propagated equivalent of <varname>depsBuildTarget</varname>. This is prefixed for the same reason of alerting potential users.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-depsHostHostPropagated">
-    <term>
-     <varname>depsHostHostPropagated</varname>
-    </term>
-    <listitem>
-     <para>
-      The propagated equivalent of <varname>depsHostHost</varname>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-propagatedBuildInputs">
-    <term>
-     <varname>propagatedBuildInputs</varname>
-    </term>
-    <listitem>
-     <para>
-      The propagated equivalent of <varname>buildInputs</varname>. This would be called <varname>depsHostTargetPropagated</varname> but for historical continuity.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-stdenv-depsTargetTargetPropagated">
-    <term>
-     <varname>depsTargetTargetPropagated</varname>
-    </term>
-    <listitem>
-     <para>
-      The propagated equivalent of <varname>depsTargetTarget</varname>. This is prefixed for the same reason of alerting potential users.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
- </section>
- <section xml:id="ssec-stdenv-attributes">
-  <title>Attributes</title>
-
-  <variablelist>
-   <title>Variables affecting <literal>stdenv</literal> initialisation</title>
-   <varlistentry xml:id="var-stdenv-NIX_DEBUG">
-    <term>
-     <varname>NIX_DEBUG</varname>
-    </term>
-    <listitem>
-     <para>
-      A natural number indicating how much information to log. If set to 1 or higher, <literal>stdenv</literal> will print moderate debugging information during the build. In particular, the <command>gcc</command> and <command>ld</command> wrapper scripts will print out the complete command line passed to the wrapped tools. If set to 6 or higher, the <literal>stdenv</literal> setup script will be run with <literal>set -x</literal> tracing. If set to 7 or higher, the <command>gcc</command> and <command>ld</command> wrapper scripts will also be run with <literal>set -x</literal> tracing.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
-
-  <variablelist>
-   <title>Attributes affecting build properties</title>
-   <varlistentry xml:id="var-stdenv-enableParallelBuilding">
-    <term>
-     <varname>enableParallelBuilding</varname>
-    </term>
-    <listitem>
-     <para>
-      If set to <literal>true</literal>, <literal>stdenv</literal> will pass specific flags to <literal>make</literal> and other build tools to enable parallel building with up to <literal>build-cores</literal> workers.
-     </para>
-     <para>
-      Unless set to <literal>false</literal>, some build systems with good support for parallel building including <literal>cmake</literal>, <literal>meson</literal>, and <literal>qmake</literal> will set it to <literal>true</literal>.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
-
-  <variablelist>
-   <title>Special variables</title>
-   <varlistentry xml:id="var-stdenv-passthru">
-    <term>
-     <varname>passthru</varname>
-    </term>
-    <listitem>
-     <para>
-      This is an attribute set which can be filled with arbitrary values. For example:
-<programlisting>
-passthru = {
-  foo = "bar";
-  baz = {
-    value1 = 4;
-    value2 = 5;
-  };
-}
-</programlisting>
-     </para>
-     <para>
-      Values inside it are not passed to the builder, so you can change them without triggering a rebuild. However, they can be accessed outside of a derivation directly, as if they were set inside a derivation itself, e.g. <literal>hello.baz.value1</literal>. We don't specify any usage or schema of <literal>passthru</literal> - it is meant for values that would be useful outside the derivation in other parts of a Nix expression (e.g. in other derivations). An example would be to convey some specific dependency of your derivation which contains a program with plugins support. Later, others who make derivations with plugins can use passed-through dependency to ensure that their plugin would be binary-compatible with built program.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id="var-passthru-updateScript">
-    <term>
-     <varname>passthru.updateScript</varname>
-    </term>
-    <listitem>
-     <para>
-      A script to be run by <filename>maintainers/scripts/update.nix</filename> when the package is matched. It needs to be an executable file, either on the file system:
-<programlisting>
-passthru.updateScript = ./update.sh;
-</programlisting>
-      or inside the expression itself:
-<programlisting>
-passthru.updateScript = writeScript "update-zoom-us" ''
-  #!/usr/bin/env nix-shell
-  #!nix-shell -i bash -p curl pcre common-updater-scripts
-
-  set -eu -o pipefail
-
-  version="$(curl -sI https://zoom.us/client/latest/zoom_x86_64.tar.xz | grep -Fi 'Location:' | pcregrep -o1 '/(([0-9]\.?)+)/')"
-  update-source-version zoom-us "$version"
-'';
-</programlisting>
-      The attribute can also contain a list, a script followed by arguments to be passed to it:
-<programlisting>
-passthru.updateScript = [ ../../update.sh pname "--requested-release=unstable" ];
-</programlisting>
-     </para>
-     <para>
-      The script will be usually run from the root of the Nixpkgs repository but you should not rely on that. Also note that the update scripts will be run in parallel by default; you should avoid running <command>git commit</command> or any other commands that cannot handle that.
-     </para>
-     <para>
-      For information about how to run the updates, execute <command>nix-shell maintainers/scripts/update.nix</command>.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
- </section>
- <section xml:id="sec-stdenv-phases">
-  <title>Phases</title>
-
-  <para>
-   The generic builder has a number of <emphasis>phases</emphasis>. Package builds are split into phases to make it easier to override specific parts of the build (e.g., unpacking the sources or installing the binaries). Furthermore, it allows a nicer presentation of build logs in the Nix build farm.
-  </para>
-
-  <para>
-   Each phase can be overridden in its entirety either by setting the environment variable <varname><replaceable>name</replaceable>Phase</varname> to a string containing some shell commands to be executed, or by redefining the shell function <varname><replaceable>name</replaceable>Phase</varname>. The former is convenient to override a phase from the derivation, while the latter is convenient from a build script. However, typically one only wants to <emphasis>add</emphasis> some commands to a phase, e.g. by defining <literal>postInstall</literal> or <literal>preFixup</literal>, as skipping some of the default actions may have unexpected consequences. The default script for each phase is defined in the file <filename>pkgs/stdenv/generic/setup.sh</filename>.
-  </para>
-
-  <section xml:id="ssec-controlling-phases">
-   <title>Controlling phases</title>
-
-   <para>
-    There are a number of variables that control what phases are executed and in what order:
-    <variablelist>
-     <title>Variables affecting phase control</title>
-     <varlistentry xml:id="var-stdenv-phases">
-      <term>
-       <varname>phases</varname>
-      </term>
-      <listitem>
-       <para>
-        Specifies the phases. You can change the order in which phases are executed, or add new phases, by setting this variable. If it’s not set, the default value is used, which is <literal>$prePhases unpackPhase patchPhase $preConfigurePhases configurePhase $preBuildPhases buildPhase checkPhase $preInstallPhases installPhase fixupPhase installCheckPhase $preDistPhases distPhase $postPhases</literal>.
-       </para>
-       <para>
-        Usually, if you just want to add a few phases, it’s more convenient to set one of the variables below (such as <varname>preInstallPhases</varname>), as you then don’t specify all the normal phases.
-       </para>
-      </listitem>
-     </varlistentry>
-     <varlistentry xml:id="var-stdenv-prePhases">
-      <term>
-       <varname>prePhases</varname>
-      </term>
-      <listitem>
-       <para>
-        Additional phases executed before any of the default phases.
-       </para>
-      </listitem>
-     </varlistentry>
-     <varlistentry xml:id="var-stdenv-preConfigurePhases">
-      <term>
-       <varname>preConfigurePhases</varname>
-      </term>
-      <listitem>
-       <para>
-        Additional phases executed just before the configure phase.
-       </para>
-      </listitem>
-     </varlistentry>
-     <varlistentry xml:id="var-stdenv-preBuildPhases">
-      <term>
-       <varname>preBuildPhases</varname>
-      </term>
-      <listitem>
-       <para>
-        Additional phases executed just before the build phase.
-       </para>
-      </listitem>
-     </varlistentry>
-     <varlistentry xml:id="var-stdenv-preInstallPhases">
-      <term>
-       <varname>preInstallPhases</varname>
-      </term>
-      <listitem>
-       <para>
-        Additional phases executed just before the install phase.
-       </para>
-      </listitem>
-     </varlistentry>
-     <varlistentry xml:id="var-stdenv-preFixupPhases">
-      <term>
-       <varname>preFixupPhases</varname>
-      </term>
-      <listitem>
-       <para>
-        Additional phases executed just before the fixup phase.
-       </para>
-      </listitem>
-     </varlistentry>
-     <varlistentry xml:id="var-stdenv-preDistPhases">
-      <term>
-       <varname>preDistPhases</varname>
-      </term>
-      <listitem>
-       <para>
-        Additional phases executed just before the distribution phase.
-       </para>
-      </listitem>
-     </varlistentry>
-     <varlistentry xml:id="var-stdenv-postPhases">
-      <term>
-       <varname>postPhases</varname>
-      </term>
-      <listitem>
-       <para>
-        Additional phases executed after any of the default phases.
-       </para>
-      </listitem>
-     </varlistentry>
-    </variablelist>
-   </para>
-  </section>
-
-  <section xml:id="ssec-unpack-phase">
-   <title>The unpack phase</title>
-
-   <para>
-    The unpack phase is responsible for unpacking the source code of the package. The default implementation of <function>unpackPhase</function> unpacks the source files listed in the <envar>src</envar> environment variable to the current directory. It supports the following files by default:
-    <variablelist>
-     <varlistentry>
-      <term>
-       Tar files
-      </term>
-      <listitem>
-       <para>
-        These can optionally be compressed using <command>gzip</command> (<filename>.tar.gz</filename>, <filename>.tgz</filename> or <filename>.tar.Z</filename>), <command>bzip2</command> (<filename>.tar.bz2</filename>, <filename>.tbz2</filename> or <filename>.tbz</filename>) or <command>xz</command> (<filename>.tar.xz</filename>, <filename>.tar.lzma</filename> or <filename>.txz</filename>).
-       </para>
-      </listitem>
-     </varlistentry>
-     <varlistentry>
-      <term>
-       Zip files
-      </term>
-      <listitem>
-       <para>
-        Zip files are unpacked using <command>unzip</command>. However, <command>unzip</command> is not in the standard environment, so you should add it to <varname>nativeBuildInputs</varname> yourself.
-       </para>
-      </listitem>
-     </varlistentry>
-     <varlistentry>
-      <term>
-       Directories in the Nix store
-      </term>
-      <listitem>
-       <para>
-        These are simply copied to the current directory. The hash part of the file name is stripped, e.g. <filename>/nix/store/1wydxgby13cz...-my-sources</filename> would be copied to <filename>my-sources</filename>.
-       </para>
-      </listitem>
-     </varlistentry>
-    </variablelist>
-    Additional file types can be supported by setting the <varname>unpackCmd</varname> variable (see below).
-   </para>
-
-   <para></para>
-
-   <variablelist>
-    <title>Variables controlling the unpack phase</title>
-    <varlistentry xml:id="var-stdenv-src">
-     <term>
-      <varname>srcs</varname> / <varname>src</varname>
-     </term>
-     <listitem>
-      <para>
-       The list of source files or directories to be unpacked or copied. One of these must be set.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-sourceRoot">
-     <term>
-      <varname>sourceRoot</varname>
-     </term>
-     <listitem>
-      <para>
-       After running <function>unpackPhase</function>, the generic builder changes the current directory to the directory created by unpacking the sources. If there are multiple source directories, you should set <varname>sourceRoot</varname> to the name of the intended directory.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-setSourceRoot">
-     <term>
-      <varname>setSourceRoot</varname>
-     </term>
-     <listitem>
-      <para>
-       Alternatively to setting <varname>sourceRoot</varname>, you can set <varname>setSourceRoot</varname> to a shell command to be evaluated by the unpack phase after the sources have been unpacked. This command must set <varname>sourceRoot</varname>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-preUnpack">
-     <term>
-      <varname>preUnpack</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the start of the unpack phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-postUnpack">
-     <term>
-      <varname>postUnpack</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the end of the unpack phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontUnpack">
-     <term>
-      <varname>dontUnpack</varname>
-     </term>
-     <listitem>
-      <para>
-       Set to true to skip the unpack phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontMakeSourcesWritable">
-     <term>
-      <varname>dontMakeSourcesWritable</varname>
-     </term>
-     <listitem>
-      <para>
-       If set to <literal>1</literal>, the unpacked sources are <emphasis>not</emphasis> made writable. By default, they are made writable to prevent problems with read-only sources. For example, copied store directories would be read-only without this.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-unpackCmd">
-     <term>
-      <varname>unpackCmd</varname>
-     </term>
-     <listitem>
-      <para>
-       The unpack phase evaluates the string <literal>$unpackCmd</literal> for any unrecognised file. The path to the current source file is contained in the <varname>curSrc</varname> variable.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
-
-  <section xml:id="ssec-patch-phase">
-   <title>The patch phase</title>
-
-   <para>
-    The patch phase applies the list of patches defined in the <varname>patches</varname> variable.
-   </para>
-
-   <variablelist>
-    <title>Variables controlling the patch phase</title>
-    <varlistentry xml:id="var-stdenv-dontPatch">
-     <term>
-      <varname>dontPatch</varname>
-     </term>
-     <listitem>
-      <para>
-       Set to true to skip the patch phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-patches">
-     <term>
-      <varname>patches</varname>
-     </term>
-     <listitem>
-      <para>
-       The list of patches. They must be in the format accepted by the <command>patch</command> command, and may optionally be compressed using <command>gzip</command> (<filename>.gz</filename>), <command>bzip2</command> (<filename>.bz2</filename>) or <command>xz</command> (<filename>.xz</filename>).
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-patchFlags">
-     <term>
-      <varname>patchFlags</varname>
-     </term>
-     <listitem>
-      <para>
-       Flags to be passed to <command>patch</command>. If not set, the argument <option>-p1</option> is used, which causes the leading directory component to be stripped from the file names in each patch.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-prePatch">
-     <term>
-      <varname>prePatch</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the start of the patch phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-postPatch">
-     <term>
-      <varname>postPatch</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the end of the patch phase.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
-
-  <section xml:id="ssec-configure-phase">
-   <title>The configure phase</title>
-
-   <para>
-    The configure phase prepares the source tree for building. The default <function>configurePhase</function> runs <filename>./configure</filename> (typically an Autoconf-generated script) if it exists.
-   </para>
-
-   <variablelist>
-    <title>Variables controlling the configure phase</title>
-    <varlistentry xml:id="var-stdenv-configureScript">
-     <term>
-      <varname>configureScript</varname>
-     </term>
-     <listitem>
-      <para>
-       The name of the configure script. It defaults to <filename>./configure</filename> if it exists; otherwise, the configure phase is skipped. This can actually be a command (like <literal>perl ./Configure.pl</literal>).
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-configureFlags">
-     <term>
-      <varname>configureFlags</varname>
-     </term>
-     <listitem>
-      <para>
-       A list of strings passed as additional arguments to the configure script.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontConfigure">
-     <term>
-      <varname>dontConfigure</varname>
-     </term>
-     <listitem>
-      <para>
-       Set to true to skip the configure phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-configureFlagsArray">
-     <term>
-      <varname>configureFlagsArray</varname>
-     </term>
-     <listitem>
-      <para>
-       A shell array containing additional arguments passed to the configure script. You must use this instead of <varname>configureFlags</varname> if the arguments contain spaces.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontAddPrefix">
-     <term>
-      <varname>dontAddPrefix</varname>
-     </term>
-     <listitem>
-      <para>
-       By default, the flag <literal>--prefix=$prefix</literal> is added to the configure flags. If this is undesirable, set this variable to true.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-prefix">
-     <term>
-      <varname>prefix</varname>
-     </term>
-     <listitem>
-      <para>
-       The prefix under which the package must be installed, passed via the <option>--prefix</option> option to the configure script. It defaults to <option>$out</option>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-prefixKey">
-     <term>
-      <varname>prefixKey</varname>
-     </term>
-     <listitem>
-      <para>
-       The key to use when specifying the prefix. By default, this is set to <option>--prefix=</option> as that is used by the majority of packages.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontAddDisableDepTrack">
-     <term>
-      <varname>dontAddDisableDepTrack</varname>
-     </term>
-     <listitem>
-      <para>
-       By default, the flag <literal>--disable-dependency-tracking</literal> is added to the configure flags to speed up Automake-based builds. If this is undesirable, set this variable to true.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontFixLibtool">
-     <term>
-      <varname>dontFixLibtool</varname>
-     </term>
-     <listitem>
-      <para>
-       By default, the configure phase applies some special hackery to all files called <filename>ltmain.sh</filename> before running the configure script in order to improve the purity of Libtool-based packages
-       <footnote xml:id="footnote-stdenv-sys-lib-search-path">
-        <para>
-         It clears the <varname>sys_lib_<replaceable>*</replaceable>search_path</varname> variables in the Libtool script to prevent Libtool from using libraries in <filename>/usr/lib</filename> and such.
-        </para>
-       </footnote>
-       . If this is undesirable, set this variable to true.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontDisableStatic">
-     <term>
-      <varname>dontDisableStatic</varname>
-     </term>
-     <listitem>
-      <para>
-       By default, when the configure script has <option>--enable-static</option>, the option <option>--disable-static</option> is added to the configure flags.
-      </para>
-      <para>
-       If this is undesirable, set this variable to true.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-configurePlatforms">
-     <term>
-      <varname>configurePlatforms</varname>
-     </term>
-     <listitem>
-      <para>
-       By default, when cross compiling, the configure script has <option>--build=...</option> and <option>--host=...</option> passed. Packages can instead pass <literal>[ "build" "host" "target" ]</literal> or a subset to control exactly which platform flags are passed. Compilers and other tools can use this to also pass the target platform.
-       <footnote xml:id="footnote-stdenv-build-time-guessing-impurity">
-        <para>
-         Eventually these will be passed building natively as well, to improve determinism: build-time guessing, as is done today, is a risk of impurity.
-        </para>
-       </footnote>
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-preConfigure">
-     <term>
-      <varname>preConfigure</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the start of the configure phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-postConfigure">
-     <term>
-      <varname>postConfigure</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the end of the configure phase.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
-
-  <section xml:id="build-phase">
-   <title>The build phase</title>
-
-   <para>
-    The build phase is responsible for actually building the package (e.g. compiling it). The default <function>buildPhase</function> simply calls <command>make</command> if a file named <filename>Makefile</filename>, <filename>makefile</filename> or <filename>GNUmakefile</filename> exists in the current directory (or the <varname>makefile</varname> is explicitly set); otherwise it does nothing.
-   </para>
-
-   <variablelist>
-    <title>Variables controlling the build phase</title>
-    <varlistentry xml:id="var-stdenv-dontBuild">
-     <term>
-      <varname>dontBuild</varname>
-     </term>
-     <listitem>
-      <para>
-       Set to true to skip the build phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-makefile">
-     <term>
-      <varname>makefile</varname>
-     </term>
-     <listitem>
-      <para>
-       The file name of the Makefile.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-makeFlags">
-     <term>
-      <varname>makeFlags</varname>
-     </term>
-     <listitem>
-      <para>
-       A list of strings passed as additional flags to <command>make</command>. These flags are also used by the default install and check phase. For setting make flags specific to the build phase, use <varname>buildFlags</varname> (see below).
-<programlisting>
-makeFlags = [ "PREFIX=$(out)" ];
-</programlisting>
-       <note>
-        <para>
-         The flags are quoted in bash, but environment variables can be specified by using the make syntax.
-        </para>
-       </note>
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-makeFlagsArray">
-     <term>
-      <varname>makeFlagsArray</varname>
-     </term>
-     <listitem>
-      <para>
-       A shell array containing additional arguments passed to <command>make</command>. You must use this instead of <varname>makeFlags</varname> if the arguments contain spaces, e.g.
-<programlisting>
-preBuild = ''
-  makeFlagsArray+=(CFLAGS="-O0 -g" LDFLAGS="-lfoo -lbar")
-'';
-</programlisting>
-       Note that shell arrays cannot be passed through environment variables, so you cannot set <varname>makeFlagsArray</varname> in a derivation attribute (because those are passed through environment variables): you have to define them in shell code.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-buildFlags">
-     <term>
-      <varname>buildFlags</varname> / <varname>buildFlagsArray</varname>
-     </term>
-     <listitem>
-      <para>
-       A list of strings passed as additional flags to <command>make</command>. Like <varname>makeFlags</varname> and <varname>makeFlagsArray</varname>, but only used by the build phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-preBuild">
-     <term>
-      <varname>preBuild</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the start of the build phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-postBuild">
-     <term>
-      <varname>postBuild</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the end of the build phase.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-
-   <para>
-    You can set flags for <command>make</command> through the <varname>makeFlags</varname> variable.
-   </para>
-
-   <para>
-    Before and after running <command>make</command>, the hooks <varname>preBuild</varname> and <varname>postBuild</varname> are called, respectively.
-   </para>
-  </section>
-
-  <section xml:id="ssec-check-phase">
-   <title>The check phase</title>
-
-   <para>
-    The check phase checks whether the package was built correctly by running its test suite. The default <function>checkPhase</function> calls <command>make check</command>, but only if the <varname>doCheck</varname> variable is enabled.
-   </para>
-
-   <variablelist>
-    <title>Variables controlling the check phase</title>
-    <varlistentry xml:id="var-stdenv-doCheck">
-     <term>
-      <varname>doCheck</varname>
-     </term>
-     <listitem>
-      <para>
-       Controls whether the check phase is executed. By default it is skipped, but if <varname>doCheck</varname> is set to true, the check phase is usually executed. Thus you should set
-<programlisting>doCheck = true;</programlisting>
-       in the derivation to enable checks. The exception is cross compilation. Cross compiled builds never run tests, no matter how <varname>doCheck</varname> is set, as the newly-built program won't run on the platform used to build it.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>makeFlags</varname> / <varname>makeFlagsArray</varname> / <varname>makefile</varname>
-     </term>
-     <listitem>
-      <para>
-       See the <link xlink:href="#var-stdenv-makeFlags">build phase</link> for details.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-checkTarget">
-     <term>
-      <varname>checkTarget</varname>
-     </term>
-     <listitem>
-      <para>
-       The make target that runs the tests. Defaults to <literal>check</literal>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-checkFlags">
-     <term>
-      <varname>checkFlags</varname> / <varname>checkFlagsArray</varname>
-     </term>
-     <listitem>
-      <para>
-       A list of strings passed as additional flags to <command>make</command>. Like <varname>makeFlags</varname> and <varname>makeFlagsArray</varname>, but only used by the check phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-checkInputs">
-     <term>
-      <varname>checkInputs</varname>
-     </term>
-     <listitem>
-      <para>
-       A list of dependencies used by the phase. This gets included in <varname>nativeBuildInputs</varname> when <varname>doCheck</varname> is set.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-preCheck">
-     <term>
-      <varname>preCheck</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the start of the check phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-postCheck">
-     <term>
-      <varname>postCheck</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the end of the check phase.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
-
-  <section xml:id="ssec-install-phase">
-   <title>The install phase</title>
-
-   <para>
-    The install phase is responsible for installing the package in the Nix store under <envar>out</envar>. The default <function>installPhase</function> creates the directory <literal>$out</literal> and calls <command>make install</command>.
-   </para>
-
-   <variablelist>
-    <title>Variables controlling the install phase</title>
-     <varlistentry xml:id="var-stdenv-dontInstall">
-     <term>
-       <varname>dontInstall</varname>
-     </term>
-     <listitem>
-      <para>
-       Set to true to skip the install phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <varname>makeFlags</varname> / <varname>makeFlagsArray</varname> / <varname>makefile</varname>
-     </term>
-     <listitem>
-      <para>
-       See the <link xlink:href="#var-stdenv-makeFlags">build phase</link> for details.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-installTargets">
-     <term>
-      <varname>installTargets</varname>
-     </term>
-     <listitem>
-      <para>
-       The make targets that perform the installation. Defaults to <literal>install</literal>. Example:
-<programlisting>
-installTargets = "install-bin install-doc";</programlisting>
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-installFlags">
-     <term>
-      <varname>installFlags</varname> / <varname>installFlagsArray</varname>
-     </term>
-     <listitem>
-      <para>
-       A list of strings passed as additional flags to <command>make</command>. Like <varname>makeFlags</varname> and <varname>makeFlagsArray</varname>, but only used by the install phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-preInstall">
-     <term>
-      <varname>preInstall</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the start of the install phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-postInstall">
-     <term>
-      <varname>postInstall</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the end of the install phase.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
-
-  <section xml:id="ssec-fixup-phase">
-   <title>The fixup phase</title>
-
-   <para>
-    The fixup phase performs some (Nix-specific) post-processing actions on the files installed under <filename>$out</filename> by the install phase. The default <function>fixupPhase</function> does the following:
-    <itemizedlist>
-     <listitem>
-      <para>
-       It moves the <filename>man/</filename>, <filename>doc/</filename> and <filename>info/</filename> subdirectories of <envar>$out</envar> to <filename>share/</filename>.
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       It strips libraries and executables of debug information.
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       On Linux, it applies the <command>patchelf</command> command to ELF executables and libraries to remove unused directories from the <literal>RPATH</literal> in order to prevent unnecessary runtime dependencies.
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       It rewrites the interpreter paths of shell scripts to paths found in <envar>PATH</envar>. E.g., <filename>/usr/bin/perl</filename> will be rewritten to <filename>/nix/store/<replaceable>some-perl</replaceable>/bin/perl</filename> found in <envar>PATH</envar>.
-      </para>
-     </listitem>
-    </itemizedlist>
-   </para>
-
-   <variablelist>
-    <title>Variables controlling the fixup phase</title>
-    <varlistentry xml:id="var-stdenv-dontFixup">
-     <term>
-      <varname>dontFixup</varname>
-     </term>
-     <listitem>
-      <para>
-       Set to true to skip the fixup phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontStrip">
-     <term>
-      <varname>dontStrip</varname>
-     </term>
-     <listitem>
-      <para>
-       If set, libraries and executables are not stripped. By default, they are.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontStripHost">
-     <term>
-      <varname>dontStripHost</varname>
-     </term>
-     <listitem>
-      <para>
-       Like <varname>dontStrip</varname>, but only affects the <command>strip</command> command targetting the package's host platform. Useful when supporting cross compilation, but otherwise feel free to ignore.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontStripTarget">
-     <term>
-      <varname>dontStripTarget</varname>
-     </term>
-     <listitem>
-      <para>
-       Like <varname>dontStrip</varname>, but only affects the <command>strip</command> command targetting the packages' target platform. Useful when supporting cross compilation, but otherwise feel free to ignore.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontMoveSbin">
-     <term>
-      <varname>dontMoveSbin</varname>
-     </term>
-     <listitem>
-      <para>
-       If set, files in <filename>$out/sbin</filename> are not moved to <filename>$out/bin</filename>. By default, they are.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-stripAllList">
-     <term>
-      <varname>stripAllList</varname>
-     </term>
-     <listitem>
-      <para>
-       List of directories to search for libraries and executables from which <emphasis>all</emphasis> symbols should be stripped. By default, it’s empty. Stripping all symbols is risky, since it may remove not just debug symbols but also ELF information necessary for normal execution.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-stripAllFlags">
-     <term>
-      <varname>stripAllFlags</varname>
-     </term>
-     <listitem>
-      <para>
-       Flags passed to the <command>strip</command> command applied to the files in the directories listed in <varname>stripAllList</varname>. Defaults to <option>-s</option> (i.e. <option>--strip-all</option>).
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-stripDebugList">
-     <term>
-      <varname>stripDebugList</varname>
-     </term>
-     <listitem>
-      <para>
-       List of directories to search for libraries and executables from which only debugging-related symbols should be stripped. It defaults to <literal>lib lib32 lib64 libexec bin sbin</literal>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-stripDebugFlags">
-     <term>
-      <varname>stripDebugFlags</varname>
-     </term>
-     <listitem>
-      <para>
-       Flags passed to the <command>strip</command> command applied to the files in the directories listed in <varname>stripDebugList</varname>. Defaults to <option>-S</option> (i.e. <option>--strip-debug</option>).
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontPatchELF">
-     <term>
-      <varname>dontPatchELF</varname>
-     </term>
-     <listitem>
-      <para>
-       If set, the <command>patchelf</command> command is not used to remove unnecessary <literal>RPATH</literal> entries. Only applies to Linux.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontPatchShebangs">
-     <term>
-      <varname>dontPatchShebangs</varname>
-     </term>
-     <listitem>
-      <para>
-       If set, scripts starting with <literal>#!</literal> do not have their interpreter paths rewritten to paths in the Nix store.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontPruneLibtoolFiles">
-     <term>
-      <varname>dontPruneLibtoolFiles</varname>
-     </term>
-     <listitem>
-      <para>
-       If set, libtool <literal>.la</literal> files associated with shared libraries won't have their <literal>dependency_libs</literal> field cleared.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-forceShare">
-     <term>
-      <varname>forceShare</varname>
-     </term>
-     <listitem>
-      <para>
-       The list of directories that must be moved from <filename>$out</filename> to <filename>$out/share</filename>. Defaults to <literal>man doc info</literal>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-setupHook">
-     <term>
-      <varname>setupHook</varname>
-     </term>
-     <listitem>
-      <para>
-       A package can export a <link linkend="ssec-setup-hooks">setup hook</link> by setting this variable. The setup hook, if defined, is copied to <filename>$out/nix-support/setup-hook</filename>. Environment variables are then substituted in it using <function
-       linkend="fun-substituteAll">substituteAll</function>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-preFixup">
-     <term>
-      <varname>preFixup</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the start of the fixup phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-postFixup">
-     <term>
-      <varname>postFixup</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the end of the fixup phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="stdenv-separateDebugInfo">
-     <term>
-      <varname>separateDebugInfo</varname>
-     </term>
-     <listitem>
-      <para>
-       If set to <literal>true</literal>, the standard environment will enable debug information in C/C++ builds. After installation, the debug information will be separated from the executables and stored in the output named <literal>debug</literal>. (This output is enabled automatically; you don’t need to set the <varname>outputs</varname> attribute explicitly.) To be precise, the debug information is stored in <filename><replaceable>debug</replaceable>/lib/debug/.build-id/<replaceable>XX</replaceable>/<replaceable>YYYY…</replaceable></filename>, where <replaceable>XXYYYY…</replaceable> is the <replaceable>build ID</replaceable> of the binary — a SHA-1 hash of the contents of the binary. Debuggers like GDB use the build ID to look up the separated debug information.
-      </para>
-      <para>
-       For example, with GDB, you can add
-<programlisting>
-set debug-file-directory ~/.nix-profile/lib/debug
-</programlisting>
-       to <filename>~/.gdbinit</filename>. GDB will then be able to find debug information installed via <literal>nix-env -i</literal>.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
-
-  <section xml:id="ssec-installCheck-phase">
-   <title>The installCheck phase</title>
-
-   <para>
-    The installCheck phase checks whether the package was installed correctly by running its test suite against the installed directories. The default <function>installCheck</function> calls <command>make installcheck</command>.
-   </para>
-
-   <variablelist>
-    <title>Variables controlling the installCheck phase</title>
-    <varlistentry xml:id="var-stdenv-doInstallCheck">
-     <term>
-      <varname>doInstallCheck</varname>
-     </term>
-     <listitem>
-      <para>
-       Controls whether the installCheck phase is executed. By default it is skipped, but if <varname>doInstallCheck</varname> is set to true, the installCheck phase is usually executed. Thus you should set
-<programlisting>doInstallCheck = true;</programlisting>
-       in the derivation to enable install checks. The exception is cross compilation. Cross compiled builds never run tests, no matter how <varname>doInstallCheck</varname> is set, as the newly-built program won't run on the platform used to build it.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-installCheckTarget">
-     <term>
-      <varname>installCheckTarget</varname>
-     </term>
-     <listitem>
-      <para>
-       The make target that runs the install tests. Defaults to <literal>installcheck</literal>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-installCheckFlags">
-     <term>
-      <varname>installCheckFlags</varname> / <varname>installCheckFlagsArray</varname>
-     </term>
-     <listitem>
-      <para>
-       A list of strings passed as additional flags to <command>make</command>. Like <varname>makeFlags</varname> and <varname>makeFlagsArray</varname>, but only used by the installCheck phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-installCheckInputs">
-     <term>
-      <varname>installCheckInputs</varname>
-     </term>
-     <listitem>
-      <para>
-       A list of dependencies used by the phase. This gets included in <varname>nativeBuildInputs</varname> when <varname>doInstallCheck</varname> is set.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-preInstallCheck">
-     <term>
-      <varname>preInstallCheck</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the start of the installCheck phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-postInstallCheck">
-     <term>
-      <varname>postInstallCheck</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the end of the installCheck phase.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
-
-  <section xml:id="ssec-distribution-phase">
-   <title>The distribution phase</title>
-
-   <para>
-    The distribution phase is intended to produce a source distribution of the package. The default <function>distPhase</function> first calls <command>make dist</command>, then it copies the resulting source tarballs to <filename>$out/tarballs/</filename>. This phase is only executed if the attribute <varname>doDist</varname> is set.
-   </para>
-
-   <variablelist>
-    <title>Variables controlling the distribution phase</title>
-    <varlistentry xml:id="var-stdenv-distTarget">
-     <term>
-      <varname>distTarget</varname>
-     </term>
-     <listitem>
-      <para>
-       The make target that produces the distribution. Defaults to <literal>dist</literal>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-distFlags">
-     <term>
-      <varname>distFlags</varname> / <varname>distFlagsArray</varname>
-     </term>
-     <listitem>
-      <para>
-       Additional flags passed to <command>make</command>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-tarballs">
-     <term>
-      <varname>tarballs</varname>
-     </term>
-     <listitem>
-      <para>
-       The names of the source distribution files to be copied to <filename>$out/tarballs/</filename>. It can contain shell wildcards. The default is <filename>*.tar.gz</filename>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-dontCopyDist">
-     <term>
-      <varname>dontCopyDist</varname>
-     </term>
-     <listitem>
-      <para>
-       If set, no files are copied to <filename>$out/tarballs/</filename>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-preDist">
-     <term>
-      <varname>preDist</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the start of the distribution phase.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="var-stdenv-postDist">
-     <term>
-      <varname>postDist</varname>
-     </term>
-     <listitem>
-      <para>
-       Hook executed at the end of the distribution phase.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </section>
- </section>
- <section xml:id="ssec-stdenv-functions">
-  <title>Shell functions</title>
-
-  <para>
-   The standard environment provides a number of useful functions.
-  </para>
-
-  <variablelist>
-   <varlistentry xml:id='fun-makeWrapper'>
-    <term>
-     <function>makeWrapper</function> <replaceable>executable</replaceable> <replaceable>wrapperfile</replaceable> <replaceable>args</replaceable>
-    </term>
-    <listitem>
-     <para>
-      Constructs a wrapper for a program with various possible arguments. For example:
-<programlisting>
-# adds `FOOBAR=baz` to `$out/bin/foo`’s environment
-makeWrapper $out/bin/foo $wrapperfile --set FOOBAR baz
-
-# prefixes the binary paths of `hello` and `git`
-# Be advised that paths often should be patched in directly
-# (via string replacements or in `configurePhase`).
-makeWrapper $out/bin/foo $wrapperfile --prefix PATH : ${lib.makeBinPath [ hello git ]}
-</programlisting>
-      There’s many more kinds of arguments, they are documented in <literal>nixpkgs/pkgs/build-support/setup-hooks/make-wrapper.sh</literal>.
-     </para>
-     <para>
-      <literal>wrapProgram</literal> is a convenience function you probably want to use most of the time.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id='fun-substitute'>
-    <term>
-     <function>substitute</function> <replaceable>infile</replaceable> <replaceable>outfile</replaceable> <replaceable>subs</replaceable>
-    </term>
-    <listitem>
-     <para>
-      Performs string substitution on the contents of <replaceable>infile</replaceable>, writing the result to <replaceable>outfile</replaceable>. The substitutions in <replaceable>subs</replaceable> are of the following form:
-      <variablelist>
-       <varlistentry>
-        <term>
-         <option>--replace</option> <replaceable>s1</replaceable> <replaceable>s2</replaceable>
-        </term>
-        <listitem>
-         <para>
-          Replace every occurrence of the string <replaceable>s1</replaceable> by <replaceable>s2</replaceable>.
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         <option>--subst-var</option> <replaceable>varName</replaceable>
-        </term>
-        <listitem>
-         <para>
-          Replace every occurrence of <literal>@<replaceable>varName</replaceable>@</literal> by the contents of the environment variable <replaceable>varName</replaceable>. This is useful for generating files from templates, using <literal>@<replaceable>...</replaceable>@</literal> in the template as placeholders.
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         <option>--subst-var-by</option> <replaceable>varName</replaceable> <replaceable>s</replaceable>
-        </term>
-        <listitem>
-         <para>
-          Replace every occurrence of <literal>@<replaceable>varName</replaceable>@</literal> by the string <replaceable>s</replaceable>.
-         </para>
-        </listitem>
-       </varlistentry>
-      </variablelist>
-     </para>
-     <para>
-      Example:
-<programlisting>
-substitute ./foo.in ./foo.out \
-    --replace /usr/bin/bar $bar/bin/bar \
-    --replace "a string containing spaces" "some other text" \
-    --subst-var someVar
-</programlisting>
-     </para>
-     <para>
-      <function>substitute</function> is implemented using the <command
-      xlink:href="http://replace.richardlloyd.org.uk/">replace</command> command. Unlike with the <command>sed</command> command, you don’t have to worry about escaping special characters. It supports performing substitutions on binary files (such as executables), though there you’ll probably want to make sure that the replacement string is as long as the replaced string.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id='fun-substituteInPlace'>
-    <term>
-     <function>substituteInPlace</function> <replaceable>file</replaceable> <replaceable>subs</replaceable>
-    </term>
-    <listitem>
-     <para>
-      Like <function>substitute</function>, but performs the substitutions in place on the file <replaceable>file</replaceable>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id='fun-substituteAll'>
-    <term>
-     <function>substituteAll</function> <replaceable>infile</replaceable> <replaceable>outfile</replaceable>
-    </term>
-    <listitem>
-     <para>
-      Replaces every occurrence of <literal>@<replaceable>varName</replaceable>@</literal>, where <replaceable>varName</replaceable> is any environment variable, in <replaceable>infile</replaceable>, writing the result to <replaceable>outfile</replaceable>. For instance, if <replaceable>infile</replaceable> has the contents
-<programlisting>
-#! @bash@/bin/sh
-PATH=@coreutils@/bin
-echo @foo@
-</programlisting>
-      and the environment contains <literal>bash=/nix/store/bmwp0q28cf21...-bash-3.2-p39</literal> and <literal>coreutils=/nix/store/68afga4khv0w...-coreutils-6.12</literal>, but does not contain the variable <varname>foo</varname>, then the output will be
-<programlisting>
-#! /nix/store/bmwp0q28cf21...-bash-3.2-p39/bin/sh
-PATH=/nix/store/68afga4khv0w...-coreutils-6.12/bin
-echo @foo@
-</programlisting>
-      That is, no substitution is performed for undefined variables.
-     </para>
-     <para>
-      Environment variables that start with an uppercase letter or an underscore are filtered out, to prevent global variables (like <literal>HOME</literal>) or private variables (like <literal>__ETC_PROFILE_DONE</literal>) from accidentally getting substituted. The variables also have to be valid bash “names”, as defined in the bash manpage (alphanumeric or <literal>_</literal>, must not start with a number).
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id='fun-substituteAllInPlace'>
-    <term>
-     <function>substituteAllInPlace</function> <replaceable>file</replaceable>
-    </term>
-    <listitem>
-     <para>
-      Like <function>substituteAll</function>, but performs the substitutions in place on the file <replaceable>file</replaceable>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id='fun-stripHash'>
-    <term>
-     <function>stripHash</function> <replaceable>path</replaceable>
-    </term>
-    <listitem>
-     <para>
-      Strips the directory and hash part of a store path, outputting the name part to <literal>stdout</literal>. For example:
-<programlisting>
-# prints coreutils-8.24
-stripHash "/nix/store/9s9r019176g7cvn2nvcw41gsp862y6b4-coreutils-8.24"
-</programlisting>
-      If you wish to store the result in another variable, then the following idiom may be useful:
-<programlisting>
-name="/nix/store/9s9r019176g7cvn2nvcw41gsp862y6b4-coreutils-8.24"
-someVar=$(stripHash $name)
-</programlisting>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry xml:id='fun-wrapProgram'>
-    <term>
-     <function>wrapProgram</function> <replaceable>executable</replaceable> <replaceable>makeWrapperArgs</replaceable>
-    </term>
-    <listitem>
-     <para>
-      Convenience function for <literal>makeWrapper</literal> that automatically creates a sane wrapper file. It takes all the same arguments as <literal>makeWrapper</literal>, except for <literal>--argv0</literal>.
-     </para>
-     <para>
-      It cannot be applied multiple times, since it will overwrite the wrapper file.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
- </section>
- <section xml:id="ssec-setup-hooks">
-  <title>Package setup hooks</title>
-
-  <para>
-   Nix itself considers a build-time dependency as merely something that should previously be built and accessible at build time—packages themselves are on their own to perform any additional setup. In most cases, that is fine, and the downstream derivation can deal with its own dependencies. But for a few common tasks, that would result in almost every package doing the same sort of setup work—depending not on the package itself, but entirely on which dependencies were used.
-  </para>
-
-  <para>
-   In order to alleviate this burden, the <firstterm>setup hook</firstterm> mechanism was written, where any package can include a shell script that [by convention rather than enforcement by Nix], any downstream reverse-dependency will source as part of its build process. That allows the downstream dependency to merely specify its dependencies, and lets those dependencies effectively initialize themselves. No boilerplate mirroring the list of dependencies is needed.
-  </para>
-
-  <para>
-   The setup hook mechanism is a bit of a sledgehammer though: a powerful feature with a broad and indiscriminate area of effect. The combination of its power and implicit use may be expedient, but isn't without costs. Nix itself is unchanged, but the spirit of added dependencies being effect-free is violated even if the letter isn't. For example, if a derivation path is mentioned more than once, Nix itself doesn't care and simply makes sure the dependency derivation is already built just the same—depending is just needing something to exist, and needing is idempotent. However, a dependency specified twice will have its setup hook run twice, and that could easily change the build environment (though a well-written setup hook will therefore strive to be idempotent so this is in fact not observable). More broadly, setup hooks are anti-modular in that multiple dependencies, whether the same or different, should not interfere and yet their setup hooks may well do so.
-  </para>
-
-  <para>
-   The most typical use of the setup hook is actually to add other hooks which are then run (i.e. after all the setup hooks) on each dependency. For example, the C compiler wrapper's setup hook feeds itself flags for each dependency that contains relevant libraries and headers. This is done by defining a bash function, and appending its name to one of <envar>envBuildBuildHooks</envar>, <envar>envBuildHostHooks</envar>, <envar>envBuildTargetHooks</envar>, <envar>envHostHostHooks</envar>, <envar>envHostTargetHooks</envar>, or <envar>envTargetTargetHooks</envar>. These 6 bash variables correspond to the 6 sorts of dependencies by platform (there's 12 total but we ignore the propagated/non-propagated axis).
-  </para>
-
-  <para>
-   Packages adding a hook should not hard code a specific hook, but rather choose a variable <emphasis>relative</emphasis> to how they are included. Returning to the C compiler wrapper example, if the wrapper itself is an <literal>n</literal> dependency, then it only wants to accumulate flags from <literal>n + 1</literal> dependencies, as only those ones match the compiler's target platform. The <envar>hostOffset</envar> variable is defined with the current dependency's host offset <envar>targetOffset</envar> with its target offset, before its setup hook is sourced. Additionally, since most environment hooks don't care about the target platform, that means the setup hook can append to the right bash array by doing something like
-<programlisting language="bash">
-addEnvHooks "$hostOffset" myBashFunction
-</programlisting>
-  </para>
-
-  <para>
-   The <emphasis>existence</emphasis> of setups hooks has long been documented and packages inside Nixpkgs are free to use this mechanism. Other packages, however, should not rely on these mechanisms not changing between Nixpkgs versions. Because of the existing issues with this system, there's little benefit from mandating it be stable for any period of time.
-  </para>
-
-  <para>
-   First, let’s cover some setup hooks that are part of Nixpkgs default stdenv. This means that they are run for every package built using <function>stdenv.mkDerivation</function>. Some of these are platform specific, so they may run on Linux but not Darwin or vice-versa.
-   <variablelist>
-    <varlistentry>
-     <term>
-      <literal>move-docs.sh</literal>
-     </term>
-     <listitem>
-      <para>
-       This setup hook moves any installed documentation to the <literal>/share</literal> subdirectory directory. This includes the man, doc and info directories. This is needed for legacy programs that do not know how to use the <literal>share</literal> subdirectory.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <literal>compress-man-pages.sh</literal>
-     </term>
-     <listitem>
-      <para>
-       This setup hook compresses any man pages that have been installed. The compression is done using the gzip program. This helps to reduce the installed size of packages.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <literal>strip.sh</literal>
-     </term>
-     <listitem>
-      <para>
-       This runs the strip command on installed binaries and libraries. This removes unnecessary information like debug symbols when they are not needed. This also helps to reduce the installed size of packages.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <literal>patch-shebangs.sh</literal>
-     </term>
-     <listitem>
-      <para>
-       This setup hook patches installed scripts to use the full path to the shebang interpreter. A shebang interpreter is the first commented line of a script telling the operating system which program will run the script (e.g <literal>#!/bin/bash</literal>). In Nix, we want an exact path to that interpreter to be used. This often replaces <literal>/bin/sh</literal> with a path in the Nix store.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <literal>audit-tmpdir.sh</literal>
-     </term>
-     <listitem>
-      <para>
-       This verifies that no references are left from the install binaries to the directory used to build those binaries. This ensures that the binaries do not need things outside the Nix store. This is currently supported in Linux only.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <literal>multiple-outputs.sh</literal>
-     </term>
-     <listitem>
-      <para>
-       This setup hook adds configure flags that tell packages to install files into any one of the proper outputs listed in <literal>outputs</literal>. This behavior can be turned off by setting <literal>setOutputFlags</literal> to false in the derivation environment. See <xref linkend="chap-multiple-output"/> for more information.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <literal>move-sbin.sh</literal>
-     </term>
-     <listitem>
-      <para>
-       This setup hook moves any binaries installed in the sbin subdirectory into bin. In addition, a link is provided from sbin to bin for compatibility.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <literal>move-lib64.sh</literal>
-     </term>
-     <listitem>
-      <para>
-       This setup hook moves any libraries installed in the lib64 subdirectory into lib. In addition, a link is provided from lib64 to lib for compatibility.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      <literal>set-source-date-epoch-to-latest.sh</literal>
-     </term>
-     <listitem>
-      <para>
-       This sets <literal>SOURCE_DATE_EPOCH</literal> to the modification time of the most recent file.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      Bintools Wrapper
-     </term>
-     <listitem>
-      <para>
-       The Bintools Wrapper wraps the binary utilities for a bunch of miscellaneous purposes. These are GNU Binutils when targetting Linux, and a mix of cctools and GNU binutils for Darwin. [The "Bintools" name is supposed to be a compromise between "Binutils" and "cctools" not denoting any specific implementation.] Specifically, the underlying bintools package, and a C standard library (glibc or Darwin's libSystem, just for the dynamic loader) are all fed in, and dependency finding, hardening (see below), and purity checks for each are handled by the Bintools Wrapper. Packages typically depend on CC Wrapper, which in turn (at run time) depends on the Bintools Wrapper.
-      </para>
-      <para>
-       The Bintools Wrapper was only just recently split off from CC Wrapper, so the division of labor is still being worked out. For example, it shouldn't care about the C standard library, but just take a derivation with the dynamic loader (which happens to be the glibc on linux). Dependency finding however is a task both wrappers will continue to need to share, and probably the most important to understand. It is currently accomplished by collecting directories of host-platform dependencies (i.e. <varname>buildInputs</varname> and <varname>nativeBuildInputs</varname>) in environment variables. The Bintools Wrapper's setup hook causes any <filename>lib</filename> and <filename>lib64</filename> subdirectories to be added to <envar>NIX_LDFLAGS</envar>. Since the CC Wrapper and the Bintools Wrapper use the same strategy, most of the Bintools Wrapper code is sparsely commented and refers to the CC Wrapper. But the CC Wrapper's code, by contrast, has quite lengthy comments. The Bintools Wrapper merely cites those, rather than repeating them, to avoid falling out of sync.
-      </para>
-      <para>
-       A final task of the setup hook is defining a number of standard environment variables to tell build systems which executables fulfill which purpose. They are defined to just be the base name of the tools, under the assumption that the Bintools Wrapper's binaries will be on the path. Firstly, this helps poorly-written packages, e.g. ones that look for just <command>gcc</command> when <envar>CC</envar> isn't defined yet <command>clang</command> is to be used. Secondly, this helps packages not get confused when cross-compiling, in which case multiple Bintools Wrappers may simultaneously be in use.
-       <footnote xml:id="footnote-stdenv-per-platform-wrapper">
-        <para>
-         Each wrapper targets a single platform, so if binaries for multiple platforms are needed, the underlying binaries must be wrapped multiple times. As this is a property of the wrapper itself, the multiple wrappings are needed whether or not the same underlying binaries can target multiple platforms.
-        </para>
-       </footnote>
-       <envar>BUILD_</envar>- and <envar>TARGET_</envar>-prefixed versions of the normal environment variable are defined for additional Bintools Wrappers, properly disambiguating them.
-      </para>
-      <para>
-       A problem with this final task is that the Bintools Wrapper is honest and defines <envar>LD</envar> as <command>ld</command>. Most packages, however, firstly use the C compiler for linking, secondly use <envar>LD</envar> anyways, defining it as the C compiler, and thirdly, only so define <envar>LD</envar> when it is undefined as a fallback. This triple-threat means Bintools Wrapper will break those packages, as LD is already defined as the actual linker which the package won't override yet doesn't want to use. The workaround is to define, just for the problematic package, <envar>LD</envar> as the C compiler. A good way to do this would be <command>preConfigure = "LD=$CC"</command>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      CC Wrapper
-     </term>
-     <listitem>
-      <para>
-       The CC Wrapper wraps a C toolchain for a bunch of miscellaneous purposes. Specifically, a C compiler (GCC or Clang), wrapped binary tools, and a C standard library (glibc or Darwin's libSystem, just for the dynamic loader) are all fed in, and dependency finding, hardening (see below), and purity checks for each are handled by the CC Wrapper. Packages typically depend on the CC Wrapper, which in turn (at run-time) depends on the Bintools Wrapper.
-      </para>
-      <para>
-       Dependency finding is undoubtedly the main task of the CC Wrapper. This works just like the Bintools Wrapper, except that any <filename>include</filename> subdirectory of any relevant dependency is added to <envar>NIX_CFLAGS_COMPILE</envar>. The setup hook itself contains some lengthy comments describing the exact convoluted mechanism by which this is accomplished.
-      </para>
-      <para>
-       Similarly, the CC Wrapper follows the Bintools Wrapper in defining standard environment variables with the names of the tools it wraps, for the same reasons described above. Importantly, while it includes a <command>cc</command> symlink to the c compiler for portability, the <envar>CC</envar> will be defined using the compiler's "real name" (i.e. <command>gcc</command> or <command>clang</command>). This helps lousy build systems that inspect on the name of the compiler rather than run it.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </para>
-
-  <para>
-   Here are some more packages that provide a setup hook. Since the list of hooks is extensible, this is not an exhaustive list. The mechanism is only to be used as a last resort, so it might cover most uses.
-   <variablelist>
-    <varlistentry>
-     <term>
-      Perl
-     </term>
-     <listitem>
-      <para>
-       Adds the <filename>lib/site_perl</filename> subdirectory of each build input to the <envar>PERL5LIB</envar> environment variable. For instance, if <varname>buildInputs</varname> contains Perl, then the <filename>lib/site_perl</filename> subdirectory of each input is added to the <envar>PERL5LIB</envar> environment variable.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      Python
-     </term>
-     <listitem>
-      <para>
-       Adds the <filename>lib/${python.libPrefix}/site-packages</filename> subdirectory of each build input to the <envar>PYTHONPATH</envar> environment variable.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      pkg-config
-     </term>
-     <listitem>
-      <para>
-       Adds the <filename>lib/pkgconfig</filename> and <filename>share/pkgconfig</filename> subdirectories of each build input to the <envar>PKG_CONFIG_PATH</envar> environment variable.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      Automake
-     </term>
-     <listitem>
-      <para>
-       Adds the <filename>share/aclocal</filename> subdirectory of each build input to the <envar>ACLOCAL_PATH</envar> environment variable.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      Autoconf
-     </term>
-     <listitem>
-      <para>
-       The <varname>autoreconfHook</varname> derivation adds <varname>autoreconfPhase</varname>, which runs autoreconf, libtoolize and automake, essentially preparing the configure script in autotools-based builds. Most autotools-based packages come with the configure script pre-generated, but this hook is necessary for a few packages and when you need to patch the package’s configure scripts.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      libxml2
-     </term>
-     <listitem>
-      <para>
-       Adds every file named <filename>catalog.xml</filename> found under the <filename>xml/dtd</filename> and <filename>xml/xsl</filename> subdirectories of each build input to the <envar>XML_CATALOG_FILES</envar> environment variable.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      teTeX / TeX Live
-     </term>
-     <listitem>
-      <para>
-       Adds the <filename>share/texmf-nix</filename> subdirectory of each build input to the <envar>TEXINPUTS</envar> environment variable.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      Qt 4
-     </term>
-     <listitem>
-      <para>
-       Sets the <envar>QTDIR</envar> environment variable to Qt’s path.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      gdk-pixbuf
-     </term>
-     <listitem>
-      <para>
-       Exports <envar>GDK_PIXBUF_MODULE_FILE</envar> environment variable to the builder. Add librsvg package to <varname>buildInputs</varname> to get svg support.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      GHC
-     </term>
-     <listitem>
-      <para>
-       Creates a temporary package database and registers every Haskell build input in it (TODO: how?).
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      GNOME platform
-     </term>
-     <listitem>
-      <para>
-       Hooks related to GNOME platform and related libraries like GLib, GTK and GStreamer are described in <xref linkend="sec-language-gnome" />.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry xml:id="setup-hook-autopatchelfhook">
-     <term>
-      autoPatchelfHook
-     </term>
-     <listitem>
-      <para>
-       This is a special setup hook which helps in packaging proprietary software in that it automatically tries to find missing shared library dependencies of ELF files based on the given <varname>buildInputs</varname> and <varname>nativeBuildInputs</varname>.
-      </para>
-      <para>
-       You can also specify a <varname>runtimeDependencies</varname> variable which lists dependencies to be unconditionally added to <glossterm>rpath</glossterm> of all executables.
-       This is useful for programs that use <citerefentry>
-       <refentrytitle>dlopen</refentrytitle>
-       <manvolnum>3</manvolnum> </citerefentry> to load libraries at runtime.
-      </para>
-      <para>
-       In certain situations you may want to run the main command (<command>autoPatchelf</command>) of the setup hook on a file or a set of directories instead of unconditionally patching all outputs. This can be done by setting the <varname>dontAutoPatchelf</varname> environment variable to a non-empty value.
-      </para>
-      <para>
-       By default <command>autoPatchelf</command> will fail as soon as any ELF file requires a dependency which cannot be resolved via the given build inputs. In some situations you might prefer to just leave missing dependencies unpatched and continue to patch the rest. This can be achieved by setting the <envar>autoPatchelfIgnoreMissingDeps</envar> environment variable to a non-empty value.
-      </para>
-      <para>
-       The <command>autoPatchelf</command> command also recognizes a <parameter class="command">--no-recurse</parameter> command line flag, which prevents it from recursing into subdirectories.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      breakpointHook
-     </term>
-     <listitem>
-      <para>
-       This hook will make a build pause instead of stopping when a failure happens. It prevents nix from cleaning up the build environment immediately and allows the user to attach to a build environment using the <command>cntr</command> command. Upon build error it will print instructions on how to use <command>cntr</command>, which can be used to enter the environment for debugging. Installing cntr and running the command will provide shell access to the build sandbox of failed build. At <filename>/var/lib/cntr</filename> the sandboxed filesystem is mounted. All commands and files of the system are still accessible within the shell. To execute commands from the sandbox use the cntr exec subcommand. <command>cntr</command> is only supported on Linux-based platforms. To use it first add <literal>cntr</literal> to your <literal>environment.systemPackages</literal> on NixOS or alternatively to the root user on non-NixOS systems. Then in the package that is supposed to be inspected, add <literal>breakpointHook</literal> to <literal>nativeBuildInputs</literal>.
-<programlisting>
-nativeBuildInputs = [ breakpointHook ];
-</programlisting>
-       When a build failure happens there will be an instruction printed that shows how to attach with <literal>cntr</literal> to the build sandbox.
-      </para>
-      <note>
-       <title>Caution with remote builds</title>
-       <para>
-        This won't work with remote builds as the build environment is on a different machine and can't be accessed by <command>cntr</command>. Remote builds can be turned off by setting <literal>--option builders ''</literal> for <command>nix-build</command> or <literal>--builders ''</literal> for <command>nix build</command>.
-       </para>
-      </note>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      installShellFiles
-     </term>
-     <listitem>
-      <para>
-       This hook helps with installing manpages and shell completion files. It exposes 2 shell functions <literal>installManPage</literal> and <literal>installShellCompletion</literal> that can be used from your <literal>postInstall</literal> hook.
-      </para>
-      <para>
-       The <literal>installManPage</literal> function takes one or more paths to manpages to install. The manpages must have a section suffix, and may optionally be compressed (with <literal>.gz</literal> suffix). This function will place them into the correct directory.
-      </para>
-      <para>
-       The <literal>installShellCompletion</literal> function takes one or more paths to shell completion files. By default it will autodetect the shell type from the completion file extension, but you may also specify it by passing one of <literal>--bash</literal>, <literal>--fish</literal>, or <literal>--zsh</literal>. These flags apply to all paths listed after them (up until another shell flag is given). Each path may also have a custom installation name provided by providing a flag <literal>--name NAME</literal> before the path. If this flag is not provided, zsh completions will be renamed automatically such that <literal>foobar.zsh</literal> becomes <literal>_foobar</literal>.
-<programlisting>
-nativeBuildInputs = [ installShellFiles ];
-postInstall = ''
-  installManPage doc/foobar.1 doc/barfoo.3
-  # explicit behavior
-  installShellCompletion --bash --name foobar.bash share/completions.bash
-  installShellCompletion --fish --name foobar.fish share/completions.fish
-  installShellCompletion --zsh --name _foobar share/completions.zsh
-  # implicit behavior
-  installShellCompletion share/completions/foobar.{bash,fish,zsh}
-'';
-</programlisting>
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      libiconv, libintl
-     </term>
-     <listitem>
-      <para>
-       A few libraries automatically add to <literal>NIX_LDFLAGS</literal> their library, making their symbols automatically available to the linker. This includes libiconv and libintl (gettext). This is done to provide compatibility between GNU Linux, where libiconv and libintl are bundled in, and other systems where that might not be the case. Sometimes, this behavior is not desired. To disable this behavior, set <literal>dontAddExtraLibs</literal>.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      validatePkgConfig
-     </term>
-     <listitem>
-      <para>
-       The <literal>validatePkgConfig</literal> hook validates all pkg-config (<filename>.pc</filename>) files in a package. This helps catching some common errors in pkg-config files, such as undefined variables.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      cmake
-     </term>
-     <listitem>
-      <para>
-       Overrides the default configure phase to run the CMake command. By default, we use the Make generator of CMake. In addition, dependencies are added automatically to CMAKE_PREFIX_PATH so that packages are correctly detected by CMake. Some additional flags are passed in to give similar behavior to configure-based packages. You can disable this hook’s behavior by setting configurePhase to a custom value, or by setting dontUseCmakeConfigure. cmakeFlags controls flags passed only to CMake. By default, parallel building is enabled as CMake supports parallel building almost everywhere. When Ninja is also in use, CMake will detect that and use the ninja generator.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      xcbuildHook
-     </term>
-     <listitem>
-      <para>
-       Overrides the build and install phases to run the “xcbuild” command. This hook is needed when a project only comes with build files for the XCode build system. You can disable this behavior by setting buildPhase and configurePhase to a custom value. xcbuildFlags controls flags passed only to xcbuild.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      Meson
-     </term>
-     <listitem>
-      <para>
-       Overrides the configure phase to run meson to generate Ninja files. To run these files, you should accompany Meson with ninja. By default, <varname>enableParallelBuilding</varname> is enabled as Meson supports parallel building almost everywhere.
-      </para>
-      <variablelist>
-       <title>Variables controlling Meson</title>
-       <varlistentry>
-        <term>
-         <varname>mesonFlags</varname>
-        </term>
-        <listitem>
-         <para>
-          Controls the flags passed to meson.
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         <varname>mesonBuildType</varname>
-        </term>
-        <listitem>
-         <para>
-          Which <link
-          xlink:href="https://mesonbuild.com/Builtin-options.html#core-options"><command>--buildtype</command></link> to pass to Meson. We default to <literal>plain</literal>.
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         <varname>mesonAutoFeatures</varname>
-        </term>
-        <listitem>
-         <para>
-          What value to set <link
-          xlink:href="https://mesonbuild.com/Builtin-options.html#core-options"><command>-Dauto_features=</command></link> to. We default to <command>enabled</command>.
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         <varname>mesonWrapMode</varname>
-        </term>
-        <listitem>
-         <para>
-          What value to set <link
-          xlink:href="https://mesonbuild.com/Builtin-options.html#core-options"><command>-Dwrap_mode=</command></link> to. We default to <command>nodownload</command> as we disallow network access.
-         </para>
-        </listitem>
-       </varlistentry>
-       <varlistentry>
-        <term>
-         <varname>dontUseMesonConfigure</varname>
-        </term>
-        <listitem>
-         <para>
-          Disables using Meson's <varname>configurePhase</varname>.
-         </para>
-        </listitem>
-       </varlistentry>
-      </variablelist>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      ninja
-     </term>
-     <listitem>
-      <para>
-       Overrides the build, install, and check phase to run ninja instead of make. You can disable this behavior with the dontUseNinjaBuild, dontUseNinjaInstall, and dontUseNinjaCheck, respectively. Parallel building is enabled by default in Ninja.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      unzip
-     </term>
-     <listitem>
-      <para>
-       This setup hook will allow you to unzip .zip files specified in $src. There are many similar packages like unrar, undmg, etc.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      wafHook
-     </term>
-     <listitem>
-      <para>
-       Overrides the configure, build, and install phases. This will run the "waf" script used by many projects. If wafPath (default ./waf) doesn’t exist, it will copy the version of waf available in Nixpkgs. wafFlags can be used to pass flags to the waf script.
-      </para>
-     </listitem>
-    </varlistentry>
-    <varlistentry>
-     <term>
-      scons
-     </term>
-     <listitem>
-      <para>
-       Overrides the build, install, and check phases. This uses the scons build system as a replacement for make. scons does not provide a configure phase, so everything is managed at build and install time.
-      </para>
-     </listitem>
-    </varlistentry>
-   </variablelist>
-  </para>
- </section>
- <section xml:id="sec-purity-in-nixpkgs">
-  <title>Purity in Nixpkgs</title>
-
-  <para>
-   [measures taken to prevent dependencies on packages outside the store, and what you can do to prevent them]
-  </para>
-
-  <para>
-   GCC doesn't search in locations such as <filename>/usr/include</filename>. In fact, attempts to add such directories through the <option>-I</option> flag are filtered out. Likewise, the linker (from GNU binutils) doesn't search in standard locations such as <filename>/usr/lib</filename>. Programs built on Linux are linked against a GNU C Library that likewise doesn't search in the default system locations.
-  </para>
- </section>
- <section xml:id="sec-hardening-in-nixpkgs">
-  <title>Hardening in Nixpkgs</title>
-
-  <para>
-   There are flags available to harden packages at compile or link-time. These can be toggled using the <varname>stdenv.mkDerivation</varname> parameters <varname>hardeningDisable</varname> and <varname>hardeningEnable</varname>.
-  </para>
-
-  <para>
-   Both parameters take a list of flags as strings. The special <varname>"all"</varname> flag can be passed to <varname>hardeningDisable</varname> to turn off all hardening. These flags can also be used as environment variables for testing or development purposes.
-  </para>
-
-  <para>
-   The following flags are enabled by default and might require disabling with <varname>hardeningDisable</varname> if the program to package is incompatible.
-  </para>
-
-  <variablelist>
-   <varlistentry>
-    <term>
-     <varname>format</varname>
-    </term>
-    <listitem>
-     <para>
-      Adds the <option>-Wformat -Wformat-security -Werror=format-security</option> compiler options. At present, this warns about calls to <varname>printf</varname> and <varname>scanf</varname> functions where the format string is not a string literal and there are no format arguments, as in <literal>printf(foo);</literal>. This may be a security hole if the format string came from untrusted input and contains <literal>%n</literal>.
-     </para>
-     <para>
-      This needs to be turned off or fixed for errors similar to:
-     </para>
-<programlisting>
-/tmp/nix-build-zynaddsubfx-2.5.2.drv-0/zynaddsubfx-2.5.2/src/UI/guimain.cpp:571:28: error: format not a string literal and no format arguments [-Werror=format-security]
-         printf(help_message);
-                            ^
-cc1plus: some warnings being treated as errors
-</programlisting>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>stackprotector</varname>
-    </term>
-    <listitem>
-     <para>
-      Adds the <option>-fstack-protector-strong --param ssp-buffer-size=4</option> compiler options. This adds safety checks against stack overwrites rendering many potential code injection attacks into aborting situations. In the best case this turns code injection vulnerabilities into denial of service or into non-issues (depending on the application).
-     </para>
-     <para>
-      This needs to be turned off or fixed for errors similar to:
-     </para>
-<programlisting>
-bin/blib.a(bios_console.o): In function `bios_handle_cup':
-/tmp/nix-build-ipxe-20141124-5cbdc41.drv-0/ipxe-5cbdc41/src/arch/i386/firmware/pcbios/bios_console.c:86: undefined reference to `__stack_chk_fail'
-</programlisting>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>fortify</varname>
-    </term>
-    <listitem>
-     <para>
-      Adds the <option>-O2 -D_FORTIFY_SOURCE=2</option> compiler options. During code generation the compiler knows a great deal of information about buffer sizes (where possible), and attempts to replace insecure unlimited length buffer function calls with length-limited ones. This is especially useful for old, crufty code. Additionally, format strings in writable memory that contain '%n' are blocked. If an application depends on such a format string, it will need to be worked around.
-     </para>
-     <para>
-      Additionally, some warnings are enabled which might trigger build failures if compiler warnings are treated as errors in the package build. In this case, set <option>NIX_CFLAGS_COMPILE</option> to <option>-Wno-error=warning-type</option>.
-     </para>
-     <para>
-      This needs to be turned off or fixed for errors similar to:
-     </para>
-<programlisting>
-malloc.c:404:15: error: return type is an incomplete type
-malloc.c:410:19: error: storage size of 'ms' isn't known
-</programlisting>
-<programlisting>
-strdup.h:22:1: error: expected identifier or '(' before '__extension__'
-</programlisting>
-<programlisting>
-strsep.c:65:23: error: register name not specified for 'delim'
-</programlisting>
-<programlisting>
-installwatch.c:3751:5: error: conflicting types for '__open_2'
-</programlisting>
-<programlisting>
-fcntl2.h:50:4: error: call to '__open_missing_mode' declared with attribute error: open with O_CREAT or O_TMPFILE in second argument needs 3 arguments
-</programlisting>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>pic</varname>
-    </term>
-    <listitem>
-     <para>
-      Adds the <option>-fPIC</option> compiler options. This options adds support for position independent code in shared libraries and thus making ASLR possible.
-     </para>
-     <para>
-      Most notably, the Linux kernel, kernel modules and other code not running in an operating system environment like boot loaders won't build with PIC enabled. The compiler will is most cases complain that PIC is not supported for a specific build.
-     </para>
-     <para>
-      This needs to be turned off or fixed for assembler errors similar to:
-     </para>
-<programlisting>
-ccbLfRgg.s: Assembler messages:
-ccbLfRgg.s:33: Error: missing or invalid displacement expression `private_key_len@GOTOFF'
-</programlisting>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>strictoverflow</varname>
-    </term>
-    <listitem>
-     <para>
-      Signed integer overflow is undefined behaviour according to the C standard. If it happens, it is an error in the program as it should check for overflow before it can happen, not afterwards. GCC provides built-in functions to perform arithmetic with overflow checking, which are correct and faster than any custom implementation. As a workaround, the option <option>-fno-strict-overflow</option> makes gcc behave as if signed integer overflows were defined.
-     </para>
-     <para>
-      This flag should not trigger any build or runtime errors.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>relro</varname>
-    </term>
-    <listitem>
-     <para>
-      Adds the <option>-z relro</option> linker option. During program load, several ELF memory sections need to be written to by the linker, but can be turned read-only before turning over control to the program. This prevents some GOT (and .dtors) overwrite attacks, but at least the part of the GOT used by the dynamic linker (.got.plt) is still vulnerable.
-     </para>
-     <para>
-      This flag can break dynamic shared object loading. For instance, the module systems of Xorg and OpenCV are incompatible with this flag. In almost all cases the <varname>bindnow</varname> flag must also be disabled and incompatible programs typically fail with similar errors at runtime.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <varname>bindnow</varname>
-    </term>
-    <listitem>
-     <para>
-      Adds the <option>-z bindnow</option> linker option. During program load, all dynamic symbols are resolved, allowing for the complete GOT to be marked read-only (due to <varname>relro</varname>). This prevents GOT overwrite attacks. For very large applications, this can incur some performance loss during initial load while symbols are resolved, but this shouldn't be an issue for daemons.
-     </para>
-     <para>
-      This flag can break dynamic shared object loading. For instance, the module systems of Xorg and PHP are incompatible with this flag. Programs incompatible with this flag often fail at runtime due to missing symbols, like:
-     </para>
-<programlisting>
-intel_drv.so: undefined symbol: vgaHWFreeHWRec
-</programlisting>
-    </listitem>
-   </varlistentry>
-  </variablelist>
-
-  <para>
-   The following flags are disabled by default and should be enabled with <varname>hardeningEnable</varname> for packages that take untrusted input like network services.
-  </para>
-
-  <variablelist>
-   <varlistentry>
-    <term>
-     <varname>pie</varname>
-    </term>
-    <listitem>
-     <para>
-      Adds the <option>-fPIE</option> compiler and <option>-pie</option> linker options. Position Independent Executables are needed to take advantage of Address Space Layout Randomization, supported by modern kernel versions. While ASLR can already be enforced for data areas in the stack and heap (brk and mmap), the code areas must be compiled as position-independent. Shared libraries already do this with the <varname>pic</varname> flag, so they gain ASLR automatically, but binary .text regions need to be build with <varname>pie</varname> to gain ASLR. When this happens, ROP attacks are much harder since there are no static locations to bounce off of during a memory corruption attack.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
-
-  <para>
-   For more in-depth information on these hardening flags and hardening in general, refer to the <link xlink:href="https://wiki.debian.org/Hardening">Debian Wiki</link>, <link xlink:href="https://wiki.ubuntu.com/Security/Features">Ubuntu Wiki</link>, <link xlink:href="https://wiki.gentoo.org/wiki/Project:Hardened">Gentoo Wiki</link>, and the <link xlink:href="https://wiki.archlinux.org/index.php/DeveloperWiki:Security"> Arch Wiki</link>.
-  </para>
- </section>
-</chapter>
diff --git a/doc/using/configuration.chapter.md b/doc/using/configuration.chapter.md
new file mode 100644
index 00000000000..932b24237c0
--- /dev/null
+++ b/doc/using/configuration.chapter.md
@@ -0,0 +1,356 @@
+# Global configuration {#chap-packageconfig}
+
+Nix comes with certain defaults about what packages can and cannot be installed, based on a package's metadata. By default, Nix will prevent installation if any of the following criteria are true:
+
+-   The package is thought to be broken, and has had its `meta.broken` set to `true`.
+
+-   The package isn't intended to run on the given system, as none of its `meta.platforms` match the given system.
+
+-   The package's `meta.license` is set to a license which is considered to be unfree.
+
+-   The package has known security vulnerabilities but has not or can not be updated for some reason, and a list of issues has been entered in to the package's `meta.knownVulnerabilities`.
+
+Note that all this is checked during evaluation already, and the check includes any package that is evaluated. In particular, all build-time dependencies are checked. `nix-env -qa` will (attempt to) hide any packages that would be refused.
+
+Each of these criteria can be altered in the nixpkgs configuration.
+
+The nixpkgs configuration for a NixOS system is set in the `configuration.nix`, as in the following example:
+
+```nix
+{
+  nixpkgs.config = {
+    allowUnfree = true;
+  };
+}
+```
+
+However, this does not allow unfree software for individual users. Their configurations are managed separately.
+
+A user's nixpkgs configuration is stored in a user-specific configuration file located at `~/.config/nixpkgs/config.nix`. For example:
+
+```nix
+{
+  allowUnfree = true;
+}
+```
+
+Note that we are not able to test or build unfree software on Hydra due to policy. Most unfree licenses prohibit us from either executing or distributing the software.
+
+## Installing broken packages {#sec-allow-broken}
+
+There are two ways to try compiling a package which has been marked as broken.
+
+-   For allowing the build of a broken package once, you can use an environment variable for a single invocation of the nix tools:
+
+    ```ShellSession
+    $ export NIXPKGS_ALLOW_BROKEN=1
+    ```
+
+-   For permanently allowing broken packages to be built, you may add `allowBroken = true;` to your user's configuration file, like this:
+
+    ```nix
+    {
+      allowBroken = true;
+    }
+    ```
+
+
+## Installing packages on unsupported systems {#sec-allow-unsupported-system}
+
+There are also two ways to try compiling a package which has been marked as unsupported for the given system.
+
+-   For allowing the build of an unsupported package once, you can use an environment variable for a single invocation of the nix tools:
+
+    ```ShellSession
+    $ export NIXPKGS_ALLOW_UNSUPPORTED_SYSTEM=1
+    ```
+
+-   For permanently allowing unsupported packages to be built, you may add `allowUnsupportedSystem = true;` to your user's configuration file, like this:
+
+    ```nix
+    {
+      allowUnsupportedSystem = true;
+    }
+    ```
+
+The difference between a package being unsupported on some system and being broken is admittedly a bit fuzzy. If a program *ought* to work on a certain platform, but doesn't, the platform should be included in `meta.platforms`, but marked as broken with e.g.  `meta.broken = !hostPlatform.isWindows`. Of course, this begs the question of what \"ought\" means exactly. That is left to the package maintainer.
+
+## Installing unfree packages {#sec-allow-unfree}
+
+There are several ways to tweak how Nix handles a package which has been marked as unfree.
+
+-   To temporarily allow all unfree packages, you can use an environment variable for a single invocation of the nix tools:
+
+    ```ShellSession
+    $ export NIXPKGS_ALLOW_UNFREE=1
+    ```
+
+-   It is possible to permanently allow individual unfree packages, while still blocking unfree packages by default using the `allowUnfreePredicate` configuration option in the user configuration file.
+
+    This option is a function which accepts a package as a parameter, and returns a boolean. The following example configuration accepts a package and always returns false:
+
+    ```nix
+    {
+      allowUnfreePredicate = (pkg: false);
+    }
+    ```
+
+    For a more useful example, try the following. This configuration only allows unfree packages named roon-server and visual studio code:
+
+    ```nix
+    {
+      allowUnfreePredicate = pkg: builtins.elem (lib.getName pkg) [
+        "roon-server"
+        "vscode"
+      ];
+    }
+    ```
+
+-   It is also possible to allow and block licenses that are specifically acceptable or not acceptable, using `allowlistedLicenses` and `blocklistedLicenses`, respectively.
+
+    The following example configuration allowlists the licenses `amd` and `wtfpl`:
+
+    ```nix
+    {
+      allowlistedLicenses = with lib.licenses; [ amd wtfpl ];
+    }
+    ```
+
+    The following example configuration blocklists the `gpl3Only` and `agpl3Only` licenses:
+
+    ```nix
+    {
+      blocklistedLicenses = with lib.licenses; [ agpl3Only gpl3Only ];
+    }
+    ```
+
+    Note that `allowlistedLicenses` only applies to unfree licenses unless `allowUnfree` is enabled. It is not a generic allowlist for all types of licenses. `blocklistedLicenses` applies to all licenses.
+
+A complete list of licenses can be found in the file `lib/licenses.nix` of the nixpkgs tree.
+
+## Installing insecure packages {#sec-allow-insecure}
+
+There are several ways to tweak how Nix handles a package which has been marked as insecure.
+
+-   To temporarily allow all insecure packages, you can use an environment variable for a single invocation of the nix tools:
+
+    ```ShellSession
+    $ export NIXPKGS_ALLOW_INSECURE=1
+    ```
+
+-   It is possible to permanently allow individual insecure packages, while still blocking other insecure packages by default using the `permittedInsecurePackages` configuration option in the user configuration file.
+
+    The following example configuration permits the installation of the hypothetically insecure package `hello`, version `1.2.3`:
+
+    ```nix
+    {
+      permittedInsecurePackages = [
+        "hello-1.2.3"
+      ];
+    }
+    ```
+
+-   It is also possible to create a custom policy around which insecure packages to allow and deny, by overriding the `allowInsecurePredicate` configuration option.
+
+    The `allowInsecurePredicate` option is a function which accepts a package and returns a boolean, much like `allowUnfreePredicate`.
+
+    The following configuration example only allows insecure packages with very short names:
+
+    ```nix
+    {
+      allowInsecurePredicate = pkg: builtins.stringLength (lib.getName pkg) <= 5;
+    }
+    ```
+
+    Note that `permittedInsecurePackages` is only checked if `allowInsecurePredicate` is not specified.
+
+## Modify packages via `packageOverrides` {#sec-modify-via-packageOverrides}
+
+You can define a function called `packageOverrides` in your local `~/.config/nixpkgs/config.nix` to override Nix packages. It must be a function that takes pkgs as an argument and returns a modified set of packages.
+
+```nix
+{
+  packageOverrides = pkgs: rec {
+    foo = pkgs.foo.override { ... };
+  };
+}
+```
+
+## Declarative Package Management {#sec-declarative-package-management}
+
+### Build an environment {#sec-building-environment}
+
+Using `packageOverrides`, it is possible to manage packages declaratively. This means that we can list all of our desired packages within a declarative Nix expression. For example, to have `aspell`, `bc`, `ffmpeg`, `coreutils`, `gdb`, `nixUnstable`, `emscripten`, `jq`, `nox`, and `silver-searcher`, we could use the following in `~/.config/nixpkgs/config.nix`:
+
+```nix
+{
+  packageOverrides = pkgs: with pkgs; {
+    myPackages = pkgs.buildEnv {
+      name = "my-packages";
+      paths = [
+        aspell
+        bc
+        coreutils
+        gdb
+        ffmpeg
+        nixUnstable
+        emscripten
+        jq
+        nox
+        silver-searcher
+      ];
+    };
+  };
+}
+```
+
+To install it into our environment, you can just run `nix-env -iA nixpkgs.myPackages`. If you want to load the packages to be built from a working copy of `nixpkgs` you just run `nix-env -f. -iA myPackages`. To explore what's been installed, just look through `~/.nix-profile/`. You can see that a lot of stuff has been installed. Some of this stuff is useful some of it isn't. Let's tell Nixpkgs to only link the stuff that we want:
+
+```nix
+{
+  packageOverrides = pkgs: with pkgs; {
+    myPackages = pkgs.buildEnv {
+      name = "my-packages";
+      paths = [
+        aspell
+        bc
+        coreutils
+        gdb
+        ffmpeg
+        nixUnstable
+        emscripten
+        jq
+        nox
+        silver-searcher
+      ];
+      pathsToLink = [ "/share" "/bin" ];
+    };
+  };
+}
+```
+
+`pathsToLink` tells Nixpkgs to only link the paths listed which gets rid of the extra stuff in the profile. `/bin` and `/share` are good defaults for a user environment, getting rid of the clutter. If you are running on Nix on MacOS, you may want to add another path as well, `/Applications`, that makes GUI apps available.
+
+### Getting documentation {#sec-getting-documentation}
+
+After building that new environment, look through `~/.nix-profile` to make sure everything is there that we wanted. Discerning readers will note that some files are missing. Look inside `~/.nix-profile/share/man/man1/` to verify this. There are no man pages for any of the Nix tools! This is because some packages like Nix have multiple outputs for things like documentation (see section 4). Let's make Nix install those as well.
+
+```nix
+{
+  packageOverrides = pkgs: with pkgs; {
+    myPackages = pkgs.buildEnv {
+      name = "my-packages";
+      paths = [
+        aspell
+        bc
+        coreutils
+        ffmpeg
+        nixUnstable
+        emscripten
+        jq
+        nox
+        silver-searcher
+      ];
+      pathsToLink = [ "/share/man" "/share/doc" "/bin" ];
+      extraOutputsToInstall = [ "man" "doc" ];
+    };
+  };
+}
+```
+
+This provides us with some useful documentation for using our packages.  However, if we actually want those manpages to be detected by man, we need to set up our environment. This can also be managed within Nix expressions.
+
+```nix
+{
+  packageOverrides = pkgs: with pkgs; rec {
+    myProfile = writeText "my-profile" ''
+      export PATH=$HOME/.nix-profile/bin:/nix/var/nix/profiles/default/bin:/sbin:/bin:/usr/sbin:/usr/bin
+      export MANPATH=$HOME/.nix-profile/share/man:/nix/var/nix/profiles/default/share/man:/usr/share/man
+    '';
+    myPackages = pkgs.buildEnv {
+      name = "my-packages";
+      paths = [
+        (runCommand "profile" {} ''
+          mkdir -p $out/etc/profile.d
+          cp ${myProfile} $out/etc/profile.d/my-profile.sh
+        '')
+        aspell
+        bc
+        coreutils
+        ffmpeg
+        man
+        nixUnstable
+        emscripten
+        jq
+        nox
+        silver-searcher
+      ];
+      pathsToLink = [ "/share/man" "/share/doc" "/bin" "/etc" ];
+      extraOutputsToInstall = [ "man" "doc" ];
+    };
+  };
+}
+```
+
+For this to work fully, you must also have this script sourced when you are logged in. Try adding something like this to your `~/.profile` file:
+
+```ShellSession
+#!/bin/sh
+if [ -d $HOME/.nix-profile/etc/profile.d ]; then
+  for i in $HOME/.nix-profile/etc/profile.d/*.sh; do
+    if [ -r $i ]; then
+      . $i
+    fi
+  done
+fi
+```
+
+Now just run `source $HOME/.profile` and you can starting loading man pages from your environment.
+
+### GNU info setup {#sec-gnu-info-setup}
+
+Configuring GNU info is a little bit trickier than man pages. To work correctly, info needs a database to be generated. This can be done with some small modifications to our environment scripts.
+
+```nix
+{
+  packageOverrides = pkgs: with pkgs; rec {
+    myProfile = writeText "my-profile" ''
+      export PATH=$HOME/.nix-profile/bin:/nix/var/nix/profiles/default/bin:/sbin:/bin:/usr/sbin:/usr/bin
+      export MANPATH=$HOME/.nix-profile/share/man:/nix/var/nix/profiles/default/share/man:/usr/share/man
+      export INFOPATH=$HOME/.nix-profile/share/info:/nix/var/nix/profiles/default/share/info:/usr/share/info
+    '';
+    myPackages = pkgs.buildEnv {
+      name = "my-packages";
+      paths = [
+        (runCommand "profile" {} ''
+          mkdir -p $out/etc/profile.d
+          cp ${myProfile} $out/etc/profile.d/my-profile.sh
+        '')
+        aspell
+        bc
+        coreutils
+        ffmpeg
+        man
+        nixUnstable
+        emscripten
+        jq
+        nox
+        silver-searcher
+        texinfoInteractive
+      ];
+      pathsToLink = [ "/share/man" "/share/doc" "/share/info" "/bin" "/etc" ];
+      extraOutputsToInstall = [ "man" "doc" "info" ];
+      postBuild = ''
+        if [ -x $out/bin/install-info -a -w $out/share/info ]; then
+          shopt -s nullglob
+          for i in $out/share/info/*.info $out/share/info/*.info.gz; do
+              $out/bin/install-info $i $out/share/info/dir
+          done
+        fi
+      '';
+    };
+  };
+}
+```
+
+`postBuild` tells Nixpkgs to run a command after building the environment. In this case, `install-info` adds the installed info pages to `dir` which is GNU info's default root node. Note that `texinfoInteractive` is added to the environment to give the `install-info` command.
diff --git a/doc/using/configuration.xml b/doc/using/configuration.xml
deleted file mode 100644
index b670f78f28b..00000000000
--- a/doc/using/configuration.xml
+++ /dev/null
@@ -1,448 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-packageconfig">
- <title>Global configuration</title>
- <para>
-  Nix comes with certain defaults about what packages can and cannot be installed, based on a package's metadata. By default, Nix will prevent installation if any of the following criteria are true:
- </para>
- <itemizedlist>
-  <listitem>
-   <para>
-    The package is thought to be broken, and has had its <literal>meta.broken</literal> set to <literal>true</literal>.
-   </para>
-  </listitem>
-  <listitem>
-   <para>
-    The package isn't intended to run on the given system, as none of its <literal>meta.platforms</literal> match the given system.
-   </para>
-  </listitem>
-  <listitem>
-   <para>
-    The package's <literal>meta.license</literal> is set to a license which is considered to be unfree.
-   </para>
-  </listitem>
-  <listitem>
-   <para>
-    The package has known security vulnerabilities but has not or can not be updated for some reason, and a list of issues has been entered in to the package's <literal>meta.knownVulnerabilities</literal>.
-   </para>
-  </listitem>
- </itemizedlist>
- <para>
-  Note that all this is checked during evaluation already, and the check includes any package that is evaluated. In particular, all build-time dependencies are checked. <literal>nix-env -qa</literal> will (attempt to) hide any packages that would be refused.
- </para>
- <para>
-  Each of these criteria can be altered in the nixpkgs configuration.
- </para>
- <para>
-  The nixpkgs configuration for a NixOS system is set in the <literal>configuration.nix</literal>, as in the following example:
-<programlisting>
-{
-  nixpkgs.config = {
-    allowUnfree = true;
-  };
-}
-</programlisting>
-  However, this does not allow unfree software for individual users. Their configurations are managed separately.
- </para>
- <para>
-  A user's nixpkgs configuration is stored in a user-specific configuration file located at <filename>~/.config/nixpkgs/config.nix</filename>. For example:
-<programlisting>
-{
-  allowUnfree = true;
-}
-</programlisting>
- </para>
- <para>
-  Note that we are not able to test or build unfree software on Hydra due to policy. Most unfree licenses prohibit us from either executing or distributing the software.
- </para>
- <section xml:id="sec-allow-broken">
-  <title>Installing broken packages</title>
-
-  <para>
-   There are two ways to try compiling a package which has been marked as broken.
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     For allowing the build of a broken package once, you can use an environment variable for a single invocation of the nix tools:
-<programlisting>$ export NIXPKGS_ALLOW_BROKEN=1</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     For permanently allowing broken packages to be built, you may add <literal>allowBroken = true;</literal> to your user's configuration file, like this:
-<programlisting>
-{
-  allowBroken = true;
-}
-</programlisting>
-    </para>
-   </listitem>
-  </itemizedlist>
- </section>
- <section xml:id="sec-allow-unsupported-system">
-  <title>Installing packages on unsupported systems</title>
-
-  <para>
-   There are also two ways to try compiling a package which has been marked as unsupported for the given system.
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     For allowing the build of an unsupported package once, you can use an environment variable for a single invocation of the nix tools:
-<programlisting>$ export NIXPKGS_ALLOW_UNSUPPORTED_SYSTEM=1</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     For permanently allowing unsupported packages to be built, you may add <literal>allowUnsupportedSystem = true;</literal> to your user's configuration file, like this:
-<programlisting>
-{
-  allowUnsupportedSystem = true;
-}
-</programlisting>
-    </para>
-   </listitem>
-  </itemizedlist>
-
-  <para>
-   The difference between a package being unsupported on some system and being broken is admittedly a bit fuzzy. If a program <emphasis>ought</emphasis> to work on a certain platform, but doesn't, the platform should be included in <literal>meta.platforms</literal>, but marked as broken with e.g. <literal>meta.broken = !hostPlatform.isWindows</literal>. Of course, this begs the question of what "ought" means exactly. That is left to the package maintainer.
-  </para>
- </section>
- <section xml:id="sec-allow-unfree">
-  <title>Installing unfree packages</title>
-
-  <para>
-   There are several ways to tweak how Nix handles a package which has been marked as unfree.
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     To temporarily allow all unfree packages, you can use an environment variable for a single invocation of the nix tools:
-<programlisting>$ export NIXPKGS_ALLOW_UNFREE=1</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     It is possible to permanently allow individual unfree packages, while still blocking unfree packages by default using the <literal>allowUnfreePredicate</literal> configuration option in the user configuration file.
-    </para>
-    <para>
-     This option is a function which accepts a package as a parameter, and returns a boolean. The following example configuration accepts a package and always returns false:
-<programlisting>
-{
-  allowUnfreePredicate = (pkg: false);
-}
-</programlisting>
-    </para>
-    <para>
-     For a more useful example, try the following. This configuration only allows unfree packages named flash player and visual studio code:
-<programlisting>
-{
-  allowUnfreePredicate = pkg: builtins.elem (lib.getName pkg) [
-    "flashplayer"
-    "vscode"
-  ];
-}
-</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     It is also possible to whitelist and blacklist licenses that are specifically acceptable or not acceptable, using <literal>whitelistedLicenses</literal> and <literal>blacklistedLicenses</literal>, respectively.
-    </para>
-    <para>
-     The following example configuration whitelists the licenses <literal>amd</literal> and <literal>wtfpl</literal>:
-<programlisting>
-{
-  whitelistedLicenses = with stdenv.lib.licenses; [ amd wtfpl ];
-}
-</programlisting>
-    </para>
-    <para>
-     The following example configuration blacklists the <literal>gpl3Only</literal> and <literal>agpl3Only</literal> licenses:
-<programlisting>
-{
-  blacklistedLicenses = with stdenv.lib.licenses; [ agpl3Only gpl3Only ];
-}
-</programlisting>
-    </para>
-   </listitem>
-  </itemizedlist>
-
-  <para>
-   A complete list of licenses can be found in the file <filename>lib/licenses.nix</filename> of the nixpkgs tree.
-  </para>
- </section>
- <section xml:id="sec-allow-insecure">
-  <title>Installing insecure packages</title>
-
-  <para>
-   There are several ways to tweak how Nix handles a package which has been marked as insecure.
-  </para>
-
-  <itemizedlist>
-   <listitem>
-    <para>
-     To temporarily allow all insecure packages, you can use an environment variable for a single invocation of the nix tools:
-<programlisting>$ export NIXPKGS_ALLOW_INSECURE=1</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     It is possible to permanently allow individual insecure packages, while still blocking other insecure packages by default using the <literal>permittedInsecurePackages</literal> configuration option in the user configuration file.
-    </para>
-    <para>
-     The following example configuration permits the installation of the hypothetically insecure package <literal>hello</literal>, version <literal>1.2.3</literal>:
-<programlisting>
-{
-  permittedInsecurePackages = [
-    "hello-1.2.3"
-  ];
-}
-</programlisting>
-    </para>
-   </listitem>
-   <listitem>
-    <para>
-     It is also possible to create a custom policy around which insecure packages to allow and deny, by overriding the <literal>allowInsecurePredicate</literal> configuration option.
-    </para>
-    <para>
-     The <literal>allowInsecurePredicate</literal> option is a function which accepts a package and returns a boolean, much like <literal>allowUnfreePredicate</literal>.
-    </para>
-    <para>
-     The following configuration example only allows insecure packages with very short names:
-<programlisting>
-{
-  allowInsecurePredicate = pkg: builtins.stringLength (lib.getName pkg) &lt;= 5;
-}
-</programlisting>
-    </para>
-    <para>
-     Note that <literal>permittedInsecurePackages</literal> is only checked if <literal>allowInsecurePredicate</literal> is not specified.
-    </para>
-   </listitem>
-  </itemizedlist>
- </section>
-<!--============================================================-->
- <section xml:id="sec-modify-via-packageOverrides">
-  <title>Modify packages via <literal>packageOverrides</literal></title>
-
-  <para>
-   You can define a function called <varname>packageOverrides</varname> in your local <filename>~/.config/nixpkgs/config.nix</filename> to override Nix packages. It must be a function that takes pkgs as an argument and returns a modified set of packages.
-<programlisting>
-{
-  packageOverrides = pkgs: rec {
-    foo = pkgs.foo.override { ... };
-  };
-}
-</programlisting>
-  </para>
- </section>
- <section xml:id="sec-declarative-package-management">
-  <title>Declarative Package Management</title>
-
-  <section xml:id="sec-building-environment">
-   <title>Build an environment</title>
-
-   <para>
-    Using <literal>packageOverrides</literal>, it is possible to manage packages declaratively. This means that we can list all of our desired packages within a declarative Nix expression. For example, to have <literal>aspell</literal>, <literal>bc</literal>, <literal>ffmpeg</literal>, <literal>coreutils</literal>, <literal>gdb</literal>, <literal>nixUnstable</literal>, <literal>emscripten</literal>, <literal>jq</literal>, <literal>nox</literal>, and <literal>silver-searcher</literal>, we could use the following in <filename>~/.config/nixpkgs/config.nix</filename>:
-   </para>
-
-<screen>
-{
-  packageOverrides = pkgs: with pkgs; {
-    myPackages = pkgs.buildEnv {
-      name = "my-packages";
-      paths = [
-        aspell
-        bc
-        coreutils
-        gdb
-        ffmpeg
-        nixUnstable
-        emscripten
-        jq
-        nox
-        silver-searcher
-      ];
-    };
-  };
-}
-</screen>
-
-   <para>
-    To install it into our environment, you can just run <literal>nix-env -iA nixpkgs.myPackages</literal>. If you want to load the packages to be built from a working copy of <literal>nixpkgs</literal> you just run <literal>nix-env -f. -iA myPackages</literal>. To explore what's been installed, just look through <filename>~/.nix-profile/</filename>. You can see that a lot of stuff has been installed. Some of this stuff is useful some of it isn't. Let's tell Nixpkgs to only link the stuff that we want:
-   </para>
-
-<screen>
-{
-  packageOverrides = pkgs: with pkgs; {
-    myPackages = pkgs.buildEnv {
-      name = "my-packages";
-      paths = [
-        aspell
-        bc
-        coreutils
-        gdb
-        ffmpeg
-        nixUnstable
-        emscripten
-        jq
-        nox
-        silver-searcher
-      ];
-      pathsToLink = [ "/share" "/bin" ];
-    };
-  };
-}
-</screen>
-
-   <para>
-    <literal>pathsToLink</literal> tells Nixpkgs to only link the paths listed which gets rid of the extra stuff in the profile. <filename>/bin</filename> and <filename>/share</filename> are good defaults for a user environment, getting rid of the clutter. If you are running on Nix on MacOS, you may want to add another path as well, <filename>/Applications</filename>, that makes GUI apps available.
-   </para>
-  </section>
-
-  <section xml:id="sec-getting-documentation">
-   <title>Getting documentation</title>
-
-   <para>
-    After building that new environment, look through <filename>~/.nix-profile</filename> to make sure everything is there that we wanted. Discerning readers will note that some files are missing. Look inside <filename>~/.nix-profile/share/man/man1/</filename> to verify this. There are no man pages for any of the Nix tools! This is because some packages like Nix have multiple outputs for things like documentation (see section 4). Let's make Nix install those as well.
-   </para>
-
-<screen>
-{
-  packageOverrides = pkgs: with pkgs; {
-    myPackages = pkgs.buildEnv {
-      name = "my-packages";
-      paths = [
-        aspell
-        bc
-        coreutils
-        ffmpeg
-        nixUnstable
-        emscripten
-        jq
-        nox
-        silver-searcher
-      ];
-      pathsToLink = [ "/share/man" "/share/doc" "/bin" ];
-      extraOutputsToInstall = [ "man" "doc" ];
-    };
-  };
-}
-</screen>
-
-   <para>
-    This provides us with some useful documentation for using our packages. However, if we actually want those manpages to be detected by man, we need to set up our environment. This can also be managed within Nix expressions.
-   </para>
-
-<screen>
-{
-  packageOverrides = pkgs: with pkgs; rec {
-    myProfile = writeText "my-profile" ''
-      export PATH=$HOME/.nix-profile/bin:/nix/var/nix/profiles/default/bin:/sbin:/bin:/usr/sbin:/usr/bin
-      export MANPATH=$HOME/.nix-profile/share/man:/nix/var/nix/profiles/default/share/man:/usr/share/man
-    '';
-    myPackages = pkgs.buildEnv {
-      name = "my-packages";
-      paths = [
-        (runCommand "profile" {} ''
-          mkdir -p $out/etc/profile.d
-          cp ${myProfile} $out/etc/profile.d/my-profile.sh
-        '')
-        aspell
-        bc
-        coreutils
-        ffmpeg
-        man
-        nixUnstable
-        emscripten
-        jq
-        nox
-        silver-searcher
-      ];
-      pathsToLink = [ "/share/man" "/share/doc" "/bin" "/etc" ];
-      extraOutputsToInstall = [ "man" "doc" ];
-    };
-  };
-}
-</screen>
-
-   <para>
-    For this to work fully, you must also have this script sourced when you are logged in. Try adding something like this to your <filename>~/.profile</filename> file:
-   </para>
-
-<screen>
-#!/bin/sh
-if [ -d $HOME/.nix-profile/etc/profile.d ]; then
-  for i in $HOME/.nix-profile/etc/profile.d/*.sh; do
-    if [ -r $i ]; then
-      . $i
-    fi
-  done
-fi
-</screen>
-
-   <para>
-    Now just run <literal>source $HOME/.profile</literal> and you can starting loading man pages from your environment.
-   </para>
-  </section>
-
-  <section xml:id="sec-gnu-info-setup">
-   <title>GNU info setup</title>
-
-   <para>
-    Configuring GNU info is a little bit trickier than man pages. To work correctly, info needs a database to be generated. This can be done with some small modifications to our environment scripts.
-   </para>
-
-<screen>
-{
-  packageOverrides = pkgs: with pkgs; rec {
-    myProfile = writeText "my-profile" ''
-      export PATH=$HOME/.nix-profile/bin:/nix/var/nix/profiles/default/bin:/sbin:/bin:/usr/sbin:/usr/bin
-      export MANPATH=$HOME/.nix-profile/share/man:/nix/var/nix/profiles/default/share/man:/usr/share/man
-      export INFOPATH=$HOME/.nix-profile/share/info:/nix/var/nix/profiles/default/share/info:/usr/share/info
-    '';
-    myPackages = pkgs.buildEnv {
-      name = "my-packages";
-      paths = [
-        (runCommand "profile" {} ''
-          mkdir -p $out/etc/profile.d
-          cp ${myProfile} $out/etc/profile.d/my-profile.sh
-        '')
-        aspell
-        bc
-        coreutils
-        ffmpeg
-        man
-        nixUnstable
-        emscripten
-        jq
-        nox
-        silver-searcher
-        texinfoInteractive
-      ];
-      pathsToLink = [ "/share/man" "/share/doc" "/share/info" "/bin" "/etc" ];
-      extraOutputsToInstall = [ "man" "doc" "info" ];
-      postBuild = ''
-        if [ -x $out/bin/install-info -a -w $out/share/info ]; then
-          shopt -s nullglob
-          for i in $out/share/info/*.info $out/share/info/*.info.gz; do
-              $out/bin/install-info $i $out/share/info/dir
-          done
-        fi
-      '';
-    };
-  };
-}
-</screen>
-
-   <para>
-    <literal>postBuild</literal> tells Nixpkgs to run a command after building the environment. In this case, <literal>install-info</literal> adds the installed info pages to <literal>dir</literal> which is GNU info's default root node. Note that <literal>texinfoInteractive</literal> is added to the environment to give the <literal>install-info</literal> command.
-   </para>
-  </section>
- </section>
-</chapter>
diff --git a/doc/using/overlays.chapter.md b/doc/using/overlays.chapter.md
new file mode 100644
index 00000000000..037580583b6
--- /dev/null
+++ b/doc/using/overlays.chapter.md
@@ -0,0 +1,149 @@
+# Overlays {#chap-overlays}
+
+This chapter describes how to extend and change Nixpkgs using overlays.  Overlays are used to add layers in the fixed-point used by Nixpkgs to compose the set of all packages.
+
+Nixpkgs can be configured with a list of overlays, which are applied in order. This means that the order of the overlays can be significant if multiple layers override the same package.
+
+## Installing overlays {#sec-overlays-install}
+
+The list of overlays can be set either explicitly in a Nix expression, or through `<nixpkgs-overlays>` or user configuration files.
+
+### Set overlays in NixOS or Nix expressions {#sec-overlays-argument}
+
+On a NixOS system the value of the `nixpkgs.overlays` option, if present, is passed to the system Nixpkgs directly as an argument. Note that this does not affect the overlays for non-NixOS operations (e.g.  `nix-env`), which are [looked up](#sec-overlays-lookup) independently.
+
+The list of overlays can be passed explicitly when importing nixpkgs, for example `import <nixpkgs> { overlays = [ overlay1 overlay2 ]; }`.
+
+NOTE: DO NOT USE THIS in nixpkgs. Further overlays can be added by calling the `pkgs.extend` or `pkgs.appendOverlays`, although it is often preferable to avoid these functions, because they recompute the Nixpkgs fixpoint, which is somewhat expensive to do.
+
+### Install overlays via configuration lookup {#sec-overlays-lookup}
+
+The list of overlays is determined as follows.
+
+1.  First, if an [`overlays` argument](#sec-overlays-argument) to the Nixpkgs function itself is given, then that is used and no path lookup will be performed.
+
+2.  Otherwise, if the Nix path entry `<nixpkgs-overlays>` exists, we look for overlays at that path, as described below.
+
+    See the section on `NIX_PATH` in the Nix manual for more details on how to set a value for `<nixpkgs-overlays>.`
+
+3.  If one of `~/.config/nixpkgs/overlays.nix` and `~/.config/nixpkgs/overlays/` exists, then we look for overlays at that path, as described below. It is an error if both exist.
+
+If we are looking for overlays at a path, then there are two cases:
+
+-   If the path is a file, then the file is imported as a Nix expression and used as the list of overlays.
+
+-   If the path is a directory, then we take the content of the directory, order it lexicographically, and attempt to interpret each as an overlay by:
+
+    -   Importing the file, if it is a `.nix` file.
+
+    -   Importing a top-level `default.nix` file, if it is a directory.
+
+Because overlays that are set in NixOS configuration do not affect non-NixOS operations such as `nix-env`, the `overlays.nix` option provides a convenient way to use the same overlays for a NixOS system configuration and user configuration: the same file can be used as `overlays.nix` and imported as the value of `nixpkgs.overlays`.
+
+## Defining overlays {#sec-overlays-definition}
+
+Overlays are Nix functions which accept two arguments, conventionally called `self` and `super`, and return a set of packages. For example, the following is a valid overlay.
+
+```nix
+self: super:
+
+{
+  boost = super.boost.override {
+    python = self.python3;
+  };
+  rr = super.callPackage ./pkgs/rr {
+    stdenv = self.stdenv_32bit;
+  };
+}
+```
+
+The first argument (`self`) corresponds to the final package set. You should use this set for the dependencies of all packages specified in your overlay. For example, all the dependencies of `rr` in the example above come from `self`, as well as the overridden dependencies used in the `boost` override.
+
+The second argument (`super`) corresponds to the result of the evaluation of the previous stages of Nixpkgs. It does not contain any of the packages added by the current overlay, nor any of the following overlays. This set should be used either to refer to packages you wish to override, or to access functions defined in Nixpkgs. For example, the original recipe of `boost` in the above example, comes from `super`, as well as the `callPackage` function.
+
+The value returned by this function should be a set similar to `pkgs/top-level/all-packages.nix`, containing overridden and/or new packages.
+
+Overlays are similar to other methods for customizing Nixpkgs, in particular the `packageOverrides` attribute described in [](#sec-modify-via-packageOverrides). Indeed, `packageOverrides` acts as an overlay with only the `super` argument. It is therefore appropriate for basic use, but overlays are more powerful and easier to distribute.
+
+## Using overlays to configure alternatives {#sec-overlays-alternatives}
+
+Certain software packages have different implementations of the same interface. Other distributions have functionality to switch between these. For example, Debian provides [DebianAlternatives](https://wiki.debian.org/DebianAlternatives).  Nixpkgs has what we call `alternatives`, which are configured through overlays.
+
+### BLAS/LAPACK {#sec-overlays-alternatives-blas-lapack}
+
+In Nixpkgs, we have multiple implementations of the BLAS/LAPACK numerical linear algebra interfaces. They are:
+
+-   [OpenBLAS](https://www.openblas.net/)
+
+    The Nixpkgs attribute is `openblas` for ILP64 (integer width = 64 bits) and `openblasCompat` for LP64 (integer width = 32 bits).  `openblasCompat` is the default.
+
+-   [LAPACK reference](http://www.netlib.org/lapack/) (also provides BLAS)
+
+    The Nixpkgs attribute is `lapack-reference`.
+
+-   [Intel MKL](https://software.intel.com/en-us/mkl) (only works on the x86_64 architecture, unfree)
+
+    The Nixpkgs attribute is `mkl`.
+
+-   [BLIS](https://github.com/flame/blis)
+
+    BLIS, available through the attribute `blis`, is a framework for linear algebra kernels. In addition, it implements the BLAS interface.
+
+-   [AMD BLIS/LIBFLAME](https://developer.amd.com/amd-aocl/blas-library/) (optimized for modern AMD x86_64 CPUs)
+
+    The AMD fork of the BLIS library, with attribute `amd-blis`, extends BLIS with optimizations for modern AMD CPUs. The changes are usually submitted to the upstream BLIS project after some time. However, AMD BLIS typically provides some performance improvements on AMD Zen CPUs. The complementary AMD LIBFLAME library, with attribute `amd-libflame`, provides a LAPACK implementation.
+
+Introduced in [PR #83888](https://github.com/NixOS/nixpkgs/pull/83888), we are able to override the `blas` and `lapack` packages to use different implementations, through the `blasProvider` and `lapackProvider` argument. This can be used to select a different provider. BLAS providers will have symlinks in `$out/lib/libblas.so.3` and `$out/lib/libcblas.so.3` to their respective BLAS libraries.  Likewise, LAPACK providers will have symlinks in `$out/lib/liblapack.so.3` and `$out/lib/liblapacke.so.3` to their respective LAPACK libraries. For example, Intel MKL is both a BLAS and LAPACK provider. An overlay can be created to use Intel MKL that looks like:
+
+```nix
+self: super:
+
+{
+  blas = super.blas.override {
+    blasProvider = self.mkl;
+  };
+
+  lapack = super.lapack.override {
+    lapackProvider = self.mkl;
+  };
+}
+```
+
+This overlay uses Intel's MKL library for both BLAS and LAPACK interfaces. Note that the same can be accomplished at runtime using `LD_LIBRARY_PATH` of `libblas.so.3` and `liblapack.so.3`. For instance:
+
+```ShellSession
+$ LD_LIBRARY_PATH=$(nix-build -A mkl)/lib:$LD_LIBRARY_PATH nix-shell -p octave --run octave
+```
+
+Intel MKL requires an `openmp` implementation when running with multiple processors. By default, `mkl` will use Intel's `iomp` implementation if no other is specified, but this is a runtime-only dependency and binary compatible with the LLVM implementation. To use that one instead, Intel recommends users set it with `LD_PRELOAD`. Note that `mkl` is only available on `x86_64-linux` and `x86_64-darwin`. Moreover, Hydra is not building and distributing pre-compiled binaries using it.
+
+For BLAS/LAPACK switching to work correctly, all packages must depend on `blas` or `lapack`. This ensures that only one BLAS/LAPACK library is used at one time. There are two versions of BLAS/LAPACK currently in the wild, `LP64` (integer size = 32 bits) and `ILP64` (integer size = 64 bits). Some software needs special flags or patches to work with `ILP64`. You can check if `ILP64` is used in Nixpkgs with `blas.isILP64` and `lapack.isILP64`. Some software does NOT work with `ILP64`, and derivations need to specify an assertion to prevent this. You can prevent `ILP64` from being used with the following:
+
+```nix
+{ stdenv, blas, lapack, ... }:
+
+assert (!blas.isILP64) && (!lapack.isILP64);
+
+stdenv.mkDerivation {
+  ...
+}
+```
+
+### Switching the MPI implementation {#sec-overlays-alternatives-mpi}
+
+All programs that are built with [MPI](https://en.wikipedia.org/wiki/Message_Passing_Interface) support use the generic attribute `mpi` as an input. At the moment Nixpkgs natively provides two different MPI implementations:
+
+-   [Open MPI](https://www.open-mpi.org/) (default), attribute name
+    `openmpi`
+
+-   [MPICH](https://www.mpich.org/), attribute name `mpich`
+
+To provide MPI enabled applications that use `MPICH`, instead of the default `Open MPI`, simply use the following overlay:
+
+```nix
+self: super:
+
+{
+  mpi = self.mpich;
+}
+```
diff --git a/doc/using/overlays.xml b/doc/using/overlays.xml
deleted file mode 100644
index 7f6ee040c7c..00000000000
--- a/doc/using/overlays.xml
+++ /dev/null
@@ -1,280 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-overlays">
- <title>Overlays</title>
- <para>
-  This chapter describes how to extend and change Nixpkgs using overlays. Overlays are used to add layers in the fixed-point used by Nixpkgs to compose the set of all packages.
- </para>
- <para>
-  Nixpkgs can be configured with a list of overlays, which are applied in order. This means that the order of the overlays can be significant if multiple layers override the same package.
- </para>
-<!--============================================================-->
- <section xml:id="sec-overlays-install">
-  <title>Installing overlays</title>
-
-  <para>
-   The list of overlays can be set either explicitly in a Nix expression, or through <literal>&lt;nixpkgs-overlays></literal> or user configuration files.
-  </para>
-
-  <section xml:id="sec-overlays-argument">
-   <title>Set overlays in NixOS or Nix expressions</title>
-
-   <para>
-    On a NixOS system the value of the <literal>nixpkgs.overlays</literal> option, if present, is passed to the system Nixpkgs directly as an argument. Note that this does not affect the overlays for non-NixOS operations (e.g. <literal>nix-env</literal>), which are <link xlink:href="#sec-overlays-lookup">looked</link> up independently.
-   </para>
-
-   <para>
-    The list of overlays can be passed explicitly when importing nixpkgs, for example <literal>import &lt;nixpkgs> { overlays = [ overlay1 overlay2 ]; }</literal>.
-   </para>
-
-   <para>
-    Further overlays can be added by calling the <literal>pkgs.extend</literal> or <literal>pkgs.appendOverlays</literal>, although it is often preferable to avoid these functions, because they recompute the Nixpkgs fixpoint, which is somewhat expensive to do.
-   </para>
-  </section>
-
-  <section xml:id="sec-overlays-lookup">
-   <title>Install overlays via configuration lookup</title>
-
-   <para>
-    The list of overlays is determined as follows.
-   </para>
-
-   <para>
-    <orderedlist>
-     <listitem>
-      <para>
-       First, if an <link xlink:href="#sec-overlays-argument"><varname>overlays</varname> argument</link> to the Nixpkgs function itself is given, then that is used and no path lookup will be performed.
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       Otherwise, if the Nix path entry <literal>&lt;nixpkgs-overlays></literal> exists, we look for overlays at that path, as described below.
-      </para>
-      <para>
-       See the section on <literal>NIX_PATH</literal> in the Nix manual for more details on how to set a value for <literal>&lt;nixpkgs-overlays>.</literal>
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       If one of <filename>~/.config/nixpkgs/overlays.nix</filename> and <filename>~/.config/nixpkgs/overlays/</filename> exists, then we look for overlays at that path, as described below. It is an error if both exist.
-      </para>
-     </listitem>
-    </orderedlist>
-   </para>
-
-   <para>
-    If we are looking for overlays at a path, then there are two cases:
-    <itemizedlist>
-     <listitem>
-      <para>
-       If the path is a file, then the file is imported as a Nix expression and used as the list of overlays.
-      </para>
-     </listitem>
-     <listitem>
-      <para>
-       If the path is a directory, then we take the content of the directory, order it lexicographically, and attempt to interpret each as an overlay by:
-       <itemizedlist>
-        <listitem>
-         <para>
-          Importing the file, if it is a <literal>.nix</literal> file.
-         </para>
-        </listitem>
-        <listitem>
-         <para>
-          Importing a top-level <filename>default.nix</filename> file, if it is a directory.
-         </para>
-        </listitem>
-       </itemizedlist>
-      </para>
-     </listitem>
-    </itemizedlist>
-   </para>
-
-   <para>
-    Because overlays that are set in NixOS configuration do not affect non-NixOS operations such as <literal>nix-env</literal>, the <filename>overlays.nix</filename> option provides a convenient way to use the same overlays for a NixOS system configuration and user configuration: the same file can be used as <filename>overlays.nix</filename> and imported as the value of <literal>nixpkgs.overlays</literal>.
-   </para>
-
-<!-- TODO: Example of sharing overlays between NixOS configuration
-     and configuration lookup. Also reference the example
-     from the sec-overlays-argument paragraph about NixOS.
- -->
-  </section>
- </section>
-<!--============================================================-->
- <section xml:id="sec-overlays-definition">
-  <title>Defining overlays</title>
-
-  <para>
-   Overlays are Nix functions which accept two arguments, conventionally called <varname>self</varname> and <varname>super</varname>, and return a set of packages. For example, the following is a valid overlay.
-  </para>
-
-<programlisting>
-self: super:
-
-{
-  boost = super.boost.override {
-    python = self.python3;
-  };
-  rr = super.callPackage ./pkgs/rr {
-    stdenv = self.stdenv_32bit;
-  };
-}
-</programlisting>
-
-  <para>
-   The first argument (<varname>self</varname>) corresponds to the final package set. You should use this set for the dependencies of all packages specified in your overlay. For example, all the dependencies of <varname>rr</varname> in the example above come from <varname>self</varname>, as well as the overridden dependencies used in the <varname>boost</varname> override.
-  </para>
-
-  <para>
-   The second argument (<varname>super</varname>) corresponds to the result of the evaluation of the previous stages of Nixpkgs. It does not contain any of the packages added by the current overlay, nor any of the following overlays. This set should be used either to refer to packages you wish to override, or to access functions defined in Nixpkgs. For example, the original recipe of <varname>boost</varname> in the above example, comes from <varname>super</varname>, as well as the <varname>callPackage</varname> function.
-  </para>
-
-  <para>
-   The value returned by this function should be a set similar to <filename>pkgs/top-level/all-packages.nix</filename>, containing overridden and/or new packages.
-  </para>
-
-  <para>
-   Overlays are similar to other methods for customizing Nixpkgs, in particular the <literal>packageOverrides</literal> attribute described in <xref linkend="sec-modify-via-packageOverrides"/>. Indeed, <literal>packageOverrides</literal> acts as an overlay with only the <varname>super</varname> argument. It is therefore appropriate for basic use, but overlays are more powerful and easier to distribute.
-  </para>
- </section>
- <section xml:id="sec-overlays-alternatives">
-   <title>Using overlays to configure alternatives</title>
-   <para>
-     Certain software packages have different implementations of the
-     same interface. Other distributions have functionality to switch
-     between these. For example, Debian provides <link
-     xlink:href="https://wiki.debian.org/DebianAlternatives">DebianAlternatives</link>.
-     Nixpkgs has what we call <literal>alternatives</literal>, which
-     are configured through overlays.
-   </para>
-   <section xml:id="sec-overlays-alternatives-blas-lapack">
-     <title>BLAS/LAPACK</title>
-     <para>
-       In Nixpkgs, we have multiple implementations of the BLAS/LAPACK
-       numerical linear algebra interfaces. They are:
-     </para>
-     <itemizedlist>
-       <listitem>
-         <para>
-           <link xlink:href="https://www.openblas.net/">OpenBLAS</link>
-         </para>
-         <para>
-           The Nixpkgs attribute is <literal>openblas</literal> for
-           ILP64 (integer width = 64 bits) and
-           <literal>openblasCompat</literal> for LP64 (integer width =
-           32 bits). <literal>openblasCompat</literal> is the default.
-         </para>
-       </listitem>
-       <listitem>
-         <para>
-           <link xlink:href="http://www.netlib.org/lapack/">LAPACK
-           reference</link> (also provides BLAS)
-         </para>
-         <para>
-           The Nixpkgs attribute is <literal>lapack-reference</literal>.
-         </para>
-       </listitem>
-       <listitem>
-         <para>
-           <link
-           xlink:href="https://software.intel.com/en-us/mkl">Intel
-           MKL</link> (only works on the x86_64 architecture, unfree)
-         </para>
-         <para>
-           The Nixpkgs attribute is <literal>mkl</literal>.
-         </para>
-       </listitem>
-       <listitem>
-         <para>
-           <link
-           xlink:href="https://developer.amd.com/amd-aocl/blas-library/">AMD
-           BLIS/LIBFLAME</link> (optimized for modern AMD x86_64 CPUs)
-         </para>
-         <para>
-          The AMD BLIS library, with attribute <literal>amd-blis</literal>,
-          provides a BLAS implementation. The complementary AMD LIBFLAME
-          library, with attribute <literal>amd-libflame</literal>, provides
-          a LAPACK implementation.
-         </para>
-       </listitem>
-     </itemizedlist>
-     <para>
-       Introduced in <link
-       xlink:href="https://github.com/NixOS/nixpkgs/pull/83888">PR
-       #83888</link>, we are able to override the <literal>blas</literal>
-       and <literal>lapack</literal> packages to use different implementations,
-       through the <literal>blasProvider</literal> and
-       <literal>lapackProvider</literal> argument. This can be used
-       to select a different provider. BLAS providers will have
-       symlinks in <literal>$out/lib/libblas.so.3</literal> and
-       <literal>$out/lib/libcblas.so.3</literal> to their respective
-       BLAS libraries. Likewise, LAPACK providers will have symlinks
-       in <literal>$out/lib/liblapack.so.3</literal> and
-       <literal>$out/lib/liblapacke.so.3</literal> to their respective
-       LAPACK libraries. For example, Intel MKL is both a BLAS and
-       LAPACK provider. An overlay can be created to use Intel MKL
-       that looks like:
-     </para>
-     <programlisting>
-self: super:
-
-{
-  blas = super.blas.override {
-    blasProvider = self.mkl;
-  }
-  lapack = super.lapack.override {
-    lapackProvider = self.mkl;
-  }
-}
-     </programlisting>
-     <para>
-       This overlay uses Intel’s MKL library for both BLAS and LAPACK
-       interfaces. Note that the same can be accomplished at runtime
-       using <literal>LD_LIBRARY_PATH</literal> of
-       <literal>libblas.so.3</literal> and
-       <literal>liblapack.so.3</literal>. For instance:
-     </para>
-     <programlisting>
-$ LD_LIBRARY_PATH=$(nix-build -A mkl)/lib:$LD_LIBRARY_PATH nix-shell -p octave --run octave
-     </programlisting>
-     <para>
-       Intel MKL requires an <literal>openmp</literal> implementation
-       when running with multiple processors. By default,
-       <literal>mkl</literal> will use Intel’s <literal>iomp</literal>
-       implementation if no other is specified, but this is a
-       runtime-only dependency and binary compatible with the LLVM
-       implementation. To use that one instead, Intel recommends users
-       set it with <literal>LD_PRELOAD</literal>. Note that
-       <literal>mkl</literal> is only available on
-       <literal>x86_64-linux</literal> and
-       <literal>x86_64-darwin</literal>. Moreover, Hydra is not
-       building and distributing pre-compiled binaries using it.
-     </para>
-     <para>
-       For BLAS/LAPACK switching to work correctly, all packages must
-       depend on <literal>blas</literal> or <literal>lapack</literal>.
-       This ensures that only one BLAS/LAPACK library is used at one
-       time. There are two versions versions of BLAS/LAPACK currently
-       in the wild, <literal>LP64</literal> (integer size = 32 bits)
-       and <literal>ILP64</literal> (integer size = 64 bits). Some
-       software needs special flags or patches to work with
-       <literal>ILP64</literal>. You can check if
-       <literal>ILP64</literal> is used in Nixpkgs with
-       <varname>blas.isILP64</varname> and
-       <varname>lapack.isILP64</varname>. Some software does NOT work
-       with <literal>ILP64</literal>, and derivations need to specify
-       an assertion to prevent this. You can prevent
-       <literal>ILP64</literal> from being used with the following:
-     </para>
-     <programlisting>
-{ stdenv, blas, lapack, ... }:
-
-assert (!blas.isILP64) &amp;&amp; (!lapack.isILP64);
-
-stdenv.mkDerivation {
-  ...
-}
-     </programlisting>
-   </section>
- </section>
-</chapter>
diff --git a/doc/using/overrides.chapter.md b/doc/using/overrides.chapter.md
new file mode 100644
index 00000000000..66e5103531a
--- /dev/null
+++ b/doc/using/overrides.chapter.md
@@ -0,0 +1,104 @@
+# Overriding {#chap-overrides}
+
+Sometimes one wants to override parts of `nixpkgs`, e.g. derivation attributes, the results of derivations.
+
+These functions are used to make changes to packages, returning only single packages. [Overlays](#chap-overlays), on the other hand, can be used to combine the overridden packages across the entire package set of Nixpkgs.
+
+## &lt;pkg&gt;.override {#sec-pkg-override}
+
+The function `override` is usually available for all the derivations in the nixpkgs expression (`pkgs`).
+
+It is used to override the arguments passed to a function.
+
+Example usages:
+
+```nix
+pkgs.foo.override { arg1 = val1; arg2 = val2; ... }
+```
+
+<!-- TODO: move below programlisting to a new section about extending and overlays and reference it -->
+
+```nix
+import pkgs.path { overlays = [ (self: super: {
+  foo = super.foo.override { barSupport = true ; };
+  })]};
+```
+
+```nix
+mypkg = pkgs.callPackage ./mypkg.nix {
+  mydep = pkgs.mydep.override { ... };
+  }
+```
+
+In the first example, `pkgs.foo` is the result of a function call with some default arguments, usually a derivation. Using `pkgs.foo.override` will call the same function with the given new arguments.
+
+## &lt;pkg&gt;.overrideAttrs {#sec-pkg-overrideAttrs}
+
+The function `overrideAttrs` allows overriding the attribute set passed to a `stdenv.mkDerivation` call, producing a new derivation based on the original one. This function is available on all derivations produced by the `stdenv.mkDerivation` function, which is most packages in the nixpkgs expression `pkgs`.
+
+Example usage:
+
+```nix
+helloWithDebug = pkgs.hello.overrideAttrs (oldAttrs: rec {
+  separateDebugInfo = true;
+});
+```
+
+In the above example, the `separateDebugInfo` attribute is overridden to be true, thus building debug info for `helloWithDebug`, while all other attributes will be retained from the original `hello` package.
+
+The argument `oldAttrs` is conventionally used to refer to the attr set originally passed to `stdenv.mkDerivation`.
+
+::: {.note}
+Note that `separateDebugInfo` is processed only by the `stdenv.mkDerivation` function, not the generated, raw Nix derivation. Thus, using `overrideDerivation` will not work in this case, as it overrides only the attributes of the final derivation. It is for this reason that `overrideAttrs` should be preferred in (almost) all cases to `overrideDerivation`, i.e. to allow using `stdenv.mkDerivation` to process input arguments, as well as the fact that it is easier to use (you can use the same attribute names you see in your Nix code, instead of the ones generated (e.g. `buildInputs` vs `nativeBuildInputs`), and it involves less typing).
+:::
+
+## &lt;pkg&gt;.overrideDerivation {#sec-pkg-overrideDerivation}
+
+::: {.warning}
+You should prefer `overrideAttrs` in almost all cases, see its documentation for the reasons why. `overrideDerivation` is not deprecated and will continue to work, but is less nice to use and does not have as many abilities as `overrideAttrs`.
+:::
+
+::: {.warning}
+Do not use this function in Nixpkgs as it evaluates a Derivation before modifying it, which breaks package abstraction and removes error-checking of function arguments. In addition, this evaluation-per-function application incurs a performance penalty, which can become a problem if many overrides are used. It is only intended for ad-hoc customisation, such as in `~/.config/nixpkgs/config.nix`.
+:::
+
+The function `overrideDerivation` creates a new derivation based on an existing one by overriding the original's attributes with the attribute set produced by the specified function. This function is available on all derivations defined using the `makeOverridable` function. Most standard derivation-producing functions, such as `stdenv.mkDerivation`, are defined using this function, which means most packages in the nixpkgs expression, `pkgs`, have this function.
+
+Example usage:
+
+```nix
+mySed = pkgs.gnused.overrideDerivation (oldAttrs: {
+  name = "sed-4.2.2-pre";
+  src = fetchurl {
+    url = ftp://alpha.gnu.org/gnu/sed/sed-4.2.2-pre.tar.bz2;
+    sha256 = "11nq06d131y4wmf3drm0yk502d2xc6n5qy82cg88rb9nqd2lj41k";
+  };
+  patches = [];
+});
+```
+
+In the above example, the `name`, `src`, and `patches` of the derivation will be overridden, while all other attributes will be retained from the original derivation.
+
+The argument `oldAttrs` is used to refer to the attribute set of the original derivation.
+
+::: {.note}
+A package's attributes are evaluated *before* being modified by the `overrideDerivation` function. For example, the `name` attribute reference in `url = "mirror://gnu/hello/${name}.tar.gz";` is filled-in *before* the `overrideDerivation` function modifies the attribute set. This means that overriding the `name` attribute, in this example, *will not* change the value of the `url` attribute. Instead, we need to override both the `name` *and* `url` attributes.
+:::
+
+## lib.makeOverridable {#sec-lib-makeOverridable}
+
+The function `lib.makeOverridable` is used to make the result of a function easily customizable. This utility only makes sense for functions that accept an argument set and return an attribute set.
+
+Example usage:
+
+```nix
+f = { a, b }: { result = a+b; };
+c = lib.makeOverridable f { a = 1; b = 2; };
+```
+
+The variable `c` is the value of the `f` function applied with some default arguments. Hence the value of `c.result` is `3`, in this example.
+
+The variable `c` however also has some additional functions, like
+[c.override](#sec-pkg-override) which can be used to override the
+default arguments. In this example the value of
+`(c.override { a = 4; }).result` is 6.
diff --git a/doc/using/overrides.xml b/doc/using/overrides.xml
deleted file mode 100644
index c9d36ddb2d7..00000000000
--- a/doc/using/overrides.xml
+++ /dev/null
@@ -1,145 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xmlns:xi="http://www.w3.org/2001/XInclude"
-         xml:id="chap-overrides">
- <title>Overriding</title>
- <para>
-  Sometimes one wants to override parts of <literal>nixpkgs</literal>, e.g. derivation attributes, the results of derivations.
- </para>
- <para>
-  These functions are used to make changes to packages, returning only single packages. <link xlink:href="#chap-overlays">Overlays</link>, on the other hand, can be used to combine the overridden packages across the entire package set of Nixpkgs.
- </para>
- <section xml:id="sec-pkg-override">
-  <title>&lt;pkg&gt;.override</title>
-
-  <para>
-   The function <varname>override</varname> is usually available for all the derivations in the nixpkgs expression (<varname>pkgs</varname>).
-  </para>
-
-  <para>
-   It is used to override the arguments passed to a function.
-  </para>
-
-  <para>
-   Example usages:
-<programlisting>pkgs.foo.override { arg1 = val1; arg2 = val2; ... }</programlisting>
-<!-- TODO: move below programlisting to a new section about extending and overlays
-           and reference it
-  -->
-<programlisting>
-import pkgs.path { overlays = [ (self: super: {
-  foo = super.foo.override { barSupport = true ; };
-  })]};
-</programlisting>
-<programlisting>
-mypkg = pkgs.callPackage ./mypkg.nix {
-  mydep = pkgs.mydep.override { ... };
-  }
-</programlisting>
-  </para>
-
-  <para>
-   In the first example, <varname>pkgs.foo</varname> is the result of a function call with some default arguments, usually a derivation. Using <varname>pkgs.foo.override</varname> will call the same function with the given new arguments.
-  </para>
- </section>
- <section xml:id="sec-pkg-overrideAttrs">
-  <title>&lt;pkg&gt;.overrideAttrs</title>
-
-  <para>
-   The function <varname>overrideAttrs</varname> allows overriding the attribute set passed to a <varname>stdenv.mkDerivation</varname> call, producing a new derivation based on the original one. This function is available on all derivations produced by the <varname>stdenv.mkDerivation</varname> function, which is most packages in the nixpkgs expression <varname>pkgs</varname>.
-  </para>
-
-  <para>
-   Example usage:
-<programlisting>
-helloWithDebug = pkgs.hello.overrideAttrs (oldAttrs: rec {
-  separateDebugInfo = true;
-});
-</programlisting>
-  </para>
-
-  <para>
-   In the above example, the <varname>separateDebugInfo</varname> attribute is overridden to be true, thus building debug info for <varname>helloWithDebug</varname>, while all other attributes will be retained from the original <varname>hello</varname> package.
-  </para>
-
-  <para>
-   The argument <varname>oldAttrs</varname> is conventionally used to refer to the attr set originally passed to <varname>stdenv.mkDerivation</varname>.
-  </para>
-
-  <note>
-   <para>
-    Note that <varname>separateDebugInfo</varname> is processed only by the <varname>stdenv.mkDerivation</varname> function, not the generated, raw Nix derivation. Thus, using <varname>overrideDerivation</varname> will not work in this case, as it overrides only the attributes of the final derivation. It is for this reason that <varname>overrideAttrs</varname> should be preferred in (almost) all cases to <varname>overrideDerivation</varname>, i.e. to allow using <varname>stdenv.mkDerivation</varname> to process input arguments, as well as the fact that it is easier to use (you can use the same attribute names you see in your Nix code, instead of the ones generated (e.g. <varname>buildInputs</varname> vs <varname>nativeBuildInputs</varname>), and it involves less typing).
-   </para>
-  </note>
- </section>
- <section xml:id="sec-pkg-overrideDerivation">
-  <title>&lt;pkg&gt;.overrideDerivation</title>
-
-  <warning>
-   <para>
-    You should prefer <varname>overrideAttrs</varname> in almost all cases, see its documentation for the reasons why. <varname>overrideDerivation</varname> is not deprecated and will continue to work, but is less nice to use and does not have as many abilities as <varname>overrideAttrs</varname>.
-   </para>
-  </warning>
-
-  <warning>
-   <para>
-    Do not use this function in Nixpkgs as it evaluates a Derivation before modifying it, which breaks package abstraction and removes error-checking of function arguments. In addition, this evaluation-per-function application incurs a performance penalty, which can become a problem if many overrides are used. It is only intended for ad-hoc customisation, such as in <filename>~/.config/nixpkgs/config.nix</filename>.
-   </para>
-  </warning>
-
-  <para>
-   The function <varname>overrideDerivation</varname> creates a new derivation based on an existing one by overriding the original's attributes with the attribute set produced by the specified function. This function is available on all derivations defined using the <varname>makeOverridable</varname> function. Most standard derivation-producing functions, such as <varname>stdenv.mkDerivation</varname>, are defined using this function, which means most packages in the nixpkgs expression, <varname>pkgs</varname>, have this function.
-  </para>
-
-  <para>
-   Example usage:
-<programlisting>
-mySed = pkgs.gnused.overrideDerivation (oldAttrs: {
-  name = "sed-4.2.2-pre";
-  src = fetchurl {
-    url = ftp://alpha.gnu.org/gnu/sed/sed-4.2.2-pre.tar.bz2;
-    sha256 = "11nq06d131y4wmf3drm0yk502d2xc6n5qy82cg88rb9nqd2lj41k";
-  };
-  patches = [];
-});
-</programlisting>
-  </para>
-
-  <para>
-   In the above example, the <varname>name</varname>, <varname>src</varname>, and <varname>patches</varname> of the derivation will be overridden, while all other attributes will be retained from the original derivation.
-  </para>
-
-  <para>
-   The argument <varname>oldAttrs</varname> is used to refer to the attribute set of the original derivation.
-  </para>
-
-  <note>
-   <para>
-    A package's attributes are evaluated *before* being modified by the <varname>overrideDerivation</varname> function. For example, the <varname>name</varname> attribute reference in <varname>url = "mirror://gnu/hello/${name}.tar.gz";</varname> is filled-in *before* the <varname>overrideDerivation</varname> function modifies the attribute set. This means that overriding the <varname>name</varname> attribute, in this example, *will not* change the value of the <varname>url</varname> attribute. Instead, we need to override both the <varname>name</varname> *and* <varname>url</varname> attributes.
-   </para>
-  </note>
- </section>
- <section xml:id="sec-lib-makeOverridable">
-  <title>lib.makeOverridable</title>
-
-  <para>
-   The function <varname>lib.makeOverridable</varname> is used to make the result of a function easily customizable. This utility only makes sense for functions that accept an argument set and return an attribute set.
-  </para>
-
-  <para>
-   Example usage:
-<programlisting>
-f = { a, b }: { result = a+b; };
-c = lib.makeOverridable f { a = 1; b = 2; };
-</programlisting>
-  </para>
-
-  <para>
-   The variable <varname>c</varname> is the value of the <varname>f</varname> function applied with some default arguments. Hence the value of <varname>c.result</varname> is <literal>3</literal>, in this example.
-  </para>
-
-  <para>
-   The variable <varname>c</varname> however also has some additional functions, like <link linkend="sec-pkg-override">c.override</link> which can be used to override the default arguments. In this example the value of <varname>(c.override { a = 4; }).result</varname> is 6.
-  </para>
- </section>
-</chapter>