Merge master into staging

It contains some mass-rebuild stuff as well, so best push the changes to staging, too.
2015-05-27 20:36:22 +02:00 · 2015-05-27 20:36:22 +02:00 · 710df5bb78
commit 710df5bb78
parent 6f67b91db3 c0f09411e8
203 changed files with 4662 additions and 1597 deletions
--- a/doc/language-support.xml
+++ b/doc/language-support.xml
@ -420,6 +420,20 @@ twisted = buildPythonPackage {
      </para></listitem>
    </varlistentry>

+    <varlistentry>
+      <term><varname>makeWrapperArgs</varname></term>
+      <listitem><para>
+        A list of strings. Arguments to be passed to
+        <varname>makeWrapper</varname>, which wraps generated binaries. By
+        default, the arguments to <varname>makeWrapper</varname> set
+        <varname>PATH</varname> and <varname>PYTHONPATH</varname> environment
+        variables before calling the binary. Additional arguments here can
+        allow a developer to set environment variables which will be
+        available when the binary is run. For example,
+        <varname>makeWrapperArgs = ["--set FOO BAR" "--set BAZ QUX"]</varname>.
+      </para></listitem>
+    </varlistentry>
+
  </variablelist>

 </section>
--- a/lib/licenses.nix
+++ b/lib/licenses.nix
@ -403,6 +403,11 @@ lib.mapAttrs (n: v: v // { shortName = n; }) rec {
    fullName = "The Unlicense";
  };

+  vim = spdx {
+    spdxId = "Vim";
+    fullName = "Vim License";
+  };
+
  vsl10 = spdx {
    spdxId = "VSL-1.0";
    fullName = "Vovida Software License v1.0";
--- a/lib/maintainers.nix
+++ b/lib/maintainers.nix
@ -8,6 +8,7 @@
  abaldeau = "Andreas Baldeau <andreas@baldeau.net>";
  abbradar = "Nikolay Amiantov <ab@fmap.me>";
  aforemny = "Alexander Foremny <alexanderforemny@googlemail.com>";
+  aflatter = "Alexander Flatter <flatter@fastmail.fm>";
  aherrmann = "Andreas Herrmann <andreash87@gmx.ch>";
  ak = "Alexander Kjeldaas <ak@formalprivacy.com>";
  akc = "Anders Claesson <akc@akc.is>";
@ -71,6 +72,7 @@
  eikek = "Eike Kettner <eike.kettner@posteo.de>";
  ellis = "Ellis Whitehead <nixos@ellisw.net>";
  emery = "Emery Hemingway <emery@vfemail.net>";
+  ericbmerritt = "Eric Merritt <eric@afiniate.com>";
  ertes = "Ertugrul Söylemez <ertesx@gmx.de>";
  exlevan = "Alexey Levan <exlevan@gmail.com>";
  falsifian = "James Cook <james.cook@utoronto.ca>";
@ -98,6 +100,7 @@
  iand675 = "Ian Duncan <ian@iankduncan.com>";
  ianwookim = "Ian-Woo Kim <ianwookim@gmail.com>";
  iElectric = "Domen Kozar <domen@dev.si>";
+  ikervagyok = "Balázs Lengyel <ikervagyok@gmail.com>";
  iyzsong = "Song Wenwu <iyzsong@gmail.com>";
  j-keck = "Jürgen Keck <jhyphenkeck@gmail.com>";
  jagajaga = "Arseniy Seroka <ars.seroka@gmail.com>";
@ -111,6 +114,7 @@
  joelteon = "Joel Taylor <me@joelt.io>";
  jpbernardy = "Jean-Philippe Bernardy <jeanphilippe.bernardy@gmail.com>";
  jwiegley = "John Wiegley <johnw@newartisans.com>";
+  jwilberding = "Jordan Wilberding <jwilberding@afiniate.com>";
  jzellner = "Jeff Zellner <jeffz@eml.cc>";
  kkallio = "Karn Kallio <tierpluspluslists@gmail.com>";
  koral = "Koral <koral@mailoo.org>";
@ -134,6 +138,7 @@
  meditans = "Carlo Nucera <meditans@gmail.com>";
  meisternu = "Matt Miemiec <meister@krutt.org>";
  michelk = "Michel Kuhlmann <michel@kuhlmanns.info>";
+  mirdhyn = "Merlin Gaillard <mirdhyn@gmail.com>";
  mschristiansen = "Mikkel Christiansen <mikkel@rheosystems.com>";
  modulistic = "Pablo Costa <modulistic@gmail.com>";
  mornfall = "Petr Ročkai <me@mornfall.net>";
--- a/nixos/modules/module-list.nix
+++ b/nixos/modules/module-list.nix
@ -202,6 +202,7 @@
  ./services/misc/mediatomb.nix
  ./services/misc/mesos-master.nix
  ./services/misc/mesos-slave.nix
+  ./services/misc/mwlib.nix
  ./services/misc/nix-daemon.nix
  ./services/misc/nix-gc.nix
  ./services/misc/nixos-manual.nix
@ -222,6 +223,7 @@
  ./services/monitoring/bosun.nix
  ./services/monitoring/cadvisor.nix
  ./services/monitoring/collectd.nix
+  ./services/monitoring/das_watchdog.nix
  ./services/monitoring/dd-agent.nix
  ./services/monitoring/graphite.nix
  ./services/monitoring/monit.nix
@ -266,6 +268,7 @@
  ./services/networking/dhcpd.nix
  ./services/networking/dnscrypt-proxy.nix
  ./services/networking/dnsmasq.nix
+  ./services/networking/docker-registry-server.nix
  ./services/networking/ejabberd.nix
  ./services/networking/firefox/sync-server.nix
  ./services/networking/firewall.nix
@ -306,6 +309,7 @@
  ./services/networking/privoxy.nix
  ./services/networking/prosody.nix
  ./services/networking/quassel.nix
+  ./services/networking/racoon.nix
  ./services/networking/radicale.nix
  ./services/networking/radvd.nix
  ./services/networking/rdnssd.nix
@ -406,6 +410,7 @@
  ./services/x11/xserver.nix
  ./system/activation/activation-script.nix
  ./system/activation/top-level.nix
+  ./system/boot/coredump.nix
  ./system/boot/emergency-mode.nix
  ./system/boot/kernel.nix
  ./system/boot/kexec.nix
@ -437,6 +442,7 @@
  ./tasks/filesystems.nix
  ./tasks/filesystems/btrfs.nix
  ./tasks/filesystems/cifs.nix
+  ./tasks/filesystems/exfat.nix
  ./tasks/filesystems/ext.nix
  ./tasks/filesystems/f2fs.nix
  ./tasks/filesystems/jfs.nix
--- a/nixos/modules/profiles/minimal.nix
+++ b/nixos/modules/profiles/minimal.nix
@ -8,4 +8,5 @@ with lib;
 {
  environment.noXlibs = mkDefault true;
  i18n.supportedLocales = [ config.i18n.defaultLocale ];
+  services.nixosManual.enable = mkDefault false;
 }
--- a/nixos/modules/services/misc/mwlib.nix
+++ b/nixos/modules/services/misc/mwlib.nix
@ -0,0 +1,258 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.mwlib;
+  pypkgs = pkgs.python27Packages;
+
+  inherit (pypkgs) python mwlib;
+
+  user = mkOption {
+    default = "nobody";
+    type = types.str;
+    description = "User to run as.";
+  };
+
+in
+{
+
+  options.services.mwlib = {
+
+    nserve = {
+      enable = mkOption {
+        default = false;
+        type = types.bool;
+        description = ''
+          Whether to enable nserve. Nserve is a HTTP
+          server.  The Collection extension is talking to
+          that program directly.  Nserve uses at least
+          one qserve instance in order to distribute
+          and manage jobs.
+        '';
+      }; # nserve.enable
+
+      port = mkOption {
+        default = 8899;
+        type = types.int;
+        description = "Specify port to listen on.";
+      }; # nserve.port
+
+      address = mkOption {
+        default = "127.0.0.1";
+        type = types.str;
+        description = "Specify network interface to listen on.";
+      }; # nserve.address
+
+      qserve = mkOption {
+        default = [ "${cfg.qserve.address}:${toString cfg.qserve.port}" ];
+        type = types.listOf types.str;
+        description = "Register qserve instance.";
+      }; # nserve.qserve
+
+      inherit user;
+    }; # nserve
+
+    qserve = {
+      enable = mkOption {
+        default = false;
+        type = types.bool;
+        description = ''
+          A job queue server used to distribute and manage
+          jobs. You should start one qserve instance
+          for each machine that is supposed to render pdf
+          files. Unless you’re operating the Wikipedia
+          installation, one machine should suffice.
+        '';
+      }; # qserve.enable
+
+      port = mkOption {
+        default = 14311;
+        type = types.int;
+        description = "Specify port to listen on.";
+      }; # qserve.port
+
+      address = mkOption {
+        default = "127.0.0.1";
+        type = types.str;
+        description = "Specify network interface to listen on.";
+      }; # qserve.address
+
+      datadir = mkOption {
+        default = "/var/lib/mwlib-qserve";
+        type = types.path;
+        description = "qserve data directory (FIXME: unused?)";
+      }; # qserve.datadir
+
+      allow = mkOption {
+        default = [ "127.0.0.1" ];
+        type = types.listOf types.str;
+        description = "List of allowed client IPs. Empty means any.";
+      }; # qserve.allow
+
+      inherit user;
+    }; # qserve
+
+    nslave = {
+      enable = mkOption {
+        default = cfg.qserve.enable;
+        type = types.bool;
+        description = ''
+          Pulls new jobs from exactly one qserve instance
+          and calls the zip and render programs
+          in order to download article collections and
+          convert them to different output formats. Nslave
+          uses a cache directory to store the generated
+          documents. Nslave also starts an internal http
+          server serving the content of the cache directory.
+        '';
+      }; # nslave.enable
+
+      cachedir = mkOption {
+        default = "/var/cache/mwlib-nslave";
+        type = types.path;
+        description = "Directory to store generated documents.";
+      }; # nslave.cachedir
+
+      numprocs = mkOption {
+        default = 10;
+        type = types.int;
+        description = "Number of parallel jobs to be executed.";
+      }; # nslave.numprocs
+
+      http = mkOption {
+        default = {};
+        description = ''
+          Internal http server serving the content of the cache directory.
+          You have to enable it, or use your own way for serving files
+          and set the http.url option accordingly.
+          '';
+        type = types.submodule ({
+          options = {
+            enable = mkOption {
+              default = true;
+              type = types.bool;
+              description = "Enable internal http server.";
+            }; # nslave.http.enable
+
+            port = mkOption {
+              default = 8898;
+              type = types.int;
+              description = "Port to listen to when serving files from cache.";
+            }; # nslave.http.port
+
+            address = mkOption {
+              default = "127.0.0.1";
+              type = types.str;
+              description = "Specify network interface to listen on.";
+            }; # nslave.http.address
+
+            url = mkOption {
+              default = "http://localhost:${toString cfg.nslave.http.port}/cache";
+              type = types.str;
+              description = ''
+                Specify URL for accessing generated files from cache.
+                The Collection extension of Mediawiki won't be able to
+                download files without it.
+                '';
+            }; # nslave.http.url
+          };
+        }); # types.submodule
+      }; # nslave.http
+
+      inherit user;
+    }; # nslave
+
+  }; # options.services
+
+  config = { 
+
+    systemd.services.mwlib-nserve = mkIf cfg.nserve.enable
+    {
+      description = "mwlib network interface";
+
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network.target" "mwlib-qserve.service" ];
+
+      serviceConfig = {
+        ExecStart = concatStringsSep " " (
+          [
+            "${mwlib}/bin/nserve"
+            "--port ${toString cfg.nserve.port}"
+            "--interface ${cfg.nserve.address}"
+          ] ++ cfg.nserve.qserve
+        );
+        User = cfg.nserve.user;
+      };
+    }; # systemd.services.mwlib-nserve
+
+    systemd.services.mwlib-qserve = mkIf cfg.qserve.enable
+    {
+      description = "mwlib job queue server";
+
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network.target" "local-fs.target" ];
+
+      preStart = ''
+        mkdir -pv '${cfg.qserve.datadir}'
+        chown -Rc ${cfg.qserve.user}:`id -ng ${cfg.qserve.user}` '${cfg.qserve.datadir}'
+        chmod -Rc u=rwX,go= '${cfg.qserve.datadir}'
+      '';
+
+      serviceConfig = {
+        ExecStart = concatStringsSep " " (
+          [
+            "${mwlib}/bin/mw-qserve"
+            "-p ${toString cfg.qserve.port}"
+            "-i ${cfg.qserve.address}"
+            "-d ${cfg.qserve.datadir}"
+          ] ++ map (a: "-a ${a}") cfg.qserve.allow
+        );
+        User = cfg.qserve.user;
+        PermissionsStartOnly = true;
+      };
+    }; # systemd.services.mwlib-qserve
+
+    systemd.services.mwlib-nslave = mkIf cfg.nslave.enable
+    {
+      description = "mwlib worker";
+
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network.target" "local-fs.target" ];
+
+      preStart = ''
+        mkdir -pv '${cfg.nslave.cachedir}'
+        chown -Rc ${cfg.nslave.user}:`id -ng ${cfg.nslave.user}` '${cfg.nslave.cachedir}'
+        chmod -Rc u=rwX,go= '${cfg.nslave.cachedir}'
+      '';
+
+      environment = {
+        PYTHONPATH = concatMapStringsSep ":"
+          (m: "${pypkgs.${m}}/lib/${python.libPrefix}/site-packages")
+          [ "mwlib-rl" "mwlib-ext" "pygments" ];
+      };
+
+      serviceConfig = {
+        ExecStart = concatStringsSep " " (
+          [
+            "${mwlib}/bin/nslave"
+            "--cachedir ${cfg.nslave.cachedir}"
+            "--numprocs ${toString cfg.nslave.numprocs}"
+            "--url ${cfg.nslave.http.url}"
+          ] ++ (
+            if cfg.nslave.http.enable then
+            [
+              "--serve-files-port ${toString cfg.nslave.http.port}"
+              "--serve-files-address ${cfg.nslave.http.address}"
+            ] else
+            [
+              "--no-serve-files"
+            ]
+          ));
+        User = cfg.nslave.user;
+        PermissionsStartOnly = true;
+      };
+    }; # systemd.services.mwlib-nslave
+
+  }; # config
+}
--- a/nixos/modules/services/monitoring/das_watchdog.nix
+++ b/nixos/modules/services/monitoring/das_watchdog.nix
@ -0,0 +1,34 @@
+# A general watchdog for the linux operating system that should run in the
+# background at all times to ensure a realtime process won't hang the machine
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+
+  inherit (pkgs) das_watchdog;
+
+in {
+  ###### interface
+
+  options = {
+    services.das_watchdog.enable = mkEnableOption "Whether to enable realtime watchdog";
+  };
+
+  ###### implementation
+
+  config = mkIf config.services.das_watchdog.enable {
+    environment.systemPackages = [ das_watchdog ];
+    systemd.services.das_watchdog = {
+      description = "Watchdog to ensure a realtime process won't hang the machine";
+      after = [ "multi-user.target" "sound.target" ];
+      wantedBy = [ "multi-user.target" ];
+      serviceConfig = {
+        User = "root";
+        Type = "oneshot";
+        ExecStart = "${das_watchdog}/bin/das_watchdog";
+        RemainAfterExit = true;
+      };
+    };
+  };
+}
--- a/nixos/modules/services/networking/ddclient.nix
+++ b/nixos/modules/services/networking/ddclient.nix
@ -126,6 +126,8 @@ in
      description = "Dynamic DNS Client";
      wantedBy = [ "multi-user.target" ];
      after = [ "network.target" ];
+
+      environment.SSL_CERT_FILE = "/etc/ssl/certs/ca-bundle.crt";
      serviceConfig = {
        # Uncomment this if too many problems occur:
        # Type = "forking";
--- a/nixos/modules/services/networking/docker-registry-server.nix
+++ b/nixos/modules/services/networking/docker-registry-server.nix
@ -0,0 +1,98 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.nodeDockerRegistry;
+
+in {
+  options.services.nodeDockerRegistry = {
+    enable = mkEnableOption "Whether to enable docker registry service.";
+
+    port = mkOption {
+      description = "Docker registry listening port.";
+      default = 8080;
+      type = types.int;
+    };
+
+    users = mkOption {
+      description = "Docker registry list of users.";
+      default = [];
+      options = [{
+        user = mkOption {
+          description = "Docker registry user username.";
+          type = types.str;
+        };
+
+        pass = mkOption {
+          description = "Docker registry user password.";
+          type = types.str;
+        };
+      }];
+      type = types.listOf types.optionSet;
+    };
+
+    onTag = mkOption {
+      description = "Docker registry hook triggered when an image is tagged.";
+      default = "";
+      type = types.str;
+    };
+
+    onImage = mkOption {
+      description = "Docker registry hook triggered when an image metadata is uploaded.";
+      default = "";
+      type = types.str;
+    };
+
+    onLayer = mkOption {
+      description = "Docker registry hook triggered when an when an image layer is uploaded.";
+      default = "";
+      type = types.str;
+    };
+
+    onVerify = mkOption {
+      description = "Docker registry hook triggered when an image layer+metadata has been verified.";
+      default = "";
+      type = types.str;
+    };
+
+    onIndex = mkOption {
+      description = "Docker registry hook triggered when an when an image file system data has been indexed.";
+      default = "";
+      type = types.str;
+    };
+
+    dataDir = mkOption {
+      description = "Docker registry data directory";
+      default = "/var/lib/docker-registry";
+      type = types.path;
+    };
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.docker-registry-server = {
+      description = "Docker Registry Service.";
+      wantedBy = ["multi-user.target"];
+      after = ["network.target"];
+      script = ''
+        ${pkgs.nodePackages.docker-registry-server}/bin/docker-registry-server \
+          --dir ${cfg.dataDir} \
+          --port ${toString cfg.port} \
+          ${concatMapStringsSep " " (u: "--user ${u.user}:${u.pass}") cfg.users} \
+          ${optionalString (cfg.onTag != "") "--on-tag '${cfg.onTag}'"} \
+          ${optionalString (cfg.onImage != "") "--on-image '${cfg.onImage}'"} \
+          ${optionalString (cfg.onVerify != "") "--on-verify '${cfg.onVerify}'"} \
+          ${optionalString (cfg.onIndex != "") "--on-index '${cfg.onIndex}'"}
+      '';
+
+      serviceConfig.User = "docker-registry";
+    };
+
+    users.extraUsers.docker-registry = {
+      uid = config.ids.uids.docker-registry;
+      description = "Docker registry user";
+      createHome = true;
+      home = cfg.dataDir;
+    };
+  };
+}
--- a/nixos/modules/services/networking/racoon.nix
+++ b/nixos/modules/services/networking/racoon.nix
@ -0,0 +1,42 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.racoon;
+in {
+  options.services.racoon = {
+    enable = mkEnableOption "Whether to enable racoon.";
+
+    config = mkOption {
+      description = "Contents of racoon configuration file.";
+      default = "";
+      type = types.str;
+    };
+
+    configPath = mkOption {
+      description = "Location of racoon config if config is not provided.";
+      default = "/etc/racoon/racoon.conf";
+      type = types.path;
+    };
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.racoon = {
+      description = "Racoon Daemon";
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network.target" ];
+      serviceConfig = {
+        ExecStart = "${pkgs.ipsecTools}/bin/racoon -f ${
+          if (cfg.config != "") then pkgs.writeText "racoon.conf" cfg.config
+          else cfg.configPath
+        }";
+        ExecReload = "${pkgs.ipsecTools}/bin/racoonctl reload-config";
+        PIDFile = "/var/run/racoon.pid";
+        Type = "forking";
+        Restart = "always";
+      };
+      preStart = "rm /var/run/racoon.pid || true";
+    };
+  };
+}
--- a/nixos/modules/system/boot/coredump.nix
+++ b/nixos/modules/system/boot/coredump.nix
@ -0,0 +1,51 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+
+  options = {
+
+    systemd.coredump = {
+
+      enable = mkOption {
+        default = false;
+        type = types.bool;
+        description = ''
+          Enables storing core dumps in systemd.
+          Note that this alone is not enough to enable core dumps. The maximum
+          file size for core dumps must be specified in limits.conf as well. See
+          <option>security.pam.loginLimits</option> as well as the limits.conf(5)
+          man page.
+        '';
+      };
+
+      extraConfig = mkOption {
+        default = "";
+        type = types.lines;
+        example = "Storage=journal";
+        description = ''
+          Extra config options for systemd-coredump. See coredump.conf(5) man page
+          for available options.
+        '';
+      };
+    };
+
+  };
+
+  config = mkIf config.systemd.coredump.enable {
+
+    environment.etc."systemd/coredump.conf".text =
+      ''
+        [Coredump]
+        ${config.systemd.coredump.extraConfig}
+      '';
+
+    # Have the kernel pass core dumps to systemd's coredump helper binary.
+    # From systemd's 50-coredump.conf file. See:
+    # <https://github.com/systemd/systemd/blob/v218/sysctl.d/50-coredump.conf.in>
+    boot.kernel.sysctl."kernel.core_pattern" = "|${pkgs.systemd}/lib/systemd/systemd-coredump %p %u %g %s %t %e";
+
+  };
+
+}
--- a/nixos/modules/system/boot/loader/grub/grub.nix
+++ b/nixos/modules/system/boot/loader/grub/grub.nix
@ -21,13 +21,13 @@ let

  grubEfi =
    # EFI version of Grub v2
-    if (cfg.devices != ["nodev"]) && cfg.efiSupport && (cfg.version == 2)
+    if cfg.efiSupport && (cfg.version == 2)
    then realGrub.override { efiSupport = cfg.efiSupport; }
    else null;

  f = x: if x == null then "" else "" + x;

-  grubConfig = pkgs.writeText "grub-config.xml" (builtins.toXML
+  grubConfig = args: pkgs.writeText "grub-config.xml" (builtins.toXML
    { splashImage = f config.boot.loader.grub.splashImage;
      grub = f grub;
      grubTarget = f (grub.grubTarget or "");
@ -35,11 +35,14 @@ let
      fullVersion = (builtins.parseDrvName realGrub.name).version;
      grubEfi = f grubEfi;
      grubTargetEfi = if cfg.efiSupport && (cfg.version == 2) then f (grubEfi.grubTarget or "") else "";
-      inherit (efi) efiSysMountPoint canTouchEfiVariables;
+      bootPath = args.path;
+      efiSysMountPoint = if args.efiSysMountPoint == null then args.path else args.efiSysMountPoint;
+      inherit (args) devices;
+      inherit (efi) canTouchEfiVariables;
      inherit (cfg)
        version extraConfig extraPerEntryConfig extraEntries
        extraEntriesBeforeNixOS extraPrepareConfig configurationLimit copyKernels timeout
-        default devices fsIdentifier efiSupport;
+        default fsIdentifier efiSupport;
      path = (makeSearchPath "bin" ([
        pkgs.coreutils pkgs.gnused pkgs.gnugrep pkgs.findutils pkgs.diffutils pkgs.btrfsProgs
        pkgs.utillinux ] ++ (if cfg.efiSupport && (cfg.version == 2) then [pkgs.efibootmgr ] else [])
@ -48,6 +51,9 @@ let
      ]);
    });

+  bootDeviceCounters = fold (device: attr: attr // { "${device}" = (attr."${device}" or 0) + 1; }) {}
+    (concatMap (args: args.devices) cfg.mirroredBoots);
+
 in

 {
@ -101,6 +107,53 @@ in
        '';
      };

+      mirroredBoots = mkOption {
+        default = [ ];
+        example = [
+          { path = "/boot1"; devices = [ "/dev/sda" ]; }
+          { path = "/boot2"; devices = [ "/dev/sdb" ]; }
+        ];
+        description = ''
+          Mirror the boot configuration to multiple partitions and install grub
+          to the respective devices corresponding to those partitions.
+        '';
+
+        type = types.listOf types.optionSet;
+
+        options = {
+
+          path = mkOption {
+            example = "/boot1";
+            type = types.str;
+            description = ''
+              The path to the boot directory where grub will be written. Generally
+              this boot parth should double as an efi path.
+            '';
+          };
+
+          efiSysMountPoint = mkOption {
+            default = null;
+            example = "/boot1/efi";
+            type = types.nullOr types.str;
+            description = ''
+              The path to the efi system mount point. Usually this is the same
+              partition as the above path and can be left as null.
+            '';
+          };
+
+          devices = mkOption {
+            default = [ ];
+            example = [ "/dev/sda" "/dev/sdb" ];
+            type = types.listOf types.str;
+            description = ''
+              The path to the devices which will have the grub mbr written.
+              Note these are typically device paths and not paths to partitions.
+            '';
+          };
+
+        };
+      };
+
      configurationName = mkOption {
        default = "";
        example = "Stable 2.6.21";
@ -291,13 +344,18 @@ in

      boot.loader.grub.devices = optional (cfg.device != "") cfg.device;

-      system.build.installBootLoader =
-        if cfg.devices == [] then
-          throw "You must set the option ‘boot.loader.grub.device’ to make the system bootable."
-        else
-          "PERL5LIB=${makePerlPath (with pkgs.perlPackages; [ FileSlurp XMLLibXML XMLSAX ListCompare ])} " +
-          (if cfg.enableCryptodisk then "GRUB_ENABLE_CRYPTODISK=y " else "") +
-          "${pkgs.perl}/bin/perl ${./install-grub.pl} ${grubConfig}";
+      boot.loader.grub.mirroredBoots = optionals (cfg.devices != [ ]) [
+        { path = "/boot"; inherit (cfg) devices; inherit (efi) efiSysMountPoint; }
+      ];
+
+      system.build.installBootLoader = pkgs.writeScript "install-grub.sh" (''
+        #!${pkgs.stdenv.shell}
+        set -e
+        export PERL5LIB=${makePerlPath (with pkgs.perlPackages; [ FileSlurp XMLLibXML XMLSAX ListCompare ])}
+        ${optionalString cfg.enableCryptodisk "export GRUB_ENABLE_CRYPTODISK=y"}
+      '' + flip concatMapStrings cfg.mirroredBoots (args: ''
+        ${pkgs.perl}/bin/perl ${./install-grub.pl} ${grubConfig args}
+      ''));

      system.build.grub = grub;

@ -312,13 +370,37 @@ in
          ${pkgs.coreutils}/bin/cp -pf "${v}" "/boot/${n}"
        '') config.boot.loader.grub.extraFiles);

-    assertions = [{ assertion = !cfg.zfsSupport || cfg.version == 2;
-                    message = "Only grub version 2 provides zfs support";}]
-      ++ flip map cfg.devices (dev: {
-        assertion = dev == "nodev" || hasPrefix "/" dev;
-        message = "Grub devices must be absolute paths, not ${dev}";
-      });
-
+      assertions = [
+        {
+          assertion = !cfg.zfsSupport || cfg.version == 2;
+          message = "Only grub version 2 provides zfs support";
+        }
+        {
+          assertion = cfg.mirroredBoots != [ ];
+          message = "You must set the option ‘boot.loader.grub.devices’ or "
+            + "'boot.loader.grub.mirroredBoots' to make the system bootable.";
+        }
+        {
+          assertion = all (c: c < 2) (mapAttrsToList (_: c: c) bootDeviceCounters);
+          message = "You cannot have duplicated devices in mirroredBoots";
+        }
+      ] ++ flip concatMap cfg.mirroredBoots (args: [
+        {
+          assertion = args.devices != [ ];
+          message = "A boot path cannot have an empty devices string in ${arg.path}";
+        }
+        {
+          assertion = hasPrefix "/" args.path;
+          message = "Boot paths must be absolute, not ${args.path}";
+        }
+        {
+          assertion = if args.efiSysMountPoint == null then true else hasPrefix "/" args.efiSysMountPoint;
+          message = "Efi paths must be absolute, not ${args.efiSysMountPoint}";
+        }
+      ] ++ flip map args.devices (device: {
+        assertion = device == "nodev" || hasPrefix "/" device;
+        message = "Grub devices must be absolute paths, not ${dev} in ${args.path}";
+      }));
    })

  ];
