Merge master into staging-next

doc/languages-frameworks/python.section.md

···
 
 ### How to use Intel's MKL with numpy and scipy?
 
-A `site.cfg` is created that configures BLAS based on the `blas` parameter of
-the `numpy` derivation. By passing in `mkl`, `numpy` and packages depending on
-`numpy` will be built with `mkl`.
-
-The following is an overlay that configures `numpy` to use `mkl`:
-
-```nix
-self: super: {
-  python37 = super.python37.override {
-    packageOverrides = python-self: python-super: {
-      numpy = python-super.numpy.override {
-        blas = super.pkgs.mkl;
-      };
-    };
-  };
-}
-```
-
-`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,darwin}` platforms;
-moreover, Hydra is not building and distributing pre-compiled binaries using it.
+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?
 

doc/using/overlays.xml

···
    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 has 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 and <literal>openblasCompat</literal> for LP64. This
+           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 x86 architecture, unfree)
+         </para>
+         <para>
+           The Nixpkgs attribute is <literal>mkl</literal>.
+         </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 ‘blas’ and ‘lapack’
+       packages to use different implementations, through the
+       ‘blasProvider’ and ‘lapackProvider’ argument. This can be used
+       to select a different provider. For example, an overlay can be
+       created 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_PRELOAD</literal> of libblas.so.3 and
+       liblapack.so.3.
+     </para>
+     <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 build
+       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>

nixos/modules/installer/tools/tools.nix

···
         # networking.proxy.noProxy = "127.0.0.1,localhost,internal.domain";
 
         # Select internationalisation properties.
-        # i18n = {
-        #   consoleFont = "Lat2-Terminus16";
-        #   consoleKeyMap = "us";
-        #   defaultLocale = "en_US.UTF-8";
+        # i18n.defaultLocale = "en_US.UTF-8";
+        # console = {
+        #   font = "Lat2-Terminus16";
+        #   keyMap = "us";
         # };
 
         # Set your time zone.

nixos/modules/programs/cdemu.nix