--- a/nixos/modules/system/boot/loader/grub/install-grub.pl
+++ b/nixos/modules/system/boot/loader/grub/install-grub.pl
@ -11,7 +11,7 @@ require List::Compare;
 use POSIX;
 use Cwd;

-my $defaultConfig = $ARGV[1] or die;
+my $defaultConfig = $ARGV[0] or die;

 my $dom = XML::LibXML->load_xml(location => $ARGV[0]);

@ -54,6 +54,7 @@ my $defaultEntry = int(get("default"));
 my $fsIdentifier = get("fsIdentifier");
 my $grubEfi = get("grubEfi");
 my $grubTargetEfi = get("grubTargetEfi");
+my $bootPath = get("bootPath");
 my $canTouchEfiVariables = get("canTouchEfiVariables");
 my $efiSysMountPoint = get("efiSysMountPoint");
 $ENV{'PATH'} = get("path");
@ -62,16 +63,16 @@ die "unsupported GRUB version\n" if $grubVersion != 1 && $grubVersion != 2;

 print STDERR "updating GRUB $grubVersion menu...\n";

-mkpath("/boot/grub", 0, 0700);
+mkpath("$bootPath/grub", 0, 0700);

-# Discover whether /boot is on the same filesystem as / and
+# Discover whether the bootPath is on the same filesystem as / and
 # /nix/store.  If not, then all kernels and initrds must be copied to