···
   options = {
     programs.cdemu = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           <command>cdemu</command> for members of

nixos/modules/programs/criu.nix

···
   options = {
     programs.criu = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Install <command>criu</command> along with necessary kernel options.

nixos/modules/programs/systemtap.nix

···
   options = {
     programs.systemtap = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Install <command>systemtap</command> along with necessary kernel options.

nixos/modules/programs/zsh/oh-my-zsh.nix

···
     options = {
       programs.zsh.ohMyZsh = {
         enable = mkOption {
+          type = types.bool;
           default = false;
           description = ''
             Enable oh-my-zsh.

nixos/modules/services/amqp/rabbitmq.nix

···
   options = {
     services.rabbitmq = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable the RabbitMQ server, an Advanced Message

nixos/modules/services/backup/mysql-backup.nix

···
 
     services.mysqlBackup = {
 
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to enable MySQL backups.
-        '';
-      };
+      enable = mkEnableOption "MySQL backups";
 
       calendar = mkOption {
         type = types.str;

nixos/modules/services/backup/postgresql-backup.nix

···
 
   options = {
     services.postgresqlBackup = {
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to enable PostgreSQL dumps.
-        '';
-      };
+      enable = mkEnableOption "PostgreSQL dumps";
 
       startAt = mkOption {
         default = "*-*-* 01:15:00";

nixos/modules/services/databases/clickhouse.nix

···
 
     services.clickhouse = {
 
-      enable = mkOption {
-        default = false;
-        description = "Whether to enable ClickHouse database server.";
-      };
+      enable = mkEnableOption "ClickHouse database server";
 
     };
 

nixos/modules/services/databases/firebird.nix

···
 
     services.firebird = {
 
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to enable the Firebird super server.
-        '';
-      };
+      enable = mkEnableOption "the Firebird super server";
 
       package = mkOption {
         default = pkgs.firebirdSuper;

nixos/modules/services/databases/memcached.nix

···
 
     services.memcached = {
 
-      enable = mkOption {
-        default = false;
-        description = "
-          Whether to enable Memcached.
-        ";
-      };
+      enable = mkEnableOption "Memcached";
 
       user = mkOption {
         default = "memcached";

nixos/modules/services/databases/mongodb.nix

···
 
     services.mongodb = {
 
-      enable = mkOption {
-        default = false;
-        description = "
-          Whether to enable the MongoDB server.
-        ";
-      };
+      enable = mkEnableOption "the MongoDB server";
 
       package = mkOption {
         default = pkgs.mongodb;

nixos/modules/services/databases/virtuoso.nix

···
 
     services.virtuoso = {
 
-      enable = mkOption {
-        default = false;
-        description = "Whether to enable Virtuoso Opensource database server.";
-      };
+      enable = mkEnableOption "Virtuoso Opensource database server";
 
       config = mkOption {
         default = "";

nixos/modules/services/hardware/ratbagd.nix

···
 
   options = {
     services.ratbagd = {
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to enable ratbagd for configuring gaming mice.
-        '';
-      };
+      enable = mkEnableOption "ratbagd for configuring gaming mice";
     };
   };
 

nixos/modules/services/hardware/thermald.nix

···
   ###### interface
   options = {
     services.thermald = {
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to enable thermald, the temperature management daemon.
-        '';
-      };
+      enable = mkEnableOption "thermald, the temperature management daemon";
 
       debug = mkOption {
         type = types.bool;

nixos/modules/services/mail/spamassassin.nix

···
   options = {
 
     services.spamassassin = {
-      enable = mkOption {
-        default = false;
-        description = "Whether to run the SpamAssassin daemon";
-      };
+      enable = mkEnableOption "the SpamAssassin daemon";
 
       debug = mkOption {
         default = false;

nixos/modules/services/misc/autofs.nix

···
     services.autofs = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Mount filesystems on demand. Unmount them automatically.

nixos/modules/services/misc/cgminer.nix

···
 
     services.cgminer = {
 
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to enable cgminer, an ASIC/FPGA/GPU miner for bitcoin and
-          litecoin.
-        '';
-      };
+      enable = mkEnableOption "cgminer, an ASIC/FPGA/GPU miner for bitcoin and litecoin";
 
       package = mkOption {
         default = pkgs.cgminer;

nixos/modules/services/misc/devmon.nix

···
 in {
   options = {
     services.devmon = {
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to enable devmon, an automatic device mounting daemon.
-        '';
-      };
+      enable = mkEnableOption "devmon, an automatic device mounting daemon";
     };
   };
 

nixos/modules/services/misc/disnix.nix

···
 
     services.disnix = {
 
-      enable = mkOption {
-        default = false;
-        description = "Whether to enable Disnix";
-      };
+      enable = mkEnableOption "Disnix";
 
       enableMultiUser = mkOption {
         type = types.bool;

nixos/modules/services/misc/felix.nix

···
 
     services.felix = {
 
-      enable = mkOption {
-        default = false;
-        description = "Whether to enable the Apache Felix OSGi service";
-      };
+      enable = mkEnableOption "the Apache Felix OSGi service";
 
       bundles = mkOption {
         type = types.listOf types.package;

nixos/modules/services/misc/ihaskell.nix

···
   options = {
     services.ihaskell = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Autostart an IHaskell notebook service.";
       };

nixos/modules/services/misc/safeeyes.nix

···
 
     services.safeeyes = {
 
-      enable = mkOption {
-        default = false;
-        description = "Whether to enable the safeeyes OSGi service";
-      };
+      enable = mkEnableOption "the safeeyes OSGi service";
 
     };
 

nixos/modules/services/misc/svnserve.nix

···
     services.svnserve = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Whether to enable svnserve to serve Subversion repositories through the SVN protocol.";
       };

nixos/modules/services/misc/synergy.nix

···
       # !!! All these option descriptions needs to be cleaned up.
 
       client = {
-        enable = mkOption {
-          default = false;
-          description = "
-            Whether to enable the Synergy client (receive keyboard and mouse events from a Synergy server).
-          ";
-        };
+        enable = mkEnableOption "the Synergy client (receive keyboard and mouse events from a Synergy server)";
+
         screenName = mkOption {
           default = "";
           description = ''
···
       };
 
       server = {
-        enable = mkOption {
-          default = false;
-          description = ''
-            Whether to enable the Synergy server (send keyboard and mouse events).
-          '';
-        };
+        enable = mkEnableOption "the Synergy server (send keyboard and mouse events)";
+
         configFile = mkOption {
           default = "/etc/synergy-server.conf";
           description = "The Synergy server configuration file.";

nixos/modules/services/network-filesystems/netatalk.nix

···
   options = {
     services.netatalk = {
 
-      enable = mkOption {
-          default = false;
-          description = "Whether to enable the Netatalk AFP fileserver.";
-        };
+      enable = mkEnableOption "the Netatalk AFP fileserver";
 
       port = mkOption {
         default = 548;
···
 
       homes = {
         enable = mkOption {
+          type = types.bool;
           default = false;
           description = "Enable sharing of the UNIX server user home directories.";
         };

nixos/modules/services/network-filesystems/rsyncd.nix

···
   options = {
     services.rsyncd = {
 
-      enable = mkOption {
-        default = false;
-        description = "Whether to enable the rsync daemon.";
-      };
+      enable = mkEnableOption "the rsync daemon";
 
       motd = mkOption {
         type = types.str;

nixos/modules/services/network-filesystems/xtreemfs.nix

···
 
       dir = {
         enable = mkOption {
+          type = types.bool;
           default = true;
           description = ''
             Whether to enable XtreemFS DIR service.
           '';
         };
+
         uuid = mkOption {
           example = "eacb6bab-f444-4ebf-a06a-3f72d7465e40";
           description = ''
···
 
       mrc = {
         enable = mkOption {
+          type = types.bool;
           default = true;
           description = ''
             Whether to enable XtreemFS MRC service.
           '';
         };
+
         uuid = mkOption {
           example = "eacb6bab-f444-4ebf-a06a-3f72d7465e41";
           description = ''
···
 
       osd = {
         enable = mkOption {
+          type = types.bool;
           default = true;
           description = ''
             Whether to enable XtreemFS OSD service.
           '';
         };
+
         uuid = mkOption {
           example = "eacb6bab-f444-4ebf-a06a-3f72d7465e42";
           description = ''

nixos/modules/services/network-filesystems/yandex-disk.nix

···
     services.yandex-disk = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = "
           Whether to enable Yandex-disk client. See https://disk.yandex.ru/

nixos/modules/services/networking/amuled.nix

···
     services.amule = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to run the AMule daemon. You need to manually run "amuled --ec-config" to configure the service for the first time.

nixos/modules/services/networking/babeld.nix

···
 
     services.babeld = {
 
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to run the babeld network routing daemon.
-        '';
-      };
+      enable = mkEnableOption "the babeld network routing daemon";
 
       interfaceDefaults = mkOption {
         default = null;

nixos/modules/services/networking/bind.nix

···
 
     services.bind = {
 
-      enable = mkOption {
-        default = false;
-        description = "
-          Whether to enable BIND domain name server.
-        ";
-      };
+      enable = mkEnableOption "BIND domain name server";
 
       cacheNetworks = mkOption {
         default = ["127.0.0.0/24"];

nixos/modules/services/networking/bitlbee.nix

···
     services.bitlbee = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to run the BitlBee IRC to other chat network gateway.

nixos/modules/services/networking/cntlm.nix

···
 
   options.services.cntlm = {
 
-    enable = mkOption {
-      default = false;
-      description = ''
-        Whether to enable the cntlm, which start a local proxy.
-      '';
-    };
+    enable = mkEnableOption "cntlm, which starts a local proxy";
 
     username = mkOption {
       description = ''

nixos/modules/services/networking/flashpolicyd.nix

···
     services.flashpolicyd = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description =
           ''

nixos/modules/services/networking/gvpe.nix

···
 {
   options = {
     services.gvpe = {
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to run gvpe
-        '';
-      };
+      enable = lib.mkEnableOption "gvpe";
+
       nodename = mkOption {
         default = null;
         description =''

nixos/modules/services/networking/hostapd.nix

···
     services.hostapd = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Enable putting a wireless interface into infrastructure mode,

nixos/modules/services/networking/ircd-hybrid/default.nix

···
 
     services.ircdHybrid = {
 
-      enable = mkOption {
-        default = false;
-        description = "
-          Enable IRCD.
-        ";
-      };
+      enable = mkEnableOption "IRCD";
 
       serverName = mkOption {
         default = "hades.arpa";

nixos/modules/services/networking/mailpile.nix

···
   options = {
 
     services.mailpile = {
-      enable = mkOption {
-        default = false;
-        description = "
-          Whether to enable Mailpile the mail client.
-        ";
-      };
+      enable = mkEnableOption "Mailpile the mail client";
+
       hostname = mkOption {
         default = "localhost";
         description = "Listen to this hostname or ip.";

nixos/modules/services/networking/ntp/chrony.nix

···
   options = {
     services.chrony = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to synchronise your machine's time using chrony.

nixos/modules/services/networking/ntp/ntpd.nix

···
     services.ntp = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to synchronise your machine's time using ntpd, as a peer in

nixos/modules/services/networking/openfire.nix

···
 
     services.openfire = {
 
-      enable = mkOption {
-        default = false;
-        description = "
-          Whether to enable OpenFire XMPP server.
-        ";
-      };
+      enable = mkEnableOption "OpenFire XMPP server";
 
       usePostgreSQL = mkOption {
         default = true;

nixos/modules/services/networking/prayer.nix

···
 
     services.prayer = {
 
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to run the prayer webmail http server.
-        '';
-      };
+      enable = mkEnableOption "the prayer webmail http server";
 
       port = mkOption {
         default = "2080";

nixos/modules/services/networking/quassel.nix

···
 
     services.quassel = {
 
-      enable = mkOption {
-        default = false;
-        description = ''
-          Whether to run the Quassel IRC client daemon.
-        '';
-      };
+      enable = mkEnableOption "the Quassel IRC client daemon";
 
       certificateFile = mkOption {
         type = types.nullOr types.str;

nixos/modules/services/networking/radvd.nix

···
   options = {
 
     services.radvd.enable = mkOption {
+      type = types.bool;
       default = false;
       description =
         ''

nixos/modules/services/networking/rdnssd.nix

···
   options = {
 
     services.rdnssd.enable = mkOption {
+      type = types.bool;
       default = false;
       #default = config.networking.enableIPv6;
       description =

nixos/modules/services/networking/sabnzbd.nix

···
 
   options = {
     services.sabnzbd = {
-      enable = mkOption {
-        default = false;
-        description = "Whether to enable the sabnzbd server.";
-      };
+      enable = mkEnableOption "the sabnzbd server";
+
       configFile = mkOption {
         default = "/var/lib/sabnzbd/sabnzbd.ini";
         description = "Path to config file.";

nixos/modules/services/networking/shairport-sync.nix

···
     services.shairport-sync = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Enable the shairport-sync daemon.

nixos/modules/services/networking/ssh/lshd.nix

···
     services.lshd = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable the GNU lshd SSH2 daemon, which allows

nixos/modules/services/networking/xinetd.nix

···
 
   options = {
 
-    services.xinetd.enable = mkOption {
-      default = false;
-      description = ''
-        Whether to enable the xinetd super-server daemon.
-      '';
-    };
+    services.xinetd.enable = mkEnableOption "the xinetd super-server daemon";
 
     services.xinetd.extraDefaults = mkOption {
       default = "";

nixos/modules/services/security/fprot.nix

···
 
     services.fprot = {
       updater = {
-        enable = mkOption {
-          default = false;
-          description = ''
-            Whether to enable automatic F-Prot virus definitions database updates.
-          '';
-        };
+        enable = mkEnableOption "automatic F-Prot virus definitions database updates";
 
         productData = mkOption {
           description = ''

nixos/modules/services/system/kerberos/default.nix

···
   ###### interface
   options = {
     services.kerberos_server = {
-      enable = mkOption {
-        default = false;
-        description = ''
-          Enable the kerberos authentification server.
-        '';
-      };
+      enable = lib.mkEnableOption "the kerberos authentification server";
 
       realms = mkOption {
         type = types.attrsOf (types.submodule realm);

nixos/modules/services/system/localtime.nix

···
   options = {
     services.localtime = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Enable <literal>localtime</literal>, simple daemon for keeping the system

nixos/modules/services/system/uptimed.nix

···
   options = {
     services.uptimed = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Enable <literal>uptimed</literal>, allowing you to track

nixos/modules/services/web-servers/jboss/default.nix

···
     services.jboss = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Whether to enable JBoss. WARNING : this package is outdated and is known to have vulnerabilities.";
       };

nixos/modules/services/x11/desktop-managers/enlightenment.nix

···
   options = {
 
     services.xserver.desktopManager.enlightenment.enable = mkOption {
+      type = types.bool;
       default = false;
       description = "Enable the Enlightenment desktop environment.";
     };

nixos/modules/services/x11/desktop-managers/gnome3.nix

···
 
     services.xserver.desktopManager.gnome3 = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Enable Gnome 3 desktop manager.";
       };

nixos/modules/services/x11/desktop-managers/kodi.nix

···
   options = {
     services.xserver.desktopManager.kodi = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = "Enable the kodi multimedia center.";
       };

nixos/modules/services/x11/display-managers/startx.nix

···
   options = {
     services.xserver.displayManager.startx = {
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable the dummy "startx" pseudo-display manager,

nixos/modules/services/x11/hardware/wacom.nix

···
     services.xserver.wacom = {
 
       enable = mkOption {
+        type = types.bool;
         default = false;
         description = ''
           Whether to enable the Wacom touchscreen/digitizer/tablet.

nixos/release-combined.nix

···
       else pkgs.lib.mapAttrs (n: v: removeMaintainers v) set
     else set;
 
-  allSupportedNixpkgs = builtins.removeAttrs (removeMaintainers (import ../pkgs/top-level/release.nix {
-    supportedSystems = supportedSystems ++ limitedSupportedSystems;
-    nixpkgs = nixpkgsSrc;
-  })) [ "unstable" ];
-
 in rec {
 
   nixos = removeMaintainers (import ./release.nix {

pkgs/applications/audio/openmpt123/default.nix

···
 , usePulseAudio ? config.pulseaudio or false, libpulseaudio }:
 
 let
-  version = "0.4.11";
+  version = "0.4.12";
 in stdenv.mkDerivation {
   pname = "openmpt123";
   inherit version;
 
   src = fetchurl {
     url = "https://lib.openmpt.org/files/libopenmpt/src/libopenmpt-${version}+release.autotools.tar.gz";
-    sha256 = "1g96bpwh419s429wb387lkmhjsn3ldsjrzrb8h9p3wva5z6943i6";
+    sha256 = "0q2yf9g6hcwvr2nk3zggkscyf0np6i03q2g7fx10i2kcdr3n9k8c";
   };
 
   enableParallelBuilding = true;

pkgs/applications/editors/apostrophe/default.nix

···
 
 in stdenv.mkDerivation rec {
   pname = "apostrophe";
-  version = "unstable-2020-03-29";
+  version = "2.2.0.2";
 
   src = fetchFromGitLab {
     owner  = "somas";
     repo   = pname;
     domain = "gitlab.gnome.org";
-    rev    = "219fa8976e3b8a6f0cea15cfefe4e336423f2bdb";
-    sha256 = "192n5qs3x6rx62mqxd6wajwm453pns8kjyz5v3xc891an6bm1kqx";
+    rev    = "v${version}";
+    sha256 = "13wvfkg0jw9mayd9ifzkqnhf8fmfjgr1lsj4niqbyrw130y9r9f6";
   };
 
   nativeBuildInputs = [ meson ninja cmake pkgconfig desktop-file-utils

pkgs/applications/editors/vscode/vscode.nix

···
   archive_fmt = if system == "x86_64-darwin" then "zip" else "tar.gz";
 
   sha256 = {
-    x86_64-linux = "15jg39hmlnicq0zrz77yar1bmn5y6gp2670dya2qm5klhva9hd0f";
-    x86_64-darwin = "1ghqhn46jpbj3is8q5zcj0biyc7gwinhiz3qdpcnf88ga2blcsz8";
+    x86_64-linux = "1n083pzp2dsz6z6rcl1ldcwhd4i03sjigdfslfardhc4v5lbvmv8";
+    x86_64-darwin = "1qk3gscyskf4fwc8i09afr3wsyd1lwwycx6rf02wwh4n9py50b20";
   }.${system};
 in
   callPackage ./generic.nix rec {
···
 
     # Please backport all compatible updates to the stable release.
     # This is important for the extension ecosystem.
-    version = "1.44.1";
+    version = "1.44.2";
     pname = "vscode";
 
     executableName = "code" + lib.optionalString isInsiders "-insiders";

pkgs/applications/editors/vscode/vscodium.nix

···
   archive_fmt = if system == "x86_64-darwin" then "zip" else "tar.gz";
 
   sha256 = {
-    x86_64-linux = "16qwhnxpwarnwvlxwvy13g687g1cnfzysq16qkykkhqig0cnalmb";
-    x86_64-darwin = "1p9qkbj59bfc0kn9fzg99gqxbzwxq297qxivxcjflsapd712s4vm";
+    x86_64-linux = "141hwj1a2bsgzpfk354dnnmg4ak00fss3xsgqplyk949pbk6v1af";
+    x86_64-darwin = "0fi8nz1gayzw5dp6d3m7jsmij3jj4yjg5rk1s9w6falpgka76dm1";
   }.${system};
 
   sourceRoot = {
···
 
     # Please backport all compatible updates to the stable release.
     # This is important for the extension ecosystem.
-    version = "1.44.1";
+    version = "1.44.2";
     pname = "vscodium";
 
     executableName = "codium";

pkgs/applications/graphics/xournalpp/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "xournalpp";
-  version = "1.0.17";
+  version = "1.0.18";
 
   src = fetchFromGitHub {
     owner = "xournalpp";
     repo = pname;
     rev = version;
-    sha256 = "0xw2mcgnm4sa9hrhfgp669lfypw97drxjmz5w8i5whaprpvmkxzw";
+    sha256 = "0a9ygbmd4dwgck3k8wsrm2grynqa0adb12wwspzmzvpisbadffjy";
   };
 
   nativeBuildInputs = [ cmake gettext pkgconfig wrapGAppsHook ];

pkgs/applications/misc/kanboard/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "kanboard";
-  version = "1.2.13";
+  version = "1.2.14";
 
   src = fetchFromGitHub {
     owner = "kanboard";
     repo = "kanboard";
     rev = "v${version}";
-    sha256 = "0mm5sx323v1rwykd1dhvk4d3ipgvgvi3wvhrlavbja3lgay3mdwk";
+    sha256 = "11bwajzidnyagdyip7i8rwni1f66acv0k4lybdm0mc4195anivjh";
   };
 
   dontBuild = true;

pkgs/applications/misc/sidequest/default.nix

···
 { stdenv, lib, fetchurl, buildFHSUserEnv, makeDesktopItem, makeWrapper, atomEnv, libuuid, at-spi2-atk, icu, openssl, zlib }:
 	let
 		pname = "sidequest";
-		version = "0.8.7";
+		version = "0.10.2";
 
 		desktopItem = makeDesktopItem rec {
 			name = "SideQuest";
···
 
 			src = fetchurl {
 				url = "https://github.com/the-expanse/SideQuest/releases/download/v${version}/SideQuest-${version}.tar.xz";
-				sha256 = "1hbr6ml689zq4k3mzmn2xcn4r4dy717rgq3lgm32pzwgy5w92i2j";
+				sha256 = "1vfxn4gx5b138gj6nk4w3jlp2l56cqpb8hq2kn5mrf4dhjii8n88";
 			};
 
 			buildInputs = [ makeWrapper ];

pkgs/applications/networking/instant-messengers/jackline/default.nix

···
 { stdenv, fetchFromGitHub, ocamlPackages }:
 
-assert stdenv.lib.versionAtLeast ocamlPackages.ocaml.version "4.02.2";
+assert stdenv.lib.versionAtLeast ocamlPackages.ocaml.version "4.07";
 
 stdenv.mkDerivation {
   pname = "jackline";
-  version = "2019-08-08";
+  version = "unstable-2020-03-22";
 
   src = fetchFromGitHub {
     owner  = "hannesm";
     repo   = "jackline";
-    rev    = "b934594010a563ded9c0f436e3fab8f1cae29856";
-    sha256 = "076h03jd970xlii90ax6kvgyq67g81gs30yvdzps366n7zzy3yfc";
+    rev    = "52f84525c74c43e8d03fb1e6ff025ccb2699e4aa";
+    sha256 = "0wir573ah1w16xzdn9rfwk3569zq4ff5frp0ywq70va4gdlb679c";
   };
 
   buildInputs = with ocamlPackages; [
-                  ocaml ocamlbuild findlib topkg ppx_sexp_conv
-                  erm_xmpp tls nocrypto x509 ocaml_lwt otr astring
-                  ptime notty sexplib hex uutf
+                  ocaml ocamlbuild findlib topkg ppx_sexp_conv ppx_deriving
+                  erm_xmpp tls mirage-crypto mirage-crypto-pk x509 domain-name
+                  ocaml_lwt otr astring ptime mtime notty sexplib hex uutf
+                  dns-client base64
                 ];
 
   buildPhase = "${ocamlPackages.topkg.run} build --pinned true";
···
 
   meta = with stdenv.lib; {
     homepage = "https://github.com/hannesm/jackline";
-    description = "Terminal-based XMPP client in OCaml";
+    description = "minimalistic secure XMPP client in OCaml";
     license = licenses.bsd2;
     maintainers = with maintainers; [ sternenseemann ];
   };

pkgs/applications/networking/instant-messengers/psi-plus/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "psi-plus";
-  version = "1.4.984";
+  version = "1.4.1086";
 
   src = fetchFromGitHub {
     owner = "psi-plus";
     repo = "psi-plus-snapshots";
     rev = version;
-    sha256 = "1nii2nfi37i6mn79xmygscmm8ax75ky244wxkzlga0ya8i8wfjh7";
+    sha256 = "0war4hbjs1m7ll6rvpl3lj44lb0p5fi0g2siinnxpjffz2ydi97p";
   };
 
-  resources = fetchFromGitHub {
-    owner = "psi-plus";
-    repo = "resources";
-    rev = "2f1c12564f7506bf902a26040fdb47ead4df6b73";
-    sha256 = "1dgm9k052fq7f2bpx13kchg7sxb227dkn115lyspzvhnhprnypz2";
-  };
-
-  postUnpack = ''
-    cp -a "${resources}/iconsets" "$sourceRoot"
-  '';
-
   cmakeFlags = [
     "-DENABLE_PLUGINS=ON"
   ];
···
     libidn qca2-qt5 libsecret libXScrnSaver hunspell
     libgcrypt libotr html-tidy libgpgerror libsignal-protocol-c
   ];
-
-  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     description = "XMPP (Jabber) client";

pkgs/applications/networking/remote/citrix-workspace/default.nix

···
 , gtk_engines
 , alsaLib
 , zlib
-, version ? "19.12.0"
+, version ? "20.04.0"
 }:
 
 let
···
         x86hash   = "07rfp90ksnvr8zv7ix7f0z6a59n48s7bd4kqbzilfwxgs4ddqmcy";
         x64suffix = "19";
         x86suffix = "19";
-        homepage  = "https://www.citrix.com/de-de/downloads/workspace-app/linux/workspace-app-for-linux-latest.html";
+        homepage  = "https://www.citrix.com/downloads/workspace-app/legacy-workspace-app-for-linux/workspace-app-for-linux-1912.html";
+      };
+
+      "20.04.0" = {
+        major     = "20";
+        minor     = "04";
+        patch     = "0";
+        x64hash   = "E923592216F9541173846F932784E6C062CB09C9E8858219C7489607BF82A0FB";
+        x86hash   = "A2E2E1882723DA6796E68916B3BB2B44DD575A83DEB03CA90A262F6C81B1A53F";
+        x64suffix = "21";
+        x86suffix = "21";
+        homepage  = "https://www.citrix.com/downloads/workspace-app/linux/workspace-app-for-linux-latest.html";
       };
     };
 

pkgs/applications/office/trilium/default.nix

···
     maintainers = with maintainers; [ emmanuelrosa dtzWill kampka ];
   };
 
-  version = "0.40.5";
+  version = "0.40.7";
 
 in {
   
···
 
     src = fetchurl {
       url = "https://github.com/zadam/trilium/releases/download/v${version}/trilium-linux-x64-${version}.tar.xz";
-      sha256 = "02hmfgv8viy1hn2ix4b0gdzbcj7piddsmjdnb0b5hpwahqrikiyi";
+      sha256 = "0xi3bb0kbphbgpk2wlsad509g0hwwb259q2vkv0kgyr4i4wcyc1f";
     };
   
     # Fetch from source repo, no longer included in release.
···
 
     src = fetchurl {
       url = "https://github.com/zadam/trilium/releases/download/v${version}/trilium-linux-x64-server-${version}.tar.xz";
-      sha256 = "00b7qx2h26qrdhw2a7y0irhbr442yynnzpm1pz55hi33zpckbrc7";
+      sha256 = "15bspngnnbq6mhp1f82j9hccg0ymhm6i4rddpgz3n7dw5wxdj0sm";
     };
 
     nativeBuildInputs = [

pkgs/applications/science/astronomy/stellarium/default.nix

···
 
 mkDerivation rec {
   pname = "stellarium";
-  version = "0.20.0";
+  version = "0.20.1";
 
   src = fetchFromGitHub {
     owner = "Stellarium";
     repo = "stellarium";
     rev = "v${version}";
-    sha256 = "1732dxkgyqd4xf0ry7v930vcbv60l8iry596869z1d47j2piibs4";
+    sha256 = "1x8svan03k1x9jwqflimbpj7jpg6mjrbz26bg1sbhsqdlc8rbhky";
   };
 
   nativeBuildInputs = [ cmake perl wrapQtAppsHook ];

pkgs/applications/science/biology/mosdepth/default.nix

···
   hts-nim = fetchFromGitHub {
     owner = "brentp";
     repo = "hts-nim";
-    rev = "v0.2.14";
-    sha256 = "0d1z4b6mrppmz3hgkxd4wcy79w68icvhi7q7n3m2k17n8f3xbdx3";
+    rev = "v0.3.4";
+    sha256 = "0670phk1bq3l9j2zaa8i5wcpc5dyfrc0l2a6c21g0l2mmdczffa7";
   };
 
   docopt = fetchFromGitHub {
···
 
 in stdenv.mkDerivation rec {
   pname = "mosdepth";
-  version = "0.2.6";
+  version = "0.2.9";
 
   src = fetchFromGitHub {
     owner = "brentp";
     repo = "mosdepth";
     rev = "v${version}";
-    sha256 = "0i9pl9lsli3y84ygxanrr525gfg8fs9h481944cbzsmqmbldwvgk";
+    sha256 = "01gm9gj2x2zs4yx6wk761fi1papi7qr3gp4ln1kkn8n2f9y9h849";
   };
 
   buildInputs = [ nim ];

pkgs/applications/science/chemistry/octopus/default.nix

···
 , libyaml, libxc, fftw, blas, lapack, gsl, netcdf, arpack, autoreconfHook
 }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "octopus";

pkgs/applications/science/machine-learning/shogun/default.nix

···
 assert pythonSupport -> pythonPackages != null;
 assert opencvSupport -> opencv != null;
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 let
   pname = "shogun";

pkgs/applications/science/math/R/default.nix

···
 , static ? false
 }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   name = "R-3.6.3";

pkgs/applications/science/math/giac/default.nix

···
 }:
 
 assert enableGUI -> libGLU != null && libGL != null && xorg != null && fltk != null;
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "giac${lib.optionalString enableGUI "-with-xcas"}";

pkgs/applications/science/math/gmsh/default.nix

···
 { stdenv, fetchurl, cmake, blas, lapack, gfortran, gmm, fltk, libjpeg
 , zlib, libGL, libGLU, xorg, opencascade-occt }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "gmsh";

pkgs/applications/science/math/sage/sage-env.nix

···
 , less
 }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 # This generates a `sage-env` shell file that will be sourced by sage on startup.
 # It sets up various environment variables, telling sage where to find its

pkgs/applications/science/math/sage/sage-with-env.nix

···
 }:
 
 # lots of segfaults with (64 bit) blas
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 # Wrapper that combined `sagelib` with `sage-env` to produce an actually
 # executable sage. No tests are run yet and no documentation is built.

pkgs/applications/science/math/sage/sagelib.nix

···
 , pplpy
 }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 # This is the core sage python package. Everything else is just wrappers gluing
 # stuff together. It is not very useful on its own though, since it will not

pkgs/applications/version-management/git-and-tools/git/update.sh

···
 set -eu -o pipefail
 
 oldVersion="$(nix-instantiate --eval -E "with import ./. {}; lib.getVersion git" | tr -d '"')"
-latestTag="$(git ls-remote --tags --sort="v:refname" git://github.com/git/git.git | grep -v '\{\}' | grep -v '\-rc' | tail -1 | sed 's|^.*/v\(.*\)|\1|')"
-targetVersion="${1:-latestTag}"
+latestTag="$(git ls-remote --tags --sort="v:refname" https://github.com/git/git.git | grep -v '\{\}' | grep -v '\-rc' | tail -1 | sed 's|^.*/v\(.*\)|\1|')"
+targetVersion="${1:-$latestTag}"
 
 if [ ! "${oldVersion}" = "${targetVersion}" ]; then
   update-source-version git "${targetVersion}"

pkgs/applications/window-managers/dwm/dwm-status.nix

···
 
 rustPlatform.buildRustPackage rec {
   pname = "dwm-status";
-  version = "1.6.3";
+  version = "1.6.4";
 
   src = fetchFromGitHub {
     owner = "Gerschtli";
     repo = "dwm-status";
     rev = version;
-    sha256 = "02sprsr7822ynkwpf3xdgmkdrgkw3vgijhlh65bayiv3b5lwb54n";
+    sha256 = "05dhd2gy7ysrnchdimrdd7jvzs1db9fyrk4ci7850jhrgavfd7c4";
   };
 
   nativeBuildInputs = [ makeWrapper pkgconfig ];
   buildInputs = [ dbus gdk-pixbuf libnotify xorg.libX11 ];
 
-  cargoSha256 = "0xybd6110b29ghl66kxfs64704qlhnn9jb5vl7lfk9sv62cs564i";
+  cargoSha256 = "0zkbps8vsjcvy7x0sgb07kacszi57dlyq8j6ia6yy0jyqnvlaqa7";
 
   postInstall = lib.optionalString (bins != [])  ''
     wrapProgram $out/bin/dwm-status --prefix "PATH" : "${stdenv.lib.makeBinPath bins}"

pkgs/build-support/alternatives/blas/default.nix

···
 { lib, stdenv
 , lapack-reference, openblasCompat, openblas
-, is64bit ? false
-, blasProvider ? if is64bit then openblas else openblasCompat }:
+, isILP64 ? false
+, blasProvider ? if isILP64 then openblas else openblasCompat }:
 
 let
   blasFortranSymbols = [
···
                        else stdenv.hostPlatform.extensions.sharedLibrary;
 
 
-  is64bit = blasProvider.blas64 or false;
+  isILP64 = blasProvider.blas64 or false;
   blasImplementation = lib.getName blasProvider;
 
 in
 
-assert is64bit -> (blasImplementation == "openblas" && blasProvider.blas64) || blasImplementation == "mkl";
+assert isILP64 -> (blasImplementation == "openblas" && blasProvider.blas64) || blasImplementation == "mkl";
 
 stdenv.mkDerivation {
   pname = "blas";
···
   };
 
   passthru = {
-    inherit is64bit;
+    inherit isILP64;
     provider = blasProvider;
     implementation = blasImplementation;
   };
···
   dontBuild = true;
   dontConfigure = true;
   unpackPhase = "src=$PWD";
+
+  dontPatchELF = true;
 
   installPhase = (''
   mkdir -p $out/lib $dev/include $dev/lib/pkgconfig
···
 EOF
 '' + stdenv.lib.optionalString (blasImplementation == "mkl") ''
   mkdir -p $out/nix-support
-  echo 'export MKL_INTERFACE_LAYER=${lib.optionalString is64bit "I"}LP64,GNU' > $out/nix-support/setup-hook
+  echo 'export MKL_INTERFACE_LAYER=${lib.optionalString isILP64 "I"}LP64,GNU' > $out/nix-support/setup-hook
+  ln -s $out/lib/libblas${canonicalExtension} $out/lib/libmkl_rt${stdenv.hostPlatform.extensions.sharedLibrary}
+  ln -sf ${blasProvider}/include/* $dev/include
 '');
 }

pkgs/build-support/alternatives/lapack/default.nix

···
 { lib, stdenv
 , lapack-reference, openblasCompat, openblas
-, is64bit ? false
-, lapackProvider ? if is64bit then openblas else openblasCompat }:
+, isILP64 ? false
+, lapackProvider ? if isILP64 then openblas else openblasCompat }:
 
 let
 
···
 
 in
 
-assert is64bit -> (lapackImplementation == "openblas" && lapackProvider.blas64) || lapackImplementation == "mkl";
+assert isILP64 -> (lapackImplementation == "openblas" && lapackProvider.blas64) || lapackImplementation == "mkl";
 
 stdenv.mkDerivation {
   pname = "lapack";
···
   };
 
   passthru = {
-    inherit is64bit;
+    inherit isILP64;
     provider = lapackProvider;
     implementation = lapackImplementation;
   };
···
   dontBuild = true;
   dontConfigure = true;
   unpackPhase = "src=$PWD";
+
+  dontPatchELF = true;
 
   installPhase = (''
   mkdir -p $out/lib $dev/include $dev/lib/pkgconfig
···
 EOF
 '' + stdenv.lib.optionalString (lapackImplementation == "mkl") ''
   mkdir -p $out/nix-support
-  echo 'export MKL_INTERFACE_LAYER=${lib.optionalString is64bit "I"}LP64,GNU' > $out/nix-support/setup-hook
+  echo 'export MKL_INTERFACE_LAYER=${lib.optionalString isILP64 "I"}LP64,GNU' > $out/nix-support/setup-hook
+  ln -s $out/lib/liblapack${canonicalExtension} $out/lib/libmkl_rt${stdenv.hostPlatform.extensions.sharedLibrary}
+  ln -sf ${lapackProvider}/include/* $dev/include
 '');
 }

pkgs/development/compilers/bs-platform/build-bs-platform.nix

···
   installPhase = ''
     mkdir -p $out/bin
     cp -rf jscomp lib ${bin_folder} vendor odoc_gen native bsb bsc bsrefmt $out
-    mkdir $out/lib/ocaml
+    mkdir -p $out/lib/ocaml
     cp jscomp/runtime/js.* jscomp/runtime/*.cm* $out/lib/ocaml
     cp jscomp/others/*.ml jscomp/others/*.mli jscomp/others/*.cm* $out/lib/ocaml
     cp jscomp/stdlib-406/*.ml jscomp/stdlib-406/*.mli jscomp/stdlib-406/*.cm* $out/lib/ocaml

pkgs/development/compilers/bs-platform/default.nix

···
 in
 (build-bs-platform rec {
   inherit stdenv runCommand fetchFromGitHub ninja nodejs python3;
-  version = "7.2.0";
+  version = "7.3.1";
   ocaml-version = "4.06.1";
 
   src = fetchFromGitHub {
     owner = "BuckleScript";
     repo = "bucklescript";
     rev = version;
-    sha256 = "1fsx7gvcp6rbqd0qf5fix02mbbmk9rgm09zbwjrx0lp5cjv3n2s4";
+    sha256 = "14vp6cl5ml7xb3pd0paqajb50qv62l8j5m8hi3b6fh0pm68j1yxd";
     fetchSubmodules = true;
   };
 }).overrideAttrs (attrs: {

pkgs/development/compilers/julia/1.3.nix

···
 , CoreServices, ApplicationServices
 }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 with stdenv.lib;
 
···
       "SHELL=${stdenv.shell}"
 
       "USE_SYSTEM_BLAS=1"
-      "USE_BLAS64=${if blas.is64bit then "1" else "0"}"
+      "USE_BLAS64=${if blas.isILP64 then "1" else "0"}"
 
       "USE_SYSTEM_LAPACK=1"
 

pkgs/development/compilers/julia/shared.nix

···
 
 with stdenv.lib;
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 let
   dsfmtVersion = "2.2.3";
···
       "SHELL=${stdenv.shell}"
 
       "USE_SYSTEM_BLAS=1"
-      "USE_BLAS64=${if blas.is64bit then "1" else "0"}"
+      "USE_BLAS64=${if blas.isILP64 then "1" else "0"}"
 
       "USE_SYSTEM_LAPACK=1"
 

pkgs/development/interpreters/octave/default.nix

···
 , darwin
 }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   version = "5.2.0";
···
   enableParallelBuilding = true;
 
   # See https://savannah.gnu.org/bugs/?50339
-  F77_INTEGER_8_FLAG = if blas.is64bit then "-fdefault-integer-8" else "";
+  F77_INTEGER_8_FLAG = if blas.isILP64 then "-fdefault-integer-8" else "";
 
   configureFlags = [
     "--with-blas=blas"
     "--with-lapack=lapack"
-    (if blas.is64bit then "--enable-64" else "--disable-64")
+    (if blas.isILP64 then "--enable-64" else "--disable-64")
   ]
     ++ (if stdenv.isDarwin then [ "--enable-link-all-dependencies" ] else [ ])
     ++ stdenv.lib.optionals enableReadline [ "--enable-readline" ]

pkgs/development/libraries/fflas-ffpack/default.nix

···
 , gmpxx
 }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "fflas-ffpack";

pkgs/development/libraries/linbox/default.nix

···
 , withSage ? false # sage support
 }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "linbox";

pkgs/development/libraries/qrupdate/default.nix

···
           -e 's,^LAPACK=.*,LAPACK=-L${lapack}/lib -llapack,' \
           Makeconf
     ''
-    + stdenv.lib.optionalString blas.is64bit
+    + stdenv.lib.optionalString blas.isILP64
     ''
       sed -i Makeconf -e '/^FFLAGS=.*/ s/$/-fdefault-integer-8/'
     '';

pkgs/development/libraries/science/math/arpack/default.nix

···
 
   cmakeFlags = [
     "-DBUILD_SHARED_LIBS=ON"
-    "-DINTERFACE64=${optionalString blas.is64bit "1"}"
+    "-DINTERFACE64=${optionalString blas.isILP64 "1"}"
   ];
 
   preCheck = if stdenv.isDarwin then ''

pkgs/development/libraries/science/math/ipopt/default.nix

···
 { stdenv, fetchurl, unzip, blas, lapack, gfortran }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "ipopt";

pkgs/development/libraries/science/math/magma/default.nix

···
-{ stdenv, fetchurl, cmake, gfortran, cudatoolkit, libpthreadstubs, lapack, blas
-, mklSupport ? false, mkl ? null
-}:
-
-assert !mklSupport || mkl != null;
+{ stdenv, fetchurl, cmake, gfortran, cudatoolkit, libpthreadstubs, lapack, blas }:
 
 with stdenv.lib;
 
···
     name = "magma-${version}.tar.gz";
   };
 
-  buildInputs = [ gfortran cudatoolkit libpthreadstubs cmake ]
-    ++ (if mklSupport then [ mkl ] else [ lapack blas ]);
+  buildInputs = [ gfortran cudatoolkit libpthreadstubs cmake lapack blas ];
 
   doCheck = false;
-
-  MKLROOT = optionalString mklSupport mkl;
 
   preConfigure = ''
     export CC=${cudatoolkit.cc}/bin/gcc CXX=${cudatoolkit.cc}/bin/g++

pkgs/development/libraries/science/math/scalapack/default.nix

···
 , gfortran, mpi, blas, lapack
 } :
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "scalapack";

pkgs/development/libraries/science/math/scs/default.nix

···
 { stdenv, fetchFromGitHub, blas, lapack, gfortran, fixDarwinDylibNames }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "scs";

pkgs/development/libraries/science/math/suitesparse/4.2.nix

···
 { stdenv, fetchurl, gfortran, blas, lapack }:
 
 let
-  int_t = if blas.is64bit then "int64_t" else "int32_t";
+  int_t = if blas.isILP64 then "int64_t" else "int32_t";
 in
 stdenv.mkDerivation rec {
   version = "4.2.1";

pkgs/development/libraries/science/math/suitesparse/4.4.nix

···
   version = "4.4.4";
   name = "suitesparse-${version}";
 
-  int_t = if blas.is64bit then "int64_t" else "int32_t";
+  int_t = if blas.isILP64 then "int64_t" else "int32_t";
   SHLIB_EXT = stdenv.hostPlatform.extensions.sharedLibrary;
 in
 stdenv.mkDerivation {

pkgs/development/libraries/science/math/suitesparse/default.nix

···
     "BLAS=-lblas"
     "LAPACK=-llapack"
     "MY_METIS_LIB=-lmetis"
-  ] ++ stdenv.lib.optionals blas.is64bit [
+  ] ++ stdenv.lib.optionals blas.isILP64 [
     "CFLAGS=-DBLAS64"
   ] ++ stdenv.lib.optionals enableCuda [
     "CUDA_PATH=${cudatoolkit}"

pkgs/development/libraries/science/math/superlu/default.nix

···
 { stdenv, fetchurl, cmake,
   gfortran, blas, lapack}:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   version = "5.2.1";

pkgs/development/libraries/sundials/2.x.nix

···
 , gfortran
 , lapackSupport ? true }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "sundials";

pkgs/development/libraries/sundials/default.nix

···
 , gfortran
 , lapackSupport ? true }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "sundials";

pkgs/development/ocaml-modules/alcotest/default.nix

···
-{ stdenv, fetchzip, ocaml, findlib, ocamlbuild, topkg, dune
-, cmdliner, astring, fmt, result, uuidm
+{ lib, buildDunePackage, fetchurl
+, astring, cmdliner, fmt, uuidm, re, stdlib-shims
 }:
 
-let param =
-  if stdenv.lib.versionAtLeast ocaml.version "4.02" then {
-    version = "0.8.5";
-    sha256 = "1mhckvdcxkikbzgvy24kjz4265l15b86a6swz7m3ynbgvqdcfzqn";
-    nativeBuildInputs = [ dune ];
-    propagatedBuildInputs = [ uuidm ];
-    buildPhase = "dune build -p alcotest";
-    inherit (dune) installPhase;
-  } else {
-    version = "0.7.2";
-    sha256 = "1qgsz2zz5ky6s5pf3j3shc4fjc36rqnjflk8x0wl1fcpvvkr52md";
-    buildInputs = [ topkg ];
-    nativeBuildInputs = [ ocamlbuild ];
-    inherit (topkg) buildPhase installPhase;
-  };
-in
+buildDunePackage rec {
+  pname = "alcotest";
+  version = "1.0.1";
 
-stdenv.mkDerivation rec {
-  name = "ocaml${ocaml.version}-alcotest-${version}";
-  inherit (param) version buildPhase installPhase;
-
-  src = fetchzip {
-    url = "https://github.com/mirage/alcotest/archive/${version}.tar.gz";
-    inherit (param) sha256;
+  src = fetchurl {
+    url = "https://github.com/mirage/alcotest/releases/download/${version}/alcotest-${version}.tbz";
+    sha256 = "1xlklxb83gamqbg8j5dzm5jk4mvcwkspxajh93p6vpw9ia1li1qc";
   };
 
-  nativeBuildInputs = [ ocaml findlib ] ++ (param.nativeBuildInputs or []);
-  buildInputs = [ findlib ] ++ (param.buildInputs or []);
-
-  propagatedBuildInputs = [ cmdliner astring fmt result ]
-  ++ (param.propagatedBuildInputs or []);
+  propagatedBuildInputs = [ astring cmdliner fmt uuidm re stdlib-shims ];
 
-  createFindlibDestdir = true;
-
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://github.com/mirage/alcotest";
     description = "A lightweight and colourful test framework";
-    license = stdenv.lib.licenses.isc;
+    license = licenses.isc;
     maintainers = [ maintainers.ericbmerritt ];
   };
 }

pkgs/development/ocaml-modules/angstrom/default.nix

···
-{ stdenv, fetchFromGitHub, buildDunePackage, alcotest, result, bigstringaf }:
+{ lib, fetchFromGitHub, buildDunePackage, ocaml, alcotest, result, bigstringaf }:
 
 buildDunePackage rec {
   pname = "angstrom";
···
     sha256 = "0w0wavqzdy2hrh7cjyl9w72ad4vndhwhknwvyacvkwkja5wys5b2";
   };
 
-  buildInputs = [ alcotest ];
+  checkInputs = [ alcotest ];
   propagatedBuildInputs = [ bigstringaf result ];
-  doCheck = true;
+  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 = stdenv.lib.licenses.bsd3;
-    maintainers = with stdenv.lib.maintainers; [ sternenseemann ];
+    license = lib.licenses.bsd3;
+    maintainers = with lib.maintainers; [ sternenseemann ];
   };
 }

pkgs/development/ocaml-modules/base64/default.nix

···
-{ lib, fetchzip, buildDunePackage, alcotest, bos }:
+{ lib, fetchpatch, fetchzip, buildDunePackage, alcotest, bos }:
 
 let version = "3.2.0"; in
 
-buildDunePackage {
+buildDunePackage rec {
   pname = "base64";
   inherit version;
 
···
 
   minimumOCamlVersion = "4.03";
 
-  buildInputs = [ alcotest bos ];
+  buildInputs = [ bos ];
+
+  # Fix test-suite for alcotest ≥ 1.0
+  patches = [(fetchpatch {
+    url = "https://github.com/mirage/ocaml-base64/commit/8d334d02aa52875158fae3e2fb8fe0a5596598d0.patch";
+    sha256 = "0lvqdp98qavpzis1wgwh3ijajq79hq47898gsrk37fpyjbrdzf5q";
+  })];
 
   doCheck = true;
+  checkInputs = [ alcotest ];
 
   meta = {
     homepage = "https://github.com/mirage/ocaml-base64";

pkgs/development/ocaml-modules/bigstringaf/default.nix

···
-{ lib, fetchFromGitHub, buildDunePackage, alcotest, bigarray-compat }:
+{ lib, fetchFromGitHub, buildDunePackage, ocaml, alcotest, bigarray-compat }:
 
 buildDunePackage rec {
   pname = "bigstringaf";
···
     sha256 = "04b088vrqzmxsyan9f9nr8721bxip4b930cgvb5zkbbmrw3ylmwc";
   };
 
-  buildInputs = [ alcotest ];
+  checkInputs = [ alcotest ];
   propagatedBuildInputs = [ bigarray-compat ];
-  doCheck = true;
+  doCheck = lib.versionAtLeast ocaml.version "4.05";
 
   meta = {
     description = "Bigstring intrinsics and fast blits based on memcpy/memmove";

pkgs/development/ocaml-modules/cstruct/ppx.nix

···
 
 	minimumOCamlVersion = "4.03";
 
-	buildInputs = [ sexplib ppx_tools_versioned ];
-	propagatedBuildInputs = [ cstruct ];
+	propagatedBuildInputs = [ cstruct ppx_tools_versioned sexplib ];
 }

pkgs/development/ocaml-modules/digestif/default.nix

···
-{ lib, fetchurl, buildDunePackage
+{ lib, fetchurl, fetchpatch, buildDunePackage
 , bigarray-compat, eqaf, stdlib-shims
 , alcotest
 }:
···
     url = "https://github.com/mirage/digestif/releases/download/v${version}/digestif-v${version}.tbz";
     sha256 = "09g4zngqiw97cljv8ds4m063wcxz3y7c7vzaprsbpjzi0ja5jdcy";
   };
+
+  # Fix tests with alcotest ≥ 1
+  patches = [ (fetchpatch {
+    url = "https://github.com/mirage/digestif/commit/b65d996c692d75da0a81323253429e07d14b72b6.patch";
+    sha256 = "0sf7qglcp19dhs65pwrrc7d9v57icf18jsrhpmvwskx8b4dchfiv";
+  })];
 
   buildInputs = lib.optional doCheck alcotest;
   propagatedBuildInputs = [ bigarray-compat eqaf stdlib-shims ];

pkgs/development/ocaml-modules/lacaml/default.nix

···
 { stdenv, fetchFromGitHub, darwin, ocaml, findlib, dune, base, stdio, lapack, blas }:
 
 assert stdenv.lib.versionAtLeast (stdenv.lib.getVersion ocaml) "4.05.0";
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "ocaml${ocaml.version}-lacaml";

pkgs/development/ocaml-modules/otr/default.nix

···
-{ lib, fetchFromGitHub, buildDunePackage
-, cstruct, sexplib0, rresult, nocrypto, astring
+{ lib, fetchurl, buildDunePackage
+, cstruct, sexplib0, rresult, mirage-crypto, mirage-crypto-pk, astring, base64
+, mirage-crypto-rng
 }:
 
 buildDunePackage rec {
   pname = "otr";
-  version = "0.3.6";
+  version = "0.3.8";
 
-  src = fetchFromGitHub {
-    owner  = "hannesm";
-    repo   = "ocaml-otr";
-    rev    = version;
-    sha256 = "0iz6p85a0jxng9aq9blqsky173zaqfr6wlc5j48ad55lgwzlbih5";
+  src = fetchurl {
+    url = "https://github.com/hannesm/ocaml-otr/releases/download/v${version}/otr-v${version}.tbz";
+    sha256 = "18hn9l8wznqnlh2jf1hpnp36f1cx80ncwiiivsbj34llhgp3893d";
   };
 
-  propagatedBuildInputs = [ cstruct sexplib0 rresult nocrypto astring ];
+  useDune2 = true;
+
+  propagatedBuildInputs = [ cstruct sexplib0 mirage-crypto mirage-crypto-pk
+                            astring rresult base64 ];
 
   doCheck = true;
+  checkInputs = [ mirage-crypto-rng ];
+
   meta = with lib; {
     homepage = "https://github.com/hannesm/ocaml-otr";
     description = "Off-the-record messaging protocol, purely in OCaml";

pkgs/development/ocaml-modules/owl/default.nix

···
 , npy
 }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 assert blas.implementation == "openblas" && lapack.implementation == "openblas";
 
 buildDunePackage rec {

pkgs/development/ocaml-modules/tls/default.nix

···
-{ stdenv, fetchFromGitHub, ocaml, findlib, ocamlbuild, topkg
-, ppx_sexp_conv, result, x509, nocrypto, cstruct-sexp, ppx_cstruct, cstruct-unix, ounit
-, lwt     ? null}:
+{ stdenv, fetchurl, buildDunePackage, ppx_sexp_conv, ppx_cstruct, cstruct
+, cstruct-sexp, sexplib, mirage-crypto, mirage-crypto-pk, mirage-crypto-rng
+, x509, domain-name, fmt, cstruct-unix, ounit2, ocaml_lwt, ptime }:
 
-with stdenv.lib;
-
-let withLwt = lwt != null; in
-
-if !versionAtLeast ocaml.version "4.04"
-then throw "tls is not available for OCaml ${ocaml.version}"
-else
+buildDunePackage rec {
+  minimumOCamlVersion = "4.07";
 
-stdenv.mkDerivation rec {
-  version = "0.10.4";
-  name = "ocaml${ocaml.version}-tls-${version}";
+  version = "0.11.1";
+  pname = "tls";
 
-  src = fetchFromGitHub {
-    owner  = "mirleft";
-    repo   = "ocaml-tls";
-    rev    = version;
-    sha256 = "02wv4lia583imn3sfci4nqv6ac5nzig5j3yfdnlqa0q8bp9rfc6g";
+  src = fetchurl {
+    url = "https://github.com/mirleft/ocaml-tls/releases/download/v${version}/tls-v${version}.tbz";
+    sha256 = "0ms13fbaxgmpbviazlfa4hb7nmi7s22nklc7ns926b0rr1aq1069";
   };
 
-  nativeBuildInputs = [ ocaml ocamlbuild findlib ];
-  buildInputs = [ findlib topkg ppx_sexp_conv ppx_cstruct ]
-  ++ optionals doCheck [ ounit cstruct-unix ];
-  propagatedBuildInputs = [ cstruct-sexp nocrypto result x509 ] ++
-                          optional withLwt lwt;
+  useDune2 = true;
 
-  buildPhase = "${topkg.run} build --tests ${boolToString doCheck} --with-mirage false --with-lwt ${boolToString withLwt}";
+  doCheck = true;
+  buildInputs = [ cstruct-unix ounit2 ];
 
-  doCheck = versionAtLeast ocaml.version "4.06";
-  checkPhase = "${topkg.run} test";
-
-  inherit (topkg) installPhase;
+  propagatedBuildInputs = [ ppx_sexp_conv ppx_cstruct cstruct cstruct-sexp
+                            sexplib mirage-crypto mirage-crypto-pk mirage-crypto-rng
+                            x509 domain-name fmt ocaml_lwt ptime ];
 
   meta = with stdenv.lib; {
     homepage = "https://github.com/mirleft/ocaml-tls";

pkgs/development/ocaml-modules/x509/default.nix

···
-{ lib, fetchurl, buildDunePackage, ocaml
+{ lib, fetchurl, buildDunePackage
 , alcotest, cstruct-unix
-, asn1-combinators, domain-name, fmt, gmap, nocrypto, rresult
+, asn1-combinators, domain-name, fmt, gmap, rresult, mirage-crypto, mirage-crypto-pk
+, logs, base64
 }:
 
 buildDunePackage rec {
+  minimumOCamlVersion = "4.07";
+
   pname = "x509";
-  version = "0.7.1";
+  version = "0.11.0";
 
   src = fetchurl {
     url = "https://github.com/mirleft/ocaml-x509/releases/download/v${version}/x509-v${version}.tbz";
-    sha256 = "0hnklgdm1fwwqi0nfvpdbp7ddqvrh9h8697mr99bxqdfhg6sxh1w";
+    sha256 = "0gcs3vpmixxxx2q4b2iphb1xw1jffya1wkp0p1xbmsfcghzrj20m";
   };
 
-  buildInputs = lib.optionals doCheck [ alcotest cstruct-unix ];
-  propagatedBuildInputs = [ asn1-combinators domain-name fmt gmap nocrypto rresult ];
+  useDune2 = true;
+
+  buildInputs = [ alcotest cstruct-unix ];
+  propagatedBuildInputs = [ asn1-combinators domain-name fmt gmap mirage-crypto mirage-crypto-pk rresult  logs base64 ];
 
-  doCheck = lib.versionAtLeast ocaml.version "4.06";
+  doCheck = true;
 
   meta = with lib; {
     homepage = "https://github.com/mirleft/ocaml-x509";

pkgs/development/python-modules/cvxopt/default.nix

···
 , withFftw ? true
 }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 buildPythonPackage rec {
   pname = "cvxopt";

pkgs/development/python-modules/numpy/default.nix

···
 , setuptoolsBuildHook
  }:
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 let
   cfg = writeTextFile {
     name = "site.cfg";
     text = (lib.generators.toINI {} {
       ${blas.implementation} = {
-        include_dirs = "${blas}/include:${lapack}/include";
+        include_dirs = "${lib.getDev blas}/include:${lib.getDev lapack}/include";
         library_dirs = "${blas}/lib:${lapack}/lib";
-      } // lib.optionalAttrs (blas.implementation == "mkl") {
-        mkl_libs = "mkl_rt";
-        lapack_libs = "";
+        libraries = "lapack,lapacke,blas,cblas";
       };
     });
   };

pkgs/development/tools/clj-kondo/default.nix

···
 
 stdenv.mkDerivation rec{
   pname = "clj-kondo";
-  version = "2020.03.20";
+  version = "2020.04.05";
 
   reflectionJson = fetchurl {
     name = "reflection.json";
···
 
   src = fetchurl {
     url = "https://github.com/borkdude/${pname}/releases/download/v${version}/${pname}-${version}-standalone.jar";
-    sha256 = "05z80cdzk8aw3j0nxfynzwpb9hhpbl54bbrv18dpqj5dj893mbgm";
+    sha256 = "0k9samcqkpkdgzbzr2bpixf75987lsabh97101v1fg12qvjhf187";
   };
 
   dontUnpack = true;

pkgs/development/tools/metals/default.nix

···
 
 let
   baseName = "metals";
-  version = "0.8.3";
+  version = "0.8.4";
   deps = stdenv.mkDerivation {
     name = "${baseName}-deps-${version}";
     buildCommand = ''
···
     '';
     outputHashMode = "recursive";
     outputHashAlgo = "sha256";
-    outputHash     = "1l196glr7rbsvrqmq6i7iw532jkz8d1w5m9nh0kh5z12visc7bkk";
+    outputHash     = "1r8aff082m3kh6wy5diyvq8bzg5x4dp1da9sfz223ii0kc1yp6w5";
   };
 in
 stdenv.mkDerivation rec {

pkgs/development/tools/ocaml/ocamlformat/default.nix

···
 
 with ocamlPackages; buildDunePackage rec {
   pname = "ocamlformat";
-  version = "0.14.0";
+  version = "0.14.1";
 
   minimumOCamlVersion = "4.06";
 
···
 
   src = fetchurl {
     url = "https://github.com/ocaml-ppx/ocamlformat/releases/download/${version}/ocamlformat-${version}.tbz";
-    sha256 = "070c0x6z5y0lyls56zm34g8lyc093wkr0jfp50dvrkr9fk1sx2wi";
+    sha256 = "03wn46xib63748157xchj7gflkw5000fcjw6n89h9g82q9slazaa";
   };
 
   buildInputs = [

pkgs/development/tools/ocaml/opam/default.nix

···
       sha256 = "02lb2d9i12bxrz2ba5wygk2bycan316skqlyri0597q7j9210g8r";
     };
     opam = fetchurl {
-      url = "https://github.com/ocaml/opam/archive/2.0.6.zip";
-      sha256 = "076070qwf7rqp5bh0mmgc5b3vyihgp4qpkd6fscxzya4in66bzf8";
+      url = "https://github.com/ocaml/opam/archive/2.0.7.zip";
+      sha256 = "03yxj4hw9p5dh34b1yzl3xd0l1v2l2az0n7ix453yjrkn0wn0xic";
     };
   };
 in stdenv.mkDerivation {
   pname = "opam";
-  version = "2.0.6";
+  version = "2.0.7";
 
   buildInputs = [ unzip curl ncurses ocaml makeWrapper getconf ] ++ lib.optional stdenv.isLinux bubblewrap;
 
···
   meta = with stdenv.lib; {
     description = "A package manager for OCaml";
     homepage = "https://opam.ocaml.org/";
-    maintainers = [ maintainers.henrytill ];
+    maintainers = [ maintainers.henrytill maintainers.marsam ];
     platforms = platforms.all;
   };
 }
-# Generated by: ./opam.nix.pl -v 2.0.6 -p opam-shebangs.patch
+# Generated by: ./opam.nix.pl -v 2.0.7 -p opam-shebangs.patch

pkgs/development/tools/ocaml/opam/opam.nix.pl

···
   meta = with stdenv.lib; {
     description = "A package manager for OCaml";
     homepage = "https://opam.ocaml.org/";
-    maintainers = [ maintainers.henrytill ];
+    maintainers = [ maintainers.henrytill maintainers.marsam ];
     platforms = platforms.all;
   };
 }

pkgs/development/tools/rust/cargo-expand/default.nix

···
-{ stdenv, rustPlatform, fetchFromGitHub, llvmPackages, darwin }:
+{ lib, rustPlatform, fetchFromGitHub }:
 
 rustPlatform.buildRustPackage rec {
   pname = "cargo-expand";
-  version = "0.4.19";
+  version = "0.5.0";
 
   src = fetchFromGitHub {
     owner = "dtolnay";
     repo = pname;
     rev = version;
-    sha256 = "15izqd6nbpxjjymdmcpzjmaiygs1vdrpg9cw1nzmrkb8fc4h5ch5";
+    sha256 = "1zpnhigsa0cyr3lj0h7z2xhi01zjrnakvvrgmqz4lyf5gabh9vcg";
   };
 
-  cargoSha256 = "0sbpymxhhwxg13w9821b17nda6p3ycqr81i7bj4fxil0n3sb910h";
-
-  buildInputs = [ llvmPackages.libclang ]
-    ++ stdenv.lib.optional stdenv.isDarwin darwin.apple_sdk.frameworks.Security;
+  cargoSha256 = "1rdh1b240gcjbk3wc384x459lbp8dy9a9mgrampqjk1n115zgbzp";
 
-  LIBCLANG_PATH = "${llvmPackages.libclang}/lib";
-
-  meta = with stdenv.lib; {
-    description = "A utility and Cargo subcommand designed to let people expand macros in their Rust source code";
+  meta = with lib; {
+    description =
+      "A utility and Cargo subcommand designed to let people expand macros in their Rust source code";
     homepage = "https://github.com/dtolnay/cargo-expand";
     license = with licenses; [ mit asl20 ];
     platforms = platforms.all;

pkgs/games/openrct2/default.nix

···
 }:
 
 let
-  name = "openrct2-${version}";
-  version = "0.2.4";
+  version = "0.2.6";
 
   openrct2-src = fetchFromGitHub {
     owner = "OpenRCT2";
     repo = "OpenRCT2";
     rev = "v${version}";
-    sha256 = "1rlw3w20llg36sj3bk50g661qw766ng8ma3p42sdkj8br9dw800h";
+    sha256 = "1vikbkg3wh5ngzdfilb6irbh6nqinf138qpdz8wz9izlvl8s36k4";
   };
 
   objects-src = fetchFromGitHub {
     owner = "OpenRCT2";
     repo = "objects";
-    rev = "v1.0.12";
-    sha256 = "0vfhyldc8nfvkg4d9kry669haxz2165walbxzgza7pqpnd7aqgrf";
+    rev = "v1.0.14";
+    sha256 = "1bqbia5y73v4r0sv5cvi5729jh2ns7cxn557blh715yxswk91590";
   };
 
   title-sequences-src = fetchFromGitHub {
···
   };
 in
 stdenv.mkDerivation {
-  inherit name;
+  inherit version;
+  pname = "openrct2";
 
   src = openrct2-src;
 
···
   '';
 
   cmakeFlags = [
-    "-DCMAKE_BUILD_TYPE=RELWITHDEBINFO"
     "-DDOWNLOAD_OBJECTS=OFF"
     "-DDOWNLOAD_TITLE_SEQUENCES=OFF"
   ];
 
-  makeFlags = ["all" "g2"];
+  enableParallelBuilding = true;
 
   preFixup = "ln -s $out/share/openrct2 $out/bin/data";
 

pkgs/servers/mautrix-whatsapp/default.nix

···
 
 buildGoModule {
   pname = "mautrix-whatsapp-unstable";
-  version = "2020-04-12";
+  version = "2020-04-21";
 
   src = fetchFromGitHub {
     owner = "tulir";
     repo = "mautrix-whatsapp";
-    rev = "44bb623e7a7486a0cdd13fd67b2aaca2ddba20ce";
-    sha256 = "1fwxn6511pq9fdc8d2jp4vgkm1zag55pig75qdxfn63hl3i2607k";
+    rev = "53fe1b18184fc0967658805abc8560641f8d2cb0";
+    sha256 = "0rahj9v7cgvk4w3m41jbs8vnya37dhq5wxyhyg74kwrv8a2nqxra";
   };
 
-  modSha256 = "04pdap1q7zsa1wv2h0j9104fawn95g37yqslmp2mq7722hiqhp9x";
+  modSha256 = "0jn88a4hagwfkw9bv8cg12ywsg35znmfkmhi1v7k2qpj5qzi81w6";
 
   meta = with stdenv.lib; {
     homepage = "https://github.com/tulir/mautrix-whatsapp";

pkgs/servers/nosql/mongodb/mongodb.nix

···
 
 with stdenv.lib;
 
-{ version, sha256, patches ? [] }@args:
+{ version, sha256, patches ? []
+, license ? stdenv.lib.licenses.sspl
+}@args:
 
 let
   python = python27.withPackages (ps: with ps; [ pyyaml typing cheetah ]);
···
   meta = {
     description = "A scalable, high-performance, open source NoSQL database";
     homepage = "http://www.mongodb.org";
-    license = licenses.sspl;
+    inherit license;
 
     maintainers = with maintainers; [ bluescreen303 offline cstrahan ];
     platforms = subtractLists systems.doubles.i686 systems.doubles.unix;

pkgs/servers/nosql/mongodb/v3_4.nix

···
   version = "3.4.24";
   sha256 = "0j6mvgv0jnsnvgkl8505bl88kbxkba66qijlpi1la0dd5pd1imfr";
   patches = [ ./forget-build-dependencies-3-4.patch ];
+  license = stdenv.lib.licenses.agpl3;
 }

pkgs/servers/tailscale/default.nix

···
 
 buildGoModule rec {
   pname = "tailscale";
-  version = "0.97";
+  version = "0.97-219";
 
   src = fetchFromGitHub {
     owner = "tailscale";
     repo = "tailscale";
-    rev = "v${version}";
-    sha256 = "0ckjqhj99c25h8xgyfkrd19nw5w4a7972nvba9r5faw5micjs02n";
+    # Tailscale uses "git describe" as version numbers. v0.97-219
+    # means "tag v0.97 plus 219 commits", which is what this rev is.
+    rev = "afbfe4f217a2a202f0eefe943c7c1ef648311339";
+    sha256 = "1an897ys3gycdmclqd0yqs9f7q88zxqxyc6r0gcgs4678svxhb68";
   };
 
   nativeBuildInputs = [ makeWrapper ];
···
   CGO_ENABLED = 0;
 
   goPackagePath = "tailscale.com";
-  modSha256 = "0anpakcqz4irwxnm0iwm7wqzh84kv3yxxdvyr38154pbd0ys5pa2";
+  modSha256 = "1xgdhbck3pkix10lfshzdszrv6d3p0hbx8jdjvswz7jjd0vzm4x1";
   subPackages = [ "cmd/tailscale" "cmd/tailscaled" ];
 
   postInstall = ''

pkgs/tools/misc/chezmoi/default.nix

···
 
 buildGoModule rec {
   pname = "chezmoi";
-  version = "1.7.18";
+  version = "1.8.0";
 
   src = fetchFromGitHub {
     owner = "twpayne";
     repo = "chezmoi";
     rev = "v${version}";
-    sha256 = "12gx78cbs7abizlqhs7y2w6lwlk5d1hhvixj0ki8d1d5vdr747bc";
+    sha256 = "1ww8xcf57csazj3q2569irxg5il29jrx43mq5cif8dvn8xjm00nn";
   };
 
-  modSha256 = "15b3hik3nzb7xnd6806dqdb36v7z2a0wmvxbrfwvnbigd8zd2y0j";
+  modSha256 = "1zmvav19nyqv6yp71mk3lx6szc5vwyf81m8kvcjj9rlzlygmcl8g";
 
   buildFlagsArray = [
     "-ldflags=-s -w -X main.version=${version} -X main.builtBy=nixpkgs"

pkgs/tools/misc/hpl/default.nix

···
 { stdenv, fetchurl, blas, lapack, mpi } :
 
-assert (!blas.is64bit) && (!lapack.is64bit);
+assert (!blas.isILP64) && (!lapack.isILP64);
 
 stdenv.mkDerivation rec {
   pname = "hpl";

pkgs/tools/misc/ili2c/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "ili2c";
-  version = "5.0.0";
+  version = "5.0.8";
 
   nativeBuildInputs = [ ant jdk makeWrapper ];
 
···
     owner = "claeis";
     repo = pname;
     rev = "${pname}-${version}";
-    sha256 = "0xps2343d5gdr2aj8j3l4cjq4k9zbxxlhnp8sjlhxh1wdczxlwx6";
+    sha256 = "1yhsyh940kb33y2n6xl7zhf0f6q0nrxbyg6c4g5n2imllpn54sgi";
   };
 
   buildPhase = "ant jar";

pkgs/tools/networking/ferm/default.nix

···
 let
   inherit (stdenv.lib.versions) majorMinor;
 in stdenv.mkDerivation rec {
-  version = "2.5";
+  version = "2.5.1";
   pname = "ferm";
 
   src = fetchurl {
     url = "http://ferm.foo-projects.org/download/${majorMinor version}/ferm-${version}.tar.xz";
-    sha256 = "0lxqcpirphihpvdqrh5kq0621aqq0h2vdy9q2v85gqdhd52js20p";
+    sha256 = "0awl9s243sxgayr2fcmfks8xydhrmb9gy8bd9sfq738dgq7vybjb";
   };
 
-  buildInputs = [ perl ipset ebtables iptables makeWrapper ];
-  preConfigure = ''
-    substituteInPlace config.mk --replace "PERL = /usr/bin/perl" "PERL = ${perl}/bin/perl"
-    substituteInPlace config.mk --replace "PREFIX = /usr" "PREFIX = $out"
-  '';
+  # perl is used at build time to gather the ferm version.
+  nativeBuildInputs = [ makeWrapper perl ];
+  buildInputs = [ perl ];
+
+  makeFlags = [
+    "PERL=perl"
+    "PREFIX=${placeholder "out"}"
+  ];
+
   postInstall = ''
     rm -r $out/lib/systemd
     for i in "$out/sbin/"*; do
-      wrapProgram "$i" --prefix PATH : "${iptables}/bin:${ipset}/bin:${ebtables}/bin"
+      wrapProgram "$i" --prefix PATH : "${stdenv.lib.makeBinPath [ iptables ipset ebtables ]}"
     done
   '';
 

pkgs/tools/networking/mu/default.nix

···
 
   enableParallelBuilding = true;
 
-  preConfigure = "./autogen.sh";
-
   preBuild = ''
     # Fix mu4e-builddir (set it to $out)
     substituteInPlace mu4e/mu4e-meta.el.in \
···
     description = "A collection of utilties for indexing and searching Maildirs";
     license = licenses.gpl3Plus;
     homepage = "https://www.djcbsoftware.nl/code/mu/";
-    platforms = platforms.mesaPlatforms;
     maintainers = with maintainers; [ antono the-kenny peterhoeg ];
+    platforms = platforms.mesaPlatforms;
   };
 }

pkgs/tools/text/gjo/default.nix

···
+{ stdenv
+, buildGoModule
+, fetchFromGitHub
+}:
+
+buildGoModule rec {
+  pname = "gjo";
+  version = "1.0.2";
+
+  src = fetchFromGitHub {
+    owner = "skanehira";
+    repo = "gjo";
+    rev = version;
+    sha256 = "1m5nkv42ri150fgj590nrl24wp90p7ygg9xdh9zblibmnqrvbz4z";
+  };
+
+  doCheck = true;
+
+  modSha256 = "0sjjj9z1dhilhpc8pq4154czrb79z9cm044jvn75kxcjv6v5l2m5";
+
+  meta = with stdenv.lib; {
+    description = "Small utility to create JSON objects";
+    homepage = "https://github.com/skanehira/gjo";
+    license = licenses.mit;
+    maintainers = with maintainers; [ doronbehar ];
+  };
+}
+

pkgs/tools/text/transifex-client/default.nix

···
 
 buildPythonApplication rec {
   pname = "transifex-client";
-  version = "0.13.6";
+  version = "0.13.9";
 
   propagatedBuildInputs = [
     urllib3 requests python-slugify six setuptools
···
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "0y6pprlmkmi7wfqr3k70sb913qa70p3i90q5mravrai7cr32y1w8";
+    sha256 = "0lgd77vrddvyn8afkxr7a7hblmp4k5sr0i9i1032xdih2bipdd9f";
   };
 
   prePatch = ''
     substituteInPlace requirements.txt --replace "urllib3<1.24" "urllib3>=1.24" \
       --replace "six==1.11.0" "six>=1.11.0" \
-      --replace "python-slugify==1.2.6" "python-slugify>=1.2.6"
+      --replace "python-slugify<2.0.0" "python-slugify>2.0.0"
   '';
 
   # Requires external resources

pkgs/top-level/all-packages.nix

···
 
   gjs = callPackage ../development/libraries/gjs { };
 
+  gjo = callPackage ../tools/text/gjo { };
+
   glances = python3Packages.callPackage ../applications/system/glances { };
 
   glasgow = with python3Packages; toPythonApplication glasgow;
···
   circus = callPackage ../tools/networking/circus { };
 
   citrix_workspace_unwrapped = callPackage ../applications/networking/remote/citrix-workspace { };
+  citrix_workspace_unwrapped_20_04_0 = citrix_workspace_unwrapped.override { version = "20.04.0"; };
   citrix_workspace_unwrapped_19_12_0 = citrix_workspace_unwrapped.override { version = "19.12.0"; };
   citrix_workspace_unwrapped_19_10_0 = citrix_workspace_unwrapped.override { version = "19.10.0"; };
   citrix_workspace_unwrapped_19_8_0 = citrix_workspace_unwrapped.override { version = "19.8.0"; };

pkgs/top-level/ocaml-packages.nix

···
 
     textutils_p4 = callPackage ../development/ocaml-modules/textutils { };
 
-    tls = callPackage ../development/ocaml-modules/tls {
-      lwt = ocaml_lwt;
-    };
+    tls = callPackage ../development/ocaml-modules/tls { };
 
     type_conv_108_08_00 = callPackage ../development/ocaml-modules/type_conv/108.08.00.nix { };
     type_conv_109_60_01 = callPackage ../development/ocaml-modules/type_conv/109.60.01.nix { };

pkgs/top-level/release-alternatives.nix

···
 {
   blas = mapListToAttrs supportedSystems (system': let system = lib.systems.elaborate { system = system'; };
     in mapListToAttrs (blasProviders system) (provider: let
-      is64bit = builtins.elem provider (["mkl64"] ++ lib.optional system.is64bit "openblas");
+      isILP64 = builtins.elem provider (["mkl64"] ++ lib.optional system.is64bit "openblas");
       pkgs = pkgsFun {
         config = { inherit allowUnfree; };
         system = system';
···
             lapackProvider = if provider == "mkl64"
                              then super.mkl
                              else builtins.getAttr provider super;
-            inherit is64bit;
+            inherit isILP64;
           };
           blas = super.blas.override {
             blasProvider = if provider == "mkl64"
                            then super.mkl
                            else builtins.getAttr provider super;
-            inherit is64bit;
+            inherit isILP64;
           };
         })];
       };