-# /boot.
-if (stat("/boot")->dev != stat("/nix/store")->dev) {
+# the bootPath.
+if (stat($bootPath)->dev != stat("/nix/store")->dev) {
    $copyKernels = 1;
 }

-# Discover information about the location of /boot
+# Discover information about the location of the bootPath
 struct(Fs => {
    device => '$',
    type => '$',
@ -206,7 +207,7 @@ sub GrubFs {
    }
    return Grub->new(path => $path, search => $search);
 }
-my $grubBoot = GrubFs("/boot");
+my $grubBoot = GrubFs($bootPath);
 my $grubStore;
 if ($copyKernels == 0) {
    $grubStore = GrubFs("/nix/store");
@ -221,7 +222,7 @@ if ($grubVersion == 1) {
        timeout $timeout
    ";
    if ($splashImage) {
-        copy $splashImage, "/boot/background.xpm.gz" or die "cannot copy $splashImage to /boot\n";
+        copy $splashImage, "$bootPath/background.xpm.gz" or die "cannot copy $splashImage to $bootPath\n";
        $conf .= "splashimage " . $grubBoot->path . "/background.xpm.gz\n";
    }
 }
@ -264,7 +265,7 @@ else {
    if ($splashImage) {
        # FIXME: GRUB 1.97 doesn't resize the background image if it
        # doesn't match the video resolution.
-        copy $splashImage, "/boot/background.png" or die "cannot copy $splashImage to /boot\n";
+        copy $splashImage, "$bootPath/background.png" or die "cannot copy $splashImage to $bootPath\n";
        $conf .= "
            insmod png
            if background_image " . $grubBoot->path . "/background.png; then
@ -285,14 +286,14 @@ $conf .= "$extraConfig\n";
 $conf .= "\n";

 my %copied;
-mkpath("/boot/kernels", 0, 0755) if $copyKernels;
+mkpath("$bootPath/kernels", 0, 0755) if $copyKernels;

 sub copyToKernelsDir {
    my ($path) = @_;
    return $grubStore->path . substr($path, length("/nix/store")) unless $copyKernels;
    $path =~ /\/nix\/store\/(.*)/ or die;
    my $name = $1; $name =~ s/\//-/g;
-    my $dst = "/boot/kernels/$name";
+    my $dst = "$bootPath/kernels/$name";
    # Don't copy the file if $dst already exists.  This means that we
    # have to create $dst atomically to prevent partially copied
    # kernels or initrd if this script is ever interrupted.
@ -396,14 +397,14 @@ if ($extraPrepareConfig ne "") {
 }

 # Atomically update the GRUB config.
-my $confFile = $grubVersion == 1 ? "/boot/grub/menu.lst" : "/boot/grub/grub.cfg";
+my $confFile = $grubVersion == 1 ? "$bootPath/grub/menu.lst" : "$bootPath/grub/grub.cfg";
 my $tmpFile = $confFile . ".tmp";
 writeFile($tmpFile, $conf);
 rename $tmpFile, $confFile or die "cannot rename $tmpFile to $confFile\n";


-# Remove obsolete files from /boot/kernels.
-foreach my $fn (glob "/boot/kernels/*") {
+# Remove obsolete files from $bootPath/kernels.
+foreach my $fn (glob "$bootPath/kernels/*") {
    next if defined $copied{$fn};
    print STDERR "removing obsolete file $fn\n";
    unlink $fn;
@ -422,7 +423,7 @@ struct(GrubState => {
 });
 sub readGrubState {
    my $defaultGrubState = GrubState->new(version => "", efi => "", devices => "", efiMountPoint => "" );
-    open FILE, "</boot/grub/state" or return $defaultGrubState;
+    open FILE, "<$bootPath/grub/state" or return $defaultGrubState;
    local $/ = "\n";
    my $version = <FILE>;
    chomp($version);
@ -491,10 +492,10 @@ if (($requireNewInstall != 0) && ($efiTarget eq "no" || $efiTarget eq "both")) {
        next if $dev eq "nodev";
        print STDERR "installing the GRUB $grubVersion boot loader on $dev...\n";
        if ($grubTarget eq "") {
-            system("$grub/sbin/grub-install", "--recheck", Cwd::abs_path($dev)) == 0
+            system("$grub/sbin/grub-install", "--recheck", "--boot-directory=$bootPath", Cwd::abs_path($dev)) == 0
                or die "$0: installation of GRUB on $dev failed\n";
        } else {
-            system("$grub/sbin/grub-install", "--recheck", "--target=$grubTarget", Cwd::abs_path($dev)) == 0
+            system("$grub/sbin/grub-install", "--recheck", "--boot-directory=$bootPath", "--target=$grubTarget", Cwd::abs_path($dev)) == 0
                or die "$0: installation of GRUB on $dev failed\n";
        }
    }
@ -505,10 +506,10 @@ if (($requireNewInstall != 0) && ($efiTarget eq "no" || $efiTarget eq "both")) {
 if (($requireNewInstall != 0) && ($efiTarget eq "only" || $efiTarget eq "both")) {
    print STDERR "installing the GRUB $grubVersion EFI boot loader into $efiSysMountPoint...\n";
    if ($canTouchEfiVariables eq "true") {
-        system("$grubEfi/sbin/grub-install", "--recheck", "--target=$grubTargetEfi", "--efi-directory=$efiSysMountPoint") == 0
+        system("$grubEfi/sbin/grub-install", "--recheck", "--target=$grubTargetEfi", "--boot-directory=$bootPath", "--efi-directory=$efiSysMountPoint") == 0
                or die "$0: installation of GRUB EFI into $efiSysMountPoint failed\n";
    } else {
-        system("$grubEfi/sbin/grub-install", "--recheck", "--target=$grubTargetEfi", "--efi-directory=$efiSysMountPoint", "--no-nvram") == 0
+        system("$grubEfi/sbin/grub-install", "--recheck", "--target=$grubTargetEfi", "--boot-directory=$bootPath", "--efi-directory=$efiSysMountPoint", "--no-nvram") == 0
                or die "$0: installation of GRUB EFI into $efiSysMountPoint failed\n";
    }
 }
@ -516,7 +517,7 @@ if (($requireNewInstall != 0) && ($efiTarget eq "only" || $efiTarget eq "both"))

 # update GRUB state file
 if ($requireNewInstall != 0) {
-    open FILE, ">/boot/grub/state" or die "cannot create /boot/grub/state: $!\n";
+    open FILE, ">$bootPath/grub/state" or die "cannot create $bootPath/grub/state: $!\n";
    print FILE get("fullVersion"), "\n" or die;
    print FILE $efiTarget, "\n" or die;
    print FILE join( ":", @deviceTargets ), "\n" or die;
--- a/nixos/modules/tasks/filesystems/exfat.nix
+++ b/nixos/modules/tasks/filesystems/exfat.nix
@ -0,0 +1,11 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+{
+  config = mkIf (any (fs: fs == "exfat") config.boot.supportedFilesystems) {
+
+    system.fsPackages = [ pkgs.exfat-utils pkgs.fuse_exfat ];
+
+  };
+}
--- a/nixos/modules/tasks/trackpoint.nix
+++ b/nixos/modules/tasks/trackpoint.nix
@ -45,6 +45,16 @@ with lib;
        '';
      };

+      fakeButtons = mkOption {
+        default = false;
+        type = types.bool;
+        description = ''
+          Switch to "bare" PS/2 mouse support in case Trackpoint buttons are not recognized
+          properly. This can happen for example on models like the L430, T450, T450s, on
+          which the Trackpoint buttons are actually a part of the Synaptics touchpad.
+        '';
+      };
+
    };

  };
@ -52,11 +62,13 @@ with lib;

  ###### implementation

-  config = mkMerge [
-    (mkIf config.hardware.trackpoint.enable {
+  config =
+  let cfg = config.hardware.trackpoint; in
+  mkMerge [
+    (mkIf cfg.enable {
      services.udev.extraRules =
      ''
-        ACTION=="add|change", SUBSYSTEM=="input", ATTR{name}=="TPPS/2 IBM TrackPoint", ATTR{device/speed}="${toString config.hardware.trackpoint.speed}", ATTR{device/sensitivity}="${toString config.hardware.trackpoint.sensitivity}"
+        ACTION=="add|change", SUBSYSTEM=="input", ATTR{name}=="TPPS/2 IBM TrackPoint", ATTR{device/speed}="${toString cfg.speed}", ATTR{device/sensitivity}="${toString cfg.sensitivity}"
      '';

      system.activationScripts.trackpoint =
@ -65,20 +77,22 @@ with lib;
        '';
    })

-    (mkIf config.hardware.trackpoint.emulateWheel {
-      services.xserver.config =
-        ''
-          Section "InputClass"
+    (mkIf (cfg.emulateWheel) {
+      services.xserver.inputClassSections =
+        [''
        Identifier "Trackpoint Wheel Emulation"
-            MatchProduct "Elantech PS/2 TrackPoint|TPPS/2 IBM TrackPoint|DualPoint Stick|Synaptics Inc. Composite TouchPad / TrackPoint|ThinkPad USB Keyboard with TrackPoint|USB Trackpoint pointing device|Composite TouchPad / TrackPoint"
+          MatchProduct "${if cfg.fakeButtons then "PS/2 Generic Mouse" else "Elantech PS/2 TrackPoint|TPPS/2 IBM TrackPoint|DualPoint Stick|Synaptics Inc. Composite TouchPad / TrackPoint|ThinkPad USB Keyboard with TrackPoint|USB Trackpoint pointing device|Composite TouchPad / TrackPoint"}"
          MatchDevicePath "/dev/input/event*"
          Option "EmulateWheel" "true"
          Option "EmulateWheelButton" "2"
          Option "Emulate3Buttons" "false"
          Option "XAxisMapping" "6 7"
          Option "YAxisMapping" "4 5"
-            EndSection
-        '';
+        ''];
+    })
+
+    (mkIf cfg.fakeButtons {
+      boot.extraModprobeConfig = "options psmouse proto=bare";
    })
  ];
 }
--- a/nixos/modules/virtualisation/docker.nix
+++ b/nixos/modules/virtualisation/docker.nix
@ -45,7 +45,7 @@ in
      };
    extraOptions =
      mkOption {
-        type = types.str;
+        type = types.separatedString " ";
        default = "";
        description =
          ''
--- a/nixos/modules/virtualisation/nova-image.nix
+++ b/nixos/modules/virtualisation/nova-image.nix
@ -46,16 +46,20 @@ with lib;

          # Register the paths in the Nix database.
          printRegistration=1 perl ${pkgs.pathsFromGraph} /tmp/xchg/closure | \
-              chroot /mnt ${config.nix.package}/bin/nix-store --load-db
+              chroot /mnt ${config.nix.package}/bin/nix-store --load-db --option build-users-group ""

          # Create the system profile to allow nixos-rebuild to work.
-          chroot /mnt ${config.nix.package}/bin/nix-env \
+          chroot /mnt ${config.nix.package}/bin/nix-env --option build-users-group "" \
              -p /nix/var/nix/profiles/system --set ${config.system.build.toplevel}

          # `nixos-rebuild' requires an /etc/NIXOS.
          mkdir -p /mnt/etc
          touch /mnt/etc/NIXOS

+          # `switch-to-configuration' requires a /bin/sh
+          mkdir -p /mnt/bin
+          ln -s ${config.system.build.binsh}/bin/sh /mnt/bin/sh
+
          # Install a configuration.nix.
          mkdir -p /mnt/etc/nixos
          cp ${./nova-config.nix} /mnt/etc/nixos/configuration.nix
@ -104,10 +108,6 @@ with lib;
    boot.initrd.supportedFilesystems = [ "unionfs-fuse" ];
    */

-  # Since Nova allows VNC access to instances, it's nice to start to
-  # start a few virtual consoles.
-  services.mingetty.ttys = [ "tty1" "tty2" ];
-
  # Allow root logins only using the SSH key that the user specified
  # at instance creation time.
  services.openssh.enable = true;
--- a/nixos/modules/virtualisation/openvswitch.nix
+++ b/nixos/modules/virtualisation/openvswitch.nix
@ -7,32 +7,33 @@ with lib;
 let
  cfg = config.virtualisation.vswitch;

-in
+in {

-{
-
-  options = {
-
-    virtualisation.vswitch.enable = mkOption {
+  options.virtualisation.vswitch = {
+    enable = mkOption {
      type = types.bool;
      default = false;
-      description =
-        ''
-        Enable Open vSwitch. A configuration 
-        daemon (ovs-server) will be started.
+      description = ''
+        Whether to enable Open vSwitch. A configuration daemon (ovs-server)
+        will be started.
        '';
    };

-
-    virtualisation.vswitch.package = mkOption {
+    package = mkOption {
      type = types.package;
      default = pkgs.openvswitch;
-      description =
-        ''
+      description = ''
        Open vSwitch package to use.
      '';
    };

+    ipsec = mkOption {
+      type = types.bool;
+      default = false;
+      description = ''
+        Whether to start racoon service for openvswitch.
+      '';
+    };
  };

  config = mkIf cfg.enable (let
@ -51,15 +52,12 @@ in
      buildInputs = with pkgs; [
        cfg.package
      ];
-      installPhase = 
-        ''
-        ensureDir $out/
-        '';
+      installPhase = "mkdir -p $out";
    };

-  in {
+  in (mkMerge [{

-    environment.systemPackages = [ cfg.package ]; 
+    environment.systemPackages = [ cfg.package pkgs.ipsecTools ];

    boot.kernelModules = [ "tun" "openvswitch" ];

@ -85,7 +83,8 @@ in
        fi
        chmod -R +w /var/db/openvswitch
        '';
-      serviceConfig.ExecStart = 
+      serviceConfig = {
+        ExecStart =
          ''
          ${cfg.package}/bin/ovsdb-server \
            --remote=punix:${runDir}/db.sock \
@ -93,15 +92,18 @@ in
            --certificate=db:Open_vSwitch,SSL,certificate \
            --bootstrap-ca-cert=db:Open_vSwitch,SSL,ca_cert \
            --unixctl=ovsdb.ctl.sock \
+            --pidfile=/var/run/openvswitch/ovsdb.pid \
+            --detach \
            /var/db/openvswitch/conf.db
          '';
-      serviceConfig.Restart = "always";
-      serviceConfig.RestartSec = 3;
-      postStart =
-        ''
+        Restart = "always";
+        RestartSec = 3;
+        PIDFile = "/var/run/openvswitch/ovsdb.pid";
+        Type = "forking";
+      };
+      postStart = ''
        ${cfg.package}/bin/ovs-vsctl --timeout 3 --retry --no-wait init
      '';
-
    };

    systemd.services.vswitchd = {
@ -109,9 +111,55 @@ in
      bindsTo = [ "ovsdb.service" ];
      after = [ "ovsdb.service" ];
      path = [ cfg.package ];
-      serviceConfig.ExecStart = ''${cfg.package}/bin/ovs-vswitchd'';
+      serviceConfig = {
+        ExecStart = ''
+          ${cfg.package}/bin/ovs-vswitchd \
+          --pidfile=/var/run/openvswitch/ovs-vswitchd.pid \
+          --detach
+        '';
+        PIDFile = "/var/run/openvswitch/ovs-vswitchd.pid";
+        Type = "forking";
+      };
    };

-  });
+  }
+  (mkIf cfg.ipsec {
+    services.racoon.enable = true;
+    services.racoon.configPath = "${runDir}/ipsec/etc/racoon/racoon.conf";
+
+    networking.firewall.extraCommands = ''
+      iptables -I INPUT -t mangle -p esp -j MARK --set-mark 1/1
+      iptables -I INPUT -t mangle -p udp --dport 4500 -j MARK --set-mark 1/1
+    '';
+
+    systemd.services.ovs-monitor-ipsec = {
+      description = "Open_vSwitch Ipsec Daemon";
+      wantedBy = [ "multi-user.target" ];
+      requires = [ "racoon.service" ];
+      after = [ "vswitchd.service" ];
+      environment.UNIXCTLPATH = "/tmp/ovsdb.ctl.sock";
+      serviceConfig = {
+        ExecStart = ''
+          ${cfg.package}/bin/ovs-monitor-ipsec \
+            --root-prefix ${runDir}/ipsec \
+            --pidfile /var/run/openvswitch/ovs-monitor-ipsec.pid \
+            --monitor --detach \
+            unix:/var/run/openvswitch/db.sock
+        '';
+        PIDFile = "/var/run/openvswitch/ovs-monitor-ipsec.pid";
+        Type = "forking";
+      };
+
+      preStart = ''
+        rm -r ${runDir}/ipsec/etc/racoon/certs || true
+        mkdir -p ${runDir}/ipsec/{etc/racoon,etc/init.d/,usr/sbin/}
+        ln -fs ${pkgs.ipsecTools}/bin/setkey ${runDir}/ipsec/usr/sbin/setkey
+        ln -fs ${pkgs.writeScript "racoon-restart" ''
+        #!${pkgs.stdenv.shell}
+        /var/run/current-system/sw/bin/systemctl $1 racoon
+        ''} ${runDir}/ipsec/etc/init.d/racoon
+      '';
+    };
+  })]));

 }
--- a/nixos/tests/installer.nix
+++ b/nixos/tests/installer.nix
@ -120,7 +120,7 @@ let
      hdFlags =''hda => "harddisk", hdaInterface => "${iface}", '';
    in
    ''
-      createDisk("harddisk", 4 * 1024);
+      createDisk("harddisk", 8 * 1024);

      my $machine = createMachine({ ${hdFlags}
        cdrom => glob("${iso}/iso/*.iso"),
--- a/nixos/tests/lightdm.nix
+++ b/nixos/tests/lightdm.nix
@ -0,0 +1,25 @@
+import ./make-test.nix {
+  name = "lightdm";
+
+  machine = { lib, ... }: {
+    imports = [ ./common/user-account.nix ];
+    services.xserver.enable = true;
+    services.xserver.displayManager.lightdm.enable = true;
+    services.xserver.windowManager.default = "icewm";
+    services.xserver.windowManager.icewm.enable = true;
+    services.xserver.desktopManager.default = "none";
+  };
+
+  enableOCR = true;
+
+  testScript = { nodes, ... }: let
+    user = nodes.machine.config.users.extraUsers.alice;
+  in ''
+    startAll;
+    $machine->waitForText(qr/${user.description}/);
+    $machine->screenshot("lightdm");
+    $machine->sendChars("${user.password}\n");
+    $machine->waitForText(qr/^\d{2}(?::\d{2}){2} (?:AM|PM)$/m);
+    $machine->screenshot("session");
+  '';
+}
--- a/pkgs/applications/audio/bitmeter/default.nix
+++ b/pkgs/applications/audio/bitmeter/default.nix
@ -0,0 +1,21 @@
+{ stdenv, fetchurl, jack2, gtk2, pkgconfig }:
+
+stdenv.mkDerivation rec {
+  name = "bitmeter-${version}";
+  version = "1.2";
+
+  src = fetchurl {
+    url = "http://devel.tlrmx.org/audio/source/${name}.tar.gz";
+    sha256 = "09ck2gxqky701dc1p0ip61rrn16v0pdc7ih2hc2sd63zcw53g2a7";
+  };
+
+  buildInputs = [ jack2 gtk2 pkgconfig ];
+
+  meta = with stdenv.lib; {
+    homepage = http://devel.tlrmx.org/audio/bitmeter/;
+    description = "Also known as jack bitscope. Useful to detect denormals.";
+    license = licenses.gpl2;
+    maintainers = [ maintainers.magnetophon ];
+    platforms = platforms.linux;
+  };
+}
--- a/pkgs/applications/audio/eq10q/default.nix
+++ b/pkgs/applications/audio/eq10q/default.nix
@ -0,0 +1,37 @@
+{ stdenv, fetchurl, cmake, fftw, gtkmm, libxcb, lv2, pkgconfig, xlibs }:
+stdenv.mkDerivation rec {
+  name = "eq10q-2-${version}";
+  version = "beta7.1";
+  src = fetchurl {
+    url = "http://downloads.sourceforge.net/project/eq10q/${name}.tar.gz";
+    sha256 = "1jmrcx4jlx8kgsy5n4jcxa6qkjqvx7d8l2p7dsmw4hj20s39lgyi";
+  };
+
+  buildInputs = [ cmake fftw gtkmm libxcb lv2 pkgconfig xlibs.libpthreadstubs xlibs.libXdmcp xlibs.libxshmfence ];
+
+  installFlags = ''
+    DESTDIR=$(out)
+  '';
+
+  fixupPhase = ''
+    cp -r $out/var/empty/local/lib $out
+    rm -R $out/var
+  '';
+
+  meta = {
+    description = "LV2 EQ plugins and more, with 64 bit processing";
+    longDescription = ''
+      Up to 10-Bands parametric equalizer with mono and stereo versions.
+      Versatile noise-gate plugin with mono and stereo versions.
+      Compressor plugin with mono and stereo versions.
+      BassUp plugin - Enhanceing the bass guitar sound or other low frequency sounding instruments.
+      Improved high frequency response for peaking filter (in equalizers).
+      64 bits floating point internal audio processing.
+      Nice GUI with powerful metering for every plugin.
+    '';
+    homepage = http://eq10q.sourceforge.net/;
+    license = stdenv.lib.licenses.gpl3;
+    maintainers = [ stdenv.lib.maintainers.magnetophon ];
+    platforms = stdenv.lib.platforms.linux;
+  };
+}
--- a/pkgs/applications/audio/foo-yc20/default.nix
+++ b/pkgs/applications/audio/foo-yc20/default.nix
@ -0,0 +1,27 @@
+{ stdenv, fetchFromGitHub,  jack2, gtk2, lv2, faust, pkgconfig }:
+
+stdenv.mkDerivation rec {
+  version = "git-2015-05-21";
+  name = "foo-yc20-${version}";
+  src = fetchFromGitHub {
+    owner = "sampov2";
+    repo = "foo-yc20";
+    rev = "edd9d14c91229429b14270a181743e1046160ca8";
+    sha256 = "0i8261n95n4xic766h70xkrpbvw3sag96n1883ahmg6h7yb94avq";
+  };
+
+  buildInputs = [ jack2 gtk2 lv2 faust pkgconfig ];
+
+  makeFlags = "PREFIX=$(out)";
+
+  # remove lv2 until https://github.com/sampov2/foo-yc20/issues/6 is resolved
+  postInstallFixup = "rm -rf $out/lib/lv2";
+
+  meta = {
+    description = "A Faust implementation of a 1969 designed Yamaha combo organ, the YC-20";
+    homepage = https://github.com/sampov2/foo-yc20;
+    license     = "BSD";
+    maintainers = stdenv.lib.maintainers.magnetophon;
+    platforms = stdenv.lib.platforms.linux;
+  };
+}
--- a/pkgs/applications/audio/tetraproc/default.nix
+++ b/pkgs/applications/audio/tetraproc/default.nix
@ -0,0 +1,33 @@
+{ stdenv, fetchurl, jack2, libclthreads, libclxclient, fftwFloat, libsndfile, freetype, x11
+}:
+
+stdenv.mkDerivation rec {
+  name = "tetraproc-${version}";
+  version = "0.8.2";
+  src = fetchurl {
+    url = "http://kokkinizita.linuxaudio.org/linuxaudio/downloads/${name}.tar.bz2";
+    sha256 = "17y3vbm5f6h5cmh3yfxjgqz4xhfwpkla3lqfspnbm4ndlzmfpykv";
+  };
+
+  buildInputs = [
+   jack2 libclthreads libclxclient fftwFloat libsndfile freetype x11
+  ];
+
+  patchPhase = ''
+    cd source
+    sed -e "s@#include <clthreads.h>@#include <${libclthreads}/include>@" -i tetraproc.cc
+    sed -e "s@#include <clxclient.h>@#include <${libclxclient}/include>@" -i *.h
+    sed -e "s@#include <clthreads.h>@#include <${libclthreads}/include>@" -i *.h
+    sed -e "s@#include <clxclient.h>@#include <${libclxclient}/include>@" -i png2img.*
+    sed -e "s@/usr/local@$out@" -i Makefile
+  '';
+
+  meta = {
+    description = "Converts the A-format signals from a tetrahedral Ambisonic microphone into B-format signals ready for recording";
+    version = "${version}";
+    homepage = "http://kokkinizita.linuxaudio.org/linuxaudio/";
+    license = stdenv.lib.licenses.gpl2;
+    maintainers = [ stdenv.lib.maintainers.magnetophon ];
+    platforms = stdenv.lib.platforms.linux;
+  };
+}
--- a/pkgs/applications/editors/bviplus/default.nix
+++ b/pkgs/applications/editors/bviplus/default.nix
@ -0,0 +1,21 @@
+{ stdenv, lib, fetchurl, ncurses }:
+
+stdenv.mkDerivation rec {
+  name = "bviplus-${version}";
+  version = "0.9.4";
+  src = fetchurl {
+    url = "http://downloads.sourceforge.net/project/bviplus/bviplus/${version}/bviplus-${version}.tgz";
+    sha256 = "10x6fbn8v6i0y0m40ja30pwpyqksnn8k2vqd290vxxlvlhzah4zb";
+  };
+  buildInputs = [
+    ncurses
+  ];
+  makeFlags = "PREFIX=$(out)";
+  meta = with lib; {
+    description = "ncurses based hex editor with a vim-like interface";
+    homepage = "http://bviplus.sourceforge.net";
+    license = licenses.gpl3;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ cstrahan ];
+  };
+}
--- a/pkgs/applications/editors/heme/default.nix
+++ b/pkgs/applications/editors/heme/default.nix
@ -0,0 +1,27 @@
+{ stdenv, lib, fetchurl, ncurses }:
+
+stdenv.mkDerivation rec {
+  name = "heme-${version}";
+  version = "0.4.2";
+  src = fetchurl {
+    url = "http://downloads.sourceforge.net/project/heme/heme/heme-${version}/heme-${version}.tar.gz";
+    sha256 = "0wsrnj5mrlazgqs4252k30aw8m86qw0z9dmrsli9zdxl7j4cg99v";
+  };
+  postPatch = ''
+    substituteInPlace Makefile \
+      --replace "/usr/local" "$out" \
+      --replace "CFLAGS = " "CFLAGS = -I${ncurses}/include " \
+      --replace "LDFLAGS = " "LDFLAGS = -L${ncurses}/lib "
+  '';
+  preBuild = ''
+    mkdir -p $out/bin
+    mkdir -p $out/man/man1
+  '';
+  meta = with lib; {
+    description = "Portable and fast console hex editor for unix operating systems";
+    homepage = "http://heme.sourceforge.net/";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ cstrahan ];
+  };
+}
--- a/pkgs/applications/editors/hexcurse/default.nix
+++ b/pkgs/applications/editors/hexcurse/default.nix
@ -0,0 +1,22 @@
+{ stdenv, lib, fetchFromGitHub, ncurses }:
+
+stdenv.mkDerivation rec {
+  name = "hexcurse-${version}";
+  version = "1.58";
+  src = fetchFromGitHub {
+    owner = "LonnyGomes";
+    repo = "hexcurse";
+    rev = "hexcurse-${version}";
+    sha256 = "0hm9mms2ija3wqba0mkk9i8fhb8q1pam6d6pjlingkzz6ygxnnp7";
+  };
+  buildInputs = [
+    ncurses
+  ];
+  meta = with lib; {
+    description = "ncurses-based console hexeditor written in C";
+    homepage = "https://github.com/LonnyGomes/hexcurse";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ cstrahan ];
+  };
+}
--- a/pkgs/applications/editors/ht/default.nix
+++ b/pkgs/applications/editors/ht/default.nix
@ -0,0 +1,20 @@
+{ stdenv, lib, fetchurl, ncurses }:
+
+stdenv.mkDerivation rec {
+  name = "ht-${version}";
+  version = "2.1.0";
+  src = fetchurl {
+    url = "http://sourceforge.net/projects/hte/files/ht-source/ht-${version}.tar.bz2";
+    sha256 = "0w2xnw3z9ws9qrdpb80q55h6ynhh3aziixcfn45x91bzrbifix9i";
+  };
+  buildInputs = [
+    ncurses
+  ];
+  meta = with lib; {
+    description = "File editor/viewer/analyzer for executables";
+    homepage = "http://hte.sourceforge.net";
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ cstrahan ];
+  };
+}
--- a/pkgs/applications/editors/idea/default.nix
+++ b/pkgs/applications/editors/idea/default.nix
@ -273,25 +273,25 @@ in

  pycharm-community = buildPycharm rec {
    name = "pycharm-community-${version}";
-    version = "4.5";
-    build = "141.1116";
+    version = "4.5.1";
+    build = "141.1245";
    description = "PyCharm Community Edition";
    license = stdenv.lib.licenses.asl20;
    src = fetchurl {
      url = "https://download.jetbrains.com/python/${name}.tar.gz";
-      sha256 = "0igx62rijalppsd1nwrri1r4m1597n93ncglyb6b94m3fm32fca6";
+      sha256 = "1rjl8r863cm7bn3bkp8kbkb9f35rb344pycg5qlvjlvwvp2f448f";
    };
  };

  pycharm-professional = buildPycharm rec {
    name = "pycharm-professional-${version}";
-    version = "4.5";
-    build = "141.1116";
+    version = "4.5.1";
+    build = "141.1245";
    description = "PyCharm Professional Edition";
    license = stdenv.lib.licenses.unfree;
    src = fetchurl {
      url = "https://download.jetbrains.com/python/${name}.tar.gz";
-      sha256 = "0zga8sxwrvjvyw9v1pvq40gasp485r1d627jj6jvwzcv78il50d9";
+      sha256 = "1wwyggl6941hd034xfsb3avjgvvah9lh0pdmzlndmvm677cdgzz1";
    };
  };

@ -309,13 +309,13 @@ in

  webstorm = buildWebStorm rec {
    name = "webstorm-${version}";
-    version = "10.0.2";
-    build = "141.728";
+    version = "10.0.3";
+    build = "141.1237";
    description = "Professional IDE for Web and JavaScript devlopment";
    license = stdenv.lib.licenses.unfree;
    src = fetchurl {
      url = "https://download.jetbrains.com/webstorm/WebStorm-${version}.tar.gz";
-      sha256 = "0ghv1r145qb5kmp2x375f5674b86d51w024fz390znlnniclizqx";
+      sha256 = "06m852mbiij2dbmiz5y10bd4mhsdg5dmpy8arg75psl2j354spf8";
    };
  };

--- a/pkgs/applications/editors/neovim/default.nix
+++ b/pkgs/applications/editors/neovim/default.nix
@ -1,65 +1,88 @@
-{ stdenv, fetchgit, fetchurl, unzip, callPackage, ncurses, gettext, pkgconfig,
-cmake, pkgs, lpeg, lua, luajit, luaMessagePack, luabitop }:
+{ stdenv, fetchFromGitHub, cmake, gettext, glib, libmsgpack
+, libtermkey, libtool, libuv, lpeg, lua, luajit, luaMessagePack
+, luabitop, ncurses, perl, pkgconfig, unibilium
+, withJemalloc ? true, jemalloc }:

+let version = "2015-05-26"; in
 stdenv.mkDerivation rec {
-  name = "neovim-nightly";
+  name = "neovim-${version}";

-  version = "nightly";
-
-  src = fetchgit {
-    url = "https://github.com/neovim/neovim";
-    rev = "68fcd8b696dae33897303c9f8265629a31afbf17";
-    sha256 = "0hxkcy641jpn4qka44gfvhmb6q3dkjx6lvn9748lcl2gx2d36w4i";
+  src = fetchFromGitHub {
+    sha256 = "0sszpqlq0yp6r62zgcjcmnllc058wzzh9ccvgb2jh9k19ksszyhc";
+    rev = "5a9ad68b258f33ebd7fa0a5da47b308f50f1e5e7";
+    repo = "neovim";
+    owner = "neovim";
  };

-  libmsgpack = stdenv.mkDerivation rec {
-    version = "0.5.9";
-    name = "libmsgpack-${version}";
+  # FIXME: this is NOT the libvterm already in nixpkgs, but some NIH silliness:
+  neovimLibvterm = let version = "2015-02-23"; in stdenv.mkDerivation rec {
+    name = "neovim-libvterm-${version}";

-    src = fetchgit {
-      rev = "ecf4b09acd29746829b6a02939db91dfdec635b4";
-      url = "https://github.com/msgpack/msgpack-c";
-      sha256 = "076ygqgxrc3vk2l20l8x2cgcv05py3am6mjjkknr418pf8yav2ww";
+    src = fetchFromGitHub {
+      sha256 = "0i2h74jrx4fy90sv57xj8g4lbjjg4nhrq2rv6rz576fmqfpllcc5";
+      rev = "20ad1396c178c72873aeeb2870bd726f847acb70";
+      repo = "libvterm";
+      owner = "neovim";
    };

-    buildInputs = [ cmake ];
+    buildInputs = [ libtool perl ];
+
+    makeFlags = "PREFIX=$(out)";
+
+    enableParallelBuilding = true;

    meta = with stdenv.lib; {
-      description = "MessagePack implementation for C and C++";
-      homepage = http://msgpack.org;
-      maintainers = [ maintainers.manveru ];
-      license = licenses.asl20;
-      platforms = platforms.all;
+      description = "VT220/xterm/ECMA-48 terminal emulator library";
+      homepage = http://www.leonerd.org.uk/code/libvterm/;
+      license = licenses.mit;
+      maintainers = with maintainers; [ nckx ];
+      platforms = platforms.unix;
    };
  };

  enableParallelBuilding = true;

  buildInputs = [
-    ncurses
-    pkgconfig
    cmake
-    pkgs.libuvVersions.v0_11_29
+    glib
+    libtermkey
+    libuv
    luajit
    lua
    lpeg
    luaMessagePack
    luabitop
    libmsgpack
+    ncurses
+    neovimLibvterm
+    pkgconfig
+    unibilium
+  ] ++ stdenv.lib.optional withJemalloc jemalloc;
+  nativeBuildInputs = [
+    gettext
  ];
-  nativeBuildInputs = [ gettext ];

  LUA_CPATH="${lpeg}/lib/lua/${lua.luaversion}/?.so;${luabitop}/lib/lua/5.2/?.so";
  LUA_PATH="${luaMessagePack}/share/lua/5.1/?.lua";
-  cmakeFlags = [
-    "-DUSE_BUNDLED_MSGPACK=ON"
-  ];

  meta = with stdenv.lib; {
-    description = "Aggressive refactor of Vim";
-    homepage    = http://www.neovim.org;
-    maintainers = with maintainers; [ manveru ];
+    description = "Vim text editor fork focused on extensibility and agility";
+    longDescription = ''
+      Neovim is a project that seeks to aggressively refactor Vim in order to:
+      - Simplify maintenance and encourage contributions
+      - Split the work between multiple developers
+      - Enable the implementation of new/modern user interfaces without any
+        modifications to the core source
+      - Improve extensibility with a new plugin architecture
+    '';
+    homepage    = http://www.neovim.io;
+    # "Contributions committed before b17d96 by authors who did not sign the
+    # Contributor License Agreement (CLA) remain under the Vim license.
+    # Contributions committed after b17d96 are licensed under Apache 2.0 unless
+    # those contributions were copied from Vim (identified in the commit logs
+    # by the vim-patch token). See LICENSE for details."
+    license = with licenses; [ asl20 vim ];
+    maintainers = with maintainers; [ manveru nckx ];
    platforms   = platforms.unix;
  };
 }
-
--- a/pkgs/applications/editors/vim/configurable.nix
+++ b/pkgs/applications/editors/vim/configurable.nix
@ -190,6 +190,7 @@ composableDerivation {
  meta = with stdenv.lib; {
    description = "The most popular clone of the VI editor";
    homepage    = http://www.vim.org;
+    license = with licenses; [ vim ];
    maintainers = with maintainers; [ lovek323 ];
    platforms   = platforms.unix;
  };
--- a/pkgs/applications/editors/vim/default.nix
+++ b/pkgs/applications/editors/vim/default.nix
@ -49,6 +49,7 @@ stdenv.mkDerivation rec {
  meta = with stdenv.lib; {
    description = "The most popular clone of the VI editor";
    homepage    = http://www.vim.org;
+    license = with licenses; [ vim ];
    maintainers = with maintainers; [ lovek323 ];
    platforms   = platforms.unix;
  };
--- a/pkgs/applications/editors/vim/macvim.nix
+++ b/pkgs/applications/editors/vim/macvim.nix
@ -87,6 +87,7 @@ stdenv.mkDerivation rec {
  meta = with stdenv.lib; {
    description = "Vim - the text editor - for Mac OS X";
    homepage    = https://github.com/b4winckler/macvim;
+    license = with licenses; [ vim ];
    maintainers = with maintainers; [ cstrahan ];
    platforms   = platforms.darwin;
  };
--- a/pkgs/applications/editors/vim/qvim.nix
+++ b/pkgs/applications/editors/vim/qvim.nix
@ -118,6 +118,7 @@ composableDerivation {
  meta = with stdenv.lib; {
    description = "The most popular clone of the VI editor (Qt GUI fork)";
    homepage    = https://bitbucket.org/equalsraf/vim-qt/wiki/Home;
+    license = with licenses; [ vim ];
    maintainers = with maintainers; [ smironov ttuegel ];
    platforms   = platforms.linux;
  };
--- a/pkgs/applications/graphics/feh/default.nix
+++ b/pkgs/applications/graphics/feh/default.nix
@ -2,11 +2,11 @@
 , libXinerama, curl, libexif }:

 stdenv.mkDerivation rec {
-  name = "feh-2.13";
+  name = "feh-2.13.1";

  src = fetchurl {
    url = "http://feh.finalrewind.org/${name}.tar.bz2";
-    sha256 = "06fa9zh1zpi63l90kw3l9a0sfavf424j7ksi396ifg9669gx35gn";
+    sha256 = "1059mflgw8hl398lwy55fj50a98xryvdf23wkpbn4s0z9388hl46";
  };

  buildInputs = [ makeWrapper x11 imlib2 libjpeg libpng libXinerama curl libexif ];
--- a/pkgs/applications/misc/rxvt_unicode/default.nix
+++ b/pkgs/applications/misc/rxvt_unicode/default.nix
@ -45,6 +45,11 @@ stdenv.mkDerivation (rec {
      ln -s $out/{lib/urxvt,lib/perl5/site_perl}
    '';

+  postInstall = ''
+    mkdir -p $out/nix-support
+    echo "$terminfo" >> $out/nix-support/propagated-user-env-packages
+  '';
+
  meta = {
    description = "A clone of the well-known terminal emulator rxvt";
    homepage = "http://software.schmorp.de/pkg/rxvt-unicode.html";
--- a/pkgs/applications/networking/instant-messengers/viber/default.nix
+++ b/pkgs/applications/networking/instant-messengers/viber/default.nix
@ -1,4 +1,4 @@
-{ fetchurl, stdenv, dpkg, makeWrapper, xlibs, qt5, gstreamer, zlib, sqlite, libxslt }:
+{ fetchurl, stdenv, dpkg, makeWrapper, xlibs, qt5Full, gstreamer, zlib, sqlite, libxslt }:

 assert stdenv.system == "x86_64-linux";

@ -22,7 +22,7 @@ stdenv.mkDerivation rec {
  unpackPhase = "true";

  libPath = stdenv.lib.makeLibraryPath [
-      qt5
+      qt5Full
      xlibs.libX11
      gstreamer
      zlib
--- a/pkgs/applications/networking/irc/irssi/default.nix
+++ b/pkgs/applications/networking/irc/irssi/default.nix
@ -4,7 +4,9 @@ stdenv.mkDerivation rec {
  name = "irssi-0.8.17";

  src = fetchurl {
-    url = "http://irssi.org/files/${name}.tar.bz2";
+    urls = [ "https://distfiles.macports.org/irssi/${name}.tar.bz2"
+             "http://irssi.org/files/${name}.tar.bz2"
+           ];
    sha256 = "01v82q2pfiimx6lh271kdvgp8hl4pahc3srg04fqzxgdsb5015iw";
  };

--- a/pkgs/applications/networking/remote/x2goclient/default.nix
+++ b/pkgs/applications/networking/remote/x2goclient/default.nix
@ -1,12 +1,12 @@
 { stdenv, fetchurl, cups, libssh, libXpm, nxproxy, openldap, makeWrapper, qt4 }:

-let version = "4.0.3.2"; in
+let version = "4.0.4.0"; in
 stdenv.mkDerivation rec {
  name = "x2goclient-${version}";

  src = fetchurl {
    url = "http://code.x2go.org/releases/source/x2goclient/${name}.tar.gz";
-    sha256 = "0vqcz9kmnbvlj8kns68zl60019fdz97rydz4wsgnsgdf7r370npn";
+    sha256 = "0mqn4nvq2w7qja5i4vx9fg2spwzl01p0hmfwbjb0mzir03hmrl46";
  };

  meta = with stdenv.lib; {
--- a/pkgs/applications/networking/syncthing/default.nix
+++ b/pkgs/applications/networking/syncthing/default.nix
@ -4,12 +4,12 @@ with goPackages;

 buildGoPackage rec {
  name = "syncthing-${version}";
-  version = "0.11.5";
+  version = "0.11.6";
  goPackagePath = "github.com/syncthing/syncthing";
  src = fetchgit {
    url = "git://github.com/syncthing/syncthing.git";
    rev = "refs/tags/v${version}";
-    sha256 = "3a68cdecaec8d00b0fbf6348fb9b8adc628910e9572a89d9a413d6e7b79e7a06";
+    sha256 = "7fe7d7034c0e502036e2a0bb1b94b1701bd194cc82f07495da8a41c4b097c6a3";
  };

  subPackages = [ "cmd/syncthing" ];
--- a/pkgs/applications/networking/umurmur/default.nix
+++ b/pkgs/applications/networking/umurmur/default.nix
@ -13,7 +13,10 @@ stdenv.mkDerivation rec {
  
  buildInputs = [ autoreconfHook openssl protobufc libconfig ];

-  configureFlags = "--with-ssl=openssl";
+  configureFlags = [
+    "--with-ssl=openssl"
+    "--enable-shmapi"
+  ];

  meta = with stdenv.lib; {
    description = "Minimalistic Murmur (Mumble server)";
--- a/pkgs/applications/science/biology/arb/default.nix
+++ b/pkgs/applications/science/biology/arb/default.nix
@ -1,86 +0,0 @@
-{ stdenv, fetchurl, glew, mesa, libpng, lesstif, lynx, freeglut
-, libtiff, rxp, sablotron, perl, jdk, transfig, gv, gnuplot, xorg }:
-
-# NOTE: This package does not build on 64-bit systems. Because of some faulty
-# int->pointer arithmatic. The build scripts are abnormal - but it appears to
-# work.
-
-stdenv.mkDerivation {
-  name = "arb-2007-Dec-07";
-  
-  src = fetchurl {
-    url = http://download.arb-home.de/release/2007_12_07/arbsrc.tgz;
-    sha256 = "04l7qj0wigg1h56a9d70hxhdr343v3dg5dhqrc7fahc1v4h8f1rd";
-  };
-
-  patches = [ ./makefile.patch ];
-
-  buildInputs =
-    [ glew mesa libpng xorg.libXpm lesstif lynx freeglut libtiff rxp
-      sablotron xorg.libXaw perl jdk transfig xorg.libX11 xorg.libXext
-      xorg.libXt gv gnuplot
-    ];
-
-  unpackPhase = ''
-    tar xzf $src
-  '';
-
-  buildPhase = ''
-    echo `make`   # avoids error signal
-    export ARBHOME=`pwd`
-    export PATH=$ARBHOME/bin:$PATH
-    make all
-  '';
-
-  installPhase = ''
-    mkdir -p $out/lib
-    shareddir=/nix/var/lib/arb
-    # link out writable shared location lib/pts
-    mkdir -p $shareddir/lib/pts
-    cp -vau lib/pts $shareddir/lib
-    rm -vrf lib/pts
-    ln -vs $shareddir/lib/pts $out/lib/pts
-    chmod a+rwx $shareddir/lib/pts
-    # link out writable shared location lib/nas/
-    mkdir -p $shareddir/lib/nas
-    cp -vau lib/nas $shareddir/lib
-    rm -vrf lib/nas
-    ln -vs $shareddir/lib/nas $out/lib/nas
-    chmod a+rwx $shareddir/lib/nas
-    # link out shared lib/pixmaps (not sure about this, yet):
-    mkdir -p $shareddir/lib/pixmaps
-    cp -vau lib/pixmaps $shareddir/lib
-    rm -vrf lib/pixmaps
-    ln -vs $shareddir/lib/pixmaps $out/lib/pixmaps
-    chmod a+rwx $shareddir/lib/pixmaps
-    # bulk copy
-    cp -vau * $out
-    
-    # replace arb script
-    mv $out/bin/arb $out/bin/arb.orig
-    cat > $out/bin/arb << ARB 
-    #!/bin/sh
-
-    echo Starting Nix compiled arb from $out
-    echo Shared databases are located in $shareddir
-    # sometimes local profiles override these:
-    export ARBHOME=$out
-    export LD_LIBRARY=$ARBHOME/lib   
-
-    $out/bin/arb_ntree $*
-
-    ARB
-    
-    chmod +x $out/bin/arb
-  '';
-
-  meta = {
-    description     = "Software for sequence database handling and analysis";
-    longDescription = ''The ARB software is a graphically oriented package comprising various tools for sequence database handling and data analysis. A central database of processed (aligned) sequences and any type of additional data linked to the respective sequence entries is structured according to phylogeny or other user defined criteria. Note that this package includes its own older versions of clustal etc.''; 
-    license     = "non-free";
-    pkgMaintainer = "http://BioLib.open-bio.org/";
-    homepage    = http://www.arb-home.de/;
-    priority    = "10";   # because it includes binaries of clustal etc.
-    broken = true;
-  };
-}
--- a/pkgs/applications/science/biology/arb/makefile.patch
+++ b/pkgs/applications/science/biology/arb/makefile.patch
@ -1,12 +0,0 @@
-diff -r a1e04cdafd13 Makefile
--- a/Makefile	Thu Sep 25 11:59:19 2008 +0200
-+++ b/Makefile	Thu Sep 25 11:59:27 2008 +0200
-@@ -109,7 +109,7 @@ endif
- 
- ALLOWED_GCC_295_VERSIONS=2.95.3
- ALLOWED_GCC_3xx_VERSIONS=3.2 3.3.1 3.3.3 3.3.4 3.3.5 3.3.6 3.4.0 3.4.2 3.4.3
-ALLOWED_GCC_4xx_VERSIONS=4.0.0 4.0.2 4.0.3 4.1.1 4.1.2 4.1.3 4.2.0 4.2.1 4.2.3
-+ALLOWED_GCC_4xx_VERSIONS=4.0.0 4.0.2 4.0.3 4.1.1 4.1.2 4.1.3 4.2.0 4.2.1 4.2.3 4.2.4
- ALLOWED_GCC_VERSIONS=$(ALLOWED_GCC_295_VERSIONS) $(ALLOWED_GCC_3xx_VERSIONS) $(ALLOWED_GCC_4xx_VERSIONS)
- 
- GCC_VERSION_FOUND=$(shell $(GCC) -dumpversion)
--- a/pkgs/applications/science/geometry/tetgen/1.4.nix
+++ b/pkgs/applications/science/geometry/tetgen/1.4.nix
@ -0,0 +1,21 @@
+{stdenv, fetchurl}:
+
+stdenv.mkDerivation rec {
+  name = "tetgen-1.4.3";
+
+  src = fetchurl {
+    url = "${meta.homepage}/files/tetgen1.4.3.tar.gz";
+    sha256 = "0d70vjqdapmy1ghlsxjlvl5z9yp310zw697bapc4zxmp0sxi29wm";
+  };
+
+  installPhase = ''
+    mkdir -p $out/bin
+    cp tetgen $out/bin
+  '';
+
+  meta = {
+    description = "Quality Tetrahedral Mesh Generator and 3D Delaunay Triangulator";
+    homepage = "http://tetgen.org/";
+    license = stdenv.lib.licenses.mit;
+  };
+}
--- a/pkgs/applications/science/geometry/tetgen/default.nix
+++ b/pkgs/applications/science/geometry/tetgen/default.nix
@ -1,11 +1,12 @@
 {stdenv, fetchurl}: 

-stdenv.mkDerivation rec {
-  name = "tetgen-1.4.3";
+let version = "1.5.0"; in
+stdenv.mkDerivation {
+  name = "tetgen-${version}";

  src = fetchurl {
-    url = "${meta.homepage}/files/tetgen1.4.3.tar.gz";
-    sha256 = "0d70vjqdapmy1ghlsxjlvl5z9yp310zw697bapc4zxmp0sxi29wm";
+    url = "http://wias-berlin.de/software/tetgen/1.5/src/tetgen${version}.tar.gz";
+    sha256 = "1www3x2r6r7pck43ismlwy82x0j6xj2qiwvfs2pn687gsmhlh4ad";
  };

  installPhase = ''
@ -14,8 +15,9 @@ stdenv.mkDerivation rec {
  '';

  meta = {
+    inherit version;
    description = "Quality Tetrahedral Mesh Generator and 3D Delaunay Triangulator";
    homepage = "http://tetgen.org/";
-    license = stdenv.lib.licenses.mit;
+    license = stdenv.lib.licenses.agpl3Plus;
  };
 }
--- a/pkgs/applications/science/logic/gappa/default.nix
+++ b/pkgs/applications/science/logic/gappa/default.nix
@ -0,0 +1,23 @@
+{ stdenv, fetchurl, gmp, mpfr, boost }:
+
+stdenv.mkDerivation {
+  name = "gappa-1.2";
+
+  src = fetchurl {
+    url = https://gforge.inria.fr/frs/download.php/file/34787/gappa-1.2.0.tar.gz;
+    sha256 = "03hfzmaf5jm54sjpbks20q7qixpmagrfbnyyc276vgmiyslk4dkh";
+  };
+
+  buildInputs = [ gmp mpfr boost.dev ];
+
+  buildPhase = "./remake";
+  installPhase = "./remake install";
+
+  meta = {
+    homepage = http://gappa.gforge.inria.fr/;
+    description = "Verifying and formally proving properties on numerical programs dealing with floating-point or fixed-point arithmetic";
+    license = with stdenv.lib.licenses; [ cecill20 gpl2 ];
+    maintainers = with stdenv.lib.maintainers; [ vbgl ];
+    platforms = stdenv.lib.platforms.all;
+  };
+}
--- a/pkgs/applications/version-management/gitolite/default.nix
+++ b/pkgs/applications/version-management/gitolite/default.nix
@ -1,15 +1,15 @@
-{ stdenv, fetchurl, perl, git }:
+{ stdenv, fetchurl, git, nettools, perl }:

 stdenv.mkDerivation rec {
  name = "gitolite-${version}";
-  version = "3.6.2";
+  version = "3.6.3";

  src = fetchurl {
    url = "https://github.com/sitaramc/gitolite/archive/v${version}.tar.gz";
-    sha256 = "1gsgzi9ayb4rablki3mqr11b0h8db4xg43df660marfpacmkfb01";
+    sha256 = "16cxifjxnri719qb6zzwkdf61x5y957acbdhcgqcan23x1mfn84v";
  };

-  buildInputs = [ perl git ];
+  buildInputs = [ git nettools perl ];
  buildPhase = "true";

  patchPhase = ''
@ -18,6 +18,8 @@ stdenv.mkDerivation rec {
      --replace /usr/bin/perl "${perl}/bin/perl"
    substituteInPlace src/lib/Gitolite/Hooks/Update.pm \
      --replace /usr/bin/perl "${perl}/bin/perl"
+    substituteInPlace src/lib/Gitolite/Setup.pm \
+      --replace hostname "${nettools}/bin/hostname"
  '';

  installPhase = ''
@ -30,6 +32,6 @@ stdenv.mkDerivation rec {
    homepage    = http://gitolite.com/gitolite/index.html;
    license     = licenses.gpl2;
    platforms   = platforms.unix;
-    maintainers = [ maintainers.thoughtpolice ];
+    maintainers = [ maintainers.thoughtpolice maintainers.lassulus ];
  };
 }
--- a/pkgs/build-support/fetchurl/default.nix
+++ b/pkgs/build-support/fetchurl/default.nix
@ -76,6 +76,9 @@ in
 , # If set, don't download the file, but write a list of all possible
  # URLs (resulting from resolving mirror:// URLs) to $out.
  showURLs ? false
+
+, # Meta information, if any.
+  meta ? {}
 }:

 assert builtins.isList urls;
@ -120,4 +123,6 @@ if (!hasHash) then throw "Specify hash for fetchurl fixed-output derivation: ${s
  # Doing the download on a remote machine just duplicates network
  # traffic, so don't do that.
  preferLocalBuild = true;
+
+  inherit meta;
 }
--- a/pkgs/build-support/ocaml/default.nix
+++ b/pkgs/build-support/ocaml/default.nix
@ -0,0 +1,36 @@
+{ stdenv, writeText, ocaml, findlib, camlp4 }:
+
+{ name, version, buildInputs ? [],
+  createFindlibDestdir ?  true,
+  dontStrip ? true,
+  minimumSupportedOcamlVersion ? null,
+  hasSharedObjects ? false,
+  setupHook ? null,
+  meta ? {}, ...
+}@args:
+let
+  ocaml_version = (builtins.parseDrvName ocaml.name).version;
+  defaultMeta = {
+    platforms = ocaml.meta.platforms;
+  };
+in
+  assert minimumSupportedOcamlVersion != null ->
+          stdenv.lib.versionOlder minimumSupportedOcamlVersion ocaml_version;
+
+stdenv.mkDerivation (args // {
+  name = "ocaml-${name}-${version}";
+
+  buildInputs = [ ocaml findlib camlp4 ] ++ buildInputs;
+
+  setupHook = if setupHook == null && hasSharedObjects
+  then writeText "setupHook.sh" ''
+    export CAML_LD_LIBRARY_PATH="''${CAML_LD_LIBRARY_PATH}''${CAML_LD_LIBRARY_PATH:+:}''$1/lib/ocaml/${ocaml_version}/site-lib/${name}/"
+    ''
+  else setupHook;
+
+  inherit ocaml_version;
+  inherit createFindlibDestdir;
+  inherit dontStrip;
+
+  meta = defaultMeta // meta;
+})
--- a/pkgs/desktops/gnome-3/3.16/apps/seahorse/default.nix
+++ b/pkgs/desktops/gnome-3/3.16/apps/seahorse/default.nix
@ -2,16 +2,16 @@
 , pkgconfig, gtk3, glib, hicolor_icon_theme
 , makeWrapper, itstool, gnupg, libsoup
 , gnome3, librsvg, gdk_pixbuf, gpgme
-, libsecret, avahi, p11_kit }:
+, libsecret, avahi, p11_kit, openssh }:

 let
-  majVer = "3.14";
+  majVer = gnome3.version;
 in stdenv.mkDerivation rec {
-  name = "seahorse-${majVer}.1";
+  name = "seahorse-${majVer}.0";

  src = fetchurl {
    url = "mirror://gnome/sources/seahorse/${majVer}/${name}.tar.xz";
-    sha256 = "14syy2qxxrim220aj64mbp76jbrrc6wmdwc4lfl4sngsh84qjah9";
+    sha256 = "0cg1grgpwbfkiny5148n17rzpc8kswyr5yff0kpm8l3lp01my2kp";
  };

  doCheck = true;
@ -24,7 +24,7 @@ in stdenv.mkDerivation rec {
                  gnome3.gsettings_desktop_schemas makeWrapper gnupg
                  gdk_pixbuf gnome3.adwaita-icon-theme librsvg gpgme
                  libsecret avahi libsoup p11_kit vala gnome3.gcr
-                  hicolor_icon_theme gnome3.adwaita-icon-theme ];
+                  hicolor_icon_theme gnome3.adwaita-icon-theme openssh ];

  preFixup = ''
    wrapProgram "$out/bin/seahorse" \
--- a/pkgs/desktops/gnome-3/3.16/core/mutter/default.nix
+++ b/pkgs/desktops/gnome-3/3.16/core/mutter/default.nix
@ -4,11 +4,11 @@


 stdenv.mkDerivation rec {
-  name = "mutter-${gnome3.version}.1.1";
+  name = "mutter-${gnome3.version}.2";

  src = fetchurl {
    url = "mirror://gnome/sources/mutter/${gnome3.version}/${name}.tar.xz";
-    sha256 = "07059jmwhc7zf2gww2xw94hhy4csjj2v30ivyzllbas2nvv88l3r";
+    sha256 = "0qq7gpkljn1z45sg2sxvmia52krj4ck2541iar89z99s1cppaasa";
  };

  # fatal error: gio/gunixfdlist.h: No such file or directory
@ -27,6 +27,8 @@ stdenv.mkDerivation rec {
      --prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH"
  '';

+  patches = [ ./x86.patch ];
+
  meta = with stdenv.lib; {
    platforms = platforms.linux;
    maintainers = [ maintainers.lethalman ];
--- a/pkgs/desktops/gnome-3/3.16/core/mutter/x86.patch
+++ b/pkgs/desktops/gnome-3/3.16/core/mutter/x86.patch
@ -0,0 +1,20 @@
+--- mutter-3.16.2/src/core/window.c.orig	2015-05-26 10:52:41.382834963 +0200
+++ mutter-3.16.2/src/core/window.c	2015-05-26 10:53:03.039948034 +0200
+@@ -3499,7 +3499,7 @@
+ 
+ static MetaMonitorInfo *
+ find_monitor_by_winsys_id (MetaWindow *window,
+-                           guint       winsys_id)
+                           gint       winsys_id)
+ {
+   int i;
+ 
+@@ -3618,7 +3618,7 @@
+    */
+ 
+   gboolean did_placement;
+-  guint old_output_winsys_id;
+  gint old_output_winsys_id;
+   MetaRectangle unconstrained_rect;
+   MetaRectangle constrained_rect;
+   MetaMoveResizeResultFlags result = 0;
--- a/pkgs/development/compilers/gcc/gfortran-darwin.nix
+++ b/pkgs/development/compilers/gcc/gfortran-darwin.nix
@ -0,0 +1,26 @@
+# This is a derivation specific to OS X (Darwin). It may work on other
+# systems as well but has not been tested.
+{gmp, mpfr, libmpc, fetchurl, stdenv}:
+
+stdenv.mkDerivation rec {
+  name = "gfortran-${version}";
+  version = "5.1.0";
+  buildInputs = [gmp mpfr libmpc];
+  src = fetchurl {
+    url = "mirror://gnu/gcc/gcc-${version}/gcc-${version}.tar.bz2";
+    sha256 = "1bd5vj4px3s8nlakbgrh38ynxq4s654m6nxz7lrj03mvkkwgvnmp";
+  };
+  configureFlags = ''
+    --enable-languages=fortran --enable-checking=release --disable-bootstrap
+    --with-gmp=${gmp}
+    --with-mpfr=${mpfr}
+    --with-mpc=${libmpc}
+  '';
+  makeFlags = ["CC=clang"];
+  meta = with stdenv.lib; {
+    description = "GNU Fortran compiler, part of the GNU Compiler Collection.";
+    homepage    = "https://gcc.gnu.org/fortran/";
+    license     = licenses.gpl3Plus;
+    platforms   = platforms.darwin;
+  };
+}
--- a/pkgs/development/compilers/llvm/3.6/clang/default.nix
+++ b/pkgs/development/compilers/llvm/3.6/clang/default.nix
@ -6,7 +6,7 @@ in stdenv.mkDerivation {
  name = "clang-${version}";

  unpackPhase = ''
-    unpackFile ${fetch "cfe" "0b8825mvdhfk5r9gwcwp1j2dl9kw5glgyk7pybq2dzhrh4vnj3my"}
+    unpackFile ${fetch "cfe" "1myssbxlyln0nggfz04nfrbzdckljksmaxp82nq7hrmqjc62vybl"}
    mv cfe-${version}.src clang
    sourceRoot=$PWD/clang
    unpackFile ${clang-tools-extra_src}
--- a/pkgs/development/compilers/llvm/3.6/default.nix
+++ b/pkgs/development/compilers/llvm/3.6/default.nix
@ -2,7 +2,7 @@
 let
  callPackage = newScope (self // { inherit isl version fetch; });

-  version = "3.6.0";
+  version = "3.6.1";

  fetch = fetch_v version;
  fetch_v = ver: name: sha256: fetchurl {
@ -10,8 +10,8 @@ let
    inherit sha256;
  };

-  compiler-rt_src = fetch "compiler-rt" "04bbn946jninynkrjyp337xqs8ihn4fkz5xgvmywxkddwmwznjbz";
-  clang-tools-extra_src = fetch "clang-tools-extra" "04n83gsmy2ghvn7vp9hamsgn332rx2g7sa4paskr0d4ihax4ka9s";
+  compiler-rt_src = fetch "compiler-rt" "17v4gf4y5krgkrd12r95hfxbw5q4c4jlf3513kqlfq5yfw663gzw";
+  clang-tools-extra_src = fetch "clang-tools-extra" "1dljzdk2jmrwyh8z92rljxl9wzdggp74i9f6g8aajl6mf3c71vpl";

  self = {
    llvm = callPackage ./llvm.nix {
--- a/pkgs/development/compilers/llvm/3.6/libc++/default.nix
+++ b/pkgs/development/compilers/llvm/3.6/libc++/default.nix
@ -3,7 +3,7 @@
 stdenv.mkDerivation rec {
  name = "libc++-${version}";

-  src = fetch "libcxx" "1dzvhyrzj54v823biadag5lwxfz37gm8a65aq72pjsh8n211x719";
+  src = fetch "libcxx" "1yf0ns4cvvirp1ml5a8h29lysnw5c23715b09x68v5zkxhxnap2s";

  # instead of allowing libc++ to link with /usr/lib/libc++abi.dylib,
  # force it to link with our copy
--- a/pkgs/development/compilers/llvm/3.6/libc++abi.nix
+++ b/pkgs/development/compilers/llvm/3.6/libc++abi.nix
@ -3,7 +3,7 @@
 stdenv.mkDerivation {
  name = "libc++abi-${version}";

-  src = fetch "libcxxabi" "1xclv63l7cmrxkl129w6j9fsxgdm8jjlcm8gswl2y9qmh3dwz2zp";
+  src = fetch "libcxxabi" "0pgimy1b5vj4favzdz2830n917fyz65hm3khdgkbgnfs43s8g0xw";

  buildInputs = [ cmake ] ++ stdenv.lib.optional (!stdenv.isDarwin) libunwind;

--- a/pkgs/development/compilers/llvm/3.6/lldb.nix
+++ b/pkgs/development/compilers/llvm/3.6/lldb.nix
@ -15,7 +15,7 @@
 stdenv.mkDerivation {
  name = "lldb-${version}";

-  src = fetch "lldb" "1cphxbc8c0yqs2rxn94vcn8his465m97rnynklpzm8sf5kad26ib";
+  src = fetch "lldb" "1fmaz7zcc1f54ns4x8rx9nvhh4pyrhbz103bl02sv1cfwxj5ryyf";

  patchPhase = ''
    sed -i 's|/usr/bin/env||' \
--- a/pkgs/development/compilers/llvm/3.6/llvm.nix
+++ b/pkgs/development/compilers/llvm/3.6/llvm.nix
@ -15,7 +15,7 @@
 }:

 let
-  src = fetch "llvm" "1kmr5vlnz1419nnvyc7lsrcfx09n65ravjbmzxrqz7ml07jnk6mk";
+  src = fetch "llvm" "0ypwcqrld91jn0zz4mkdksl2mbb0ds9lh5gf0xkbb81sj4awc01g";
 in stdenv.mkDerivation rec {
  name = "llvm-${version}";

--- a/pkgs/development/compilers/rustc/1.0.0.nix
+++ b/pkgs/development/compilers/rustc/1.0.0.nix
@ -2,7 +2,7 @@
 callPackage ./makeRustcDerivation.nix {
  shortVersion = "1.0.0";
  isRelease = true;
-  srcSha = "1fjyk5xhg9dx85d1kkjmb1jai7awvdmzcjf2fdmi2pdjyzacn163";
+  srcSha = "14brziw91d3r88fa1kvpvhap5ws4z8h2mas7h6k9lpsc2zl9blak";
  snapshotHashLinux686 = "1ef82402ed16f5a6d2f87a9a62eaa83170e249ec";
  snapshotHashLinux64 = "ef2154372e97a3cb687897d027fd51c8f2c5f349";
  snapshotHashDarwin686 = "0310b1a970f2da7e61770fd14dbbbdca3b518234";
--- a/pkgs/development/compilers/rustc/makeRustcDerivation.nix
+++ b/pkgs/development/compilers/rustc/makeRustcDerivation.nix
@ -1,5 +1,5 @@
-{ stdenv, fetchurl, fetchgit, which, file, perl, curl, python27, makeWrapper
-, tzdata, git, valgrind, procps, coreutils
+{ stdenv, fetchurl, fetchgit, fetchzip, which, file, perl, curl, python27
+, makeWrapper, tzdata, git, valgrind, procps, coreutils

 , shortVersion, isRelease
 , srcSha, srcRev ? ""
@ -85,7 +85,7 @@ stdenv.mkDerivation {
  inherit meta;

  src = if isRelease then
-      fetchurl {
+      fetchzip {
        url = "http://static.rust-lang.org/dist/rustc-${version}-src.tar.gz";
        sha256 = srcSha;
      }
--- a/pkgs/development/haskell-modules/configuration-common.nix
+++ b/pkgs/development/haskell-modules/configuration-common.nix
@ -115,9 +115,6 @@ self: super: {
  # Cannot compile its own test suite: https://github.com/haskell/network-uri/issues/10.
  network-uri = dontCheck super.network-uri;

-  # Agda-2.4.2.2 needs these overrides to compile.
-  Agda = super.Agda.override { equivalence = self.equivalence_0_2_5; cpphs = self.cpphs_1_18_9; };
-
  # Help libconfig find it's C language counterpart.
  libconfig = (dontCheck super.libconfig).override { config = pkgs.libconfig; };

--- a/pkgs/development/haskell-modules/configuration-ghc-7.10.x.nix
+++ b/pkgs/development/haskell-modules/configuration-ghc-7.10.x.nix
@ -127,7 +127,7 @@ self: super: {
  # Until the changes have been pushed to Hackage
  mueval = appendPatch super.mueval (pkgs.fetchpatch {
    url = "https://github.com/gwern/mueval/commit/c41aa40ed63b74c069d1e4e3caa8c8d890cde960.patch";
-    sha256 = "1gs8p89d1qsrd1qycbhf6kv4qw0sbb8m6dy106dqkmdzcjzcyq74";
+    sha256 = "0h1lx4z15imq009k0qmwkn5l3hmigw463ahvwffdnszi2n618kpg";
  });
  present = appendPatch super.present (pkgs.fetchpatch {
    url = "https://github.com/chrisdone/present/commit/6a61f099bf01e2127d0c68f1abe438cd3eaa15f7.patch";
@ -166,7 +166,7 @@ self: super: {

  misfortune = appendPatch super.misfortune (pkgs.fetchpatch {
    url = "https://github.com/mokus0/misfortune/commit/9e0a38cf8d59a0de9ae1156034653f32099610e4.patch";
-    sha256 = "15frwdallm3i6k7mil26bbjd4wl6k9h20ixf3cmyris3q3jhlcfh";
+    sha256 = "01m1l199ihq85j9pyc3n0wqv1z4my453hhhcvg3yz3gpz3lf224r";
  });

  timezone-series = doJailbreak super.timezone-series;
--- a/pkgs/development/haskell-modules/hackage-packages.nix
+++ b/pkgs/development/haskell-modules/hackage-packages.nix
@ -654,26 +654,25 @@ self: {

  "Agda" = callPackage
    ({ mkDerivation, alex, array, base, binary, boxes, bytestring
-     , containers, cpphs, data-hash, deepseq, directory, emacs
-     , equivalence, filepath, geniplate, happy, hashable, hashtables
-     , haskeline, haskell-src-exts, mtl, parallel, pretty, process
-     , QuickCheck, STMonadTrans, strict, template-haskell, text, time
-     , transformers, unordered-containers, xhtml, zlib
+     , containers, cpphs, data-hash, deepseq, directory, edit-distance
+     , emacs, equivalence, filepath, geniplate-mirror, happy, hashable
+     , hashtables, haskeline, haskell-src-exts, mtl, parallel, pretty
+     , process, QuickCheck, strict, template-haskell, text, time
+     , transformers, transformers-compat, unordered-containers, xhtml
+     , zlib
     }:
     mkDerivation {
       pname = "Agda";
-       version = "2.4.2.2";
-       revision = "1";
-       sha256 = "1hxvapnvlkx6imifswc70ng869zll0zfsygivhc2mjyhaiv10i13";
-       editedCabalFile = "b604adb3c6609d27384834ce1d9483841245ac3d59e07571bc1ec114a080dcf3";
+       version = "2.4.2.3";
+       sha256 = "09vvipvab6bys8g7cdka1iirs0wc0jzcyynncccgb614wd2yyvdw";
       isLibrary = true;
       isExecutable = true;
       buildDepends = [
         array base binary boxes bytestring containers data-hash deepseq
-         directory equivalence filepath geniplate hashable hashtables
-         haskeline haskell-src-exts mtl parallel pretty process QuickCheck
-         STMonadTrans strict template-haskell text time transformers
-         unordered-containers xhtml zlib
+         directory edit-distance equivalence filepath geniplate-mirror
+         hashable hashtables haskeline haskell-src-exts mtl parallel pretty
+         process QuickCheck strict template-haskell text time transformers
+         transformers-compat unordered-containers xhtml zlib
       ];
       buildTools = [ alex cpphs emacs happy ];
       jailbreak = true;
@ -1057,8 +1056,8 @@ self: {
     }:
     mkDerivation {
       pname = "BNFC";
-       version = "2.7.1";
-       sha256 = "1n9l64wzga3i7ifh2k5rwhxp60gb0av5fszygw5mvr31r64cf4fp";
+       version = "2.8";
+       sha256 = "0d3zcxspxcpnifv3kqg8d6gp01wxybakcbw7jh69gqg8rzfmzgi1";
       isLibrary = true;
       isExecutable = true;
       buildDepends = [
@ -8944,10 +8943,8 @@ self: {
     }:
     mkDerivation {
       pname = "JuicyPixels";
-       version = "3.2.4";
-       revision = "1";
-       sha256 = "113w66rd6h04x0zbkqh34x33pf15hmrn3l9yy8kirs55kbg266w0";
-       editedCabalFile = "0ea6de6b2defec5f1be0f98fc995b3a9654fbf8d3b34cd3fa77a0f2e3919dc2b";
+       version = "3.2.5.1";
+       sha256 = "11wpk4lr7h7s7mhl48i27dq1wwvzjviv2fnq3yl8dnikcl00k6dq";
       buildDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
@ -12643,16 +12640,16 @@ self: {
     }) {};

  "Rasterific" = callPackage
-    ({ mkDerivation, base, dlist, FontyFruity, free, JuicyPixels, mtl
-     , primitive, vector, vector-algorithms
+    ({ mkDerivation, base, bytestring, containers, dlist, FontyFruity
+     , free, JuicyPixels, mtl, primitive, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "Rasterific";
-       version = "0.5.2.1";
-       sha256 = "1wd12l4vpav3jsjf2mib5yrblys5aifwq6xniqm4l92qs5vjh4a2";
+       version = "0.6.1";
+       sha256 = "1y9jciiaam0dn2falhxc0nb97vy35dfvv71xzc1bhiw4gn66n4rm";
       buildDepends = [
-         base dlist FontyFruity free JuicyPixels mtl primitive vector
-         vector-algorithms
+         base bytestring containers dlist FontyFruity free JuicyPixels mtl
+         primitive vector vector-algorithms
       ];
       description = "A pure haskell drawing engine";
       license = stdenv.lib.licenses.bsd3;
@ -17385,7 +17382,9 @@ self: {
     mkDerivation {
       pname = "aeson-native";
       version = "0.3.3.2";
+       revision = "1";
       sha256 = "1s5i88r8sdd7ayrpjw6f18273k6r0igk0sswb503hzvjagzmzffh";
+       editedCabalFile = "c9519a30bce75564cfbe84aade5ffb99fad12ecea1c7d2c362cca2234b8ae497";
       buildDepends = [
         attoparsec base blaze-builder blaze-textual-native bytestring
         containers deepseq hashable mtl old-locale syb text time
@ -20824,21 +20823,21 @@ self: {
     }) {};

  "asciidiagram" = callPackage
-    ({ mkDerivation, base, containers, filepath, FontyFruity
-     , JuicyPixels, lens, linear, mtl, optparse-applicative
+    ({ mkDerivation, base, bytestring, containers, directory, filepath
+     , FontyFruity, JuicyPixels, lens, linear, mtl, optparse-applicative
     , rasterific-svg, svg-tree, text, vector
     }:
     mkDerivation {
       pname = "asciidiagram";
-       version = "1.1";
-       sha256 = "0vd4m3i4997vdd5wzy3jbidaz4rcsncqjdz0pf5ggrm9c5a8jb2y";
+       version = "1.1.1.1";
+       sha256 = "0nzg4m1nd41x6fyki5qva5jj80sl7jd1z1gd674v50zchkw71a9m";
       isLibrary = true;
       isExecutable = true;
       buildDepends = [
-         base containers filepath FontyFruity JuicyPixels lens linear mtl
-         optparse-applicative rasterific-svg svg-tree text vector
+         base bytestring containers directory filepath FontyFruity
+         JuicyPixels lens linear mtl optparse-applicative rasterific-svg
+         svg-tree text vector
       ];
-       jailbreak = true;
       description = "Pretty rendering of Ascii diagram into svg or png";
       license = stdenv.lib.licenses.bsd3;
     }) {};
@ -23032,8 +23031,8 @@ self: {
    ({ mkDerivation, base, ghc-prim, hspec }:
     mkDerivation {
       pname = "base-orphans";
-       version = "0.3.1";
-       sha256 = "12nabqwniywwxsysdk0kh1zscdwyjk10z1fk3iqqcg0bqmyb67i5";
+       version = "0.3.2";
+       sha256 = "1qbnhxchl2kdjbwqz3mp7rq963w6y6ws4kflmv6hmcp25aaqh6pl";
       buildDepends = [ base ghc-prim ];
       testDepends = [ base hspec ];
       homepage = "https://github.com/haskell-compat/base-orphans#readme";
@ -35590,6 +35589,7 @@ self: {
         base cprng-aes crypto-random crypto-random-effect
         extensible-effects
       ];
+       jailbreak = true;
       homepage = "https://github.com/ibotty/crypto-random-effect";
       description = "Run random effect using cprng-aes, a crypto pseudo number generator";
       license = stdenv.lib.licenses.mit;
@ -36491,6 +36491,7 @@ self: {
         base bytestring crypto-random extensible-effects securemem
         transformers
       ];
+       jailbreak = true;
       homepage = "https://github.com/ibotty/crypto-random-effect";
       description = "A random effect using crypto-random";
       license = stdenv.lib.licenses.mit;
@ -37813,21 +37814,19 @@ self: {
  "darkplaces-rcon-util" = callPackage
    ({ mkDerivation, base, bytestring, ConfigFile, containers
     , darkplaces-rcon, darkplaces-text, directory, filepath, haskeline
-     , HostAndPort, hspec, hspec-core, mtl, old-locale
-     , optparse-applicative, text, time, utf8-string
+     , HostAndPort, hspec, hspec-core, mtl, optparse-applicative, text
+     , time, utf8-string
     }:
     mkDerivation {
       pname = "darkplaces-rcon-util";
-       version = "0.1";
-       revision = "3";
-       sha256 = "0accwwwifhmlnrc5rqb9kc44mcrpbfibakip8pwi2aqs7xvchavr";
-       editedCabalFile = "c26b82e362cada670c0edc2c27c5c571f1898edb5ec29ab4c35d913c537b264d";
+       version = "0.1.1";
+       sha256 = "1xv9906ag2vgkzbk66f9r6lr5j6qwlwss246hjl7iriq315dmqlg";
       isLibrary = true;
       isExecutable = true;
       buildDepends = [
         base bytestring ConfigFile containers darkplaces-rcon
         darkplaces-text directory filepath haskeline HostAndPort mtl
-         old-locale optparse-applicative text time utf8-string
+         optparse-applicative text time utf8-string
       ];
       testDepends = [
         base bytestring darkplaces-rcon darkplaces-text hspec hspec-core
@ -46625,6 +46624,26 @@ self: {
       license = stdenv.lib.licenses.bsd3;
     }) {};

+  "exherbo-cabal" = callPackage
+    ({ mkDerivation, base, bytestring, Cabal, containers
+     , haddock-library, http-client, pcre-light, pretty
+     }:
+     mkDerivation {
+       pname = "exherbo-cabal";
+       version = "0.1.0.0";
+       sha256 = "0ap3j5shgy5l1crsyq6dkz2g4gd9y7r8vx4rsppib7y0gqqczpfm";
+       isLibrary = false;
+       isExecutable = true;
+       buildDepends = [
+         base bytestring Cabal containers haddock-library http-client
+         pcre-light pretty
+       ];
+       jailbreak = true;
+       description = "Exheres generator for cabal packages";
+       license = stdenv.lib.licenses.gpl2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
  "exif" = callPackage
    ({ mkDerivation, base, exif }:
     mkDerivation {
@ -46984,19 +47003,20 @@ self: {

  "extensible-effects" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
-     , test-framework-hunit, test-framework-quickcheck2, transformers
-     , transformers-base, type-aligned, void
+     , test-framework-hunit, test-framework-quickcheck2
+     , test-framework-th, transformers, transformers-base, type-aligned
+     , void
     }:
     mkDerivation {
       pname = "extensible-effects";
-       version = "1.9.2.2";
-       sha256 = "07mhvwxbqzn8bhhcgyc9b7bzbf1axbxsg3ps8b3zsz35r480irc3";
+       version = "1.10.0.1";
+       sha256 = "0zj72lnwncy9diagicp1xkvryakal17p5fslv1pl731z8janal1s";
       buildDepends = [
         base transformers transformers-base type-aligned void
       ];
       testDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
-         test-framework-quickcheck2 void
+         test-framework-quickcheck2 test-framework-th void
       ];
       homepage = "https://github.com/suhailshergill/extensible-effects";
       description = "An Alternative to Monad Transformers";
@ -47776,8 +47796,8 @@ self: {
     }:
     mkDerivation {
       pname = "feed";
-       version = "0.3.9.4";
-       sha256 = "18jq1zw1qb2z6lga2vpn4z7dsylglgzl4bskb9x2skw9wv7pgsnk";
+       version = "0.3.9.5";
+       sha256 = "1kbi0hb2ywp5qbhjw65p86bj4cxag9ngi5dvjcjd63r673kwicv1";
       buildDepends = [
         base old-locale old-time time time-locale-compat utf8-string xml
       ];
@ -48231,8 +48251,8 @@ self: {
    ({ mkDerivation, base, bytestring, clock, directory, zip-archive }:
     mkDerivation {
       pname = "file-collection";
-       version = "0.1.1.6";
-       sha256 = "12rsizcxisys6bf3z3ghmqpm2201pyqpihhyhhx2s14mgmf53l7l";
+       version = "0.1.1.9";
+       sha256 = "06bcj143j85p8m519zn88z6qn4bg5ifrw5pv5yva5x49gc3jq6gc";
       buildDepends = [ base bytestring clock directory zip-archive ];
       homepage = "https://github.com/joelwilliamson/file-collection";
       description = "Provide a uniform interface over file archives and directories";
@ -48317,8 +48337,8 @@ self: {
     }:
     mkDerivation {
       pname = "filediff";
-       version = "1.0.0.5";
-       sha256 = "1mi0qywbaw0v3ilscmrn3cq467f8y2p09v4xsfa1hk90aybyz2lv";
+       version = "2.0.0";
+       sha256 = "15a02dya0qhgxq98whxza268vqsrkw6b1ipdskw3hwnjp02hnc9p";
       buildDepends = [
         base bytestring data-default data-memocombinators directory either
         hashmap mtl rainbow tasty tasty-hunit text threads time
@ -51823,9 +51843,10 @@ self: {
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "geniplate-mirror";
-       version = "0.6.0.6";
-       sha256 = "1fgs9aak7l7r3xlgna1kbq43zm55nd43phsv0w4ssy305dqylshj";
+       version = "0.6.0.7";
+       sha256 = "0az8q9jjakbi891ypzm4qg8ys78102zqxqpznk6mm08ng2hzb0wz";
       buildDepends = [ base mtl template-haskell ];
+       homepage = "https://github.com/danr/geniplate";
       description = "Use Template Haskell to generate Uniplate-like functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};
@ -56079,21 +56100,37 @@ self: {
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hBDD";
-       version = "0.0.2";
-       sha256 = "15pq6r8kz7ki1siz9xihd85qck9gnkp17cdz331srgr5kzij3lgv";
+       version = "0.0.3";
+       sha256 = "1jj8hj8wl95fy0n1qixhra4sqlmgddgn080plk7q7iv000qv67gk";
       buildDepends = [ base ];
       description = "An abstraction layer for BDD libraries";
       license = "LGPL";
     }) {};

+  "hBDD-CMUBDD" = callPackage
+    ({ mkDerivation, base, bdd, c2hs, containers, deepseq, hBDD, mem
+     , unix
+     }:
+     mkDerivation {
+       pname = "hBDD-CMUBDD";
+       version = "0.0.3";
+       sha256 = "16pvi496qi3q2rrw08p6lndnsz6d6p65i8m10ldjlh143y8k9ga9";
+       buildDepends = [ base containers deepseq hBDD unix ];
+       buildTools = [ c2hs ];
+       extraLibraries = [ bdd mem ];
+       description = "An FFI binding to CMU/Long's BDD library";
+       license = "LGPL";
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) { bdd = null;  mem = null;};
+
  "hBDD-CUDD" = callPackage
    ({ mkDerivation, base, c2hs, containers, cudd, deepseq, epd, hBDD
     , mtr, st, unix, util
     }:
     mkDerivation {
       pname = "hBDD-CUDD";
-       version = "0.0.2";
-       sha256 = "0rjfycxnhwwylpdb5sm4kqzypfbigzmx6azrs44sixmkq0cv5yb4";
+       version = "0.0.3";
+       sha256 = "1r94nj23pj134bd5b2mqk01g8xvbcn4ik2xs9yp01v1jg2clhjha";
       buildDepends = [ base containers deepseq hBDD unix ];
       buildTools = [ c2hs ];
       extraLibraries = [ cudd epd mtr st util ];
@ -61877,7 +61914,9 @@ self: {
     mkDerivation {
       pname = "hbro";
       version = "1.4.0.0";
+       revision = "1";
       sha256 = "08vw5j3a22gszbsjhjp13dkgvxj2875zjsx6w3w7c2dkjg4lijpr";
+       editedCabalFile = "331a844037ba6df7831151e45e40223eed66313dabef7dc0285a6e658747b15c";
       isLibrary = true;
       isExecutable = true;
       buildDepends = [
@ -62081,12 +62120,12 @@ self: {
     }:
     mkDerivation {
       pname = "hdaemonize";
-       version = "0.5.0.0";
-       sha256 = "15dyaa9rbmsjp3sg9yxg1i90kfy9rvlzmwg5kl8kwal69ajzjjgv";
+       version = "0.5.0.1";
+       sha256 = "03daf8qb8x0503h5k2vr6r4lyv6fv1a5n6mhykx5872khl81d8ms";
       buildDepends = [
         base extensible-exceptions filepath hsyslog mtl unix
       ];
-       homepage = "http://github.com/madhadron/hdaemonize";
+       homepage = "http://github.com/greydot/hdaemonize";
       description = "Library to handle the details of writing daemons for UNIX";
       license = stdenv.lib.licenses.bsd3;
     }) {};
@ -64824,8 +64863,8 @@ self: {
     }:
     mkDerivation {
       pname = "hjsonschema";
-       version = "0.5.3.2";
-       sha256 = "0w4m50glqvqipv99bk55jipzdga8dwics0sw1k52kmbf34qac5ih";
+       version = "0.6.0.0";
+       sha256 = "01v2nb77bp94jx9va757b2iimvvi9p73aqw7izyrqp1li4gd6yq2";
       buildDepends = [
         aeson base bytestring file-embed hashable hjsonpointer http-client
         http-types regexpr scientific text unordered-containers vector
@ -69076,10 +69115,9 @@ self: {
    ({ mkDerivation, base, hslogger, mtl, template-haskell }:
     mkDerivation {
       pname = "hslogger-template";
-       version = "2.0.2";
-       sha256 = "0qkyclj9fajvzbfcs0ik8ncy66x916r40jd85r4wi5nh482i7sp3";
+       version = "2.0.3";
+       sha256 = "1q5g2jgx4yjzvbrc22qcxrb3r9cma64jg90wzx9yc19yxq0fa95k";
       buildDepends = [ base hslogger mtl template-haskell ];
-       jailbreak = true;
       description = "Automatic generation of hslogger functions";
       license = stdenv.lib.licenses.publicDomain;
     }) {};
@ -73001,8 +73039,8 @@ self: {
     }:
     mkDerivation {
       pname = "ide-backend-common";
-       version = "0.9.1.1";
-       sha256 = "1k3sp9byqmhk80l918jnklck635dp1cfx48akah483jkhzjph0fj";
+       version = "0.9.1.2";
+       sha256 = "1cj594vq0x87h9mvwsj9mplacrdn999bbsknjwdpvrpsbadlx5q7";
       buildDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         containers crypto-api data-accessor directory filepath fingertree
@ -73011,6 +73049,7 @@ self: {
       ];
       description = "Shared library used be ide-backend and ide-backend-server";
       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend-rts" = callPackage
@ -73044,6 +73083,7 @@ self: {
       ];
       description = "An IDE backend server";
       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ideas" = callPackage
@ -74389,8 +74429,8 @@ self: {
     }:
     mkDerivation {
       pname = "inline-c";
-       version = "0.5.0.1";
-       sha256 = "1gkk9ldlac8jfiibyw15madrxa731fk2qbll22c8lm0l83r9kpsa";
+       version = "0.5.2.0";
+       sha256 = "1i0x80g8sy7lb7wln22n4hbh3i553v1ky9gz7x72xf0gifszlr4y";
       isLibrary = true;
       isExecutable = true;
       buildDepends = [
@ -76554,13 +76594,13 @@ self: {
     , bifunctors, byteable, bytestring, crypto-pubkey
     , crypto-pubkey-types, crypto-random, cryptohash
     , data-default-class, ghc-prim, hspec, integer-gmp, lens
-     , network-uri, old-locale, safe, semigroups, template-haskell, text
-     , time, unordered-containers, vector, x509
+     , network-uri, safe, semigroups, template-haskell, text, time
+     , unordered-containers, vector, x509
     }:
     mkDerivation {
       pname = "jose";
-       version = "0.3.41.1";
-       sha256 = "1grb1yq3knm7hniqiivkx76mxkgacyq2qa12mv5lz097w7bldf4l";
+       version = "0.3.41.2";
+       sha256 = "0pamg1wkp85zpwnbsvmsszy7nxsifl3zhbxvfmh44n0b6d2wg4w5";
       buildDepends = [
         aeson attoparsec base base64-bytestring bifunctors byteable
         bytestring crypto-pubkey crypto-pubkey-types crypto-random
@ -76571,9 +76611,9 @@ self: {
       testDepends = [
         aeson attoparsec base base64-bytestring bifunctors byteable
         bytestring crypto-pubkey crypto-pubkey-types crypto-random
-         cryptohash data-default-class hspec lens network-uri old-locale
-         safe semigroups template-haskell text time unordered-containers
-         vector x509
+         cryptohash data-default-class hspec lens network-uri safe
+         semigroups template-haskell text time unordered-containers vector
+         x509
       ];
       jailbreak = true;
       homepage = "https://github.com/frasertweedale/hs-jose";
@ -78685,9 +78725,9 @@ self: {
     mkDerivation {
       pname = "lambdabot-utils";
       version = "4.2.2";
-       revision = "1";
+       revision = "3";
       sha256 = "0mmz9rn6vv8xnavmz66g164h1liir3rzg1n7lmbcsgwcyhm925d7";
-       editedCabalFile = "1936d25bbfb2ce39465857c136e0d77c656714feb2c1936024da4d763e9dbbf3";
+       editedCabalFile = "f54d43d6964d63f1d8796606419b512a6e7b87b1defe960748c27c7417f59a08";
       buildDepends = [
         base binary bytestring containers haskell-src mtl network old-time
         process random regex-compat regex-posix syb tagsoup unix
@ -80103,8 +80143,8 @@ self: {
     }:
     mkDerivation {
       pname = "leksah";
-       version = "0.14.4.0";
-       sha256 = "13p6fil3s8pgjgicxgkn1qfcdhvv5j0lilk85a66nz7vw4rg3x2v";
+       version = "0.15.0.1";
+       sha256 = "169vrqdxcx8xkilrw3dh5zmdsb876fny4n0k5gzvi8fian0dl8nh";
       isLibrary = true;
       isExecutable = true;
       buildDepends = [
@ -80122,7 +80162,6 @@ self: {
         leksah-server ltk monad-loops QuickCheck text transformers
         webkitgtk3
       ];
-       jailbreak = true;
       homepage = "http://www.leksah.org";
       description = "Haskell IDE written in Haskell";
       license = "GPL";
@ -80130,31 +80169,30 @@ self: {
     }) {};

  "leksah-server" = callPackage
-    ({ mkDerivation, attoparsec, attoparsec-conduit, base, binary
-     , binary-shared, bytestring, Cabal, conduit, conduit-extra
-     , containers, deepseq, directory, executable-path, filepath, ghc
-     , haddock-api, hslogger, HTTP, HUnit, ltk, network, network-uri
-     , parsec, pretty, process, resourcet, strict, text, time
-     , transformers, unix
+    ({ mkDerivation, attoparsec, attoparsec-conduit, base
+     , bin-package-db, binary, binary-shared, bytestring, Cabal, conduit
+     , conduit-extra, containers, deepseq, directory, executable-path
+     , filepath, ghc, haddock-api, haddock-library, hslogger, HTTP
+     , HUnit, ltk, network, network-uri, parsec, pretty, process
+     , resourcet, strict, text, time, transformers, unix
     }:
     mkDerivation {
       pname = "leksah-server";
-       version = "0.14.3.2";
-       sha256 = "0gbjxbma0jyw0jli63f3apfsap9by6nr75qx77773nj2l48hxz3w";
+       version = "0.15.0.1";
+       sha256 = "04sxfzl8p9fk8qkzmwnm7fkg5sgrzjx0992kivgbrnyx7wh06xsp";
       isLibrary = true;
       isExecutable = true;
       buildDepends = [
-         attoparsec attoparsec-conduit base binary binary-shared bytestring
-         Cabal conduit conduit-extra containers deepseq directory
-         executable-path filepath ghc haddock-api hslogger HTTP ltk network
-         network-uri parsec pretty process resourcet strict text time
-         transformers unix
+         attoparsec attoparsec-conduit base bin-package-db binary
+         binary-shared bytestring Cabal conduit conduit-extra containers
+         deepseq directory executable-path filepath ghc haddock-api
+         haddock-library hslogger HTTP ltk network network-uri parsec pretty
+         process resourcet strict text time transformers unix
       ];
       testDepends = [
         base conduit conduit-extra hslogger HUnit process resourcet
         transformers
       ];
-       jailbreak = true;
       homepage = "http://leksah.org";
       description = "Metadata collection for leksah";
       license = "GPL";
@ -81564,8 +81602,8 @@ self: {
    ({ mkDerivation, base, containers, ghc-prim, mtl, transformers }:
     mkDerivation {
       pname = "linearscan";
-       version = "0.5.0.0";
-       sha256 = "0n8xcj5pkz50mkx4cvqh1iywlf9vrk6bk4d3lv8fa22ik88mdr15";
+       version = "0.5.1.0";
+       sha256 = "123gs28vfb1lx9izzjran79caqj92p1l0v051pd0pf2nfm6iymgb";
       buildDepends = [ base containers ghc-prim mtl transformers ];
       homepage = "http://github.com/jwiegley/linearscan";
       description = "Linear scan register allocator, formally verified in Coq";
@ -81579,8 +81617,8 @@ self: {
     }:
     mkDerivation {
       pname = "linearscan-hoopl";
-       version = "0.5.0.0";
-       sha256 = "0z8lhi4q89f1b2fk5a3vn0a9q9h4w81b0wjqdypb7bz5lisvvg0s";
+       version = "0.5.1.0";
+       sha256 = "147ryhliilbpmzy87bda7aapfpfhw4r6rcy6jla2ampy7qvvvbyk";
       buildDepends = [
         base containers free hoopl linearscan transformers
       ];
@ -83447,8 +83485,8 @@ self: {
     }:
     mkDerivation {
       pname = "ltk";
-       version = "0.15.0.0";
-       sha256 = "1hl9cbr8n2nczsz8gkd4lkcmf3bhzcji82p8ym176abzyz2i3h09";
+       version = "0.15.0.1";
+       sha256 = "0qw689ip8kibczjvar6bicns6g8a0zwlb6vdcmpicxxmpr1p7g16";
       buildDepends = [
         base Cabal containers filepath ghc glib gtk3 mtl parsec pretty text
         transformers
@ -85771,8 +85809,8 @@ self: {
     }:
     mkDerivation {
       pname = "memory";
-       version = "0.2";
-       sha256 = "05v7ywbxn61bk8gk8sc4fpm1n76kcvbab1jgvbq82m6g56dhmrh0";
+       version = "0.3";
+       sha256 = "17dry2yfnj7vldrdh0kynyaa4pfyy88k3035w3hxggh7n325dfir";
       buildDepends = [ base bytestring deepseq ghc-prim ];
       testDepends = [ base tasty tasty-hunit tasty-quickcheck ];
       homepage = "https://github.com/vincenthz/hs-memory";
@ -88178,7 +88216,9 @@ self: {
     mkDerivation {
       pname = "mono-traversable";
       version = "0.9.1";
+       revision = "1";
       sha256 = "0hzqlldilkkfmrq3pkymwkzpp9dn40v6fa18kahxlf4qiyih0xzc";
+       editedCabalFile = "28392123a8b245f7bc2c13bb63f5c3008118ed38e107cf0534be37461fb64daf";
       buildDepends = [
         base bytestring comonad containers dlist dlist-instances hashable
         semigroupoids semigroups text transformers unordered-containers
@ -89762,8 +89802,8 @@ self: {
     }:
     mkDerivation {
       pname = "mvc";
-       version = "1.0.4";
-       sha256 = "0mbbcjcvd05ql76ys5fmsr57aif1bysasz91rvmp795a9wj3i83i";
+       version = "1.0.5";
+       sha256 = "1lrq0nkxi0ljs6pxf7p4awhrf9ix9dqwvwsydph6fw356ypc39r2";
       buildDepends = [
         async base contravariant foldl managed mmorph pipes
         pipes-concurrency transformers
@ -92963,12 +93003,12 @@ self: {
     }) {};

  "observable-sharing" = callPackage
-    ({ mkDerivation, base }:
+    ({ mkDerivation, base, unordered-containers }:
     mkDerivation {
       pname = "observable-sharing";
-       version = "0.1.0.0";
-       sha256 = "1l9l7jjk1zxc6wzw2n89l4mr964ys87b37sc55jsm73km19q07jy";
-       buildDepends = [ base ];
+       version = "0.2.0.0";
+       sha256 = "01lri324xygda17nzc7bg6s3f52nivi8qjigbx9ack7zxhm9jyd7";
+       buildDepends = [ base unordered-containers ];
       description = "Simple observable sharing";
       license = stdenv.lib.licenses.bsd3;
     }) {};
@ -94271,8 +94311,8 @@ self: {
     }:
     mkDerivation {
       pname = "orgmode-parse";
-       version = "0.1.1.0";
-       sha256 = "1hrbfifm9476n28l2gxyr9m00hjibnl78anc5m7inqm8wr1s3cl0";
+       version = "0.1.1.1";
+       sha256 = "17slf2i7k8bk1d47l165awn38dlpq2rdw6glzvp8if1dir2l2jl7";
       buildDepends = [
         aeson attoparsec base bytestring containers free hashable
         old-locale text thyme unordered-containers
@ -94808,10 +94848,8 @@ self: {
     }:
     mkDerivation {
       pname = "pandoc-crossref";
-       version = "0.1.0.2";
-       revision = "1";
-       sha256 = "0mnksd8wl6y9qh4z5p6nzf64lic2cxws0hm2n1aj8vq8asfy28af";
-       editedCabalFile = "c209bec5811d40360ca07a9218404186ab8564ee649b14d6e3ece04b4006204f";
+       version = "0.1.1.0";
+       sha256 = "1z6q9sb5h0bbvkdlv6abvhgz0cgw4vixs3pv531l9jpkmvfri8r4";
       isLibrary = false;
       isExecutable = true;
       buildDepends = [
@ -95353,8 +95391,8 @@ self: {
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "parsek";
-       version = "1.0.1.2";
-       sha256 = "0ybh76cx5y73ywhlv4g2z74x1mvg5n2rxl045mscs6dwcyw9vhbd";
+       version = "1.0.1.3";
+       sha256 = "184cbw9gz3vv2jbr2wzkygv25y70jayxd8d76pgpvjcaps4qqxp7";
       buildDepends = [ base ];
       description = "Parallel Parsing Processes";
       license = stdenv.lib.licenses.gpl3;
@ -98921,10 +98959,13 @@ self: {
     mkDerivation {
       pname = "pool-conduit";
       version = "0.1.2.3";
+       revision = "1";
       sha256 = "1myjbmbh0jm89ycx9d961mpgw8hp7al8wgnsls4p19gvr73gcbfv";
+       editedCabalFile = "b894f71054b3824a0a05753e8273efbc7c1dc48efa9c6d56625ba4411a74afa5";
       buildDepends = [
         base monad-control resource-pool resourcet transformers
       ];
+       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Resource pool allocations via ResourceT. (deprecated)";
       license = stdenv.lib.licenses.mit;
@ -101168,6 +101209,29 @@ self: {
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

+  "pseudo-boolean" = callPackage
+    ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder
+     , containers, deepseq, dlist, hashable, HUnit, parsec, QuickCheck
+     , tasty, tasty-hunit, tasty-quickcheck, tasty-th, temporary
+     }:
+     mkDerivation {
+       pname = "pseudo-boolean";
+       version = "0.1.0.0";
+       sha256 = "1dqy8zpf7016rm3wyvgwipllm95wmrr9na04v4x402k1f8pvkdvc";
+       buildDepends = [
+         attoparsec base bytestring bytestring-builder containers deepseq
+         dlist hashable parsec
+       ];
+       testDepends = [
+         base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
+         tasty-th temporary
+       ];
+       homepage = "https://github.com/msakai/pseudo-boolean";
+       description = "Reading\/Writing OPB\/WBO files used in pseudo boolean competition";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
  "pseudo-trie" = callPackage
    ({ mkDerivation, base, semigroups }:
     mkDerivation {
@ -103070,8 +103134,8 @@ self: {
     }:
     mkDerivation {
       pname = "rasterific-svg";
-       version = "0.2.2.1";
-       sha256 = "1p8bpy9kh1j2lhczw8wyj1918h26yf7w7ii370g6m63szx6v1lj6";
+       version = "0.2.3";
+       sha256 = "1gr050dlvq8pfp77g21ywc6cknbgmkw8bcc4d8klw8jpf0ppar45";
       isLibrary = true;
       isExecutable = true;
       buildDepends = [
@ -112551,16 +112615,19 @@ self: {
     }) {};

  "smallcheck-series" = callPackage
-    ({ mkDerivation, base, bytestring, doctest, Glob, smallcheck, text
+    ({ mkDerivation, base, bytestring, containers, doctest, Glob
+     , logict, smallcheck, text, transformers
     }:
     mkDerivation {
       pname = "smallcheck-series";
-       version = "0.2";
-       sha256 = "1666pf3ki46w3zi01c3lzih7jh0jgqx9jyc1ykrjs056mlnbxp3v";
-       buildDepends = [ base bytestring smallcheck text ];
+       version = "0.3";
+       sha256 = "1vdwafwdv38n1bvjf1rybfhh42a0q0g0g4wmw0v4fgxh73qndfdv";
+       buildDepends = [
+         base bytestring containers logict smallcheck text transformers
+       ];
       testDepends = [ base doctest Glob ];
       homepage = "https://github.com/jdnavarro/smallcheck-series";
-       description = "Extra SmallCheck series";
+       description = "Extra SmallCheck series and utilities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

@ -113916,6 +113983,7 @@ self: {
       homepage = "https://github.com/dbp/snaplet-wordpress";
       description = "A snaplet that communicates with wordpress over its api";
       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snappy" = callPackage
@ -116655,8 +116723,8 @@ self: {
     }:
     mkDerivation {
       pname = "stm-conduit";
-       version = "2.6.0";
-       sha256 = "0lhqhsvisyn4wgj5qk0slzbgy7lbmzgcryi4vlw1d058nsjnpxwj";
+       version = "2.6.1";
+       sha256 = "0cd99aj9azlr6d9bayjyrbigbzll9yfny7qan1wnrh413i1z1x0p";
       buildDepends = [
         async base cereal cereal-conduit conduit conduit-combinators
         conduit-extra directory ghc-prim lifted-async lifted-base
@ -122069,16 +122137,16 @@ self: {
     }:
     mkDerivation {
       pname = "th-typegraph";
-       version = "0.14";
-       sha256 = "1f2wgr429hkv687mk9qgaqnr1n9nznl90cy7w74w4jzp6fd6rskp";
+       version = "0.17";
+       sha256 = "0k6bjf3r6g64h5al7gxcrkwb5b67kjpx8y4ib6f3a6l00p620297";
       buildDepends = [
         base containers data-default haskell-src-exts lens mtl syb
         template-haskell th-desugar th-orphans
       ];
       testDepends = [
-         array base bytestring containers deepseq ghc-prim hspec hspec-core
-         lens mtl syb template-haskell text th-desugar th-orphans
-         th-reify-many
+         array base bytestring containers data-default deepseq ghc-prim
+         hspec hspec-core lens mtl syb template-haskell text th-desugar
+         th-orphans th-reify-many
       ];
       homepage = "https://github.com/seereason/th-typegraph";
       description = "Graph of the subtype relation";
@ -123656,17 +123724,17 @@ self: {
     }) {};

  "topkata" = callPackage
-    ({ mkDerivation, ALUT, array, base, filepath, GLUT, OpenAL, OpenGL
-     , random
+    ({ mkDerivation, ALUT, array, base, filepath, GLFW-b, OpenAL
+     , OpenGL, parseargs, random
     }:
     mkDerivation {
       pname = "topkata";
-       version = "0.2.3";
-       sha256 = "19lm9i65ywh3a8hsrqnihq8gkfxmz81zznyqlqgcf1914w826i3a";
+       version = "0.2.4";
+       sha256 = "06b938i2362c4jcd0923lwrcf6hqgxdscizj91ns51wx73nm8fxi";
       isLibrary = false;
       isExecutable = true;
       buildDepends = [
-         ALUT array base filepath GLUT OpenAL OpenGL random
+         ALUT array base filepath GLFW-b OpenAL OpenGL parseargs random
       ];
       homepage = "http://home.arcor.de/chr_bauer/topkata.html";
       description = "OpenGL Arcade Game";
@ -135621,6 +135689,31 @@ self: {
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

+  "yesod-raml" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, containers, hspec
+     , network-uri, optparse-applicative, regex-posix, template-haskell
+     , text, unordered-containers, yaml, yesod-core
+     }:
+     mkDerivation {
+       pname = "yesod-raml";
+       version = "0.1.0";
+       sha256 = "1vcllxsyqvr26a27l9vfi76kpdzld3ws1i0q6g9jnwhkr16bmc3f";
+       isLibrary = true;
+       isExecutable = true;
+       buildDepends = [
+         aeson base bytestring containers network-uri optparse-applicative
+         regex-posix template-haskell text unordered-containers yaml
+         yesod-core
+       ];
+       testDepends = [
+         aeson base bytestring containers hspec network-uri regex-posix
+         template-haskell text unordered-containers yaml yesod-core
+       ];
+       description = "RAML style route definitions for Yesod";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
  "yesod-recaptcha" = callPackage
    ({ mkDerivation, base, bytestring, data-default, http-conduit
     , http-types, lifted-base, network, network-info, resourcet, text
--- a/pkgs/development/interpreters/ruby/bundler.nix
+++ b/pkgs/development/interpreters/ruby/bundler.nix
@ -1,7 +1,8 @@
-{ buildRubyGem, coreutils }:
+{ buildRubyGem, makeWrapper, ruby, coreutils }:

 buildRubyGem {
  name = "bundler-1.9.2";
+  namePrefix = "";
  sha256 = "0ck9bnqg7miimggj1d6qlabrsa5h9yaw241fqn15cvqh915209zk";
  dontPatchShebangs = true;
  postInstall = ''
@ -9,5 +10,8 @@ buildRubyGem {
      substituteInPlace $f \
         --replace "/usr/bin/env" "${coreutils}/bin/env"
    done
+
+    wrapProgram $out/bin/bundler \
+      --prefix PATH ":" ${ruby}/bin
  '';
 }
--- a/pkgs/development/libraries/catch/default.nix
+++ b/pkgs/development/libraries/catch/default.nix
@ -0,0 +1,36 @@
+{ stdenv, lib, cmake, fetchFromGitHub }:
+
+stdenv.mkDerivation rec {
+
+  name = "catch-${version}";
+  version = "1.1-3";
+
+  src = fetchFromGitHub {
+    owner = "philsquared";
+    repo = "Catch";
+    rev = "c51e86819dc993d590e5d0adaf1952f4b53e5355";
+    sha256 = "0kgi7wxxysgjbpisqfj4dj0k19cyyai92f001zi8gzkybd4fkgv5";
+  };
+
+  buildInputs = [ cmake ];
+  dontUseCmakeConfigure = true;
+
+  buildPhase = ''
+    cmake -Hprojects/CMake -BBuild -DCMAKE_BUILD_TYPE=Release
+    cd Build
+    make
+    cd ..
+  '';
+
+  installPhase = ''
+    mkdir -p $out
+    mv include $out/.
+  '';
+
+  meta = with stdenv.lib; {
+    description = "A multi-paradigm automated test framework for C++ and Objective-C (and, maybe, C)";
+    homepage = "http://catch-lib.net";
+    license = licenses.boost;
+    maintainers = with maintainers; [ edwtjo ];
+  };
+}
--- a/pkgs/development/libraries/ccrtp/1.8.nix
+++ b/pkgs/development/libraries/ccrtp/1.8.nix
@ -18,5 +18,6 @@ stdenv.mkDerivation {
    license = stdenv.lib.licenses.gpl2;
    maintainers = [ stdenv.lib.maintainers.marcweber ];
    platforms = stdenv.lib.platforms.linux;
+    broken = true; # fails to compile with libgcrypt >= 1.6
  };
 }
--- a/pkgs/development/libraries/glfw/3.x.nix
+++ b/pkgs/development/libraries/glfw/3.x.nix
@ -1,16 +1,23 @@
-{ stdenv, fetchurl, cmake, mesa, libXrandr, libXi, libXxf86vm, libXfixes, x11 }:
+{ stdenv, fetchurl, cmake, mesa, libXrandr, libXi, libXxf86vm, libXfixes, x11
+, libXinerama, libXcursor
+}:

 stdenv.mkDerivation rec {
-  name = "glfw-3.0.4";
+  name = "glfw-3.1.1";

  src = fetchurl {
    url = "mirror://sourceforge/glfw/${name}.tar.bz2";
-    sha256 = "1h7g16ncgkl38w19x4dvnn17k9j0kqfvbb9whw9qc71lkq5xf2ag";
+    sha256 = "0q9dhbj2az7jwwi556zai0qr8zmg6d2lyxcqngppkw0x7hi1d1aa";
  };

  enableParallelBuilding = true;

-  buildInputs = [ cmake mesa libXrandr libXi libXxf86vm libXfixes x11 ];
+  buildInputs = [
+    cmake mesa libXrandr libXi libXxf86vm libXfixes x11
+    libXinerama libXcursor
+  ];
+
+  cmakeFlags = "-DBUILD_SHARED_LIBS=ON";

  meta = with stdenv.lib; { 
    description = "Multi-platform library for creating OpenGL contexts and managing input, including keyboard, mouse, joystick and time";
--- a/pkgs/development/libraries/gstreamer/default.nix
+++ b/pkgs/development/libraries/gstreamer/default.nix
@ -18,4 +18,6 @@ rec {
  gnonlin = callPackage ./gnonlin { inherit gst-plugins-base; };

  gst-editing-services = callPackage ./ges { inherit gnonlin; };
+
+  gst-vaapi = callPackage ./vaapi { inherit gst-plugins-base gstreamer gst-plugins-bad; };
 }
--- a/pkgs/development/libraries/gstreamer/vaapi/default.nix
+++ b/pkgs/development/libraries/gstreamer/vaapi/default.nix
@ -0,0 +1,32 @@
+{ stdenv, fetchurl, pkgconfig, gst-plugins-base, bzip2, libva
+, libdrm, udev, xorg, mesa, yasm, gstreamer, gst-plugins-bad, nasm
+, libvpx
+}:
+
+stdenv.mkDerivation rec {
+  name = "gst-vaapi-${version}";
+  version = "0.5.10";
+
+  src = fetchurl {
+    url = "${meta.homepage}/software/vaapi/releases/gstreamer-vaapi/gstreamer-vaapi-${version}.tar.bz2";
+    sha256 = "179wnz4c4gnw9ibfgjrad9b44icygadaknsgjfw24lr2pz3kdlhd";
+  };
+
+  nativeBuildInputs = with stdenv.lib; [ pkgconfig bzip2 ];
+
+  buildInputs = with stdenv.lib; [ gstreamer gst-plugins-base gst-plugins-bad libva libdrm udev
+    xorg.libX11 xorg.libXext xorg.libXv xorg.libXrandr mesa nasm libvpx ];
+
+  preConfigure = "
+    export GST_PLUGIN_PATH_1_0=$out/lib/gstreamer-1.0
+    mkdir -p $GST_PLUGIN_PATH_1_0
+    ";
+  configureFlags = "--disable-builtin-libvpx --with-gstreamer-api=1.0";
+
+  meta = {
+    homepage = "http://www.freedesktop.org";
+    license = stdenv.lib.licenses.lgpl21Plus;
+    platforms = stdenv.lib.platforms.linux;
+    maintainers = with stdenv.lib.maintainers; [ tstrobel ];
+  };
+}
--- a/pkgs/development/libraries/iniparser/default.nix
+++ b/pkgs/development/libraries/iniparser/default.nix
@ -1,5 +1,9 @@
 { stdenv, fetchurl }:

+let
+  inherit (stdenv.lib) optional;
+  isClang = (stdenv.cc.cc.isClang or false);
+in
 stdenv.mkDerivation rec{
  name = "iniparser-3.1";

@ -10,12 +14,12 @@ stdenv.mkDerivation rec{

  patches = ./no-usr.patch;

-  buildFlags = "libiniparser.so";
+  # TODO: Build dylib on Darwin
+  buildFlags = (if stdenv.isDarwin then [ "libiniparser.a" ] else [ "libiniparser.so" ])
+    ++ optional isClang "CC=clang";

  installPhase = ''
    mkdir -p $out/lib
-    cp libiniparser.so.0 $out/lib
-    ln -s libiniparser.so.0 $out/lib/libiniparser.so

    mkdir -p $out/include
    cp src/*.h $out/include
@ -25,7 +29,13 @@ stdenv.mkDerivation rec{
      bzip2 -c -9 $i > $out/share/doc/${name}/$i.bz2;
    done;
    cp -r html $out/share/doc/${name}
-  '';
+
+  '' + (if stdenv.isDarwin then ''
+    cp libiniparser.a $out/lib
+  '' else ''
+    cp libiniparser.so.0 $out/lib
+    ln -s libiniparser.so.0 $out/lib/libiniparser.so
+  '');

  meta = {
    homepage = http://ndevilla.free.fr/iniparser;
--- a/pkgs/development/libraries/lesstif-0.93/c-bad_integer_cast.patch
+++ b/pkgs/development/libraries/lesstif-0.93/c-bad_integer_cast.patch
@ -1,13 +0,0 @@
--- lesstif2-0.94.4.orig/include/Motif-2.1/XmI/XpmI.h
-+++ lesstif2-0.94.4/include/Motif-2.1/XmI/XpmI.h
-@@ -217,8 +217,8 @@
- FUNC(xpmHashSlot, xpmHashAtom *, (xpmHashTable *table, char *s));
- FUNC(xpmHashIntern, int, (xpmHashTable *table, char *tag, void *data));
- 
-#define HashAtomData(i) ((void *)i)
-#define HashColorIndex(slot) ((unsigned int)((*slot)->data))
-+#define HashAtomData(i) ((void *)(uintptr_t)i)
-+#define HashColorIndex(slot) ((uintptr_t)((*slot)->data))
- #define USE_HASHTABLE (cpp > 2 && ncolors > 4)
- 
- /* I/O utility */
--- a/pkgs/development/libraries/lesstif-0.93/c-render_table_crash.patch
+++ b/pkgs/development/libraries/lesstif-0.93/c-render_table_crash.patch
@ -1,11 +0,0 @@
--- lesstif2-0.95.0.orig/lib/Xm-2.1/RenderTable.c
-+++ lesstif2-0.95.0/lib/Xm-2.1/RenderTable.c
-@@ -465,7 +465,7 @@
- 	DEBUGOUT(_LtDebug(__FILE__, w, "_XmRenderTableFinaliseTag(%s)\n", tag));
- #if 1
- 	/* Experimental start */
-	if (r->dpy == 0)
-+	if (r->dpy == 0  &&  w)
- 		r->dpy = XtDisplay(w);
- 	/* Experimental end */
- #endif
--- a/pkgs/development/libraries/lesstif-0.93/c-xim_chained_list_crash.patch
+++ b/pkgs/development/libraries/lesstif-0.93/c-xim_chained_list_crash.patch
@ -1,24 +0,0 @@
-diff -ru lesstif2-0.94.4-old/lib/Xm-2.1/XmIm.c lesstif2-0.94.4/lib/Xm-2.1/XmIm.c
--- lesstif2-0.94.4-old/lib/Xm-2.1/XmIm.c	2004-10-20 21:32:11.000000000 +0200
-+++ lesstif2-0.94.4/lib/Xm-2.1/XmIm.c	2007-03-28 14:39:27.000000000 +0200
-@@ -133,7 +133,10 @@
- 		p->next = q->next;
- 	}
- 
-	XtFree((char *)stuff);
-+	/* if count!=0 then someone uses the stuff as orig_xim
-+	   so unlink it but not free it */
-+	if (!stuff->count)
-+		XtFree((char *)stuff);
- }
- 
- /*
-@@ -1060,6 +1063,8 @@
- 		   XCloseIM(stuff->xim);
- 		DEBUGOUT(_LtDebug(__FILE__, w, "XCloseIM(%p)\n", stuff->xim));
- 		stuff->orig_xim->xim = NULL;
-+		/* stuff->orig_xim is now useless */
-+		XtFree(stuff->orig_xim);
- 	} else {
- 		DEBUGOUT(_LtDebug(__FILE__, w, "XmImCloseXIM(%p), count -> %d\n",
- 			stuff->xim, stuff->orig_xim->count));
--- a/pkgs/development/libraries/lesstif-0.93/default.nix
+++ b/pkgs/development/libraries/lesstif-0.93/default.nix
@ -1,26 +0,0 @@
-{ stdenv, fetchurl, x11, libXp, libXau }:
-
-stdenv.mkDerivation {
-  name = "lesstif-0.93.94";
-  
-  src = fetchurl {
-    url = http://prdownloads.sourceforge.net/lesstif/lesstif-0.93.94.tar.bz2;
-    sha256 = "0v4l46ill6dhhswsw1hk6rqyng98d85nsr214vhd2k0mfajpig1y";
-  };
-  
-  buildInputs = [x11];
-  
-  propagatedBuildInputs = [libXp libXau];
-
-  # This is an older release of lesstif which works with arb.
-  patches =
-    [ ./c-bad_integer_cast.patch    
-      ./c-xim_chained_list_crash.patch
-      ./c-render_table_crash.patch 
-      ./stdint.patch
-    ];
-    
-  meta = {
-    priority = "5";
-  };
-}
--- a/pkgs/development/libraries/lesstif-0.93/stdint.patch
+++ b/pkgs/development/libraries/lesstif-0.93/stdint.patch
@ -1,11 +0,0 @@
-diff -r 97ac365bfcd6 lesstif-0.93.94/lib/Xm-2.1/Xpm.c
--- lesstif-0.93.94/lib/Xm-2.1/Xpm.c	Mon Oct 06 15:52:50 2008 +0200
-+++ lesstif-0.93.94/lib/Xm-2.1/Xpm.c	Mon Oct 06 15:53:16 2008 +0200
-@@ -54,6 +54,7 @@
- #include <io.h>
- #endif
- 
-+#include <stdint.h>
- #include <X11/Intrinsic.h> /* Avoid re-definition of Pixel-type */
- 
- #include <Xm/XpmP.h>
--- a/pkgs/development/libraries/libpqxx/default.nix
+++ b/pkgs/development/libraries/libpqxx/default.nix
@ -0,0 +1,26 @@
+{ lib, stdenv, fetchurl, postgresql, python }:
+
+stdenv.mkDerivation rec {
+  name = "libpqxx-4.0.1";
+
+  src = fetchurl {
+    url = "http://pqxx.org/download/software/libpqxx/${name}.tar.gz";
+    sha256 = "0f6wxspp6rx12fkasanb0z2g2gc8dhcfwnxagx8wwqbpg6ifsz09";
+  };
+
+  buildInputs = [ postgresql python ];
+
+  preConfigure = ''
+    patchShebangs .
+  '';
+
+  configureFlags = "--enable-shared";
+
+  meta = {
+    description = "A C++ library to access PostgreSQL databases";
+    homepage = http://pqxx.org/development/libpqxx/;
+    license = lib.licenses.postgresql;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.eelco ];
+  };
+}
--- a/pkgs/development/libraries/libssh/0001-Reintroduce-ssh_forward_listen-Fixes-194.patch
+++ b/pkgs/development/libraries/libssh/0001-Reintroduce-ssh_forward_listen-Fixes-194.patch
@ -0,0 +1,28 @@
+From 3c8fe6e2c595ee019408249c364b3019b6c31a8a Mon Sep 17 00:00:00 2001
+From: Mike DePaulo <mikedep333@gmail.com>
+Date: Fri, 15 May 2015 22:22:13 -0400
+Subject: [PATCH] Reintroduce ssh_forward_listen() (Fixes: #194)
+
+---
+ src/channels.c | 5 +++++
+ 1 file changed, 5 insertions(+)
+
+diff --git a/src/channels.c b/src/channels.c
+index 7a4e71f..db5f83a 100644
+--- a/src/channels.c
+++ b/src/channels.c
+@@ -2206,6 +2206,11 @@ error:
+ }
+ 
+ /* DEPRECATED */
+int ssh_forward_listen(ssh_session session, const char *address, int port, int *bound_port) {
+  return ssh_channel_listen_forward(session, address, port, bound_port);
+}
+
+/* DEPRECATED */
+ ssh_channel ssh_forward_accept(ssh_session session, int timeout_ms) {
+   return ssh_channel_accept(session, SSH_CHANNEL_FORWARDED_TCPIP, timeout_ms, NULL);
+ }
+-- 
+2.1.4
+
--- a/pkgs/development/libraries/libssh/default.nix
+++ b/pkgs/development/libraries/libssh/default.nix
@ -30,10 +30,12 @@ stdenv.mkDerivation rec {
  name = "libssh-0.7.0";

  src = fetchurl {
-    url = "https://red.libssh.org/attachments/download/140/libssh-0.7.0.tar.xz";
-    sha256 = "0as07vz3h5qa14ysvgsddb90m1qh605p6ccv6kf1sr1k3wsbql85";
+    url = "https://git.libssh.org/projects/libssh.git/snapshot/libssh-0.7.0.tar.gz";
+    sha256 = "1wfrdqhv97f4ycd9bcpgb6gw47kr7b2iq8cz5knk8a6n9c6870k0";
  };

+  patches = [ ./0001-Reintroduce-ssh_forward_listen-Fixes-194.patch ];
+
  postPatch = ''
    # Fix headers to use libsodium instead of NaCl
    sed -i 's,nacl/,sodium/,g' ./include/libssh/curve25519.h src/curve25519.c
--- a/pkgs/development/libraries/science/math/openblas/default.nix
+++ b/pkgs/development/libraries/science/math/openblas/default.nix
@ -1,4 +1,4 @@
-{ stdenv, fetchurl, gfortran, perl, liblapack, config }:
+{ stdenv, fetchurl, gfortran, perl, liblapack, config, coreutils }:

 with stdenv.lib;

@ -7,6 +7,7 @@ let local = config.openblas.preferLocalBuild or false;
      {
        i686-linux = "32";
        x86_64-linux = "64";
+        x86_64-darwin = "64";
      }."${stdenv.system}" or (throw "unsupported system: ${stdenv.system}");
    genericFlags =
      [
@ -29,14 +30,18 @@ stdenv.mkDerivation rec {

  preBuild = "cp ${liblapack.src} lapack-${liblapack.meta.version}.tgz";

-  nativeBuildInputs = [gfortran perl];
+  nativeBuildInputs = optionals stdenv.isDarwin [coreutils] ++ [gfortran perl];

  makeFlags =
    (if local then localFlags else genericFlags)
    ++
+    optionals stdenv.isDarwin ["MACOSX_DEPLOYMENT_TARGET=10.9"]
+    ++
    [
      "FC=gfortran"
-      "CC=gcc"
+      # Note that clang is available through the stdenv on OSX and
+      # thus is not an explicit dependency.
+      "CC=${if stdenv.isDarwin then "clang" else "gcc"}"
      ''PREFIX="''$(out)"''
      "INTERFACE64=1"
    ];
@ -45,7 +50,7 @@ stdenv.mkDerivation rec {
    description = "Basic Linear Algebra Subprograms";
    license = licenses.bsd3;
    homepage = "https://github.com/xianyi/OpenBLAS";
-    platforms = with platforms; linux;
+    platforms = with platforms; unix;
    maintainers = with maintainers; [ ttuegel ];
  };
 }
--- a/pkgs/development/libraries/webkitgtk/2.4.nix
+++ b/pkgs/development/libraries/webkitgtk/2.4.nix
@ -59,8 +59,7 @@ stdenv.mkDerivation rec {
    (if withGtk2 then gtk2 else gtk3)
  ];

-  # Probably OK now, see:
-  # https://bugs.webkit.org/show_bug.cgi?id=79498
-  enableParallelBuilding = true;
-}
+  # Still fails with transient errors in version 2.4.9.
+  enableParallelBuilding = false;

+}
--- a/pkgs/development/ocaml-modules/alcotest/default.nix
+++ b/pkgs/development/ocaml-modules/alcotest/default.nix
@ -0,0 +1,20 @@
+{stdenv, buildOcaml, fetchurl, ounit, re, cmdliner}:
+
+buildOcaml rec {
+  name = "alcotest";
+  version = "0.3.1";
+
+  src = fetchurl {
+    url = "https://github.com/samoht/alcotest/archive/${version}.tar.gz";
+    sha256 = "a0e6c9a33c59b206ecc949655fa6e17bdd1078c8b610b14d8f6f0f1b489b0b43";
+  };
+
+  propagatedBuildInputs = [ ounit re cmdliner ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/samoht/alcotest;
+    description = "A lightweight and colourful test framework";
+    license = stdenv.lib.licenses.isc;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/async/default.nix
+++ b/pkgs/development/ocaml-modules/async/default.nix
@ -0,0 +1,23 @@
+{stdenv, buildOcaml, fetchurl, async_kernel,
+ async_unix, async_extra, pa_ounit}:
+
+buildOcaml rec {
+  name = "async";
+  version = "112.24.00";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/async/archive/${version}.tar.gz";
+    sha256 = "ecc4ca939ab098e689332921b110dbaacd06d9f8d8bf697023dfff3ca37dc1e9";
+  };
+
+  propagatedBuildInputs = [ async_kernel async_unix async_extra pa_ounit ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/async;
+    description = "Jane Street Capital's asynchronous execution library";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/async_extra/default.nix
+++ b/pkgs/development/ocaml-modules/async_extra/default.nix
@ -0,0 +1,26 @@
+{stdenv, buildOcaml, fetchurl, async_kernel, async_unix,
+ bin_prot, core, custom_printf, fieldslib, herelib, pa_ounit,
+ pipebang, pa_test, sexplib}:
+
+buildOcaml rec {
+  name = "async_extra";
+  version = "112.24.00";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/async_extra/archive/${version}.tar.gz";
+    sha256 = "51f6f67a9ad56fe5dcf09faeeca6ec2fea53a7a975a72bc80504b90841212e28";
+  };
+
+  buildInputs = [ pa_test pa_ounit ];
+  propagatedBuildInputs = [ async_kernel async_unix core bin_prot custom_printf
+                            fieldslib herelib pipebang sexplib ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/async_extra;
+    description = "Jane Street Capital's asynchronous execution library (extra)";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/async_find/default.nix
+++ b/pkgs/development/ocaml-modules/async_find/default.nix
@ -0,0 +1,22 @@
+{stdenv, buildOcaml, fetchurl, async, core, sexplib}:
+
+buildOcaml rec {
+  name = "async_find";
+  version = "111.28.00";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/async_find/archive/${version}.tar.gz";
+    sha256 = "4e3fda72f50174f05d96a5a09323f236c041b1a685890c155822956f3deb8803";
+  };
+
+  propagatedBuildInputs = [ async core sexplib ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/async_find;
+    description = "Directory traversal with Async";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/async_kernel/default.nix
+++ b/pkgs/development/ocaml-modules/async_kernel/default.nix
@ -0,0 +1,25 @@
+{stdenv, buildOcaml, fetchurl, core_kernel,
+ bin_prot, fieldslib, pa_ounit, pa_test,
+ sexplib, herelib}:
+
+buildOcaml rec {
+  name = "async_kernel";
+  version = "112.24.00";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/async_kernel/archive/${version}.tar.gz";
+    sha256 = "95caf4249b55c5a6b38da56e314845e9ea9a0876eedd4cf0ddcb6c8dd660c6a0";
+  };
+
+  buildInputs = [ pa_test pa_ounit ];
+  propagatedBuildInputs = [ core_kernel bin_prot fieldslib herelib sexplib ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/async_kernel;
+    description = "Jane Street Capital's asynchronous execution library (core) ";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/async_shell/default.nix
+++ b/pkgs/development/ocaml-modules/async_shell/default.nix
@ -0,0 +1,22 @@
+{stdenv, buildOcaml, fetchurl, async, core, core_extended}:
+
+buildOcaml rec {
+  name = "async_shell";
+  version = "109.28.03";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/async_shell/archive/${version}.tar.gz";
+    sha256 = "0b4497bea9124c5a665ee58fb0a73c5cbf2f757479df902e6870627196e6c105";
+  };
+
+  propagatedBuildInputs = [ async core core_extended ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/async_shell;
+    description = "Shell helpers for Async";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/async_ssl/default.nix
+++ b/pkgs/development/ocaml-modules/async_ssl/default.nix
@ -0,0 +1,25 @@
+{stdenv, buildOcaml, fetchurl, async, comparelib, core, ctypes, openssl,
+ fieldslib, herelib, pa_bench, pa_ounit, pipebang, pa_test, sexplib}:
+
+buildOcaml rec {
+  name = "async_ssl";
+  version = "112.24.03";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/async_ssl/archive/${version}.tar.gz";
+    sha256 = "1b0bea92142eef11da6bf649bbe229bd4b8d9cc807303d8142406908c0d28c68";
+  };
+
+  buildInputs = [ pa_bench pa_test ];
+  propagatedBuildInputs = [ ctypes async comparelib core fieldslib pa_ounit
+                            herelib pipebang sexplib openssl ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/async_ssl;
+    description = "Async wrappers for ssl";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/async_unix/default.nix
+++ b/pkgs/development/ocaml-modules/async_unix/default.nix
@ -0,0 +1,27 @@
+{stdenv, buildOcaml, fetchurl, async_kernel,
+ bin_prot, comparelib, core, fieldslib, herelib, pa_ounit,
+ pipebang, pa_test, sexplib}:
+
+buildOcaml rec {
+  name = "async_unix";
+  version = "112.24.00";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/async_unix/archive/${version}.tar.gz";
+    sha256 = "d490b1dc42f0987a131fa9695b55f215ad90cdaffbfac35b7f9f88f3834337ab";
+  };
+
+  hasSharedObjects = true;
+  buildInputs = [ pa_ounit ];
+  propagatedBuildInputs = [ async_kernel core bin_prot comparelib
+                            fieldslib herelib pipebang pa_test sexplib ];
+
+   meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/async_unix;
+    description = "Jane Street Capital's asynchronous execution library (unix)";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+   };
+}
--- a/pkgs/development/ocaml-modules/atd/default.nix
+++ b/pkgs/development/ocaml-modules/atd/default.nix
@ -0,0 +1,26 @@
+{stdenv, menhir, easy-format, buildOcaml, fetchurl, which}:
+
+buildOcaml rec {
+  name = "atd";
+  version = "1.1.2";
+
+  src = fetchurl {
+    url = "https://github.com/mjambon/atd/archive/v${version}.tar.gz";
+    sha256 = "0ef10c63192aed75e9a4274e89c5f9ca27efb1ef230d9949eda53ad4a9a37291";
+  };
+
+  installPhase = ''
+    mkdir -p $out/bin
+    make PREFIX=$out install
+  '';
+
+  buildInputs = [ which ];
+  propagatedBuildInputs = [ menhir easy-format ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/mjambon/atd;
+    description = "Syntax for cross-language type definitions";
+    license = licenses.bsd3;
+    maintainers = [ maintainers.jwilberding ];
+  };
+}
--- a/pkgs/development/ocaml-modules/atdgen/default.nix
+++ b/pkgs/development/ocaml-modules/atdgen/default.nix
@ -0,0 +1,25 @@
+{stdenv, atd, yojson, menhir, easy-format, biniou, cppo, buildOcaml, fetchurl, which}:
+
+buildOcaml rec {
+  name = "atdgen";
+  version = "1.6.0";
+
+  src = fetchurl {
+    url = "https://github.com/mjambon/atdgen/archive/v${version}.tar.gz";
+    sha256 = "1icdxgb7qqq1pcbfqi0ikryiwaljd594z3acyci8g3bnlq0yc7zn";
+  };
+
+  installPhase = ''
+    mkdir -p $out/bin
+    make PREFIX=$out install
+  '';
+
+  buildInputs = [ which atd biniou yojson ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/mjambon/atdgen;
+    description = "Generates optimized boilerplate OCaml code for JSON and Biniou IO from type definitions";
+    license = licenses.bsd3;
+    maintainers = [ maintainers.jwilberding ];
+  };
+}
--- a/pkgs/development/ocaml-modules/bin_prot/default.nix
+++ b/pkgs/development/ocaml-modules/bin_prot/default.nix
@ -0,0 +1,24 @@
+{stdenv, writeText, buildOcaml, fetchurl, type_conv}:
+
+buildOcaml rec {
+  name = "bin_prot";
+  version = "112.24.00";
+
+  minimumSupportedOcamlVersion = "4.00";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/bin_prot/archive/${version}.tar.gz";
+    sha256 = "dc0c978a825c7c123990af3317637c218f61079e6f35dc878260651084f1adb4";
+  };
+
+  propagatedBuildInputs = [ type_conv ];
+
+  hasSharedObjects = true;
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/bin_prot;
+    description = "Binary protocol generator ";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/cohttp/default.nix
+++ b/pkgs/development/ocaml-modules/cohttp/default.nix
@ -0,0 +1,29 @@
+{stdenv, buildOcaml, fetchurl, cmdliner, re, uri, fieldslib, sexplib, conduit,
+ stringext, base64, magic-mime, ounit, alcotest, lwt ? null,
+ async ? null, async_ssl ? null}:
+
+buildOcaml rec {
+  name = "cohttp";
+  version = "0.17.1";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/mirage/ocaml-cohttp/archive/v${version}.tar.gz";
+    sha256 = "fb124fb2fb5ff2e74559bf380627f6a537e208c1518ddcb01f0d37b62b55f673";
+  };
+
+  buildInputs = [ alcotest ];
+  propagatedBuildInputs = [ cmdliner re uri fieldslib sexplib sexplib
+                            conduit stringext base64 magic-mime ounit async
+                            async_ssl lwt ];
+
+  buildFlags = "PREFIX=$(out)";
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/mirage/ocaml-cohttp;
+    description = "Very lightweight HTTP server using Lwt or Async";
+    license = licenses.mit;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/comparelib/default.nix
+++ b/pkgs/development/ocaml-modules/comparelib/default.nix
@ -0,0 +1,22 @@
+{stdenv, buildOcaml, fetchurl, type_conv}:
+
+buildOcaml rec {
+  name = "comparelib";
+  version = "109.60.00";
+
+  minimumSupportedOcamlVersion = "4.00";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/comparelib/archive/${version}.tar.gz";
+    sha256 = "1075fb05e0d1e290f71ad0f6163f32b2cb4cebdc77568491c7eb38ba91f5db7e";
+  };
+
+  propagatedBuildInputs = [ type_conv ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/comparelib;
+    description = "Syntax extension for deriving \"compare\" functions automatically";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/conduit/default.nix
+++ b/pkgs/development/ocaml-modules/conduit/default.nix
@ -0,0 +1,24 @@
+{stdenv, buildOcaml, fetchurl, sexplib, stringext, uri, cstruct, ipaddr,
+ async ? null, async_ssl ? null, lwt ? null}:
+
+buildOcaml rec {
+  name = "conduit";
+  version = "0.8.3";
+
+  src = fetchurl {
+    url = "https://github.com/mirage/ocaml-conduit/archive/v${version}.tar.gz";
+    sha256 = "5cf1a46aa0254345e5143feebe6b54bdef96314e9987f44e69f24618d620faa1";
+  };
+
+  propagatedBuildInputs = ([ sexplib stringext uri cstruct ipaddr ]
+                            ++ stdenv.lib.optional (lwt != null) lwt
+                            ++ stdenv.lib.optional (async != null) async
+                            ++ stdenv.lib.optional (async_ssl != null) async_ssl);
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/mirage/ocaml-conduit;
+    description = "Resolve URIs into communication channels for Async or Lwt ";
+    license = licenses.mit;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/core/default.nix
+++ b/pkgs/development/ocaml-modules/core/default.nix
@ -0,0 +1,30 @@
+{stdenv, buildOcaml, fetchurl, type_conv,
+ core_kernel, bin_prot, comparelib, custom_printf, enumerate,
+ fieldslib, herelib, pa_bench, pa_test, pa_ounit,
+ pipebang, sexplib, typerep, variantslib}:
+
+buildOcaml rec {
+  name = "core";
+  version = "112.24.01";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/core/archive/${version}.tar.gz";
+    sha256 = "be5d53ebd4fd04ef23ebf9b3b2840c7aeced6bc4cc6cd3f5e89f71c9949000f4";
+  };
+
+  hasSharedObjects = true;
+
+  buildInputs = [ pa_bench pa_test pa_ounit ];
+  propagatedBuildInputs = [ type_conv core_kernel bin_prot comparelib
+                            custom_printf enumerate fieldslib herelib
+                            pipebang sexplib typerep variantslib ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/core;
+    description = "Jane Street Capital's standard library overlay";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/core_extended/default.nix
+++ b/pkgs/development/ocaml-modules/core_extended/default.nix
@ -0,0 +1,26 @@
+{stdenv, buildOcaml, fetchurl, bin_prot, comparelib, core, custom_printf,
+ fieldslib, pa_bench, pa_ounit, pipebang, pa_test, textutils, re2, sexplib}:
+
+buildOcaml rec {
+  name = "core_extended";
+  version = "112.24.00";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/core_extended/archive/${version}.tar.gz";
+    sha256 = "f87b0661b6c2cfb545ec61d1cb2ab1b9c4967b6ac14e651de41d3a6fb7f0f1e3";
+  };
+
+  hasSharedObjects = true;
+  buildInputs = [ pa_bench pa_test pa_ounit ];
+  propagatedBuildInputs = [bin_prot comparelib core custom_printf fieldslib
+                           pipebang textutils re2 sexplib ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/core_extended;
+    description = "Jane Street Capital's standard library overlay";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/core_kernel/default.nix
+++ b/pkgs/development/ocaml-modules/core_kernel/default.nix
@ -0,0 +1,30 @@
+{stdenv, buildOcaml, fetchurl, type_conv,
+ bin_prot, comparelib, custom_printf, enumerate,
+ fieldslib, herelib, pa_bench, pa_test, pa_ounit,
+ pipebang, sexplib, typerep, variantslib}:
+
+buildOcaml rec {
+  name = "core_kernel";
+  version = "112.24.00";
+
+  minimumSupportedOcamlVersion = "4.02";
+
+  src = fetchurl {
+    url = "https://github.com/janestreet/core_kernel/archive/${version}.tar.gz";
+    sha256 = "93e1f21e35ade98a2bfbe45ba76eef4a8ad3fed97cdc0769f96e0fcc86d6a761";
+  };
+
+  hasSharedObjects = true;
+
+  buildInputs = [ pa_test pa_ounit ];
+  propagatedBuildInputs = [ type_conv pa_bench bin_prot comparelib custom_printf
+                            enumerate fieldslib herelib pipebang sexplib
+                            typerep variantslib ];
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/janestreet/core_kernel;
+    description = "Jane Street Capital's standard library overlay (kernel)";
+    license = licenses.asl20;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/pkgs/development/ocaml-modules/cstruct/default.nix
+++ b/pkgs/development/ocaml-modules/cstruct/default.nix
@ -1,27 +1,31 @@
-{ stdenv, fetchzip, ocaml, findlib, sexplib, ocplib-endian, lwt, camlp4 }:
+{stdenv, writeText, fetchurl, ocaml, ocplib-endian, sexplib, findlib,
+ async ? null, lwt ? null, camlp4}:

-let version = "1.6.0"; in
+let
+  ocaml_version = (builtins.parseDrvName ocaml.name).version;
+in

 stdenv.mkDerivation {
-  name = "ocaml-cstruct-${version}";
+  name = "ocaml-cstruct-1.6.0";

-  src = fetchzip {
-    url = "https://github.com/mirage/ocaml-cstruct/archive/v${version}.tar.gz";
-    sha256 = "09qw3rhfiq2kkns6660p9cwm5610k72md52a04cy91gr6gsig6ic";
+  src = fetchurl {
+    url = https://github.com/mirage/ocaml-cstruct/archive/v1.6.0.tar.gz;
+    sha256 = "0f90a1b7a03091cf22a3ccb11a0cce03b6500f064ad3766b5ed81418ac008ece";
  };

-  buildInputs = [ ocaml findlib lwt camlp4 ];
-  propagatedBuildInputs = [ ocplib-endian sexplib ];
-
-  configureFlags = "--enable-lwt";
+  configureFlags = stdenv.lib.strings.concatStringsSep " " ((if lwt != null then ["--enable-lwt"] else []) ++
+                                          (if async != null then ["--enable-async"] else []));
+  buildInputs = [ocaml findlib camlp4];
+  propagatedBuildInputs = [ocplib-endian sexplib lwt async];

  createFindlibDestdir = true;
+  dontStrip = true;

-  meta = {
-    description = "Map OCaml arrays onto C-like structs";
+  meta = with stdenv.lib; {
    homepage = https://github.com/mirage/ocaml-cstruct;
+    description = "Map OCaml arrays onto C-like structs";
    license = stdenv.lib.licenses.isc;
-    maintainers = with stdenv.lib.maintainers; [ vbgl ];
+    maintainers = [ maintainers.vbgl maintainers.ericbmerritt ];
    platforms = ocaml.meta.platforms;
  };
 }
--- a/pkgs/development/ocaml-modules/ctypes/default.nix
+++ b/pkgs/development/ocaml-modules/ctypes/default.nix
@ -0,0 +1,32 @@
+{stdenv, buildOcaml, fetchurl, libffi, pkgconfig, ncurses}:
+
+buildOcaml rec {
+  name = "ctypes";
+  version = "0.4.1";
+
+  src = fetchurl {
+    url = "https://github.com/ocamllabs/ocaml-ctypes/archive/${version}.tar.gz";
+    sha256 = "74564e049de5d3c0e76ea284c225cb658ac1a2b483345be1efb9be4b3c1702f5";
+  };
+
+  buildInputs = [ ncurses pkgconfig ];
+  propagatedBuildInputs = [ libffi ];
+
+  hasSharedObjects = true;
+
+  buildPhase =  ''
+     make XEN=false libffi.config ctypes-base ctypes-stubs
+     make XEN=false ctypes-foreign
+  '';
+
+  installPhase =  ''
+    make install XEN=false
+  '';
+
+  meta = with stdenv.lib; {
+    homepage = https://github.com/ocamllabs/ocaml-ctypes;
+    description = "Library for binding to C libraries using pure OCaml";
+    license = licenses.mit;
+    maintainers = [ maintainers.ericbmerritt ];
+  };
+}
--- a/Show More
+++ b/Show More