pkgs/applications: stdenv.lib -> lib

pkgs/applications/display-managers/lightdm/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , nix-update-script
 , substituteAll
···
 , yelp-tools
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "lightdm";

pkgs/applications/display-managers/lightdm/gtk-greeter.nix

···
     "--sysconfdir=/etc"
     "--disable-indicator-services-command"
     "--sbindir=${placeholder "out"}/bin" # for wrapGAppsHook to wrap automatically
-  ] ++ stdenv.lib.optional useGTK2 "--with-gtk2";
+  ] ++ lib.optional useGTK2 "--with-gtk2";
 
   preConfigure = ''
     configureFlagsArray+=( --enable-at-spi-command="${at-spi2-core}/libexec/at-spi-bus-launcher --launch-immediately" )

pkgs/applications/misc/1password/default.nix

···
       sha256 = "0pycia75vdfh6gxfd2hr32cxrryfxydid804n0v76l2fpr9v9v3d";
     };
 
-  buildInputs = stdenv.lib.optionals stdenv.isDarwin [ xar cpio ];
+  buildInputs = lib.optionals stdenv.isDarwin [ xar cpio ];
 
-  unpackPhase = stdenv.lib.optionalString stdenv.isDarwin ''
+  unpackPhase = lib.optionalString stdenv.isDarwin ''
     xar -xf $src
     zcat Payload | cpio -i
   '';
···
 
   dontStrip = stdenv.isDarwin;
 
-  nativeBuildInputs = stdenv.lib.optionals stdenv.isLinux [ autoPatchelfHook ];
+  nativeBuildInputs = lib.optionals stdenv.isLinux [ autoPatchelfHook ];
 
   doInstallCheck = true;
 

pkgs/applications/misc/abook/default.nix

···
-{ stdenv, fetchurl, fetchpatch, pkgconfig, ncurses, readline, autoreconfHook }:
+{ lib, stdenv, fetchurl, fetchpatch, pkgconfig, ncurses, readline, autoreconfHook }:
 
 stdenv.mkDerivation rec {
   name = "abook-0.6.1";
···
   meta = {
     homepage = "http://abook.sourceforge.net/";
     description = "Text-based addressbook program designed to use with mutt mail client";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [ stdenv.lib.maintainers.edwtjo ];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2;
+    maintainers = [ lib.maintainers.edwtjo ];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/misc/adobe-reader/default.nix

···
-{ stdenv, fetchurl, libX11, cups, zlib, libxml2, pango, atk, gtk2, glib
+{ lib, stdenv, fetchurl, libX11, cups, zlib, libxml2, pango, atk, gtk2, glib
 , gdk-pixbuf, gdk-pixbuf-xlib }:
 
 assert stdenv.hostPlatform.system == "i686-linux";
···
   # We should probably remove those and use the regular Nixpkgs
   # versions.
 
-  libPath = stdenv.lib.makeLibraryPath
+  libPath = lib.makeLibraryPath
     [ stdenv.cc.cc libX11 zlib libxml2 cups pango atk gtk2 glib gdk-pixbuf gdk-pixbuf-xlib ];
 
   passthru.mozillaPlugin = "/libexec/adobe-reader/Browser/intellinux";
···
   meta = {
     description = "Adobe Reader, a viewer for PDF documents";
     homepage = "http://www.adobe.com/products/reader";
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
     knownVulnerabilities = [
       "Numerous unresolved vulnerabilities"
       "See: https://www.cvedetails.com/product/497/Adobe-Acrobat-Reader.html?vendor_id=53"

pkgs/applications/misc/almanah/default.nix

···
   version = "0.12.2";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "IWYOnOu0C9uQ9k1dgWkJ6Kv+o/jY+6Llfsi4PusHE24=";
   };
 

pkgs/applications/misc/ape/apeclex.nix

···
-{ stdenv, attemptoClex, callPackage }:
+{ lib, stdenv, attemptoClex, callPackage }:
 
 callPackage ./. {
   pname = "ape-clex";
   lexiconPath = "${attemptoClex}/clex_lexicon.pl";
   description = "Parser for Attempto Controlled English (ACE) with a large lexicon (~100,000 entries)";
-  license = with stdenv.lib; [ licenses.lgpl3 licenses.gpl3 ];
+  license = with lib; [ licenses.lgpl3 licenses.gpl3 ];
 }

pkgs/applications/misc/apvlv/default.nix

···
     cp ../Startup.pdf $out/share/doc/apvlv/Startup.pdf
     cp ../main_menubar.glade $out/share/doc/apvlv/main_menubar.glade
   ''
-  + stdenv.lib.optionalString (!stdenv.isDarwin) ''
+  + lib.optionalString (!stdenv.isDarwin) ''
     install -D ../apvlv.desktop $out/share/applications/apvlv.desktop
   '';
 

pkgs/applications/misc/audio/sox/default.nix

···
 , enableLibpulseaudio ? true, libpulseaudio ? null
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   name = "sox-14.4.2";

pkgs/applications/misc/audio/soxr/default.nix

···
-{ stdenv, fetchurl, cmake }:
+{ lib, stdenv, fetchurl, cmake }:
 
 stdenv.mkDerivation rec {
   name = "soxr-0.1.3";
···
   meta = {
     description = "An audio resampling library";
     homepage = "http://soxr.sourceforge.net";
-    license = stdenv.lib.licenses.lgpl21Plus;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.lgpl21Plus;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/misc/audio/wavesurfer/default.nix

···
-{ stdenv, fetchurl, snack, tcl, tk, makeWrapper }:
+{ lib, stdenv, fetchurl, snack, tcl, tk, makeWrapper }:
 
 stdenv.mkDerivation {
   name = "wavesurfer-1.8.5";
···
     ln -s $out/{nix-support,bin}/wavesurfer.tcl
     wrapProgram "$out/nix-support/wavesurfer.tcl"  \
                  --set TCLLIBPATH "${snack}/lib" \
-                 --prefix PATH : "${stdenv.lib.makeBinPath [ tcl tk ]}"
+                 --prefix PATH : "${lib.makeBinPath [ tcl tk ]}"
   '';
 
   meta = {
     description = "Tool for recording, playing, editing, viewing and labeling of audio";
     homepage = "http://www.speech.kth.se/wavesurfer/";
-    license = stdenv.lib.licenses.bsd0;
+    license = lib.licenses.bsd0;
   };
 }

pkgs/applications/misc/avrdudess/default.nix

···
 
     cat >> "$out/bin/avrdudess" << __EOF__
     #!${runtimeShell}
-    export LD_LIBRARY_PATH="${stdenv.lib.makeLibraryPath [gtk2 mono]}"
+    export LD_LIBRARY_PATH="${lib.makeLibraryPath [gtk2 mono]}"
     # We need PATH from user env for xdg-open to find its tools, which
     # typically depend on the currently running desktop environment.
-    export PATH="${stdenv.lib.makeBinPath [ avrdude xdg_utils ]}:\$PATH"
+    export PATH="${lib.makeBinPath [ avrdude xdg_utils ]}:\$PATH"
 
     # avrdudess must have its resource files in its current working directory
     cd $out/avrdudess && exec ${mono}/bin/mono "$out/avrdudess/avrdudess.exe" "\$@"

pkgs/applications/misc/azuredatastudio/default.nix

···
     ${gnutar}/bin/tar xf $src --strip 1 -C ${targetPath}
   '';
 
-  sqltoolsserviceRpath = stdenv.lib.makeLibraryPath [
+  sqltoolsserviceRpath = lib.makeLibraryPath [
     stdenv.cc.cc
     libunwind
     libuuid
···
   # this will most likely need to be updated when azuredatastudio's version changes
   sqltoolsservicePath = "${targetPath}/resources/app/extensions/mssql/sqltoolsservice/Linux/2.0.0-release.56";
 
-  rpath = stdenv.lib.concatStringsSep ":" [
+  rpath = lib.concatStringsSep ":" [
     atomEnv.libPath
     (
-      stdenv.lib.makeLibraryPath [
+      lib.makeLibraryPath [
         libuuid
         at-spi2-core
         at-spi2-atk
···
   '';
 
   meta = {
-    maintainers = with stdenv.lib.maintainers; [ xavierzwirtz ];
+    maintainers = with lib.maintainers; [ xavierzwirtz ];
     description = "A data management tool that enables working with SQL Server, Azure SQL DB and SQL DW";
     homepage = "https://docs.microsoft.com/en-us/sql/azure-data-studio/download-azure-data-studio";
     license = lib.licenses.unfreeRedistributable;

pkgs/applications/misc/barrier/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, curl, xorg, avahi, qtbase, mkDerivation,
+{ lib, stdenv, fetchFromGitHub, cmake, curl, xorg, avahi, qtbase, mkDerivation,
   openssl, wrapGAppsHook,
   avahiWithLibdnssdCompat ? avahi.override { withLibdnssdCompat = true; }
 }:
···
   '';
 
   qtWrapperArgs = [
-    ''--prefix PATH : ${stdenv.lib.makeBinPath [ openssl ]}''
+    ''--prefix PATH : ${lib.makeBinPath [ openssl ]}''
   ];
 
   meta = {
···
     '';
     homepage = "https://github.com/debauchee/barrier";
     downloadPage = "https://github.com/debauchee/barrier/releases";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [ stdenv.lib.maintainers.phryneas ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = [ lib.maintainers.phryneas ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/bemenu/default.nix

···
     ++ lib.optional waylandSupport "wayland"
     ++ lib.optional x11Support "x11";
 
-  buildInputs = with stdenv.lib; [
+  buildInputs = with lib; [
     cairo
     fribidi
     harfbuzz

pkgs/applications/misc/bibletime/default.nix

···
-{ mkDerivation, stdenv, fetchurl, cmake, pkgconfig, sword, boost, clucene_core
+{ lib, mkDerivation, stdenv, fetchurl, cmake, pkgconfig, sword, boost, clucene_core
 , qtbase, qttools, qtsvg, qtwebkit
 }:
 
···
   meta = {
     description = "A Qt4 Bible study tool";
     homepage = "http://www.bibletime.info/";
-    platforms = stdenv.lib.platforms.linux;
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [ stdenv.lib.maintainers.piotr ];
+    platforms = lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = [ lib.maintainers.piotr ];
   };
 }

pkgs/applications/misc/cli-visualizer/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, fftw, ncurses5, libpulseaudio, makeWrapper }:
+{ lib, stdenv, fetchFromGitHub, cmake, fftw, ncurses5, libpulseaudio, makeWrapper }:
 
 stdenv.mkDerivation rec {
   version = "1.8";
···
   meta = {
     homepage = "https://github.com/dpayne/cli-visualizer";
     description = "CLI based audio visualizer";
-    license = stdenv.lib.licenses.mit;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.matthiasbeyer ];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/misc/clipit/default.nix

···
   buildInputs = [ gtk3 libayatana-appindicator ];
 
   gappsWrapperArgs = [
-    "--prefix" "PATH" ":" "${stdenv.lib.makeBinPath [ xdotool which ]}"
+    "--prefix" "PATH" ":" "${lib.makeBinPath [ xdotool which ]}"
   ];
 
   meta = with lib; {

pkgs/applications/misc/confclerk/default.nix

···
-{ stdenv, fetchurl, qt4, qmake4Hook }:
+{ lib, stdenv, fetchurl, qt4, qmake4Hook }:
 
 let version = "0.6.4"; in
 stdenv.mkDerivation {
···
   meta = {
     description = "Offline conference schedule viewer";
     homepage = "http://www.toastfreeware.priv.at/confclerk";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ ehmry ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ ehmry ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/corectrl/default.nix

···
   ];
 
   runtimeDeps = [ mesa-demos vulkan-tools ];
-  binPath = stdenv.lib.makeBinPath runtimeDeps;
+  binPath = lib.makeBinPath runtimeDeps;
 
   dontWrapQtApps = true;
 

pkgs/applications/misc/cpu-x/default.nix

···
 
   postInstall = ''
     wrapProgram $out/bin/cpu-x \
-      --prefix PATH : ${stdenv.lib.makeBinPath [ stdenv.cc ]}
+      --prefix PATH : ${lib.makeBinPath [ stdenv.cc ]}
   '';
 
   meta = with lib; {

pkgs/applications/misc/crow-translate/default.nix

···
-{ stdenv
+{ lib
+, stdenv
 , mkDerivation
 , fetchFromGitHub
 , substituteAll
···
 
   buildInputs = [ leptonica tesseract4 qtmultimedia qtx11extras ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "A simple and lightweight translator that allows to translate and speak text using Google, Yandex and Bing";
     homepage = "https://crow-translate.github.io/";
     license = licenses.gpl3Plus;

pkgs/applications/misc/crumbs/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   pname = "crumbs";
···
     cp crumbs-completion.fish $out/share/fish/vendor_completions.d/crumbs.fish
   '';
 
-  meta = with stdenv.lib;
+  meta = with lib;
     { description = "Bookmarks for the command line";
       homepage    = "https://github.com/fasseg/crumbs";
       license     = licenses.wtfpl;

pkgs/applications/misc/dbeaver/default.nix

···
 
     makeWrapper $out/dbeaver/dbeaver $out/bin/dbeaver \
       --prefix PATH : ${jdk}/bin \
-      --prefix LD_LIBRARY_PATH : ${stdenv.lib.makeLibraryPath ([ glib gtk3 libXtst ])} \
+      --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath ([ glib gtk3 libXtst ])} \
       --prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH"
 
     # Create desktop item.

pkgs/applications/misc/dfilemanager/default.nix

···
-{ stdenv, mkDerivation, fetchFromGitHub, cmake, file, qtbase, qttools, solid }:
+{ lib, stdenv, mkDerivation, fetchFromGitHub, cmake, file, qtbase, qttools, solid }:
 
 mkDerivation {
   pname = "dfilemanager";
···
   meta = {
     homepage = "http://dfilemanager.sourceforge.net/";
     description = "File manager written in Qt/C++";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/misc/diffpdf/default.nix

···
-{ stdenv, mkDerivation, fetchurl, fetchpatch, qmake, qttools, qtbase, poppler }:
+{ lib, stdenv, mkDerivation, fetchurl, fetchpatch, qmake, qttools, qtbase, poppler }:
 
 mkDerivation rec {
   version = "2.1.3";
···
   meta = {
     homepage = "http://www.qtrac.eu/diffpdfc.html";
     description = "Tool for diffing pdf files visually or textually";
-    license = stdenv.lib.licenses.gpl2Plus;
-    maintainers = with stdenv.lib.maintainers; [ tstrobel ];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2Plus;
+    maintainers = with lib.maintainers; [ tstrobel ];
+    platforms = with lib.platforms; linux;
     inherit version;
   };
 }

pkgs/applications/misc/ding/default.nix

···
     cp -v ding.png $out/share/pixmaps/
     cp -v ding.desktop $out/share/applications/
 
-    wrapProgram $out/bin/ding --prefix PATH : ${stdenv.lib.makeBinPath [ gnugrep aspellEnv tk fortune ]} --prefix ASPELL_CONF : "\"prefix ${aspellEnv};\""
+    wrapProgram $out/bin/ding --prefix PATH : ${lib.makeBinPath [ gnugrep aspellEnv tk fortune ]} --prefix ASPELL_CONF : "\"prefix ${aspellEnv};\""
   '';
 
   meta = with lib; {

pkgs/applications/misc/doomseeker/default.nix

···
   nativeBuildInputs = [ cmake qttools pkgconfig xxd ];
   buildInputs = [ qtbase qtmultimedia zlib bzip2 ];
 
-  hardeningDisable = stdenv.lib.optional stdenv.isDarwin "format";
+  hardeningDisable = lib.optional stdenv.isDarwin "format";
 
   meta = with lib; {
     homepage = "http://doomseeker.drdteam.org/";

pkgs/applications/misc/dozenal/default.nix

···
-{ stdenv, fetchFromGitHub, ncurses, hdate, lua5_2 }:
+{ lib, stdenv, fetchFromGitHub, ncurses, hdate, lua5_2 }:
 
 stdenv.mkDerivation rec {
   version = "12010904";
···
          Defaults to dozenal Roman numerals.
     '';
     homepage = "https://github.com/dgoodmaniii/dozenal/";
-    maintainers = with stdenv.lib.maintainers; [ CharlesHD ];
-    license = stdenv.lib.licenses.gpl3;
+    maintainers = with lib.maintainers; [ CharlesHD ];
+    license = lib.licenses.gpl3;
   };
 }

pkgs/applications/misc/electrum/default.nix

···
     cp -ar ${tests} $sourceRoot/electrum/tests
   '';
 
-  nativeBuildInputs = stdenv.lib.optionals enableQt [ wrapQtAppsHook ];
+  nativeBuildInputs = lib.optionals enableQt [ wrapQtAppsHook ];
 
   propagatedBuildInputs = with python3.pkgs; [
     aiohttp
···
     keepkey
     trezor
     btchip
-  ] ++ stdenv.lib.optionals enableQt [ pyqt5 qdarkstyle ];
+  ] ++ lib.optionals enableQt [ pyqt5 qdarkstyle ];
 
   preBuild = ''
     sed -i 's,usr_share = .*,usr_share = "'$out'/share",g' setup.py
···
     sed -i '/qdarkstyle/d' contrib/requirements/requirements.txt
   '');
 
-  postInstall = stdenv.lib.optionalString stdenv.isLinux ''
+  postInstall = lib.optionalString stdenv.isLinux ''
     # Despite setting usr_share above, these files are installed under
     # $out/nix ...
     mv $out/${python3.sitePackages}/nix/store"/"*/share $out
···
 
   '';
 
-  postFixup = stdenv.lib.optionalString enableQt ''
+  postFixup = lib.optionalString enableQt ''
     wrapQtApp $out/bin/electrum
   '';
 

pkgs/applications/misc/elogind/default.nix

···
 , enableSystemd ? false
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "elogind";

pkgs/applications/misc/evtest/default.nix

···
 
   meta = with lib; {
     description = "Simple tool for input event debugging";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     platforms = platforms.linux;
     maintainers = [ maintainers.bjornfor ];
   };

pkgs/applications/misc/expenses/default.nix

···
-{ stdenv
+{ lib
+, stdenv
 , buildGoModule
 , fetchFromGitHub
 , sqlite
···
     "-ldflags=-s -w -X github.com/manojkarthick/expenses/cmd.Version=${version}"
   ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
    description = "An interactive command line expense logger";
    license = licenses.mit;
    maintainers = [ maintainers.manojkarthick ];

pkgs/applications/misc/far2l/default.nix

···
   nativeBuildInputs = [ cmake pkgconfig m4 makeWrapper imagemagick ];
 
   buildInputs = [ wxGTK30 glib pcre ]
-    ++ stdenv.lib.optional stdenv.isDarwin darwin.apple_sdk.frameworks.Cocoa;
+    ++ lib.optional stdenv.isDarwin darwin.apple_sdk.frameworks.Cocoa;
 
-  postPatch = stdenv.lib.optionalString stdenv.isLinux ''
+  postPatch = lib.optionalString stdenv.isLinux ''
     substituteInPlace far2l/bootstrap/trash.sh \
       --replace 'gvfs-trash'  '${gvfs}/bin/gvfs-trash'
-  '' + stdenv.lib.optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     substituteInPlace far2l/CMakeLists.txt \
       --replace "-framework System" -lSystem
   '' + ''
···
       mkdir -p $out/share/icons/hicolor/$size/apps
       convert -size $size ../far2l/DE/icons/hicolor/$size/apps/far2l.svg $out/share/icons/hicolor/$size/apps/far2l.png
     done
-  '' + stdenv.lib.optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     wrapProgram $out/bin/far2l --argv0 $out/bin/far2l
   '';
 

pkgs/applications/misc/fbreader/default.nix

···
 , AppKit, Cocoa
 }:
 
-with stdenv.lib;
+with lib;
 
 assert elem uiTarget [ "desktop" "macosx" ];
 assert elem uiType [ "qt4" "gtk" "cocoa" ];

pkgs/applications/misc/fetchmail/default.nix

···
-{ stdenv, fetchurl, openssl }:
+{ lib, stdenv, fetchurl, openssl }:
 
 let
   version = "6.4.14";
···
       IPSEC.
     '';
 
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.peti ];
-    license = stdenv.lib.licenses.gpl2Plus;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.peti ];
+    license = lib.licenses.gpl2Plus;
   };
 }

pkgs/applications/misc/fff/default.nix

···
     sha256 = "14ymdw6l6phnil0xf1frd5kgznaiwppcic0v4hb61s1zpf4wrshg";
   };
 
-  pathAdd = stdenv.lib.makeSearchPath "bin" ([ xdg_utils file coreutils w3m xdotool ]);
+  pathAdd = lib.makeSearchPath "bin" ([ xdg_utils file coreutils w3m xdotool ]);
 
   nativeBuildInputs = [ makeWrapper ];
   buildInputs = [ bashInteractive ];

pkgs/applications/misc/firestarter/default.nix

···
   withCuda ? true
 }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   pname = "firestarter";
   version = "1.7.4";

pkgs/applications/misc/fsv/default.nix

···
     pname    = "gtkglarea";
     version = "2.1.0";
     src = fetchurl {
-      url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+      url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
       sha256 = "1pl2vdj6l64j864ilhkq1bcggb3hrlxjwk5m029i7xfjfxc587lf";
     };
     nativeBuildInputs = [ pkgconfig ];

pkgs/applications/misc/gammu/default.nix

···
-{ stdenv, fetchFromGitHub, python, pkgconfig, cmake, bluez, libusb1, curl
+{ lib, stdenv, fetchFromGitHub, python, pkgconfig, cmake, bluez, libusb1, curl
 , libiconv, gettext, sqlite
 , dbiSupport ? false, libdbi ? null, libdbiDrivers ? null
 , postgresSupport ? false, postgresql ? null
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "gammu";

pkgs/applications/misc/garmin-plugin/default.nix

···
-{ stdenv, fetchurl, garmintools, libgcrypt, libusb-compat-0_1, pkgconfig, tinyxml, zlib }:
+{ lib, stdenv, fetchurl, garmintools, libgcrypt, libusb-compat-0_1, pkgconfig, tinyxml, zlib }:
 stdenv.mkDerivation {
   name = "garmin-plugin-0.3.26";
   src = fetchurl {
···
   '';
   meta = {
     homepage = "http://www.andreas-diesner.de/garminplugin";
-    license = stdenv.lib.licenses.gpl3;
+    license = lib.licenses.gpl3;
     maintainers = [ ];
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/gcal/default.nix

···
-{ stdenv, fetchurl, ncurses, fetchpatch }:
+{ lib, stdenv, fetchurl, ncurses, fetchpatch }:
 
 stdenv.mkDerivation rec {
   pname = "gcal";
···
       also displays holiday lists for many countries around the globe.
     '';
     homepage = "https://www.gnu.org/software/gcal/";
-    license = stdenv.lib.licenses.gpl3Plus;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.romildo ];
+    license = lib.licenses.gpl3Plus;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.romildo ];
   };
 }

pkgs/applications/misc/get_iplayer/default.nix

···
-{stdenv, fetchFromGitHub, atomicparsley, flvstreamer, ffmpeg_3, makeWrapper, perl, perlPackages, rtmpdump}:
+{ lib, stdenv, fetchFromGitHub, atomicparsley, flvstreamer, ffmpeg_3, makeWrapper, perl, perlPackages, rtmpdump}:
 
-with stdenv.lib;
+with lib;
 
 perlPackages.buildPerlPackage rec {
   pname = "get_iplayer";

pkgs/applications/misc/gkrellm/default.nix

···
-{ fetchurl, stdenv, gettext, pkgconfig, glib, gtk2, libX11, libSM, libICE, which
+{ lib, fetchurl, stdenv, gettext, pkgconfig, glib, gtk2, libX11, libSM, libICE, which
 , IOKit ? null }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   name = "gkrellm-2.3.11";

pkgs/applications/misc/gksu/default.nix

···
-{ stdenv, fetchurl, pkgconfig, gtk2, gnome2, gnome3, libgksu,
+{ lib, stdenv, fetchurl, pkgconfig, gtk2, gnome2, gnome3, libgksu,
   intltool, libstartup_notification, gtk-doc, wrapGAppsHook
 }:
 
···
       as another user.
     '';
     homepage = "https://www.nongnu.org/gksu/";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [ stdenv.lib.maintainers.romildo ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = [ lib.maintainers.romildo ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/glava/default.nix

···
 , enableGlfw ? false, glfw, runtimeShell }:
 
 let
-  inherit (stdenv.lib) optional makeLibraryPath;
+  inherit (lib) optional makeLibraryPath;
 
   wrapperScript = writeScript "glava" ''
     #!${runtimeShell}

pkgs/applications/misc/glom/default.nix

···
   outputs = [ "out" "lib" "dev" "doc" "devdoc" ];
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "1wcd4kd3crwqjv0jfp73jkyyf5ws8mvykg37kqxmcb58piz21gsk";
   };
 
···
   preConfigure = "NOCONFIGURE=1 ./autogen.sh";
 
   configureFlags = [
-    "--with-boost-python=boost_python${stdenv.lib.versions.major python3.version}${stdenv.lib.versions.minor python3.version}"
+    "--with-boost-python=boost_python${lib.versions.major python3.version}${lib.versions.minor python3.version}"
   ];
 
   makeFlags = [

pkgs/applications/misc/gmtp/default.nix

···
-{ stdenv, fetchurl, pkgconfig, libmtp, libid3tag, flac, libvorbis, gtk3
+{ lib, stdenv, fetchurl, pkgconfig, libmtp, libid3tag, flac, libvorbis, gtk3
 , gsettings-desktop-schemas, wrapGAppsHook
 }:
 
···
   meta = {
     description = "A simple MP3 and Media player client for UNIX and UNIX like systems";
     homepage = "https://gmtp.sourceforge.io";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
     maintainers = [ ];
-    license = stdenv.lib.licenses.bsd3;
+    license = lib.licenses.bsd3;
   };
 }

pkgs/applications/misc/gnome-multi-writer/default.nix

···
   version = "3.32.1";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "1apdd8yi12zagf82k376a9wmdm27wzwdxpm2wf2pnwkaf786rmdw";
   };
 

pkgs/applications/misc/gnome-recipes/default.nix

···
   name = "${pname}-${version}";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${name}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${name}.tar.xz";
     sha256 = "1yymii3yf823d9x28fbhqdqm1wa30s40j94x0am9fjj0nzyd5s8v";
   };
 

pkgs/applications/misc/gnome-usage/default.nix

···
   version = "3.38.0";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "0mqs39yi2cqwkzlmmgzrszsva5hbdpws6zk4lbi4w2cjzl185mcl";
   };
 

pkgs/applications/misc/goldendict/default.nix

···
 
   patches = [
     ./0001-dont-check-for-updates.patch
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [
+  ] ++ lib.optionals stdenv.isDarwin [
     ./0001-dont-use-maclibs.patch
   ];
 
   postPatch = ''
     substituteInPlace goldendict.pro \
-      --replace "hunspell-1.6.1" "hunspell-${stdenv.lib.versions.majorMinor hunspell.version}"
+      --replace "hunspell-1.6.1" "hunspell-${lib.versions.majorMinor hunspell.version}"
   '';
 
   nativeBuildInputs = [ pkgconfig qmake ];
   buildInputs = [
     qtbase qtsvg qtwebkit qttools
     libvorbis hunspell xz lzo
-  ] ++ stdenv.lib.optionals stdenv.isLinux [ qtx11extras libXtst ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ bzip2 libiconv ]
-    ++ stdenv.lib.optional withCC opencc
-    ++ stdenv.lib.optional withEpwing libeb
-    ++ stdenv.lib.optional withExtraTiff libtiff
-    ++ stdenv.lib.optionals withFFmpeg [ libao ffmpeg_3 ]
-    ++ stdenv.lib.optional withZim zstd;
+  ] ++ lib.optionals stdenv.isLinux [ qtx11extras libXtst ]
+    ++ lib.optionals stdenv.isDarwin [ bzip2 libiconv ]
+    ++ lib.optional withCC opencc
+    ++ lib.optional withEpwing libeb
+    ++ lib.optional withExtraTiff libtiff
+    ++ lib.optionals withFFmpeg [ libao ffmpeg_3 ]
+    ++ lib.optional withZim zstd;
 
-  qmakeFlags = with stdenv.lib; [
+  qmakeFlags = with lib; [
     "goldendict.pro"
     (optional withCC "CONFIG+=chinese_conversion_support")
     (optional (!withCC) "CONFIG+=no_chinese_conversion_support")
···
     (optional withZim "CONFIG+=zim_support")
   ];
 
-  postInstall = stdenv.lib.optionalString stdenv.isDarwin ''
+  postInstall = lib.optionalString stdenv.isDarwin ''
     mkdir -p $out/Applications
     mv GoldenDict.app $out/Applications
     wrapQtApp $out/Applications/GoldenDict.app/Contents/MacOS/GoldenDict

pkgs/applications/misc/gollum/default.nix

···
   in ''
     mkdir -p $out/bin
     makeWrapper ${env}/bin/gollum $out/bin/gollum \
-      --prefix PATH ":" ${stdenv.lib.makeBinPath [ git ]}
+      --prefix PATH ":" ${lib.makeBinPath [ git ]}
     makeWrapper ${env}/bin/gollum-migrate-tags $out/bin/gollum-migrate-tags \
-      --prefix PATH ":" ${stdenv.lib.makeBinPath [ git ]}
+      --prefix PATH ":" ${lib.makeBinPath [ git ]}
   '';
 
   passthru.updateScript = bundlerUpdateScript "gollum";

pkgs/applications/misc/gollum/gemset.nix

···
     };
     version = "0.16.10";
   };
-}
+}

pkgs/applications/misc/googleearth/default.nix

···
     then "0dwnppn5snl5bwkdrgj4cyylnhngi0g66fn2k41j3dvis83x24k6"
     else "0gndbxrj3kgc2dhjqwjifr3cl85hgpm695z0wi01wvwzhrjqs0l2";
   version = "7.1.8.3036";
-  fullPath = stdenv.lib.makeLibraryPath [
+  fullPath = lib.makeLibraryPath [
     glibc
     glib
     stdenv.cc.cc

pkgs/applications/misc/gpg-mdp/default.nix

···
-{ fetchurl, stdenv, ncurses, gnupg }:
+{ fetchurl, lib, stdenv, ncurses, gnupg }:
 
 let version = "0.7.4";
 in stdenv.mkDerivation {
···
   inherit version;
   meta = {
     homepage = "https://tamentis.com/projects/mdp/";
-    license = [stdenv.lib.licenses.isc];
+    license = [lib.licenses.isc];
     description = "Manage your passwords with GnuPG and a text editor";
   };
   src = fetchurl {

pkgs/applications/misc/gpsbabel/default.nix

···
   configureFlags = [ "--with-zlib=system" ]
     # Floating point behavior on i686 causes test failures. Preventing
     # extended precision fixes this problem.
-    ++ stdenv.lib.optionals stdenv.isi686 [
+    ++ lib.optionals stdenv.isi686 [
       "CFLAGS=-ffloat-store" "CXXFLAGS=-ffloat-store"
     ];
 

pkgs/applications/misc/gpsbabel/gui.nix

···
   '';
 
   qtWrapperArgs = [
-    "--prefix PATH : ${stdenv.lib.makeBinPath [ gpsbabel ]}"
+    "--prefix PATH : ${lib.makeBinPath [ gpsbabel ]}"
   ];
 
   postInstall = ''

pkgs/applications/misc/gpx/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook }:
+{ lib, stdenv, fetchFromGitHub, autoreconfHook }:
 
 stdenv.mkDerivation rec {
   pname = "gpx";
···
   meta = {
     description = "Gcode to x3g conversion postprocessor";
     homepage = "https://github.com/markwal/GPX/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.leo60228 ];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.leo60228 ];
   };
 }

pkgs/applications/misc/gramps/default.nix

···
   nativeBuildInputs = [ wrapGAppsHook intltool gettext ];
   buildInputs = [ gtk3 gobject-introspection pango gexiv2 ]
     # Map support
-    ++ stdenv.lib.optional enableOSM osm-gps-map
+    ++ lib.optional enableOSM osm-gps-map
     # Graphviz support
-    ++ stdenv.lib.optional enableGraphviz graphviz
+    ++ lib.optional enableGraphviz graphviz
     # Ghostscript support
-    ++ stdenv.lib.optional enableGhostscript ghostscript
+    ++ lib.optional enableGhostscript ghostscript
   ;
 
   src = fetchFromGitHub {

pkgs/applications/misc/grip/default.nix

···
-{ stdenv, fetchurl, gtk2, glib, pkgconfig, libgnome, libgnomeui, vte
+{ lib, stdenv, fetchurl, gtk2, glib, pkgconfig, libgnome, libgnomeui, vte
 , curl, cdparanoia, libid3tag, ncurses, libtool }:
 
 stdenv.mkDerivation rec {
···
   meta = {
     description = "GTK-based audio CD player/ripper";
     homepage = "http://nostatic.org/grip";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
 
-    maintainers = with stdenv.lib.maintainers; [ marcweber peti ];
-    platforms = stdenv.lib.platforms.linux;
+    maintainers = with lib.maintainers; [ marcweber peti ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/gsimplecal/default.nix

···
-{ stdenv, fetchurl, automake, autoconf, pkgconfig, gtk3 }:
+{ lib, stdenv, fetchurl, automake, autoconf, pkgconfig, gtk3 }:
 
 stdenv.mkDerivation rec {
   pname = "gsimplecal";
···
       Also, you can configure it to not only show the calendar, but also
       display multiple clocks for different world time zones.
     '';
-    license = stdenv.lib.licenses.bsd3;
-    maintainers = [ stdenv.lib.maintainers.romildo ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.bsd3;
+    maintainers = [ lib.maintainers.romildo ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/gummi/default.nix

···
-{ stdenv, pkgs
+{ lib, stdenv, pkgs
 , glib, gnome3, gtk3, gtksourceview3, gtkspell3, poppler, texlive
 , pkgconfig, intltool, autoreconfHook, wrapGAppsHook
 }:
···
   meta = {
     homepage = "https://gummi.app";
     description = "Simple LaTex editor for GTK users";
-    license = stdenv.lib.licenses.mit;
-    maintainers = with stdenv.lib.maintainers; [ flokli ];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ flokli ];
+    platforms = with lib.platforms; linux;
     inherit version;
   };
 }

pkgs/applications/misc/gv/default.nix

···
-{ stdenv, fetchurl, Xaw3d, ghostscriptX, perl, pkgconfig, libiconv }:
+{ lib, stdenv, fetchurl, Xaw3d, ghostscriptX, perl, pkgconfig, libiconv }:
 
 let
   name = "gv-3.7.4";
···
     sha256 = "0q8s43z14vxm41pfa8s5h9kyyzk1fkwjhkiwbf2x70alm6rv6qi1";
   };
 
-  configureFlags = stdenv.lib.optionals stdenv.isDarwin [
+  configureFlags = lib.optionals stdenv.isDarwin [
     "--enable-SIGCHLD-fallback"
   ];
 
···
     ghostscriptX
     perl
     pkgconfig
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [
+  ] ++ lib.optionals stdenv.isDarwin [
     libiconv
   ];
 
···
       interface for the Ghostscript interpreter.
     '';
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
     maintainers = [ ];
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/misc/gxmessage/default.nix

···
-{ stdenv, fetchurl, gtk3, intltool, pkgconfig, texinfo }:
+{ lib, stdenv, fetchurl, gtk3, intltool, pkgconfig, texinfo }:
 
 stdenv.mkDerivation rec {
   pname = "gxmessage";
···
   meta = {
     description = "A GTK enabled dropin replacement for xmessage";
     homepage = "http://homepages.ihug.co.nz/~trmusson/programs.html#gxmessage";
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = with stdenv.lib.maintainers; [jfb];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl3;
+    maintainers = with lib.maintainers; [jfb];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/misc/hdate/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   version = "1.6.02";
···
   meta = {
     description = "Hebrew calendar and solar astronomical times library and utilities";
     homepage = "https://sourceforge.net/projects/libhdate/";
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = with stdenv.lib.maintainers; [ CharlesHD ];
+    license = lib.licenses.gpl3;
+    maintainers = with lib.maintainers; [ CharlesHD ];
   };
 }

pkgs/applications/misc/hello-unfree/default.nix

···
-{ stdenv, runtimeShell }:
+{ lib, stdenv, runtimeShell }:
 
 stdenv.mkDerivation {
   pname = "example-unfree-package";
···
 
   meta = {
     description = "An example package with unfree license (for testing)";
-    license = stdenv.lib.licenses.unfree;
-    maintainers = [ stdenv.lib.maintainers.oxij ];
+    license = lib.licenses.unfree;
+    maintainers = [ lib.maintainers.oxij ];
   };
 }

pkgs/applications/misc/houdini/runtime.nix

···
-{ stdenv, requireFile, zlib, libpng, libSM, libICE, fontconfig, xorg, libGLU, libGL, alsaLib, dbus, xkeyboardconfig, bc, addOpenGLRunpath }:
+{ lib, stdenv, requireFile, zlib, libpng, libSM, libICE, fontconfig, xorg, libGLU, libGL, alsaLib, dbus, xkeyboardconfig, bc, addOpenGLRunpath }:
 
 let
   ld_library_path = builtins.concatStringsSep ":" [
     "${stdenv.cc.cc.lib}/lib64"
-    (stdenv.lib.makeLibraryPath [
+    (lib.makeLibraryPath [
       libGLU
       libGL
       xorg.libXmu
···
   meta = {
     description = "3D animation application software";
     homepage = "https://www.sidefx.com";
-    license = stdenv.lib.licenses.unfree;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.canndrew ];
+    license = lib.licenses.unfree;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.canndrew ];
   };
 }
 

pkgs/applications/misc/hstr/default.nix

···
-{ stdenv, fetchFromGitHub, readline, ncurses
+{ lib, stdenv, fetchFromGitHub, readline, ncurses
 , autoreconfHook, pkgconfig, gettext }:
 
 stdenv.mkDerivation rec {
···
   meta = {
     homepage = "https://github.com/dvorka/hstr";
     description = "Shell history suggest box - easily view, navigate, search and use your command history";
-    license = stdenv.lib.licenses.asl20;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
-    platforms = with stdenv.lib.platforms; linux ++ darwin;
+    license = lib.licenses.asl20;
+    maintainers = [ lib.maintainers.matthiasbeyer ];
+    platforms = with lib.platforms; linux ++ darwin;
   };
 
 }

pkgs/applications/misc/hubstaff/default.nix

···
 
   inherit (data) version url sha256;
 
-  rpath = stdenv.lib.makeLibraryPath
+  rpath = lib.makeLibraryPath
     [ libX11 zlib libSM libICE libXext freetype libXrender fontconfig libXft
       libXinerama stdenv.cc.cc.lib libnotify glib gtk3 libappindicator-gtk3
       curl libXfixes libXScrnSaver ];

pkgs/applications/misc/icesl/default.nix

···
 { stdenv, lib, fetchzip, freeglut, libXmu, libXi, libX11, libICE, libGLU, libGL, libSM, libXext, dialog, makeWrapper }:
 let
-  lpath = stdenv.lib.makeLibraryPath [ libXmu libXi libX11 freeglut libICE libGLU libGL libSM libXext ];
+  lpath = lib.makeLibraryPath [ libXmu libXi libX11 freeglut libICE libGLU libGL libSM libXext ];
 in
 stdenv.mkDerivation rec {
   pname = "iceSL";

pkgs/applications/misc/ikiwiki/default.nix

···
-{ stdenv, fetchurl, perlPackages, gettext, makeWrapper, PerlMagick, which, highlight
+{ lib, stdenv, fetchurl, perlPackages, gettext, makeWrapper, PerlMagick, which, highlight
 , gitSupport ? false, git ? null
 , docutilsSupport ? false, python ? null, docutils ? null
 , monotoneSupport ? false, monotone ? null
···
 let
   name = "ikiwiki";
   version = "3.20200202.3";
-
-  lib = stdenv.lib;
 in
 stdenv.mkDerivation {
   name = "${name}-${version}";
···
   meta = {
     description = "Wiki compiler, storing pages and history in a RCS";
     homepage = "http://ikiwiki.info/";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.peti ];
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.peti ];
   };
 }

pkgs/applications/misc/imag/default.nix

···
 
   nativeBuildInputs = [ installShellFiles pkg-config ];
   buildInputs = [ openssl ]
-    ++ stdenv.lib.optional stdenv.isDarwin Security;
+    ++ lib.optional stdenv.isDarwin Security;
   checkInputs = [ gitMinimal util-linuxMinimal ];
 
   LIBCLANG_PATH = "${llvmPackages.libclang}/lib";

pkgs/applications/misc/ipmicfg/default.nix

···
 
     patchelf \
        --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-       --set-rpath "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc ]}" \
+       --set-rpath "${lib.makeLibraryPath [ stdenv.cc.cc ]}" \
        "$out/opt/ipmicfg/IPMICFG-Linux.x86_64"
 
     ln -s "$out/opt/ipmicfg/IPMICFG-Linux.x86_64" "$out/bin/ipmicfg"

pkgs/applications/misc/ipmiview/default.nix

···
       else throw "IPMIView is not supported on this platform";
     in
   ''
-    patchelf --set-rpath "${stdenv.lib.makeLibraryPath [ libX11 libXext libXrender libXtst libXi ]}" ./jre/lib/amd64/libawt_xawt.so
-    patchelf --set-rpath "${stdenv.lib.makeLibraryPath [ freetype ]}" ./jre/lib/amd64/libfontmanager.so
+    patchelf --set-rpath "${lib.makeLibraryPath [ libX11 libXext libXrender libXtst libXi ]}" ./jre/lib/amd64/libawt_xawt.so
+    patchelf --set-rpath "${lib.makeLibraryPath [ freetype ]}" ./jre/lib/amd64/libfontmanager.so
     patchelf --set-rpath "${gcc.cc}/lib:$out/jre/lib/amd64/jli" --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" ./jre/bin/java
     patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" ./BMCSecurity/${stunnelBinary}
   '';
···
     # WORK_DIR: unfortunately the ikvm related binaries are loaded from
     #           and user configuration is written to files in the CWD
     makeWrapper $out/jre/bin/java $out/bin/IPMIView \
-      --set LD_LIBRARY_PATH "${stdenv.lib.makeLibraryPath [ fontconfig gcc-unwrapped.lib ]}" \
+      --set LD_LIBRARY_PATH "${lib.makeLibraryPath [ fontconfig gcc-unwrapped.lib ]}" \
       --prefix PATH : "$out/jre/bin:${iputils}/bin:${psmisc}/bin" \
       --add-flags "-jar $out/IPMIView20.jar" \
       --run 'WORK_DIR=''${XDG_DATA_HOME:-~/.local/share}/ipmiview

pkgs/applications/misc/jbidwatcher/default.nix

···
-{ stdenv, fetchurl, java, runtimeShell }:
+{ lib, stdenv, fetchurl, java, runtimeShell }:
 
 stdenv.mkDerivation rec {
   pname = "jbidwatcher";
···
       binary.
     '';
 
-    platforms = stdenv.lib.platforms.linux ++ stdenv.lib.platforms.darwin;
+    platforms = lib.platforms.linux ++ lib.platforms.darwin;
   };
 }

pkgs/applications/misc/jekyll/basic/gemset.nix

···
     };
     version = "2.4.2";
   };
-}
+}

pkgs/applications/misc/jgmenu/default.nix

···
     xorg.libXinerama
     xorg.libXrandr
     python3Packages.python
-  ] ++ stdenv.lib.optionals enableXfcePanelApplet [
+  ] ++ lib.optionals enableXfcePanelApplet [
     gtk3
     xfce.libxfce4util
     xfce.xfce4-panel
···
 
   configureFlags = [
   ]
-  ++ stdenv.lib.optionals enableXfcePanelApplet [
+  ++ lib.optionals enableXfcePanelApplet [
     "--with-xfce4-panel-applet"
   ];
 

pkgs/applications/misc/jigdo/default.nix

···
-{ stdenv, fetchurl, db, gtk2, bzip2 }:
+{ lib, stdenv, fetchurl, db, gtk2, bzip2 }:
 
 stdenv.mkDerivation {
   name = "jigdo-0.7.3";
···
   meta = {
     description = "Download utility that can fetch files from several sources simultaneously";
     homepage = "http://atterer.net/jigdo/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/misc/josm/default.nix

···
 
   dontUnpack = true;
 
-  buildInputs = stdenv.lib.optionals (!stdenv.isDarwin) [ jre makeWrapper ];
+  buildInputs = lib.optionals (!stdenv.isDarwin) [ jre makeWrapper ];
 
   installPhase =
     if stdenv.isDarwin then ''

pkgs/applications/misc/k2pdfopt/default.nix

···
 , enableTesseract ? true, leptonica, tesseract4
 }:
 
-with stdenv.lib;
+with lib;
 
 # k2pdfopt is a pain to package. It requires modified versions of mupdf,
 # leptonica, and tesseract.  Instead of shipping patches for these upstream

pkgs/applications/misc/kdbplus/default.nix

···
-{ stdenv, requireFile, unzip, rlwrap, bash, zlib }:
+{ lib, stdenv, requireFile, unzip, rlwrap, bash, zlib }:
 
 assert (stdenv.hostPlatform.system == "i686-linux");
 
 let
-  libPath = stdenv.lib.makeLibraryPath
+  libPath = lib.makeLibraryPath
     [ stdenv.cc.libc stdenv.cc.cc zlib ];
 in
 stdenv.mkDerivation rec {
···
   meta = {
     description = "Analytics and time-series database";
     homepage    = "http://www.kx.com/";
-    license     = stdenv.lib.licenses.unfree;
+    license     = lib.licenses.unfree;
     platforms   = [ "i686-linux" ];
-    maintainers = [ stdenv.lib.maintainers.thoughtpolice ];
+    maintainers = [ lib.maintainers.thoughtpolice ];
   };
 }

pkgs/applications/misc/keepass-plugins/keeagent/default.nix

···
-{ stdenv, buildEnv, fetchzip, mono }:
+{ lib, stdenv, buildEnv, fetchzip, mono }:
 
 let
   version = "0.12.0";
···
     meta = {
       description = "KeePass plugin to allow other programs to access SSH keys stored in a KeePass database for authentication";
       homepage    = "http://lechnology.com/software/keeagent";
-      platforms   = with stdenv.lib.platforms; linux;
-      license     = stdenv.lib.licenses.gpl2;
+      platforms   = with lib.platforms; linux;
+      license     = lib.licenses.gpl2;
       maintainers = [ ];
     };
 

pkgs/applications/misc/keepass-plugins/keepasshttp/default.nix

···
-{ stdenv, buildEnv, fetchFromGitHub, mono }:
+{ lib, stdenv, buildEnv, fetchFromGitHub, mono }:
 
 let
   version = "1.8.4.2";
···
     meta = {
       description = "KeePass plugin to expose password entries securely (256bit AES/CBC) over HTTP";
       homepage    = "https://github.com/pfn/keepasshttp";
-      platforms   = with stdenv.lib.platforms; linux;
-      license     = stdenv.lib.licenses.gpl3;
+      platforms   = with lib.platforms; linux;
+      license     = lib.licenses.gpl3;
     };
 
     pluginFilename = "KeePassHttp.plgx";

pkgs/applications/misc/keepass-plugins/otpkeyprov/default.nix

···
-{ stdenv, buildEnv, fetchzip, mono }:
+{ lib, stdenv, buildEnv, fetchzip, mono }:
 
 let
   version = "2.6";
···
     meta = {
       description = "OtpKeyProv is a key provider based on one-time passwords";
       homepage    = "https://keepass.info/plugins.html#otpkeyprov";
-      platforms   = with stdenv.lib.platforms; linux;
-      license     = stdenv.lib.licenses.gpl2;
-      maintainers = [ stdenv.lib.maintainers.ente ];
+      platforms   = with lib.platforms; linux;
+      license     = lib.licenses.gpl2;
+      maintainers = [ lib.maintainers.ente ];
     };
 
     pluginFilename = "OtpKeyProv.plgx";

pkgs/applications/misc/keepass/default.nix

···
     desktopName = "Keepass";
     genericName = "Password manager";
     categories = "Utility;";
-    mimeType = stdenv.lib.concatStringsSep ";" [
+    mimeType = lib.concatStringsSep ";" [
       "application/x-keepass2"
       ""
     ];
···
   # is found and does not pollute output path.
   binPaths = lib.concatStrings (lib.intersperse ":" (map (x: x + "/bin") plugins));
 
-  dynlibPath = stdenv.lib.makeLibraryPath [ gtk2 ];
+  dynlibPath = lib.makeLibraryPath [ gtk2 ];
 
   postInstall =
   let
···
   meta = {
     description = "GUI password manager with strong cryptography";
     homepage = "http://www.keepass.info/";
-    maintainers = with stdenv.lib.maintainers; [ amorsillo obadz jraygauthier ];
-    platforms = with stdenv.lib.platforms; all;
-    license = stdenv.lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ amorsillo obadz jraygauthier ];
+    platforms = with lib.platforms; all;
+    license = lib.licenses.gpl2;
   };
 }

pkgs/applications/misc/keepassx/2.0.nix

···
-{ stdenv, fetchurl, cmake, libgcrypt, qt4, xorg }:
+{ lib, stdenv, fetchurl, cmake, libgcrypt, qt4, xorg }:
 
 stdenv.mkDerivation rec {
   pname = "keepassx2";
···
   meta = {
     description = "Qt password manager compatible with its Win32 and Pocket PC versions";
     homepage = "https://www.keepassx.org/";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ qknight ];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ qknight ];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/misc/keepassx/community.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , fetchpatch
 , cmake
···
 , withKeePassFDOSecrets ? true
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "keepassxc";
···
     sha256 = "032dzywvwpclhsl3n1pq2m9gyxqpg0gkci6axbvbs7bn82wznc4h";
   };
 
-  NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.cc.isClang [
+  NIX_CFLAGS_COMPILE = lib.optionalString stdenv.cc.isClang [
     "-Wno-old-style-cast"
     "-Wno-error"
     "-D__BIG_ENDIAN__=${if stdenv.isBigEndian then "1" else "0"}"
   ];
 
-  postPatch = stdenv.lib.optionalString stdenv.isDarwin ''
+  postPatch = lib.optionalString stdenv.isDarwin ''
     substituteInPlace CMakeLists.txt \
       --replace "/usr/local/bin" "../bin" \
       --replace "/usr/local/share/man" "../share/man"
   '';
-  NIX_LDFLAGS = stdenv.lib.optionalString stdenv.isDarwin "-rpath ${libargon2}/lib";
+  NIX_LDFLAGS = lib.optionalString stdenv.isDarwin "-rpath ${libargon2}/lib";
 
   patches = [
     ./darwin.patch
···
     yubikey-personalization
     zlib
   ]
-  ++ stdenv.lib.optional withKeePassKeeShareSecure quazip
-  ++ stdenv.lib.optional stdenv.isDarwin qtmacextras
-  ++ stdenv.lib.optional (stdenv.isDarwin && withKeePassTouchID) darwin.apple_sdk.frameworks.LocalAuthentication;
+  ++ lib.optional withKeePassKeeShareSecure quazip
+  ++ lib.optional stdenv.isDarwin qtmacextras
+  ++ lib.optional (stdenv.isDarwin && withKeePassTouchID) darwin.apple_sdk.frameworks.LocalAuthentication;
 
   preFixup = optionalString stdenv.isDarwin ''
     # Make it work without Qt in PATH.

pkgs/applications/misc/keepassx/default.nix

···
-{ stdenv, fetchurl, bzip2, qt4, qmake4Hook, libX11, xorgproto, libXtst }:
+{ lib, stdenv, fetchurl, bzip2, qt4, qmake4Hook, libX11, xorgproto, libXtst }:
 
 stdenv.mkDerivation rec {
   pname = "keepassx";
···
   meta = {
     description = "Qt password manager compatible with its Win32 and Pocket PC versions";
     homepage = "https://www.keepassx.org/";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ qknight ];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ qknight ];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/misc/keystore-explorer/default.nix

···
-{ fetchzip, stdenv, jdk8, runtimeShell }:
+{ fetchzip, lib, stdenv, jdk8, runtimeShell }:
 
 stdenv.mkDerivation rec {
   version = "5.4.4";
···
 
   meta = {
     description = "Open source GUI replacement for the Java command-line utilities keytool and jarsigner";
-    license = stdenv.lib.licenses.gpl3Only;
-    maintainers = [ stdenv.lib.maintainers.numinit ];
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl3Only;
+    maintainers = [ lib.maintainers.numinit ];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/misc/khard/default.nix

···
-{ stdenv, glibcLocales, python3 }:
+{ lib, stdenv, glibcLocales, python3 }:
 
 python3.pkgs.buildPythonApplication rec {
   version = "0.17.0";
···
   meta = {
     homepage = "https://github.com/scheibler/khard";
     description = "Console carddav client";
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = with stdenv.lib.maintainers; [ matthiasbeyer ];
+    license = lib.licenses.gpl3;
+    maintainers = with lib.maintainers; [ matthiasbeyer ];
   };
 }

pkgs/applications/misc/kiwix/default.nix

···
-{ stdenv, fetchurl, makeWrapper, pkg-config
+{ lib, stdenv, fetchurl, makeWrapper, pkg-config
 , zip, python, zlib, which, icu, libmicrohttpd, lzma, aria2, wget, bc
 , libuuid, libX11, libXext, libXt, libXrender, glib, dbus, dbus-glib
 , gtk2, gdk-pixbuf, pango, cairo, freetype, fontconfig, alsaLib, atk, cmake
 , xapian, ctpp2, zimlib
 }:
 
-with stdenv.lib;
+with lib;
 
 let
   xulrunner64_tar = fetchurl {

pkgs/applications/misc/koreader/default.nix

···
     done
     ln -s "${font-droid}/share/fonts/opentype/NerdFonts/Droid Sans Mono Nerd Font Complete Mono.otf" $out/lib/koreader/fonts/droid/DroidSansMono.ttf
     wrapProgram $out/bin/koreader --prefix LD_LIBRARY_PATH : ${
-      stdenv.lib.makeLibraryPath [ gtk3-x11 SDL2 glib ]
+      lib.makeLibraryPath [ gtk3-x11 SDL2 glib ]
     }
   '';
 

pkgs/applications/misc/masterpdfeditor4/default.nix

···
     runHook postInstall
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Master PDF Editor - version 4, without watermark";
     homepage = "https://code-industry.net/free-pdf-editor/";
     license = licenses.unfreeRedistributable;

pkgs/applications/misc/memo/default.nix

···
-{ fetchFromGitHub, silver-searcher, tree, man, stdenv,
+{ fetchFromGitHub, silver-searcher, tree, man, lib, stdenv,
   git,
   pandocSupport ? true, pandoc ? null
   , ... }:
···
     '';
     homepage = "http://palovandalo.com/memo/";
     downloadPage = "https://github.com/mrVanDalo/memo/releases";
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = [ stdenv.lib.maintainers.mrVanDalo ];
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.gpl3;
+    maintainers = [ lib.maintainers.mrVanDalo ];
+    platforms = lib.platforms.all;
   };
 }

pkgs/applications/misc/milu/default.nix

···
-{ stdenv, fetchFromGitHub, unzip, pkgconfig, glib, llvmPackages }:
+{ lib, stdenv, fetchFromGitHub, unzip, pkgconfig, glib, llvmPackages }:
 
 stdenv.mkDerivation {
   pname = "milu-nightly";
···
   meta = {
     description = "Higher Order Mutation Testing Tool for C and C++ programs";
     homepage = "https://github.com/yuejia/Milu";
-    license = stdenv.lib.licenses.bsd2;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.vrthra ];
+    license = lib.licenses.bsd2;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.vrthra ];
   };
 }
 

pkgs/applications/misc/minergate-cli/default.nix

···
     interpreter=${stdenv.glibc}/lib/ld-linux-x86-64.so.2
     patchelf --set-interpreter "$interpreter" $pgm
 
-    wrapProgram $pgm --prefix LD_LIBRARY_PATH : ${stdenv.lib.makeLibraryPath [ openssl stdenv.cc.cc ]}
+    wrapProgram $pgm --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ openssl stdenv.cc.cc ]}
 
     rm $out/usr/bin/minergate-cli
     mkdir -p $out/bin

pkgs/applications/misc/minergate/default.nix

···
     interpreter=${stdenv.glibc}/lib/ld-linux-x86-64.so.2
     patchelf --set-interpreter "$interpreter" $pgm
 
-    wrapProgram $pgm --prefix LD_LIBRARY_PATH : ${stdenv.lib.makeLibraryPath [ fontconfig freetype openssl stdenv.cc.cc xorg.libX11 xorg.libxcb ]} --prefix "QT_XKB_CONFIG_ROOT" ":" "${xkeyboard_config}/share/X11/xkb"
+    wrapProgram $pgm --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ fontconfig freetype openssl stdenv.cc.cc xorg.libX11 xorg.libxcb ]} --prefix "QT_XKB_CONFIG_ROOT" ":" "${xkeyboard_config}/share/X11/xkb"
 
     rm $out/usr/bin/minergate
     mkdir -p $out/bin

pkgs/applications/misc/mkgmap/default.nix

···
     cp ${fastutil} lib/compile/${fastutil.name}
     cp ${osmpbf} lib/compile/${osmpbf.name}
     cp ${protobuf} lib/compile/${protobuf.name}
-  '' + stdenv.lib.optionalString doCheck ''
+  '' + lib.optionalString doCheck ''
     mkdir -p lib/test
     cp ${fastutil} lib/test/${fastutil.name}
     cp ${osmpbf} lib/test/${osmpbf.name}
···
     cp ${hamcrest-core} lib/test/${hamcrest-core.name}
 
     mkdir -p test/resources/in/img
-    ${stdenv.lib.concatMapStringsSep "\n" (res: ''
+    ${lib.concatMapStringsSep "\n" (res: ''
       cp ${res} test/resources/in/${builtins.replaceStrings [ "__" ] [ "/" ] res.name}
     '') testInputs}
   '';
···
     cp -r dist/lib/ $out/share/java/mkgmap/
     makeWrapper ${jre}/bin/java $out/bin/mkgmap \
       --add-flags "-jar $out/share/java/mkgmap/mkgmap.jar"
-  '' + stdenv.lib.optionalString withExamples ''
+  '' + lib.optionalString withExamples ''
     mkdir -p $out/share/mkgmap
     cp -r dist/examples $out/share/mkgmap/
   '';

pkgs/applications/misc/mkgmap/splitter/default.nix

···
     cp ${osmpbf} lib/compile/${osmpbf.name}
     cp ${protobuf} lib/compile/${protobuf.name}
     cp ${xpp3} lib/compile/${xpp3.name}
-  '' + stdenv.lib.optionalString doCheck ''
+  '' + lib.optionalString doCheck ''
     mkdir -p lib/test
     cp ${junit} lib/test/${junit.name}
     cp ${hamcrest-core} lib/test/${hamcrest-core.name}
 
     mkdir -p test/resources/in/osm
-    ${stdenv.lib.concatMapStringsSep "\n" (res: ''
+    ${lib.concatMapStringsSep "\n" (res: ''
       cp ${res} test/resources/in/${builtins.replaceStrings [ "__" ] [ "/" ] res.name}
     '') testInputs}
   '';

pkgs/applications/misc/multibootusb/default.nix

···
       --prefix "PYTHONPATH" ":" "$out/lib/${python36Packages.python.libPrefix}/site-packages"
 
       # Add some runtime dependencies
-      --prefix "PATH" ":" "${stdenv.lib.makeBinPath runTimeDeps}"
+      --prefix "PATH" ":" "${lib.makeBinPath runTimeDeps}"
 
       # Finally, move to directory that contains data
       --run "cd $out/share/${pname}"

pkgs/applications/misc/mupdf/1.17.nix

···
 
   patches =
     # Use shared libraries to decrease size
-    stdenv.lib.optional (!stdenv.isDarwin) ./mupdf-1.14-shared_libs.patch
-    ++ stdenv.lib.optional stdenv.isDarwin ./darwin.patch
+    lib.optional (!stdenv.isDarwin) ./mupdf-1.14-shared_libs.patch
+    ++ lib.optional stdenv.isDarwin ./darwin.patch
   ;
 
   postPatch = ''

pkgs/applications/misc/mupdf/default.nix

···
   };
 
   patches =
-    stdenv.lib.optional stdenv.isDarwin ./darwin.patch ++ [
+    lib.optional stdenv.isDarwin ./darwin.patch ++ [
     (fetchpatch {
         name = "pdfocr.patch";
         url = "http://git.ghostscript.com/?p=mupdf.git;a=patch;h=a507b139adf37d2c742e039815601cdc2aa00a84";

pkgs/applications/misc/nanoblogger/default.nix

···
-{ fetchurl, stdenv, bash }:
+{ fetchurl, lib, stdenv, bash }:
 
 stdenv.mkDerivation rec {
   version = "3.5-rc1";
···
   meta = {
     description = "Small weblog engine written in Bash for the command line";
     homepage = "http://nanoblogger.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/misc/navipowm/default.nix

···
-{ stdenv, fetchurl, qt4, qmake4Hook }:
+{ lib, stdenv, fetchurl, qt4, qmake4Hook }:
 stdenv.mkDerivation rec {
   name = "navipowm-0.2.4";
 
···
   meta = {
     homepage = "http://navipowm.sourceforge.net/";
     description = "Car navigation system";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ ];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ ];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/misc/navit/default.nix

···
-{ stdenv, fetchFromGitHub, pkgconfig, gtk2, fontconfig, freetype, imlib2
+{ lib, stdenv, fetchFromGitHub, pkgconfig, gtk2, fontconfig, freetype, imlib2
 , SDL_image, libGLU, libGL, libXmu, freeglut, pcre, dbus, dbus-glib, glib
 , librsvg, freeimage, libxslt, cairo, gdk-pixbuf, pango
 , atk, patchelf, fetchurl, bzip2, python, gettext, quesoglc
···
 
 assert speechdSupport -> speechd != null;
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   pname = "navit";
   version = "0.5.3";
···
   '';
 
   # TODO: fix upstream?
-  libPath = stdenv.lib.makeLibraryPath ([ stdenv.cc.libc ] ++ buildInputs );
+  libPath = lib.makeLibraryPath ([ stdenv.cc.libc ] ++ buildInputs );
   postFixup =
   ''
     find "$out/lib" -type f -name "*.so" -exec patchelf --set-rpath $libPath {} \;

pkgs/applications/misc/nnn/default.nix

···
-{ stdenv, fetchFromGitHub, pkgconfig, ncurses, readline, conf ? null }:
+{ lib, stdenv, fetchFromGitHub, pkgconfig, ncurses, readline, conf ? null }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "nnn";

pkgs/applications/misc/noice/default.nix

···
-{ stdenv, fetchgit, ncurses, conf ? null }:
+{ lib, stdenv, fetchgit, ncurses, conf ? null }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "noice";

pkgs/applications/misc/nrsc5/default.nix

···
   meta = with lib; {
     homepage = "https://github.com/theori-io/nrsc5";
     description = "HD-Radio decoder for RTL-SDR";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
     license = licenses.gpl3;
     maintainers = with maintainers; [ markuskowa ];
   };

pkgs/applications/misc/obinskit/default.nix

···
   postFixup = ''
     makeWrapper ${electron}/bin/electron $out/bin/${pname} \
       --add-flags $out/opt/obinskit/resources/app.asar \
-      --prefix LD_LIBRARY_PATH : "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc.lib libxkbcommon (lib.getLib systemd) xorg.libXt ]}"
+      --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ stdenv.cc.cc.lib libxkbcommon (lib.getLib systemd) xorg.libXt ]}"
   '';
 
   meta = with lib; {

pkgs/applications/misc/ocropus/default.nix

···
 
   enableParallelBuilding = true;
 
-  preConfigure = with stdenv.lib; ''
+  preConfigure = with lib; ''
     ${concatStrings (map (x: "cp -R ${x.src} models/`basename ${x.name}`;")
       models)}
 

pkgs/applications/misc/onboard/default.nix

···
     udev
     xorg.libXtst
     xorg.libxkbfile
-  ] ++ stdenv.lib.optional atspiSupport at-spi2-core;
+  ] ++ lib.optional atspiSupport at-spi2-core;
 
   propagatedBuildInputs = with python3.pkgs; [
     dbus-python

pkgs/applications/misc/openbox-menu/default.nix

···
-{ stdenv, fetchurl, pkgconfig, glib, gtk2, menu-cache }:
+{ lib, stdenv, fetchurl, pkgconfig, glib, gtk2, menu-cache }:
 
 stdenv.mkDerivation rec {
   pname = "openbox-menu";
···
       dynamic menu listing installed applications. Most of the work is done by
       the LXDE library menu-cache.
     '';
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = [ stdenv.lib.maintainers.romildo ];
-    platforms   = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl3;
+    maintainers = [ lib.maintainers.romildo ];
+    platforms   = lib.platforms.unix;
   };
 }

pkgs/applications/misc/openbrf/default.nix

···
     install -Dm644 reference.brf $out/share/openBrf/reference.brf
 
     patchelf  \
-      --set-rpath "${stdenv.lib.makeLibraryPath [ qtbase glew stdenv.cc.cc libGLU libGL ]}" \
+      --set-rpath "${lib.makeLibraryPath [ qtbase glew stdenv.cc.cc libGLU libGL ]}" \
       $out/share/openBrf/openBrf
 
     mkdir -p "$out/bin"
···
   meta = with lib; {
     description = "A tool to edit resource files (BRF)";
     homepage = "https://github.com/cfcohen/openbrf";
-    maintainers = with stdenv.lib.maintainers; [ abbradar ];
+    maintainers = with lib.maintainers; [ abbradar ];
     license = licenses.free;
     platforms = platforms.linux;
   };

pkgs/applications/misc/opencpn/default.nix

···
-{ stdenv, fetchFromGitHub, pkg-config, cmake, gtk2, wxGTK30, libpulseaudio, curl,
+{ lib, stdenv, fetchFromGitHub, pkg-config, cmake, gtk2, wxGTK30, libpulseaudio, curl,
   gettext, glib, portaudio }:
 
 stdenv.mkDerivation rec {
···
 
   meta = {
     description = "A concise ChartPlotter/Navigator";
-    maintainers = [ stdenv.lib.maintainers.kragniz ];
+    maintainers = [ lib.maintainers.kragniz ];
     platforms = [ "x86_64-linux" ];
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     homepage = "https://opencpn.org/";
   };
 }

pkgs/applications/misc/openjump/default.nix

···
-{ stdenv, fetchurl, unzip, makeWrapper
+{ lib, stdenv, fetchurl, unzip, makeWrapper
 , coreutils, gawk, which, gnugrep, findutils
 , jdk
 }:
···
   meta = {
     description = "Open source Geographic Information System (GIS) written in the Java programming language";
     homepage = "http://www.openjump.org/index.html";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [stdenv.lib.maintainers.marcweber];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = [lib.maintainers.marcweber];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/orca/default.nix

···
   format = "other";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "UAX/LhHdH3E/WswZA6JwEZvFjDD9uMn4K8rHFJfGwjw=";
   };
 

pkgs/applications/misc/osm2xmap/default.nix

···
     description = "Converter from OpenStreetMap data format to OpenOrienteering Mapper format";
     license = licenses.gpl3;
     maintainers = [ maintainers.mpickering ];
-    platforms = with stdenv.lib.platforms; linux;
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/misc/pass-secret-service/default.nix

···
-{ stdenv, fetchFromGitHub, python3, dbus, gnupg }:
+{ lib, stdenv, fetchFromGitHub, python3, dbus, gnupg }:
 
 python3.pkgs.buildPythonApplication rec {
   pname = "pass-secret-service";
···
   meta = {
     description = "Libsecret D-Bus API with pass as the backend";
     homepage = "https://github.com/mdellweg/pass_secret_service/";
-    license = stdenv.lib.licenses.gpl3Only;
-    platforms = stdenv.lib.platforms.all;
-    maintainers = with stdenv.lib.maintainers; [ jluttine ];
+    license = lib.licenses.gpl3Only;
+    platforms = lib.platforms.all;
+    maintainers = with lib.maintainers; [ jluttine ];
   };
 }

pkgs/applications/misc/pastel/default.nix

···
 
   cargoSha256 = "1ji64h0f8f2sq12cx33kymypzar9swhaj903gclf3jdwgna77326";
 
-  buildInputs = stdenv.lib.optional stdenv.isDarwin Security;
+  buildInputs = lib.optional stdenv.isDarwin Security;
 
   meta = with lib; {
     description = "A command-line tool to generate, analyze, convert and manipulate colors";

pkgs/applications/misc/pcmanfm/default.nix

···
 let
   libfm' = libfm.override { inherit withGtk3; };
   gtk = if withGtk3 then gtk3 else gtk2;
-  inherit (stdenv.lib) optional;
+  inherit (lib) optional;
 in
 stdenv.mkDerivation rec {
   name = "pcmanfm-1.3.1";

pkgs/applications/misc/pdfmod/default.nix

···
   version = "0.9.1";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.bz2";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.bz2";
     sha256 = "eb7c987514a053106ddf03f26544766c751c801d87762909b36415d46bc425c9";
   };
 

pkgs/applications/misc/pdfpc/default.nix

···
     json-glib
   ];
 
-  cmakeFlags = stdenv.lib.optional stdenv.isDarwin "-DMOVIES=OFF";
+  cmakeFlags = lib.optional stdenv.isDarwin "-DMOVIES=OFF";
 
   meta = with lib; {
     description = "A presenter console with multi-monitor support for PDF files";

pkgs/applications/misc/phwmon/default.nix

···
-{ stdenv, fetchFromGitLab, pythonPackages }:
+{ lib, stdenv, fetchFromGitLab, pythonPackages }:
 
 stdenv.mkDerivation {
   pname = "phwmon";
···
   meta = {
     homepage = "https://gitlab.com/o9000/phwmon";
     description = "Hardware monitor (CPU, memory, network and disk I/O) for the system tray";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.romildo ];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.romildo ];
   };
 }

pkgs/applications/misc/playonlinux/default.nix

···
 let
   version = "4.4";
 
-  binpath = stdenv.lib.makeBinPath [
+  binpath = lib.makeBinPath [
     cabextract
     python
     gettext
···
     else if stdenv.hostPlatform.system == "i686-linux" then "${stdenv.cc}/nix-support/dynamic-linker"
     else throw "Unsupported platform for PlayOnLinux: ${stdenv.hostPlatform.system}";
   ld64 = "${stdenv.cc}/nix-support/dynamic-linker";
-  libs = pkgs: stdenv.lib.makeLibraryPath [ xorg.libX11 libGL ];
+  libs = pkgs: lib.makeLibraryPath [ xorg.libX11 libGL ];
 
   python = python2.withPackages(ps: with ps; [
     wxPython

pkgs/applications/misc/polar-bookshelf/default.nix

···
   meta = {
     homepage = "https://getpolarized.io/";
     description = "Personal knowledge repository for PDF and web content supporting incremental reading and document annotation";
-    license = stdenv.lib.licenses.gpl3;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.noneucat ];
+    license = lib.licenses.gpl3;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.noneucat ];
   };
 
 }

pkgs/applications/misc/pt/gemset.nix

···
     };
     version = "1.0.5";
   };
-}
+}

pkgs/applications/misc/qpdfview/default.nix

···
-{stdenv, mkDerivation, fetchurl, qmake, qtbase, qtsvg, pkgconfig, poppler, djvulibre, libspectre, cups
+{lib, stdenv, mkDerivation, fetchurl, qmake, qtbase, qtsvg, pkgconfig, poppler, djvulibre, libspectre, cups
 , file, ghostscript
 }:
 let
···
   meta = {
     inherit (s) version;
     description = "A tabbed document viewer";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.linux;
     homepage = "https://launchpad.net/qpdfview";
     updateWalker = true;
   };

pkgs/applications/misc/qt-video-wlr/default.nix

···
 { stdenv, lib, fetchFromGitHub, pkg-config, meson, ninja, wayland, pixman, cairo, librsvg, wayland-protocols, wlroots, libxkbcommon, gst_all_1, wrapQtAppsHook, qtbase, qtmultimedia }:
 let
- gstreamerPath = with gst_all_1; stdenv.lib.makeSearchPath "lib/gstreamer-1.0" [
+ gstreamerPath = with gst_all_1; lib.makeSearchPath "lib/gstreamer-1.0" [
      gstreamer
      gst-plugins-base
      gst-plugins-good

pkgs/applications/misc/quicksynergy/default.nix

···
-{stdenv, fetchurl, pkgconfig, gtk2, synergy}:
+{lib, stdenv, fetchurl, pkgconfig, gtk2, synergy}:
 
 stdenv.mkDerivation rec {
   pname = "quicksynergy";
···
       Remember to open port 24800 (used by synergys program) if you want to
       host mouse and keyboard.";
     homepage = "https://sourceforge.net/projects/quicksynergy/";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [ stdenv.lib.maintainers.spinus ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = [ lib.maintainers.spinus ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/ranger/default.nix

···
 { stdenv, lib, fetchFromGitHub, python3Packages, file, less, highlight
 , imagePreviewSupport ? true, w3m ? null}:
 
-with stdenv.lib;
+with lib;
 
 assert imagePreviewSupport -> w3m != null;
 
···
       --replace "/bin/echo" "echo"
 
     substituteInPlace ranger/__init__.py \
-      --replace "DEFAULT_PAGER = 'less'" "DEFAULT_PAGER = '${stdenv.lib.getBin less}/bin/less'"
+      --replace "DEFAULT_PAGER = 'less'" "DEFAULT_PAGER = '${lib.getBin less}/bin/less'"
 
     for i in ranger/config/rc.conf doc/config/rc.conf ; do
       substituteInPlace $i --replace /usr/share $out/share

pkgs/applications/misc/reddsaver/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , rustPlatform
 , openssl
···
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ openssl ]
-    ++ stdenv.lib.optional stdenv.isDarwin Security;
+    ++ lib.optional stdenv.isDarwin Security;
 
   # package does not contain tests as of v0.2.2
   docCheck = false;
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "CLI tool to download saved images from Reddit";
     homepage = "https://github.com/manojkarthick/reddsaver";
     license = with licenses; [ mit /* or */ asl20 ];

pkgs/applications/misc/redshift/default.nix

···
     stdenv.mkDerivation rec {
       inherit pname version src meta;
 
-      patches = stdenv.lib.optionals (pname != "gammastep") [
+      patches = lib.optionals (pname != "gammastep") [
         # https://github.com/jonls/redshift/pull/575
         ./575.patch
       ];
···
         "--enable-drm=${if withDrm then "yes" else "no"}"
         "--enable-quartz=${if withQuartz then "yes" else "no"}"
         "--enable-corelocation=${if withCoreLocation then "yes" else "no"}"
-      ] ++ stdenv.lib.optionals (pname == "gammastep") [
+      ] ++ lib.optionals (pname == "gammastep") [
         "--with-systemduserunitdir=${placeholder "out"}/share/systemd/user/"
         "--enable-apparmor"
       ];
···
         gobject-introspection
         gtk3
         python
-      ] ++ stdenv.lib.optional  withRandr        libxcb
-        ++ stdenv.lib.optional  withGeoclue      geoclue
-        ++ stdenv.lib.optional  withDrm          libdrm
-        ++ stdenv.lib.optional  withQuartz       ApplicationServices
-        ++ stdenv.lib.optionals withCoreLocation [ CoreLocation Foundation Cocoa ]
-        ++ stdenv.lib.optional  withAppIndicator (if (pname != "gammastep")
+      ] ++ lib.optional  withRandr        libxcb
+        ++ lib.optional  withGeoclue      geoclue
+        ++ lib.optional  withDrm          libdrm
+        ++ lib.optional  withQuartz       ApplicationServices
+        ++ lib.optionals withCoreLocation [ CoreLocation Foundation Cocoa ]
+        ++ lib.optional  withAppIndicator (if (pname != "gammastep")
              then libappindicator
              else libayatana-appindicator)
         ;
···
     meta = redshift.meta // {
       name = "${pname}-${version}";
       longDescription = "Gammastep"
-        + stdenv.lib.removePrefix "Redshift" redshift.meta.longDescription;
+        + lib.removePrefix "Redshift" redshift.meta.longDescription;
       homepage = "https://gitlab.com/chinstrap/gammastep";
-      maintainers = [ stdenv.lib.maintainers.primeos ] ++ redshift.meta.maintainers;
+      maintainers = [ lib.maintainers.primeos ] ++ redshift.meta.maintainers;
     };
   };
 }

pkgs/applications/misc/robo3t/default.nix

···
-{ stdenv, fetchurl, zlib, glib, xorg, dbus, fontconfig, libGL,
+{ lib, stdenv, fetchurl, zlib, glib, xorg, dbus, fontconfig, libGL,
   freetype, xkeyboard_config, makeDesktopItem, makeWrapper }:
 
 stdenv.mkDerivation rec {
···
 
   nativeBuildInputs = [makeWrapper];
 
-  ldLibraryPath = stdenv.lib.makeLibraryPath [
+  ldLibraryPath = lib.makeLibraryPath [
     stdenv.cc.cc
     zlib
     glib
···
     homepage = "https://robomongo.org/";
     description = "Query GUI for mongodb";
     platforms = [ "x86_64-linux" ];
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = [ stdenv.lib.maintainers.eperuffo ];
+    license = lib.licenses.gpl3;
+    maintainers = [ lib.maintainers.eperuffo ];
   };
 }

pkgs/applications/misc/robomongo/default.nix

···
 
   nativeBuildInputs = [makeWrapper];
 
-  ldLibraryPath = stdenv.lib.makeLibraryPath [
+  ldLibraryPath = lib.makeLibraryPath [
     stdenv.cc.cc
     zlib
     glib
···
   meta = {
     homepage = "https://robomongo.org/";
     description = "Query GUI for mongodb";
-    platforms = stdenv.lib.intersectLists stdenv.lib.platforms.linux stdenv.lib.platforms.x86_64;
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = [ stdenv.lib.maintainers.eperuffo ];
+    platforms = lib.intersectLists lib.platforms.linux lib.platforms.x86_64;
+    license = lib.licenses.gpl3;
+    maintainers = [ lib.maintainers.eperuffo ];
   };
 }

pkgs/applications/misc/sbagen/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   name = "sbagen-1.4.4";
···
   meta = {
     description = "Binaural sound generator";
     homepage = "http://uazu.net/sbagen";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     platforms = [ "i686-linux" ];
   };
 }

pkgs/applications/misc/sequelpro/default.nix

···
-{ stdenv, fetchurl, undmg }:
+{ lib, stdenv, fetchurl, undmg }:
 
 stdenv.mkDerivation {
   pname = "sequel-pro";
···
   meta = {
     description = "MySQL database management for macOS";
     homepage = "http://www.sequelpro.com/";
-    license = stdenv.lib.licenses.mit;
-    platforms = stdenv.lib.platforms.darwin;
+    license = lib.licenses.mit;
+    platforms = lib.platforms.darwin;
   };
 }

pkgs/applications/misc/signumone-ks/default.nix

···
-{ stdenv, fetchurl, dpkg, autoPatchelfHook, makeWrapper,
+{ lib, stdenv, fetchurl, dpkg, autoPatchelfHook, makeWrapper,
   atk, ffmpeg, gdk-pixbuf, glibc, gtk3, libav_0_8, libXtst }:
 
 stdenv.mkDerivation rec {
···
     libav_0_8 gtk3 libXtst
   ];
 
-  libPath = stdenv.lib.makeLibraryPath buildInputs;
+  libPath = lib.makeLibraryPath buildInputs;
 
   unpackPhase = ''
     dpkg-deb -x ${src} ./
···
       --prefix LD_LIBRARY_PATH : ${libPath}
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Digital signature tool for Costa Rican electronic invoicing";
     homepage = "https://signum.one/download.html";
     license = licenses.unfree;

pkgs/applications/misc/simplenote/default.nix

···
 
     postFixup = ''
       makeWrapper $out/opt/Simplenote/simplenote $out/bin/simplenote \
-        --prefix LD_LIBRARY_PATH : "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc ] }" \
+        --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ stdenv.cc.cc ] }" \
         "''${gappsWrapperArgs[@]}"
     '';
   };

pkgs/applications/misc/sleepyhead/default.nix

···
     cp sleepyhead/SleepyHead $out/bin
   '';
 
-  postFixup = stdenv.lib.optionalString stdenv.isDarwin ''
+  postFixup = lib.optionalString stdenv.isDarwin ''
     wrapQtApp "$out/Applications/SleepyHead.app/Contents/MacOS/SleepyHead"
   '';
 

pkgs/applications/misc/slmenu/default.nix

···
-{stdenv, fetchhg}:
+{lib, stdenv, fetchhg}:
 let
   s =
   rec {
···
   meta = {
     inherit (s) version;
     description = ''A console dmenu-like tool'';
-    license = stdenv.lib.licenses.mit;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.mit;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/slstatus/default.nix

···
-{ stdenv, fetchgit, pkgconfig, writeText, libX11, conf ? null, patches ? [] }:
+{ lib, stdenv, fetchgit, pkgconfig, writeText, libX11, conf ? null, patches ? [] }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "slstatus";

pkgs/applications/misc/snowsql/default.nix

···
 
   nativeBuildInputs = [ rpmextract makeWrapper ];
 
-  libPath = stdenv.lib.makeLibraryPath [ openssl ];
+  libPath = lib.makeLibraryPath [ openssl ];
 
   buildCommand = ''
     mkdir -p $out/bin/

pkgs/applications/misc/spacefm/default.nix

···
-{ pkgs, fetchFromGitHub, stdenv, gtk3, udev, desktop-file-utils
+{ pkgs, fetchFromGitHub, lib, stdenv, gtk3, udev, desktop-file-utils
 , shared-mime-info, intltool, pkgconfig, wrapGAppsHook, ffmpegthumbnailer
 , jmtpfs, ifuseSupport ? false, ifuse ? null, lsof, udisks2 }:
 
···
   # Introduced because ifuse doesn't build due to CVEs in libplist
   # Revert when libplist builds again…
 
-  meta = with stdenv.lib;  {
+  meta = with lib;  {
     description = "A multi-panel tabbed file manager";
     longDescription = ''
       Multi-panel tabbed file and desktop manager for Linux

pkgs/applications/misc/stag/default.nix

···
-{ stdenv, fetchgit, curses }:
+{ lib, stdenv, fetchgit, curses }:
 
 stdenv.mkDerivation {
   name = "stag-1.0";
···
   meta = {
     homepage = "https://github.com/seenaburns/stag";
     description = "Terminal streaming bar graph passed through stdin";
-    license = stdenv.lib.licenses.bsdOriginal;
-    maintainers = [ stdenv.lib.maintainers.matthiasbeyer ];
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.bsdOriginal;
+    maintainers = [ lib.maintainers.matthiasbeyer ];
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/misc/sweethome3d/default.nix

···
 
   stdenv.mkDerivation rec {
     inherit pname version src description;
-    exec = stdenv.lib.toLower module;
+    exec = lib.toLower module;
     sweethome3dItem = makeDesktopItem {
       inherit exec desktopName;
       name = pname;
···
       homepage = "http://www.sweethome3d.com/index.jsp";
       inherit description;
       inherit license;
-      maintainers = [ stdenv.lib.maintainers.edwtjo ];
-      platforms = stdenv.lib.platforms.linux;
+      maintainers = [ lib.maintainers.edwtjo ];
+      platforms = lib.platforms.linux;
     };
   };
 
-  d2u = stdenv.lib.replaceChars ["."] ["_"];
+  d2u = lib.replaceChars ["."] ["_"];
 
 in {
 
   application = mkSweetHome3D rec {
-    pname = stdenv.lib.toLower module + "-application";
+    pname = lib.toLower module + "-application";
     version = "6.4.2";
     module = "SweetHome3D";
     description = "Design and visualize your future home";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
     src = fetchsvn {
       url = "https://svn.code.sf.net/p/sweethome3d/code/tags/V_" + d2u version + "/SweetHome3D/";
       sha256 = "13rczayakwb5246hqnp8lnw61p0p7ywr2294bnlp4zwsrz1in9z4";

pkgs/applications/misc/sweethome3d/editors.nix

···
-{ stdenv, fetchcvs, makeWrapper, makeDesktopItem, jdk, jre, ant
+{ lib, stdenv, fetchcvs, makeWrapper, makeDesktopItem, jdk, jre, ant
 , gtk3, gsettings-desktop-schemas, sweethome3dApp }:
 
 let
 
-  sweetExec = with stdenv.lib;
+  sweetExec = with lib;
     m: "sweethome3d-"
     + removeSuffix "libraryeditor" (toLower m)
     + "-editor";
···
       homepage = "http://www.sweethome3d.com/index.jsp";
       inherit description;
       inherit license;
-      maintainers = [ stdenv.lib.maintainers.edwtjo ];
-      platforms = stdenv.lib.platforms.linux;
+      maintainers = [ lib.maintainers.edwtjo ];
+      platforms = lib.platforms.linux;
     };
 
   };
 
-  d2u = stdenv.lib.replaceChars ["."] ["_"];
+  d2u = lib.replaceChars ["."] ["_"];
 
 in {
 
···
     module = "TexturesLibraryEditor";
     pname = module;
     description = "Easily create SH3T files and edit the properties of the texture images it contain";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
     src = fetchcvs {
       cvsRoot = ":pserver:[e-mail]:/cvsroot/sweethome3d";
       sha256 = "15wxdns3hc8yq362x0rj53bcxran2iynxznfcb9js85psd94zq7h";
···
     module = "FurnitureLibraryEditor";
     pname = module;
     description = "Quickly create SH3F files and edit the properties of the 3D models it contain";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     src = fetchcvs {
       cvsRoot = ":pserver:[e-mail]:/cvsroot/sweethome3d";
       sha256 = "0rr4nqil1mngak3ds5vz7f1whrgcgzpk6fb0qcr5ljms0jx0ylvs";

pkgs/applications/misc/taskjuggler/2.x/default.nix

···
 
   meta = {
     homepage = "http://www.taskjuggler.org";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     description = "Project management tool";
     longDescription = ''
       TaskJuggler is a modern and powerful, Open Source project management

pkgs/applications/misc/taskjuggler/gemset.nix

···
     };
     version = "1.20.2";
   };
-}
+}

pkgs/applications/misc/taskopen/default.nix

···
     description = "Script for taking notes and open urls with taskwarrior";
     homepage = "https://github.com/ValiValpas/taskopen";
     platforms = platforms.linux;
-    license = stdenv.lib.licenses.free ;
+    license = lib.licenses.free ;
     maintainers = [ maintainers.winpat ];
   };
 }

pkgs/applications/misc/terminal-typeracer/default.nix

···
 
   cargoSha256 = "VSwku0rtQECirCHx2CXe72gCA+p3DdPC4YYwEYu8WfM=";
 
-  buildInputs = [ openssl sqlite ] ++ stdenv.lib.optionals stdenv.isDarwin [ libiconv Security ];
+  buildInputs = [ openssl sqlite ] ++ lib.optionals stdenv.isDarwin [ libiconv Security ];
   nativeBuildInputs = [ pkg-config ];
 
   meta = with lib; {

pkgs/applications/misc/teseq/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 let
   version = "1.1.1";
···
   meta = {
     homepage = "https://www.gnu.org/software/teseq/";
     description = "Escape sequence illuminator";
-    license = stdenv.lib.licenses.gpl3;
+    license = lib.licenses.gpl3;
 
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.vaibhavsagar ];
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.vaibhavsagar ];
   };
 }

pkgs/applications/misc/tomboy/default.nix

···
     homepage = "https://wiki.gnome.org/Apps/Tomboy";
     description = "A simple note-taking application with synchronization";
     platforms = platforms.linux;
-    license = stdenv.lib.licenses.lgpl2;
+    license = lib.licenses.lgpl2;
     maintainers = with maintainers; [ stesie ];
   };
 }

pkgs/applications/misc/tpmmanager/default.nix

···
-{ stdenv, fetchgit, qt4, qmake4Hook, trousers }:
+{ lib, stdenv, fetchgit, qt4, qmake4Hook, trousers }:
 
 stdenv.mkDerivation rec {
   version = "0.8.1";
···
   meta = {
     homepage = "https://projects.sirrix.com/trac/tpmmanager";
     description = "Tool for managing the TPM";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ tstrobel ];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ tstrobel ];
+    platforms = with lib.platforms; linux;
     inherit version;
   };
 }

pkgs/applications/misc/translate-shell/default.nix

···
 
   postInstall = ''
     wrapProgram $out/bin/trans \
-      --prefix PATH : ${stdenv.lib.makeBinPath [
+      --prefix PATH : ${lib.makeBinPath [
         gawk
         curl
         ncurses

pkgs/applications/misc/udevil/default.nix

···
-{ stdenv, fetchurl, intltool, glib, pkgconfig, udev, util-linux, acl }:
+{ lib, stdenv, fetchurl, intltool, glib, pkgconfig, udev, util-linux, acl }:
 stdenv.mkDerivation {
   name = "udevil-0.4.4";
   src = fetchurl {
···
   meta = {
     description = "A command line Linux program which mounts and unmounts removable devices without a password, shows device info, and monitors device changes";
     homepage = "https://ignorantguru.github.io/udevil/";
-    platforms = stdenv.lib.platforms.linux;
-    license = stdenv.lib.licenses.gpl3;
+    platforms = lib.platforms.linux;
+    license = lib.licenses.gpl3;
   };
 }

pkgs/applications/misc/ulauncher/default.nix

···
   '';
 
   preFixup = ''
-    gappsWrapperArgs+=(--prefix PATH : "${stdenv.lib.makeBinPath [ wmctrl ]}")
+    gappsWrapperArgs+=(--prefix PATH : "${lib.makeBinPath [ wmctrl ]}")
   '';
 
   passthru = {

pkgs/applications/misc/upwork/default.nix

···
     libXtst nspr nss libxcb pango systemd libXScrnSaver
   ];
 
-  libPath = stdenv.lib.makeLibraryPath buildInputs;
+  libPath = lib.makeLibraryPath buildInputs;
 
   unpackPhase = ''
     dpkg-deb -x ${src} ./

pkgs/applications/misc/valentina/default.nix

···
-{ mkDerivation, stdenv, fetchhg
+{ mkDerivation, lib, stdenv, fetchhg
 , qmake, qttools
 , qtbase, qtsvg, qtxmlpatterns
 , poppler_utils
 }:
 
-with stdenv.lib;
+with lib;
 
 mkDerivation rec {
   pname = "valentina";

pkgs/applications/misc/veracrypt/default.nix

···
-{ stdenv, fetchurl, fetchpatch, pkgconfig, makeself, yasm, fuse, wxGTK, lvm2 }:
+{ lib, stdenv, fetchurl, fetchpatch, pkgconfig, makeself, yasm, fuse, wxGTK, lvm2 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "veracrypt";

pkgs/applications/misc/viking/default.nix

···
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ makeWrapper intltool gettext gtk2 expat curl gpsd bc file gnome-doc-utils
     libexif libxml2 libxslt scrollkeeper docbook_xml_dtd_412 gexiv2
-  ] ++ stdenv.lib.optional withMapnik mapnik
-    ++ stdenv.lib.optional withGeoClue geoclue2
-    ++ stdenv.lib.optional withMd5Hash nettle
-    ++ stdenv.lib.optional withOAuth liboauth
-    ++ stdenv.lib.optional withMBTiles sqlite;
+  ] ++ lib.optional withMapnik mapnik
+    ++ lib.optional withGeoClue geoclue2
+    ++ lib.optional withMd5Hash nettle
+    ++ lib.optional withOAuth liboauth
+    ++ lib.optional withMBTiles sqlite;
 
   configureFlags = [
     "--disable-scrollkeeper"
-    (stdenv.lib.enableFeature withMapnik "mapnik")
-    (stdenv.lib.enableFeature withGeoClue "geoclue")
-    (stdenv.lib.enableFeature withMd5Hash "nettle")
-    (stdenv.lib.enableFeature withOAuth "oauth")
-    (stdenv.lib.enableFeature withMBTiles "mbtiles")
+    (lib.enableFeature withMapnik "mapnik")
+    (lib.enableFeature withGeoClue "geoclue")
+    (lib.enableFeature withMd5Hash "nettle")
+    (lib.enableFeature withOAuth "oauth")
+    (lib.enableFeature withMBTiles "mbtiles")
   ];
 
   preBuild = ''

pkgs/applications/misc/vue/default.nix

···
-{ stdenv, fetchurl, jre, runtimeShell }:
+{ lib, stdenv, fetchurl, jre, runtimeShell }:
 
 stdenv.mkDerivation rec {
   pname = "vue";
···
 
   meta = {
     description = "Visual Understanding Environment - mind mapping software";
-    maintainers = with stdenv.lib.maintainers; [ raskin ];
-    platforms = with stdenv.lib.platforms; linux;
-    license = stdenv.lib.licenses.free; # Apache License fork, actually
+    maintainers = with lib.maintainers; [ raskin ];
+    platforms = with lib.platforms; linux;
+    license = lib.licenses.free; # Apache License fork, actually
   };
 }

pkgs/applications/misc/waybar/default.nix

···
 
     nativeBuildInputs = [
       meson ninja pkgconfig scdoc wrapGAppsHook cmake
-    ] ++ stdenv.lib.optional withMediaPlayer gobject-introspection;
+    ] ++ lib.optional withMediaPlayer gobject-introspection;
 
-    propagatedBuildInputs = stdenv.lib.optionals withMediaPlayer [
+    propagatedBuildInputs = lib.optionals withMediaPlayer [
       glib
       playerctl
       python38Packages.pygobject3
     ];
     strictDeps = false;
 
-    buildInputs = with stdenv.lib;
+    buildInputs = with lib;
       [ wayland wlroots gtkmm3 libsigcxx jsoncpp fmt spdlog gtk-layer-shell howard-hinnant-date ]
       ++ optional  traySupport  libdbusmenu-gtk3
       ++ optional  pulseSupport libpulseaudio
···
       ++ optional  swaySupport  sway
       ++ optional  mpdSupport   mpd_clientlib;
 
-    mesonFlags = (stdenv.lib.mapAttrsToList
+    mesonFlags = (lib.mapAttrsToList
       (option: enable: "-D${option}=${if enable then "enabled" else "disabled"}")
       {
         dbusmenu-gtk = traySupport;
···
       "-Dsystemd=disabled"
     ];
 
-    preFixup = stdenv.lib.optional withMediaPlayer ''
+    preFixup = lib.optional withMediaPlayer ''
       cp $src/resources/custom_modules/mediaplayer.py $out/bin/waybar-mediaplayer.py
 
       wrapProgram $out/bin/waybar-mediaplayer.py \

pkgs/applications/misc/wego/default.nix

···
-{ stdenv, buildGoPackage, fetchgit }:
+{ lib, stdenv, buildGoPackage, fetchgit }:
 
 buildGoPackage rec {
   pname = "wego";
···
   goDeps = ./deps.nix;
 
   meta = {
-    license = stdenv.lib.licenses.isc;
+    license = lib.licenses.isc;
     homepage = "https://github.com/schachmat/wego";
     description = "Weather app for the terminal";
   };

pkgs/applications/misc/wikicurses/default.nix

···
-{ stdenv, fetchFromGitHub, pythonPackages }:
+{ lib, stdenv, fetchFromGitHub, pythonPackages }:
 
 pythonPackages.buildPythonApplication rec {
   version = "1.4";
···
   meta = {
     description = "A simple curses interface for MediaWiki sites such as Wikipedia";
     homepage = "https://github.com/ids1024/wikicurses/";
-    license = stdenv.lib.licenses.mit;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = with stdenv.lib.maintainers; [ pSub ];
+    license = lib.licenses.mit;
+    platforms = lib.platforms.unix;
+    maintainers = with lib.maintainers; [ pSub ];
   };
 
 }

pkgs/applications/misc/with-shell/default.nix

···
-{ stdenv, fetchFromGitHub }:
+{ lib, stdenv, fetchFromGitHub }:
 stdenv.mkDerivation {
   name = "with-2016-08-20";
   src = fetchFromGitHub {
···
   meta = {
     homepage = "https://github.com/mchav/With";
     description = "Command prefixing for continuous workflow using a single tool";
-    license = stdenv.lib.licenses.asl20;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.asl20;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/misc/wmname/default.nix

···
-{ stdenv, fetchurl, libX11 }:
+{ lib, stdenv, fetchurl, libX11 }:
 
 stdenv.mkDerivation rec {
   name = "wmname-0.1";
···
   meta = {
     description = "Prints or set the window manager name property of the root window";
     homepage = "https://tools.suckless.org/wmname";
-    license = stdenv.lib.licenses.mit;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.mit;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/misc/wordnet/default.nix

···
-{ stdenv, fetchurl, tcl, tk, Cocoa, xlibsWrapper, makeWrapper }:
+{ lib, stdenv, fetchurl, tcl, tk, Cocoa, xlibsWrapper, makeWrapper }:
 
 stdenv.mkDerivation rec {
   version = "3.0";
···
   };
 
   buildInputs = [ tcl tk xlibsWrapper makeWrapper ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ Cocoa ];
+    ++ lib.optionals stdenv.isDarwin [ Cocoa ];
 
   hardeningDisable = [ "format" ];
 
···
       url = "https://wordnet.princeton.edu/license-and-commercial-use";
     };
     maintainers = [ ];
-    platforms = with stdenv.lib.platforms; linux ++ darwin;
+    platforms = with lib.platforms; linux ++ darwin;
   };
 }

pkgs/applications/misc/workrave/default.nix

···
 
   src = fetchFromGitHub {
     sha256 = "0v2mx2idaxlsyv5w66b7pknlill9j9i2gqcs3vq54gak7ix9fj1p";
-    rev = with stdenv.lib;
+    rev = with lib;
       "v" + concatStringsSep "_" (splitVersion version);
     repo = "workrave";
     owner = "rcaelers";

pkgs/applications/misc/xautoclick/default.nix

···
 
   nativeBuildInputs = [ cmake pkg-config ];
   buildInputs = [ libevdev xorg.libXtst ]
-    ++ stdenv.lib.optionals gtkSupport [ gtk3 pcre glib wrapGAppsHook ]
-    ++ stdenv.lib.optionals fltkSupport [ fltk ]
-    ++ stdenv.lib.optionals qtSupport [ qt5.qtbase qt5.wrapQtAppsHook ];
+    ++ lib.optionals gtkSupport [ gtk3 pcre glib wrapGAppsHook ]
+    ++ lib.optionals fltkSupport [ fltk ]
+    ++ lib.optionals qtSupport [ qt5.qtbase qt5.wrapQtAppsHook ];
 
   meta = with lib; {
     description = "Autoclicker application, which enables you to automatically click the left mousebutton";

pkgs/applications/misc/xfe/default.nix

···
-{ stdenv, fetchurl, fox, pkgconfig, gettext, xlibsWrapper, gcc, intltool, file, libpng }:
+{ lib, stdenv, fetchurl, fox, pkgconfig, gettext, xlibsWrapper, gcc, intltool, file, libpng }:
 
 stdenv.mkDerivation rec {
   name = "xfe-1.42";
···
       Xfe aims to be the filemanager of choice for all the Unix addicts!
     '';
     homepage = "https://sourceforge.net/projects/xfe/";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     maintainers = [];
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/xfontsel/default.nix

···
 # at https://www.x.org/releases/individual/.
 # That is why this expression is not inside pkgs.xorg
 
-{stdenv, fetchurl, makeWrapper, libX11, pkgconfig, libXaw}:
+{lib, stdenv, fetchurl, makeWrapper, libX11, pkgconfig, libXaw}:
 stdenv.mkDerivation rec {
   name = "xfontsel-1.0.6";
 
···
   meta = {
     homepage = "https://www.x.org/";
     description = "Allows testing the fonts available in an X server";
-    license = stdenv.lib.licenses.free;
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; linux ++ darwin;
+    license = lib.licenses.free;
+    maintainers = with lib.maintainers; [viric];
+    platforms = with lib.platforms; linux ++ darwin;
   };
 }

pkgs/applications/misc/xpdf/default.nix

···
   # Fix "No known features for CXX compiler", see
   # https://cmake.org/pipermail/cmake/2016-December/064733.html and the note at
   # https://cmake.org/cmake/help/v3.10/command/cmake_minimum_required.html
-  patches = stdenv.lib.optional stdenv.isDarwin  ./cmake_version.patch;
+  patches = lib.optional stdenv.isDarwin  ./cmake_version.patch;
 
   nativeBuildInputs =
     [ cmake ]
-    ++ stdenv.lib.optional enableGUI wrapQtAppsHook;
+    ++ lib.optional enableGUI wrapQtAppsHook;
 
   cmakeFlags = ["-DSYSTEM_XPDFRC=/etc/xpdfrc" "-DA4_PAPER=ON" "-DOPI_SUPPORT=ON"]
-    ++ stdenv.lib.optional (!enablePrinting) "-DXPDFWIDGET_PRINTING=OFF";
+    ++ lib.optional (!enablePrinting) "-DXPDFWIDGET_PRINTING=OFF";
 
   buildInputs = [ zlib libpng ] ++
-    stdenv.lib.optional enableGUI qtbase ++
-    stdenv.lib.optional enablePrinting cups ++
-    stdenv.lib.optional enablePDFtoPPM freetype;
+    lib.optional enableGUI qtbase ++
+    lib.optional enablePrinting cups ++
+    lib.optional enablePDFtoPPM freetype;
 
   hardeningDisable = [ "format" ];
 

pkgs/applications/misc/xrandr-invert-colors/default.nix

···
 
   meta = with lib; {
     description = "Inverts the colors of your screen";
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
     homepage = "https://github.com/zoltanp/xrandr-invert-colors";
-    maintainers = [stdenv.lib.maintainers.magnetophon ];
+    maintainers = [lib.maintainers.magnetophon ];
     platforms = platforms.linux;
   };
 }

pkgs/applications/misc/xrq/default.nix

···
-{ stdenv, fetchFromGitHub, libX11}:
+{ lib, stdenv, fetchFromGitHub, libX11}:
 
 stdenv.mkDerivation {
   name = "xrq-unstable-2016-01-15";
 
   src = fetchFromGitHub {
-	  owner = "arianon";
-	  repo = "xrq";
+    owner = "arianon";
+    repo = "xrq";
     rev = "d5dc19c63881ebdd1287a02968e3a1447dde14a9";
     sha256 = "1bxf6h3fjw3kjraz7028m7p229l423y1ngy88lqvf0xl1g3dhp36";
   };
···
   meta = {
     description = "X utility for querying xrdb";
     homepage = "https://github.com/arianon/xrq";
-    license = stdenv.lib.licenses.mit;
-    platforms = with stdenv.lib.platforms; unix;
+    license = lib.licenses.mit;
+    platforms = with lib.platforms; unix;
   };
 }

pkgs/applications/misc/xxkb/default.nix

···
-{ stdenv, fetchurl, libX11, libXt, libXext, libXpm, imake, gccmakedep
+{ lib, stdenv, fetchurl, libX11, libXt, libXext, libXpm, imake, gccmakedep
 , svgSupport ? false, librsvg, glib, gdk-pixbuf, pkgconfig
 }:
 
···
   nativeBuildInputs = [ imake gccmakedep ];
   buildInputs = [
     libX11 libXt libXext libXpm
-  ] ++ stdenv.lib.optionals svgSupport [ librsvg glib gdk-pixbuf pkgconfig ];
+  ] ++ lib.optionals svgSupport [ librsvg glib gdk-pixbuf pkgconfig ];
 
   outputs = [ "out" "man" ];
 
-  imakeFlags = stdenv.lib.optionalString svgSupport "-DWITH_SVG_SUPPORT";
+  imakeFlags = lib.optionalString svgSupport "-DWITH_SVG_SUPPORT";
 
   makeFlags = [
     "BINDIR=${placeholder "out"}/bin"
···
   meta = {
     description = "A keyboard layout indicator and switcher";
     homepage = "http://xxkb.sourceforge.net/";
-    license = stdenv.lib.licenses.artistic2;
-    maintainers = with stdenv.lib.maintainers; [ rasendubi ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.artistic2;
+    maintainers = with lib.maintainers; [ rasendubi ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/misc/xygrib/default.nix

···
   nativeBuildInputs = [ cmake qttools wrapQtAppsHook ];
   buildInputs = [ bzip2 qtbase libnova proj openjpeg libpng ];
   cmakeFlags = [ "-DOPENJPEG_INCLUDE_DIR=${openjpeg.dev}/include/openjpeg-2.3" ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ "-DLIBNOVA_LIBRARY=${libnova}/lib/libnova.dylib" ];
+    ++ lib.optionals stdenv.isDarwin [ "-DLIBNOVA_LIBRARY=${libnova}/lib/libnova.dylib" ];
 
   postInstall = if stdenv.isDarwin then ''
     mkdir -p "$out/Applications" "$out/XyGrib/XyGrib.app/Contents/Resources"

pkgs/applications/misc/yubioath-desktop/default.nix

···
       --prefix PYTHONPATH : "$program_PYTHONPATH" \
       --prefix QML2_IMPORT_PATH : "${pyotherside}/${qtbase.qtQmlPrefix}" \
       --prefix LD_PRELOAD : "${yubikey-personalization}/lib/libykpers-1.so" \
-      --prefix LD_LIBRARY_PATH : "${stdenv.lib.getLib pcsclite}/lib:${yubikey-personalization}/lib"
+      --prefix LD_LIBRARY_PATH : "${lib.getLib pcsclite}/lib:${yubikey-personalization}/lib"
 
       mkdir -p $out/share/applications
       cp resources/com.yubico.yubioath.desktop \
···
     downloadPage = "https://developers.yubico.com/yubioath-desktop/Releases/";
     changelog = "https://developers.yubico.com/yubioath-desktop/Release_Notes.html";
 
-    license = stdenv.lib.licenses.bsd2;
+    license = lib.licenses.bsd2;
     maintainers = with maintainers; [ mic92 risson ];
   };
 }

pkgs/applications/misc/zathura/core/default.nix

···
-{ stdenv, fetchurl, meson, ninja, wrapGAppsHook, pkgconfig
+{ lib, stdenv, fetchurl, meson, ninja, wrapGAppsHook, pkgconfig
 , appstream-glib, desktop-file-utils, python3
 , gtk, girara, gettext, libxml2, check
 , sqlite, glib, texlive, libintl, libseccomp
···
 , gtk-mac-integration
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "zathura";

pkgs/applications/misc/zk-shell/default.nix

···
-{ stdenv, fetchFromGitHub, pythonPackages }:
+{ lib, stdenv, fetchFromGitHub, pythonPackages }:
 
 pythonPackages.buildPythonApplication rec {
   version = "1.0.0";
···
   meta = {
     description = "A powerful & scriptable shell for Apache ZooKeeper";
     homepage = "https://github.com/rgs1/zk_shell";
-    license = stdenv.lib.licenses.asl20;
-    maintainers = [ stdenv.lib.maintainers.mahe ];
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.asl20;
+    maintainers = [ lib.maintainers.mahe ];
+    platforms = lib.platforms.all;
   };
 }

pkgs/applications/misc/zola/default.nix

···
 
   nativeBuildInputs = [ cmake pkg-config ];
   buildInputs = [ openssl oniguruma ]
-    ++ stdenv.lib.optional stdenv.isDarwin CoreServices;
+    ++ lib.optional stdenv.isDarwin CoreServices;
 
   RUSTONIG_SYSTEM_LIBONIG = true;
 

pkgs/applications/networking/browsers/firefox/wrapper.nix

···
         desktopName = "${desktopName}${nameSuffix}${lib.optionalString forceWayland " (Wayland)"}";
         genericName = "Web Browser";
         categories = "Network;WebBrowser;";
-        mimeType = stdenv.lib.concatStringsSep ";" [
+        mimeType = lib.concatStringsSep ";" [
           "text/html"
           "text/xml"
           "application/xhtml+xml"

pkgs/applications/networking/browsers/google-chrome/default.nix

···
-{ stdenv, patchelf, makeWrapper
+{ lib, stdenv, patchelf, makeWrapper
 
 # Linked dynamic libraries.
 , glib, fontconfig, freetype, pango, cairo, libX11, libXi, atk, gconf, nss, nspr
···
 , gnome3
 }:
 
-with stdenv.lib;
+with lib;
 
 let
   opusWithCustomModes = libopus.override {

pkgs/applications/networking/browsers/lynx/default.nix

···
     "--enable-default-colors"
     "--enable-widec"
     "--enable-ipv6"
-  ] ++ stdenv.lib.optional sslSupport "--with-ssl";
+  ] ++ lib.optional sslSupport "--with-ssl";
 
   depsBuildBuild = [ buildPackages.stdenv.cc ];
   nativeBuildInputs = [ nukeReferences ]
-    ++ stdenv.lib.optional sslSupport pkgconfig;
+    ++ lib.optional sslSupport pkgconfig;
 
-  buildInputs = [ ncurses gzip ] ++ stdenv.lib.optional sslSupport openssl.dev;
+  buildInputs = [ ncurses gzip ] ++ lib.optional sslSupport openssl.dev;
 
   # cfg_defs.h captures lots of references to build-only dependencies, derived
   # from config.cache.

pkgs/applications/networking/browsers/w3m/default.nix

···
-{ stdenv, fetchFromGitHub, fetchpatch
+{ lib, stdenv, fetchFromGitHub, fetchpatch
 , ncurses, boehmgc, gettext, zlib
 , sslSupport ? true, openssl ? null
 , graphicsSupport ? !stdenv.isDarwin, imlib2 ? null
···
 assert x11Support -> graphicsSupport && libX11 != null;
 assert mouseSupport -> gpm-ncurses != null;
 
-with stdenv.lib;
+with lib;
 
 let
   mktable = buildPackages.stdenv.mkDerivation {
···
     homepage = "http://w3m.sourceforge.net/";
     description = "A text-mode web browser";
     maintainers = [ maintainers.cstrahan ];
-    platforms = stdenv.lib.platforms.unix;
-    license = stdenv.lib.licenses.mit;
+    platforms = lib.platforms.unix;
+    license = lib.licenses.mit;
   };
 }

pkgs/applications/networking/cawbird/default.nix

···
     homepage = "https://ibboard.co.uk/cawbird/";
     license = licenses.gpl3;
     platforms = platforms.linux;
-    maintainers = with stdenv.lib.maintainers; [ jonafato schmittlauch ];
+    maintainers = with lib.maintainers; [ jonafato schmittlauch ];
   };
 }

pkgs/applications/networking/cluster/click/default.nix

···
 
   cargoSha256 = "1f9yn4pvp58laylngdrfdkwygisnzkhkm7pndf6l33k3aqxhz5mm";
 
-  buildInputs = stdenv.lib.optionals stdenv.isDarwin [ darwin.apple_sdk.frameworks.Security ];
+  buildInputs = lib.optionals stdenv.isDarwin [ darwin.apple_sdk.frameworks.Security ];
 
   meta = with lib; {
     description = ''The "Command Line Interactive Controller for Kubernetes"'';

pkgs/applications/networking/cluster/hadoop/default.nix

···
           inherit sha256;
         };
 
-        postUnpack = stdenv.lib.optionalString (tomcat != null) ''
+        postUnpack = lib.optionalString (tomcat != null) ''
           install -D ${tomcat.src} $sourceRoot/hadoop-hdfs-project/hadoop-hdfs-httpfs/downloads/apache-tomcat-${tomcat.version}.tar.gz
           install -D ${tomcat.src} $sourceRoot/hadoop-common-project/hadoop-kms/downloads/apache-tomcat-${tomcat.version}.tar.gz
         '';
···
           # 'maven.repo.local' must be writable
           mvn package --offline -Dmaven.repo.local=$(cp -dpR ${fetched-maven-deps}/.m2 ./ && chmod +w -R .m2 && pwd)/.m2 ${mavenFlags}
           # remove runtime dependency on $jdk/jre/lib/amd64/server/libjvm.so
-          patchelf --set-rpath ${stdenv.lib.makeLibraryPath [glibc]} hadoop-dist/target/hadoop-${version}/lib/native/libhadoop.so.1.0.0
-          patchelf --set-rpath ${stdenv.lib.makeLibraryPath [glibc]} hadoop-dist/target/hadoop-${version}/lib/native/libhdfs.so.0.0.0
+          patchelf --set-rpath ${lib.makeLibraryPath [glibc]} hadoop-dist/target/hadoop-${version}/lib/native/libhadoop.so.1.0.0
+          patchelf --set-rpath ${lib.makeLibraryPath [glibc]} hadoop-dist/target/hadoop-${version}/lib/native/libhdfs.so.0.0.0
         '';
         installPhase = "mv hadoop-dist/target/hadoop-${version} $out";
       };
···
             if [ -f "$n" ]; then # only regular files
               mv $n $out/bin.wrapped/
               makeWrapper $out/bin.wrapped/$(basename $n) $n \
-                --prefix PATH : "${stdenv.lib.makeBinPath [ which jre bash coreutils ]}" \
-                --prefix JAVA_LIBRARY_PATH : "${stdenv.lib.makeLibraryPath [ opensslPkg snappy zlib bzip2 ]}" \
+                --prefix PATH : "${lib.makeBinPath [ which jre bash coreutils ]}" \
+                --prefix JAVA_LIBRARY_PATH : "${lib.makeLibraryPath [ opensslPkg snappy zlib bzip2 ]}" \
                 --set JAVA_HOME "${jre}" \
                 --set HADOOP_PREFIX "$out"
             fi

pkgs/applications/networking/cluster/kanif/default.nix

···
-{ stdenv, fetchurl, perl , taktuk}:
+{ lib, stdenv, fetchurl, perl , taktuk}:
 
 stdenv.mkDerivation rec {
   version = "1.2.2";
···
       remote files or directories locally ('kaget' command). It relies on TakTuk
       for efficiency and scalability.'';
     homepage = "http://taktuk.gforge.inria.fr/kanif";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [ stdenv.lib.maintainers.bzizou ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = [ lib.maintainers.bzizou ];
+    platforms = lib.platforms.linux;
   };
 
 }

pkgs/applications/networking/cluster/kubelogin/default.nix

···
   buildFlagsArray = ''
     -ldflags=
         -X main.version=${version}
-        -X main.goVersion=${stdenv.lib.getVersion go}
+        -X main.goVersion=${lib.getVersion go}
   '';
 
   meta = with lib; {

pkgs/applications/networking/cluster/node-problem-detector/default.nix

···
   # Linux-only feature. See 'ENABLE_JOURNALD' upstream:
   # https://github.com/kubernetes/node-problem-detector/blob/master/Makefile
   subPackages = [ "cmd/nodeproblemdetector" ] ++
-    stdenv.lib.optionals stdenv.isLinux [ "cmd/logcounter" ];
+    lib.optionals stdenv.isLinux [ "cmd/logcounter" ];
 
   preBuild = ''
     export CGO_ENABLED=${if stdenv.isLinux then "1" else "0"}
   '';
 
-  buildInputs = stdenv.lib.optionals stdenv.isLinux [ systemd ];
+  buildInputs = lib.optionals stdenv.isLinux [ systemd ];
 
   buildFlags = "-mod vendor" +
-    stdenv.lib.optionalString stdenv.isLinux " -tags journald";
+    lib.optionalString stdenv.isLinux " -tags journald";
 
   buildFlagsArray = [
     "-ldflags="

pkgs/applications/networking/cluster/openshift/default.nix

···
 
 let
   version = "4.1.0";
-  ver = stdenv.lib.elemAt (stdenv.lib.splitVersion version);
+  ver = lib.elemAt (lib.splitVersion version);
   versionMajor = ver 0;
   versionMinor = ver 1;
   versionPatch = ver 2;

pkgs/applications/networking/cluster/pig/default.nix

···
 
     for n in $out/{bin,sbin}"/"*; do
       wrapProgram $n \
-        --prefix PATH : "${stdenv.lib.makeBinPath [ jre bash ]}" \
+        --prefix PATH : "${lib.makeBinPath [ jre bash ]}" \
         --set JAVA_HOME "${jre}" --set HADOOP_PREFIX "${hadoop}"
     done
   '';

pkgs/applications/networking/cluster/spacegun/node-composition.nix

···
 import ./node-packages.nix {
   inherit (pkgs) fetchurl fetchgit;
   inherit nodeEnv;
-}
+}

pkgs/applications/networking/cluster/spacegun/node-packages.nix

···
     bypassCache = true;
     reconstructLock = true;
   };
-}
+}

pkgs/applications/networking/cluster/spark/default.nix

···
-{ stdenv, fetchzip, makeWrapper, jre, pythonPackages, coreutils, hadoop
+{ lib, stdenv, fetchzip, makeWrapper, jre, pythonPackages, coreutils, hadoop
 , RSupport? true, R
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
 
···
   meta = {
     description      = "Apache Spark is a fast and general engine for large-scale data processing";
     homepage         = "http://spark.apache.org";
-    license          = stdenv.lib.licenses.asl20;
-    platforms        = stdenv.lib.platforms.all;
+    license          = lib.licenses.asl20;
+    platforms        = lib.platforms.all;
     maintainers      = with maintainers; [ thoughtpolice offline kamilchm ];
     repositories.git = "git://git.apache.org/spark.git";
   };

pkgs/applications/networking/cluster/taktuk/default.nix

···
-{ stdenv, fetchurl, perl }:
+{ lib, stdenv, fetchurl, perl }:
 
 stdenv.mkDerivation rec {
   version = "3.7.7";
···
       require any specific software on the nodes thanks to a self-propagation
       algorithm.'';
     homepage = "http://taktuk.gforge.inria.fr/";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [ stdenv.lib.maintainers.bzizou ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = [ lib.maintainers.bzizou ];
+    platforms = lib.platforms.linux;
   };
 }
 

pkgs/applications/networking/cluster/terraform-landscape/gemset.nix

···
     };
     version = "1.6.10";
   };
-}
+}

pkgs/applications/networking/enhanced-ctorrent/default.nix

···
-{ stdenv, fetchurl, fetchpatch }:
+{ lib, stdenv, fetchurl, fetchpatch }:
 
 stdenv.mkDerivation {
   version = "3.3.2";
···
       performance enhancements.
     '';
     homepage = "http://www.rahul.net/dholmes/ctorrent/";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.devhell ];
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.devhell ];
   };
 }

pkgs/applications/networking/esniper/default.nix

···
 
   postInstall = ''
     sed <"frontends/snipe" >"$out/bin/snipe" \
-      -e "2i export PATH=\"$out/bin:${stdenv.lib.makeBinPath [ coreutils gawk bash which ]}:\$PATH\""
+      -e "2i export PATH=\"$out/bin:${lib.makeBinPath [ coreutils gawk bash which ]}:\$PATH\""
     chmod 555 "$out/bin/snipe"
   '';
 

pkgs/applications/networking/feedreaders/canto-curses/default.nix

···
-{ stdenv, fetchFromGitHub, python3Packages, readline, ncurses, canto-daemon }:
+{ lib, stdenv, fetchFromGitHub, python3Packages, readline, ncurses, canto-daemon }:
 
 python3Packages.buildPythonApplication rec {
   version = "0.9.9";
···
       and extensibility using the excellent Python programming language.
     '';
     homepage = "https://codezen.org/canto-ng/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.devhell ];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.devhell ];
   };
 }

pkgs/applications/networking/feedreaders/newsboat/default.nix

···
     substituteInPlace Makefile --replace "|| true" ""
   ''
     # TODO: Check if that's still needed
-    + stdenv.lib.optionalString stdenv.isDarwin ''
+    + lib.optionalString stdenv.isDarwin ''
       # Allow other ncurses versions on Darwin
       substituteInPlace config.sh \
         --replace "ncurses5.4" "ncurses"
···
     pkg-config
     asciidoctor
     gettext
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [ makeWrapper ncurses ];
+  ] ++ lib.optionals stdenv.isDarwin [ makeWrapper ncurses ];
 
   buildInputs = [ stfl sqlite curl libxml2 json_c ncurses ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ Security Foundation libiconv gettext ];
+    ++ lib.optionals stdenv.isDarwin [ Security Foundation libiconv gettext ];
 
   postBuild = ''
     make prefix="$out"
   '';
 
   # TODO: Check if that's still needed
-  NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.isDarwin " -Wno-error=format-security";
+  NIX_CFLAGS_COMPILE = lib.optionalString stdenv.isDarwin " -Wno-error=format-security";
 
   # https://github.com/NixOS/nixpkgs/pull/98471#issuecomment-703100014 . We set
   # these for all platforms, since upstream's gettext crate behavior might
   # change in the future.
-  GETTEXT_LIB_DIR = "${stdenv.lib.getLib gettext}/lib";
-  GETTEXT_INCLUDE_DIR = "${stdenv.lib.getDev gettext}/include";
-  GETTEXT_BIN_DIR = "${stdenv.lib.getBin gettext}/bin";
+  GETTEXT_LIB_DIR = "${lib.getLib gettext}/lib";
+  GETTEXT_INCLUDE_DIR = "${lib.getDev gettext}/include";
+  GETTEXT_BIN_DIR = "${lib.getBin gettext}/bin";
 
   doCheck = true;
 
···
   postInstall = ''
     make prefix="$out" install
     cp -r contrib $out
-  '' + stdenv.lib.optionalString stdenv.isDarwin ''
+  '' + lib.optionalString stdenv.isDarwin ''
     for prog in $out/bin/*; do
       wrapProgram "$prog" --prefix DYLD_LIBRARY_PATH : "${stfl}/lib"
     done

pkgs/applications/networking/feedreaders/rsstail/default.nix

···
     owner = "flok99";
   };
 
-  buildInputs = [ libmrss ] ++ stdenv.lib.optionals stdenv.isDarwin [ libiconv ];
+  buildInputs = [ libmrss ] ++ lib.optionals stdenv.isDarwin [ libiconv ];
   checkInputs = [ cppcheck ];
 
   postPatch = ''

pkgs/applications/networking/ids/daq/default.nix

···
-{stdenv, fetchurl, flex, bison, libpcap, libdnet, libnfnetlink, libnetfilter_queue}:
+{ lib, stdenv, fetchurl, flex, bison, libpcap, libdnet, libnfnetlink, libnetfilter_queue}:
 
 stdenv.mkDerivation rec {
   name = "daq-2.2.2";
···
   meta = {
     description = "Data AcQuisition library (DAQ), for packet I/O";
     homepage = "https://www.snort.org";
-    maintainers = with stdenv.lib.maintainers; [ aycanirican ];
-    license = stdenv.lib.licenses.gpl2;
-    platforms = with stdenv.lib.platforms; linux;
+    maintainers = with lib.maintainers; [ aycanirican ];
+    license = lib.licenses.gpl2;
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/networking/ids/snort/default.nix

···
-{stdenv, pkgconfig, luajit, openssl, fetchurl, libpcap, pcre, libdnet, daq, zlib, flex, bison, makeWrapper
+{lib, stdenv, pkgconfig, luajit, openssl, fetchurl, libpcap, pcre, libdnet, daq, zlib, flex, bison, makeWrapper
 , libtirpc
 }:
 
···
   meta = {
     description = "Network intrusion prevention and detection system (IDS/IPS)";
     homepage = "https://www.snort.org";
-    maintainers = with stdenv.lib.maintainers; [ aycanirican ];
-    license = stdenv.lib.licenses.gpl2;
-    platforms = with stdenv.lib.platforms; linux;
+    maintainers = with lib.maintainers; [ aycanirican ];
+    license = lib.licenses.gpl2;
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/networking/ids/zeek/default.nix

···
 
   nativeBuildInputs = [ cmake flex bison file ];
   buildInputs = [ openssl libpcap zlib curl libmaxminddb gperftools python swig ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ gettext ];
+    ++ lib.optionals stdenv.isDarwin [ gettext ];
 
   #see issue https://github.com/zeek/zeek/issues/804 to modify hardlinking duplicate files.
   inherit preConfigure;
 
-  patches = stdenv.lib.optionals stdenv.cc.isClang [
+  patches = lib.optionals stdenv.cc.isClang [
     # Fix pybind c++17 build with Clang. See: https://github.com/pybind/pybind11/issues/1604
     (fetchpatch {
       url = "https://github.com/pybind/pybind11/commit/759221f5c56939f59d8f342a41f8e2d2cacbc8cf.patch";

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

···
-{stdenv, fetchurl, zlib, openssl, libre, librem, pkgconfig, gst_all_1
+{ lib, stdenv, fetchurl, zlib, openssl, libre, librem, pkgconfig, gst_all_1
 , cairo, mpg123, alsaLib, SDL, libv4l, celt, libsndfile, srtp, ffmpeg_3
 , gsm, speex, portaudio, spandsp, libuuid, libvpx
 }:
···
     "USE_BV32=" "USE_COREAUDIO=" "USE_G711=1" "USE_G722=1" "USE_G722_1="
     "USE_ILBC=" "USE_OPUS=" "USE_SILK="
   ]
-  ++ stdenv.lib.optional (stdenv.cc.cc != null) "SYSROOT_ALT=${stdenv.cc.cc}"
-  ++ stdenv.lib.optional (stdenv.cc.libc != null) "SYSROOT=${stdenv.cc.libc}"
+  ++ lib.optional (stdenv.cc.cc != null) "SYSROOT_ALT=${stdenv.cc.cc}"
+  ++ lib.optional (stdenv.cc.libc != null) "SYSROOT=${stdenv.cc.libc}"
   ;
 
   NIX_CFLAGS_COMPILE='' -I${librem}/include/rem -I${gsm}/include/gsm
···
     -D__need_timeval -D__need_timespec -D__need_time_t '';
   meta = {
     homepage = "http://www.creytiv.com/baresip.html";
-    platforms = with stdenv.lib.platforms; linux;
-    maintainers = with stdenv.lib.maintainers; [raskin];
-    license = stdenv.lib.licenses.bsd3;
+    platforms = with lib.platforms; linux;
+    maintainers = with lib.maintainers; [raskin];
+    license = lib.licenses.bsd3;
     inherit version;
     downloadPage = "http://www.creytiv.com/pub/";
     updateWalker = true;

pkgs/applications/networking/instant-messengers/bitlbee-discord/default.nix

···
-{ fetchFromGitHub, stdenv, bitlbee, autoreconfHook, pkgconfig, glib }:
+{ lib, fetchFromGitHub, stdenv, bitlbee, autoreconfHook, pkgconfig, glib }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   pname = "bitlbee-discord";
   version = "0.4.3";
···
     homepage = "https://github.com/sm00th/bitlbee-discord";
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ lassulus jb55 ];
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/networking/instant-messengers/bitlbee-facebook/default.nix

···
-{ fetchFromGitHub, stdenv, bitlbee, autoconf, automake, libtool, pkgconfig, glib, json-glib }:
+{ lib, fetchFromGitHub, stdenv, bitlbee, autoconf, automake, libtool, pkgconfig, glib, json-glib }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   pname = "bitlbee-facebook";
   version = "1.2.1";
···
 
     homepage = "https://github.com/bitlbee/bitlbee-facebook";
     license = licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/networking/instant-messengers/bitlbee-mastodon/default.nix

···
-{ fetchgit, stdenv, bitlbee, autoreconfHook, pkgconfig, glib }:
+{ lib, fetchgit, stdenv, bitlbee, autoreconfHook, pkgconfig, glib }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   pname = "bitlbee-mastodon";
   version = "1.4.4";
···
     homepage = "https://alexschroeder.ch/cgit/bitlbee-mastodon/about";
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ jpotier ];
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/networking/instant-messengers/bitlbee-steam/default.nix

···
-{ fetchFromGitHub, stdenv, bitlbee, autoconf, automake, libtool, pkgconfig, glib, libgcrypt }:
+{ lib, fetchFromGitHub, stdenv, bitlbee, autoconf, automake, libtool, pkgconfig, glib, libgcrypt }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   version = "1.4.2";
   pname = "bitlbee-steam";
···
 
     homepage = "https://github.com/jgeboski/bitlbee-steam";
     license = licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

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

···
-{ fetchurl, fetchpatch, stdenv, gnutls, glib, pkgconfig, check, libotr, python
+{ lib, fetchurl, fetchpatch, stdenv, gnutls, glib, pkgconfig, check, libotr, python
 , enableLibPurple ? false, pidgin ? null
 , enablePam ? false, pam ? null
 }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   name = "bitlbee-3.6";
 

pkgs/applications/networking/instant-messengers/bitlbee/plugins.nix

···
-{ stdenv, bitlbee }:
+{ lib, stdenv, bitlbee }:
 
-with stdenv.lib;
+with lib;
 
 plugins:
 

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

···
   nativeBuildInputs = [ rpmextract makeWrapper ];
 
   libPath =
-    stdenv.lib.makeLibraryPath
+    lib.makeLibraryPath
       [
         libnotify
         libuuid

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

···
-{stdenv, fetchurl, gnused, openssl, curl, ncurses, libjpeg
+{ lib, stdenv, fetchurl, gnused, openssl, curl, ncurses, libjpeg
 , withGpg ? true, gpgme ? null}:
 
 stdenv.mkDerivation rec {
···
   CXXFLAGS = "-std=gnu++98";
 
   buildInputs = [ openssl curl ncurses libjpeg ]
-    ++ stdenv.lib.optional withGpg gpgme;
+    ++ lib.optional withGpg gpgme;
 
   preConfigure = ''
     ${gnused}/bin/sed -i '1,1i#include <stdio.h>' libicq2000/libicq2000/sigslot.h
···
   meta = {
     homepage = "http://www.centerim.org/";
     description = "Fork of CenterICQ, a curses instant messaging program";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/networking/instant-messengers/discord/base.nix

···
 
   dontWrapGApps = true;
 
-  libPath = stdenv.lib.makeLibraryPath [
+  libPath = lib.makeLibraryPath [
     libcxx systemd libpulseaudio
     stdenv.cc.cc alsaLib atk at-spi2-atk at-spi2-core cairo cups dbus expat fontconfig freetype
     gdk-pixbuf glib gtk3 libnotify libX11 libXcomposite libuuid

pkgs/applications/networking/instant-messengers/element/element-web.nix

···
   meta = {
     description = "A glossy Matrix collaboration client for the web";
     homepage = "https://element.io/";
-    maintainers = stdenv.lib.teams.matrix.members;
-    license = stdenv.lib.licenses.asl20;
-    platforms = stdenv.lib.platforms.all;
+    maintainers = lib.teams.matrix.members;
+    license = lib.licenses.asl20;
+    platforms = lib.platforms.all;
     hydraPlatforms = [];
   };
 }

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

···
 , pango, systemd }:
 
 let gitterDirectorySuffix = "opt/gitter";
-   libPath = stdenv.lib.makeLibraryPath [
+   libPath = lib.makeLibraryPath [
      alsaLib
      atk
      at-spi2-core

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

···
-{stdenv, fetchurl, ncurses, openssl, tcl, tk}:
+{lib, stdenv, fetchurl, ncurses, openssl, tcl, tk}:
 
 stdenv.mkDerivation {
   name = "gtmess-0.97";
···
   meta = {
     description = "Console MSN Messenger client for Linux and other unix systems";
     homepage = "http://gtmess.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = with lib.platforms; linux;
   };
 }

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

···
 let
   version = "4.30.5.1682";
 
-  rpath = stdenv.lib.makeLibraryPath [
+  rpath = lib.makeLibraryPath [
     xdg_utils
     xorg.libXext
     xorg.libSM

pkgs/applications/networking/instant-messengers/jitsi-meet-electron/default.nix

···
   postFixup = ''
     makeWrapper ${electron}/bin/electron $out/bin/${pname} \
       --add-flags $out/share/${pname}/resources/app.asar \
-      --prefix LD_LIBRARY_PATH : "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc ]}"
+      --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ stdenv.cc.cc ]}"
   '';
 
   meta = with lib; {

pkgs/applications/networking/instant-messengers/matrix-recorder/composition.nix

···
 
 let
   nodeEnv = import ./node-env.nix {
-    inherit (pkgs) stdenv python2 util-linux runCommand writeTextFile;
+    inherit (pkgs) lib stdenv python2 util-linux runCommand writeTextFile;
     inherit nodejs;
     libtool = if pkgs.stdenv.isDarwin then pkgs.darwin.cctools else null;
   };
-locpkgs = 
-import ./node-packages.nix {
+locpkgs = import ./node-packages.nix {
   inherit (pkgs) fetchurl fetchgit;
   inherit nodeEnv;
   globalBuildInputs = [

pkgs/applications/networking/instant-messengers/matrix-recorder/default.nix

···
-{ stdenv, pkgs }:
+{ lib, stdenv, pkgs }:
 (import ./composition.nix {
   inherit pkgs;
   inherit (stdenv.hostPlatform) system;
···
   meta = {
     description = "Matrix message recorder";
     homepage = "https://gitlab.com/argit/matrix-recorder/";
-    license = stdenv.lib.licenses.mit;
-    maintainers = [ stdenv.lib.maintainers.raskin ];
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.raskin ];
   };
 }

pkgs/applications/networking/instant-messengers/matrix-recorder/node-env.nix

···
 # This file originates from node2nix
 
-{stdenv, nodejs, python2, util-linux, libtool, runCommand, writeTextFile}:
+{lib, stdenv, nodejs, python2, util-linux, libtool, runCommand, writeTextFile}:
 
 let
   python = if nodejs ? python then nodejs.python else python2;
···
     };
 
   includeDependencies = {dependencies}:
-    stdenv.lib.optionalString (dependencies != [])
-      (stdenv.lib.concatMapStrings (dependency:
+    lib.optionalString (dependencies != [])
+      (lib.concatMapStrings (dependency:
         ''
           # Bundle the dependencies of the package
           mkdir -p node_modules
···
       cd "$DIR/${packageName}"
       ${includeDependencies { inherit dependencies; }}
       cd ..
-      ${stdenv.lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
+      ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
     '';
 
   pinpointDependencies = {dependencies, production}:
···
     ''
       node ${pinpointDependenciesFromPackageJSON} ${if production then "production" else "development"}
 
-      ${stdenv.lib.optionalString (dependencies != [])
+      ${lib.optionalString (dependencies != [])
         ''
           if [ -d node_modules ]
           then
               cd node_modules
-              ${stdenv.lib.concatMapStrings (dependency: pinpointDependenciesOfPackage dependency) dependencies}
+              ${lib.concatMapStrings (dependency: pinpointDependenciesOfPackage dependency) dependencies}
               cd ..
           fi
         ''}
···
           cd "${packageName}"
           ${pinpointDependencies { inherit dependencies production; }}
           cd ..
-          ${stdenv.lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
+          ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
       fi
     '';
 
···
         cd "${packageName}"
         runHook preRebuild
 
-        ${stdenv.lib.optionalString bypassCache ''
-          ${stdenv.lib.optionalString reconstructLock ''
+        ${lib.optionalString bypassCache ''
+          ${lib.optionalString reconstructLock ''
             if [ -f package-lock.json ]
             then
                 echo "WARNING: Reconstruct lock option enabled, but a lock file already exists!"
···
           node ${addIntegrityFieldsScript}
         ''}
 
-        npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${stdenv.lib.optionalString production "--production"} rebuild
+        npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${lib.optionalString production "--production"} rebuild
 
         if [ "$dontNpmInstall" != "1" ]
         then
             # NPM tries to download packages even when they already exist if npm-shrinkwrap is used.
             rm -f npm-shrinkwrap.json
 
-            npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${stdenv.lib.optionalString production "--production"} install
+            npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${lib.optionalString production "--production"} install
         fi
     '';
 
···
     stdenv.mkDerivation ({
       name = "node_${name}-${version}";
       buildInputs = [ tarWrapper python nodejs ]
-        ++ stdenv.lib.optional (stdenv.isLinux) util-linux
-        ++ stdenv.lib.optional (stdenv.isDarwin) libtool
+        ++ lib.optional (stdenv.isLinux) util-linux
+        ++ lib.optional (stdenv.isDarwin) libtool
         ++ buildInputs;
 
       inherit dontStrip; # Stripping may fail a build for some package deployments
···
         name = "node-dependencies-${name}-${version}";
 
         buildInputs = [ tarWrapper python nodejs ]
-          ++ stdenv.lib.optional (stdenv.isLinux) util-linux
-          ++ stdenv.lib.optional (stdenv.isDarwin) libtool
+          ++ lib.optional (stdenv.isLinux) util-linux
+          ++ lib.optional (stdenv.isDarwin) libtool
           ++ buildInputs;
 
         inherit dontStrip; # Stripping may fail a build for some package deployments
···
           # Create fake package.json to make the npm commands work properly
           cp ${src}/package.json .
           chmod 644 package.json
-          ${stdenv.lib.optionalString bypassCache ''
+          ${lib.optionalString bypassCache ''
             if [ -f ${src}/package-lock.json ]
             then
                 cp ${src}/package-lock.json .
···
 
           # Go to the parent folder to make sure that all packages are pinpointed
           cd ..
-          ${stdenv.lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
+          ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
 
           ${prepareAndInvokeNPM { inherit packageName bypassCache reconstructLock npmFlags production; }}
 
           # Expose the executables that were installed
           cd ..
-          ${stdenv.lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
+          ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
 
           mv ${packageName} lib
           ln -s $out/lib/node_modules/.bin $out/bin
···
     stdenv.mkDerivation {
       name = "node-shell-${name}-${version}";
 
-      buildInputs = [ python nodejs ] ++ stdenv.lib.optional (stdenv.isLinux) util-linux ++ buildInputs;
+      buildInputs = [ python nodejs ] ++ lib.optional (stdenv.isLinux) util-linux ++ buildInputs;
       buildCommand = ''
         mkdir -p $out/bin
         cat > $out/bin/shell <<EOF
···
 
       # Provide the dependencies in a development shell through the NODE_PATH environment variable
       inherit nodeDependencies;
-      shellHook = stdenv.lib.optionalString (dependencies != []) ''
+      shellHook = lib.optionalString (dependencies != []) ''
         export NODE_PATH=$nodeDependencies/lib/node_modules
         export PATH="$nodeDependencies/bin:$PATH"
       '';
     };
 in
 {
-  buildNodeSourceDist = stdenv.lib.makeOverridable buildNodeSourceDist;
-  buildNodePackage = stdenv.lib.makeOverridable buildNodePackage;
-  buildNodeShell = stdenv.lib.makeOverridable buildNodeShell;
+  buildNodeSourceDist = lib.makeOverridable buildNodeSourceDist;
+  buildNodePackage = lib.makeOverridable buildNodePackage;
+  buildNodeShell = lib.makeOverridable buildNodeShell;
 }

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

···
-{ stdenv, fetchgit
+{ lib, stdenv, fetchgit
   , buildPythonApplication, buildPythonPackage
   , pygobject3, pytestrunner, requests, responses, pytest, python-olm
   , canonicaljson, olm
···
     name = "${pname}-${version}";
     pname = "matrix-python-sdk-matrixcli";
     version = "0.0.2019-08-15";
-    
+
     src = "${mainsrc}/matrix-python-sdk/";
 
     propagatedBuildInputs = [
···
     doInstallCheck = false;
 
     meta = {
-      license = stdenv.lib.licenses.asl20;
+      license = lib.licenses.asl20;
       description = "Fork of Matrix Python SDK";
-      platforms = stdenv.lib.platforms.linux;
+      platforms = lib.platforms.linux;
     };
   };
 
···
 
   meta = {
     description = "CLI client for Matrix";
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.linux;
     homepage = "https://github.com/saadnpq/matrixcli";
   };
 }

pkgs/applications/networking/instant-messengers/mattermost-desktop/default.nix

···
 hicolor-icon-theme, libuuid, at-spi2-core, at-spi2-atk }:
 
 let
-  rpath = stdenv.lib.makeLibraryPath [
+  rpath = lib.makeLibraryPath [
     alsaLib
     at-spi2-atk
     at-spi2-core

pkgs/applications/networking/instant-messengers/mikutter/gemset.nix

···
     };
     version = "3.7.6";
   };
-}
+}

pkgs/applications/networking/instant-messengers/pidgin-plugins/msn-pecan/default.nix

···
-{ stdenv, fetchurl, pidgin} :
+{ lib, stdenv, fetchurl, pidgin} :
 
 stdenv.mkDerivation {
   name = "pidgin-msn-pecan-0.1.4";
···
   meta = {
     description = "Alternative MSN protocol plug-in for Pidgin IM";
     homepage = "https://github.com/felipec/msn-pecan";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 
   makeFlags = [

pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-latex/default.nix

···
   '';
 
   passthru = {
-    wrapArgs = "--prefix PATH ':' ${stdenv.lib.makeBinPath [ texLive imagemagick ]}";
+    wrapArgs = "--prefix PATH ':' ${lib.makeBinPath [ texLive imagemagick ]}";
   };
 
   meta = with lib; {

pkgs/applications/networking/instant-messengers/pidgin-plugins/pidgin-mra/default.nix

···
-{ stdenv, fetchgit, pkgconfig, pidgin } :
+{ lib, stdenv, fetchgit, pkgconfig, pidgin } :
 
 let
   version = "54b2992";
···
   meta = {
     homepage = "https://github.com/dreadatour/pidgin-mra";
     description = "Mail.ru Agent plugin for Pidgin / libpurple";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/networking/instant-messengers/pidgin-plugins/purple-vk-plugin/default.nix

···
-{ stdenv, fetchhg, pidgin, cmake, libxml2 } :
+{ lib, stdenv, fetchhg, pidgin, cmake, libxml2 } :
 
 let
   version = "40ddb6d";
···
   meta = {
     homepage = "https://bitbucket.org/olegoandreev/purple-vk-plugin";
     description = "Vk (russian social network) plugin for Pidgin / libpurple";
-    license = stdenv.lib.licenses.gpl3;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/networking/instant-messengers/pidgin-plugins/skype4pidgin/default.nix

···
-{ stdenv, fetchurl, pkgconfig, pidgin, libnotify, gdk-pixbuf, glib, dbus
+{ lib, stdenv, fetchurl, pkgconfig, pidgin, libnotify, gdk-pixbuf, glib, dbus
 , dbus-glib }:
 
 stdenv.mkDerivation rec {
···
 
   meta = {
     homepage = "https://github.com/novas0x2a/skype4pidgin";
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
     description = "Plugin to use a running skype account through pidgin";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

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

···
-{ stdenv, buildGoPackage, trousers, dclxvi, wrapGAppsHook, pkgconfig, gtk3, gtkspell3,
+{ lib, stdenv, buildGoPackage, trousers, dclxvi, wrapGAppsHook, pkgconfig, gtk3, gtkspell3,
   fetchgit }:
 
 let
···
 in
 buildGoPackage rec {
   pname = "pond";
-  version = "20150830-${stdenv.lib.strings.substring 0 7 rev}";
+  version = "20150830-${lib.strings.substring 0 7 rev}";
   rev = "bce6e0dc61803c23699c749e29a83f81da3c41b2";
 
   goPackagePath = "github.com/agl/pond";
···
 
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ trousers gtk3 gtkspell3 ]
-    ++ stdenv.lib.optional stdenv.hostPlatform.isx86_64 dclxvi
-    ++ stdenv.lib.optionals gui [ wrapGAppsHook ];
-  buildFlags = stdenv.lib.optionals (!gui) [ "-tags" "nogui" ];
+    ++ lib.optional stdenv.hostPlatform.isx86_64 dclxvi
+    ++ lib.optionals gui [ wrapGAppsHook ];
+  buildFlags = lib.optionals (!gui) [ "-tags" "nogui" ];
   excludedPackages = "\\(appengine\\|bn256cgo\\)";
-  postPatch = stdenv.lib.optionalString stdenv.hostPlatform.isx86_64 ''
+  postPatch = lib.optionalString stdenv.hostPlatform.isx86_64 ''
     grep -r 'bn256' | awk -F: '{print $1}' | xargs sed -i \
       -e "s,golang.org/x/crypto/bn256,github.com/agl/pond/bn256cgo,g" \
       -e "s,bn256\.,bn256cgo.,g"

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

···
-{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, glib, openssl
+{ lib, stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, glib, openssl
 , glibcLocales, expect, ncurses, libotr, curl, readline, libuuid
 , cmocka, libmicrohttpd, expat, sqlite, libmesode, autoconf-archive
 
···
 assert pythonPluginSupport -> python != null;
 assert omemoSupport        -> libsignal-protocol-c != null && libgcrypt != null;
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "profanity";

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

···
     qtbase qtsvg qttranslations
     ffmpeg_3 filter-audio libexif libopus libsodium
     libvpx openal pcre qrencode sqlcipher
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [ AVFoundation] ;
+  ] ++ lib.optionals stdenv.isDarwin [ AVFoundation] ;
 
   nativeBuildInputs = [ cmake pkg-config qttools ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ perl ];
+    ++ lib.optionals stdenv.isDarwin [ perl ];
 
   cmakeFlags = [
     "-DGIT_DESCRIBE=v${version}"

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

···
-{ stdenv, fetchgit, libtoxcore
+{ lib, stdenv, fetchgit, libtoxcore
 , conf ? null }:
 
-with stdenv.lib;
+with lib;
 
 let
   configFile = optionalString (conf!=null) (builtins.toFile "config.h" conf);

pkgs/applications/networking/instant-messengers/ring-daemon/default.nix

···
     ];
   };
 
-  pjsip' = stdenv.lib.overrideDerivation pjsip (old: {
+  pjsip' = lib.overrideDerivation pjsip (old: {
     patches = [
       "${patchdir}/pjproject/gnutls.patch"
       ./notestsapps.patch # this one had to be modified

pkgs/applications/networking/instant-messengers/signal-desktop/default.nix

···
 
   preFixup = ''
     gappsWrapperArgs+=(
-      --prefix LD_LIBRARY_PATH : "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc ] }"
+      --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ stdenv.cc.cc ] }"
       ${customLanguageWrapperArgs}
     )
 

pkgs/applications/networking/instant-messengers/silc-client/default.nix

···
-{ stdenv, fetchurl, perl, pkgconfig, glib, ncurses
+{ lib, stdenv, fetchurl, perl, pkgconfig, glib, ncurses
 , enablePlugin ? false }:
 
 # Enabling the plugin and using it with a recent irssi, segafults on join:
···
   basename = "silc-client-1.1.11";
 in
 stdenv.mkDerivation {
-  name = basename + stdenv.lib.optionalString enablePlugin "-irssi-plugin";
+  name = basename + lib.optionalString enablePlugin "-irssi-plugin";
 
   src = fetchurl {
     url = "mirror://sourceforge/silc/silc/client/sources/${basename}.tar.bz2";
···
 
   configureFlags = [ "--with-ncurses=${ncurses.dev}" ];
 
-  preConfigure = stdenv.lib.optionalString enablePlugin ''
+  preConfigure = lib.optionalString enablePlugin ''
     configureFlags="$configureFlags --with-silc-plugin=$out/lib/irssi"
   '';
 
···
   meta = {
     homepage = "http://silcnet.org/";
     description = "Secure Internet Live Conferencing server";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [viric];
+    platforms = with lib.platforms; linux;
   };
 }

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

···
   # source of the latter disappears much faster.
   version = "8.66.0.74";
 
-  rpath = stdenv.lib.makeLibraryPath [
+  rpath = lib.makeLibraryPath [
     alsaLib
     atk
     at-spi2-atk
···
     description = "Linux client for skype";
     homepage = "https://www.skype.com";
     license = licenses.unfree;
-    maintainers = with stdenv.lib.maintainers; [ panaeon jraygauthier ];
+    maintainers = with lib.maintainers; [ panaeon jraygauthier ];
     platforms = [ "x86_64-linux" ];
   };
 }

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

···
 
     passthru.updateScript = ./update.sh;
 
-    rpath = stdenv.lib.makeLibraryPath [
+    rpath = lib.makeLibraryPath [
       alsaLib
       at-spi2-atk
       at-spi2-core

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

···
 { lib, stdenv, fetchurl, dpkg, alsaLib, atk, cairo, cups, dbus, expat, fontconfig
 , freetype, gdk-pixbuf, glib, gnome2, nspr, nss, pango, udev, xorg }:
 let
-  fullPath = stdenv.lib.makeLibraryPath [
+  fullPath = lib.makeLibraryPath [
     alsaLib
     atk
     cairo

pkgs/applications/networking/instant-messengers/teamspeak/client.nix

···
       patchelf --replace-needed libquazip.so ${quazip}/lib/libquazip5.so ts3client
       patchelf \
         --interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-        --set-rpath ${stdenv.lib.makeLibraryPath deps}:$(cat $NIX_CC/nix-support/orig-cc)/${libDir} \
+        --set-rpath ${lib.makeLibraryPath deps}:$(cat $NIX_CC/nix-support/orig-cc)/${libDir} \
         --force-rpath \
         ts3client
     '';

pkgs/applications/networking/instant-messengers/telepathy/gabble/default.nix

···
     homepage = "https://telepathy.freedesktop.org/components/telepathy-gabble/";
     description = "Jabber/XMPP connection manager for the Telepathy framework";
     license = licenses.lgpl21Plus;
-    platforms = stdenv.lib.platforms.gnu ++ stdenv.lib.platforms.linux;
+    platforms = lib.platforms.gnu ++ lib.platforms.linux;
   };
 }

pkgs/applications/networking/instant-messengers/telepathy/haze/default.nix

···
-{ stdenv, fetchurl, fetchpatch, pidgin, telepathy-glib, glib, dbus-glib, pkgconfig, libxslt }:
+{ lib, stdenv, fetchurl, fetchpatch, pidgin, telepathy-glib, glib, dbus-glib, pkgconfig, libxslt }:
 
 stdenv.mkDerivation rec {
   pname = "telepathy-haze";
···
 
   meta = {
     description = "A Telepathy connection manager based on libpurple";
-    platforms = stdenv.lib.platforms.gnu ++ stdenv.lib.platforms.linux; # Random choice
+    platforms = lib.platforms.gnu ++ lib.platforms.linux; # Random choice
   };
 }

pkgs/applications/networking/instant-messengers/telepathy/idle/default.nix

···
-{ stdenv, fetchurl, glib, dconf, pkgconfig, dbus-glib, telepathy-glib, libxslt, makeWrapper }:
+{ lib, stdenv, fetchurl, glib, dconf, pkgconfig, dbus-glib, telepathy-glib, libxslt, makeWrapper }:
 
 stdenv.mkDerivation rec {
   pname = "telepathy-idle";
···
   };
 
   nativeBuildInputs = [ pkgconfig ];
-  buildInputs = [ glib telepathy-glib dbus-glib libxslt telepathy-glib.python (stdenv.lib.getLib dconf) makeWrapper ];
+  buildInputs = [ glib telepathy-glib dbus-glib libxslt telepathy-glib.python (lib.getLib dconf) makeWrapper ];
 
   preFixup = ''
     wrapProgram "$out/libexec/telepathy-idle" \
-      --prefix GIO_EXTRA_MODULES : "${stdenv.lib.getLib dconf}/lib/gio/modules"
+      --prefix GIO_EXTRA_MODULES : "${lib.getLib dconf}/lib/gio/modules"
   '';
 
   meta = {
     description = "IRC connection manager for the Telepathy framework";
-    license = stdenv.lib.licenses.lgpl21;
-    platforms = stdenv.lib.platforms.gnu ++ stdenv.lib.platforms.linux;
+    license = lib.licenses.lgpl21;
+    platforms = lib.platforms.gnu ++ lib.platforms.linux;
   };
 }

pkgs/applications/networking/instant-messengers/telepathy/logger/default.nix

···
 
   preFixup = ''
     wrapProgram "$out/libexec/telepathy-logger" \
-      --prefix GIO_EXTRA_MODULES : "${stdenv.lib.getLib dconf}/lib/gio/modules" \
+      --prefix GIO_EXTRA_MODULES : "${lib.getLib dconf}/lib/gio/modules" \
       --prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH"
   '';
 

pkgs/applications/networking/instant-messengers/telepathy/mission-control/default.nix

···
 
   preFixup = ''
     wrapProgram "$lib/libexec/mission-control-5" \
-      --prefix GIO_EXTRA_MODULES : "${stdenv.lib.getLib dconf}/lib/gio/modules" \
+      --prefix GIO_EXTRA_MODULES : "${lib.getLib dconf}/lib/gio/modules" \
       --prefix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH"
   '';
 

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

···
 
   buildInputs = [
     libtoxcore libsodium ncurses curl gdk-pixbuf libnotify
-  ] ++ stdenv.lib.optionals (!stdenv.isAarch32) [
+  ] ++ lib.optionals (!stdenv.isAarch32) [
     openal libopus libvpx freealut qrencode
   ];
   nativeBuildInputs = [ pkgconfig libconfig ];

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

···
 { lib, stdenv, fetchpatch, python3Packages }:
 
-with stdenv.lib;
+with lib;
 with python3Packages;
 
 buildPythonPackage rec {

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

···
-{fetchurl, stdenv, dpkg, makeWrapper,
+{fetchurl, lib, stdenv, dpkg, makeWrapper,
  alsaLib, cups, curl, dbus, expat, fontconfig, freetype, glib, gst_all_1,
  harfbuzz, libcap, libGL, libGLU, libpulseaudio, libxkbcommon, libxml2, libxslt,
  nspr, nss, openssl, systemd, wayland, xorg, zlib, ...
···
 
   dontUnpack = true;
 
-  libPath = stdenv.lib.makeLibraryPath [
+  libPath = lib.makeLibraryPath [
       alsaLib
       cups
       curl
···
   meta = {
     homepage = "http://www.viber.com";
     description = "An instant messaging and Voice over IP (VoIP) app";
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
     platforms = [ "x86_64-linux" ];
-    maintainers = with stdenv.lib.maintainers; [ jagajaga ];
+    maintainers = with lib.maintainers; [ jagajaga ];
   };
 
 }

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

···
 , xorg
 }:
 
-with stdenv.lib;
+with lib;
 
 let
   bits = "x86_64";

pkgs/applications/networking/instant-messengers/xmpp-client/default.nix

···
 
 buildGoPackage rec {
   pname = "xmpp-client";
-  version = "20160916-${stdenv.lib.strings.substring 0 7 rev}";
+  version = "20160916-${lib.strings.substring 0 7 rev}";
   rev = "abbf9020393e8caae3e8996a16ce48446e31cf0e";
 
   goPackagePath = "github.com/agl/xmpp-client";

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

···
-{ stdenv, fetchurl, ncurses }:
+{ lib, stdenv, fetchurl, ncurses }:
 
 stdenv.mkDerivation rec {
   pname = "ytalk";
···
   meta = {
     homepage    = "http://ytalk.ourproject.org";
     description = "A terminal based talk client";
-    platforms   = stdenv.lib.platforms.unix;
-    maintainers = with stdenv.lib.maintainers; [ taeer ];
-    license     = stdenv.lib.licenses.gpl2Plus;
+    platforms   = lib.platforms.unix;
+    maintainers = with lib.maintainers; [ taeer ];
+    license     = lib.licenses.gpl2Plus;
   };
 }

pkgs/applications/networking/instant-messengers/zoom-us/default.nix

···
-{ stdenv, fetchurl, mkDerivation, autoPatchelfHook, bash
+{ lib, stdenv, fetchurl, mkDerivation, autoPatchelfHook, bash
 , fetchFromGitHub
 # Dynamic libraries
 , dbus, glib, libGL, libX11, libXfixes, libuuid, libxcb, qtbase, qtdeclarative
···
 assert pulseaudioSupport -> libpulseaudio != null;
 
 let
-  inherit (stdenv.lib) concatStringsSep makeBinPath optional;
+  inherit (lib) concatStringsSep makeBinPath optional;
 
   version = "5.4.53350.1027";
   srcs = {
···
   meta = {
     homepage = "https://zoom.us/";
     description = "zoom.us video conferencing application";
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
     platforms = builtins.attrNames srcs;
-    maintainers = with stdenv.lib.maintainers; [ danbst tadfisher doronbehar ];
+    maintainers = with lib.maintainers; [ danbst tadfisher doronbehar ];
   };
 
 }

pkgs/applications/networking/iptraf/default.nix

···
-{stdenv, fetchurl, ncurses}:
+{lib, stdenv, fetchurl, ncurses}:
 
 stdenv.mkDerivation {
   name = "iptraf-3.0.1";
···
 
   meta = {
     homepage = "http://iptraf.seul.org/";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
     description = "Console-based network statistics utility for Linux";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
     broken = true; # required isdn headers have been removed from the linux kernel
   };
 }

pkgs/applications/networking/irc/bip/default.nix

···
-{ stdenv, fetchurl, fetchpatch, bison, flex, autoconf, automake, openssl }:
+{ lib, stdenv, fetchurl, fetchpatch, bison, flex, autoconf, automake, openssl }:
 
 stdenv.mkDerivation rec {
   pname = "bip";
···
   meta = {
     description = "An IRC proxy (bouncer)";
     homepage = "http://bip.milkypond.org/";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     downloadPage = "https://projects.duckcorp.org/projects/bip/files";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/networking/irc/communi/default.nix

···
     "COMMUNI_INSTALL_THEMES=${placeholder "out"}/share/communi/themes"
   ];
 
-  postInstall = stdenv.lib.optionalString stdenv.isLinux ''
+  postInstall = lib.optionalString stdenv.isLinux ''
     substituteInPlace "$out/share/applications/communi.desktop" \
       --replace "/usr/bin" "$out/bin"
   '';

pkgs/applications/networking/irc/convos/default.nix

···
-{ stdenv, fetchFromGitHub, perl, perlPackages, makeWrapper, shortenPerlShebang
+{ lib, stdenv, fetchFromGitHub, perl, perlPackages, makeWrapper, shortenPerlShebang
 , nixosTests
 }:
 
-with stdenv.lib;
+with lib;
 
 perlPackages.buildPerlPackage rec {
   pname = "convos";
···
   meta = {
     homepage = "https://convos.chat";
     description = "Convos is the simplest way to use IRC in your browser";
-    license = stdenv.lib.licenses.artistic2;
+    license = lib.licenses.artistic2;
     maintainers = with maintainers; [ sgo ];
   };
 }

pkgs/applications/networking/irc/epic5/default.nix

···
 
   # Darwin needs libiconv, tcl; while Linux build don't
   buildInputs = [ openssl ncurses ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ libiconv tcl ];
+    ++ lib.optionals stdenv.isDarwin [ libiconv tcl ];
 
   patches = [
     (fetchpatch {

pkgs/applications/networking/irc/ii/default.nix

···
-{stdenv, fetchurl}:
+{lib, stdenv, fetchurl}:
 
 stdenv.mkDerivation rec {
   name = "ii-1.8";
···
 
   meta = {
     homepage = "https://tools.suckless.org/ii/";
-    license = stdenv.lib.licenses.mit;
+    license = lib.licenses.mit;
     description = "Irc it, simple FIFO based irc client";
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/networking/irc/irssi/default.nix

···
-{ stdenv, fetchurl, pkgconfig, ncurses, glib, openssl, perl, libintl, libgcrypt, libotr }:
+{ lib, stdenv, fetchurl, pkgconfig, ncurses, glib, openssl, perl, libintl, libgcrypt, libotr }:
 
 stdenv.mkDerivation rec {
   pname = "irssi";
···
   meta = {
     homepage    = "https://irssi.org";
     description = "A terminal based IRC client";
-    platforms   = stdenv.lib.platforms.unix;
-    maintainers = with stdenv.lib.maintainers; [ lovek323 ];
-    license     = stdenv.lib.licenses.gpl2Plus;
+    platforms   = lib.platforms.unix;
+    maintainers = with lib.maintainers; [ lovek323 ];
+    license     = lib.licenses.gpl2Plus;
   };
 }

pkgs/applications/networking/irc/irssi/fish/default.nix

···
-{ stdenv, fetchurl, irssi, gmp, automake, autoconf, libtool, openssl, glib, pkgconfig }:
+{ lib, stdenv, fetchurl, irssi, gmp, automake, autoconf, libtool, openssl, glib, pkgconfig }:
 
 stdenv.mkDerivation rec {
   name = "fish-irssi-20130413-e98156bebd";
-  
+
   src = fetchurl {
     url = "https://github.com/falsovsky/FiSH-irssi/tarball/e98156bebd";
     name = "${name}.tar.gz";
···
     mkdir -p $out/lib/irssi/modules
     cp src/.libs/libfish.so $out/lib/irssi/modules
   '';
-  
+
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ gmp automake autoconf libtool openssl glib ];
-  
+
   meta = {
     homepage = "https://github.com/falsovsky/FiSH-irssi";
-    license = stdenv.lib.licenses.unfree; # I can't find any mention of license
-    maintainers = with stdenv.lib.maintainers; [viric];
+    license = lib.licenses.unfree; # I can't find any mention of license
+    maintainers = with lib.maintainers; [viric];
   };
 }

pkgs/applications/networking/irc/sic/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   pname = "sic";
···
   meta = {
     description = "Simple IRC client";
     homepage = "https://tools.suckless.org/sic/";
-    license = stdenv.lib.licenses.mit;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.mit;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/applications/networking/irc/weechat/default.nix

···
 
       outputs = [ "out" "man" ] ++ map (p: p.name) enabledPlugins;
 
-      cmakeFlags = with stdenv.lib; [
+      cmakeFlags = with lib; [
         "-DENABLE_MAN=ON"
         "-DENABLE_DOC=ON"
         "-DENABLE_JAVASCRIPT=OFF"  # Requires v8 <= 3.24.3, https://github.com/weechat/weechat/issues/360
···
         ;
 
       nativeBuildInputs = [ cmake pkg-config makeWrapper asciidoctor ];
-      buildInputs = with stdenv.lib; [
+      buildInputs = with lib; [
           ncurses openssl aspell gnutls gettext zlib curl
           libgcrypt ]
         ++ optionals stdenv.isDarwin [ libobjc libresolv ]
···
 
       NIX_CFLAGS_COMPILE = "-I${python}/include/${python.libPrefix}"
         # Fix '_res_9_init: undefined symbol' error
-        + (stdenv.lib.optionalString stdenv.isDarwin "-DBIND_8_COMPAT=1 -lresolv");
+        + (lib.optionalString stdenv.isDarwin "-DBIND_8_COMPAT=1 -lresolv");
 
-      postInstall = with stdenv.lib; ''
+      postInstall = with lib; ''
         for p in ${concatMapStringsSep " " (p: p.name) enabledPlugins}; do
           from=$out/lib/weechat/plugins/$p.so
           to=''${!p}/lib/weechat/plugins/$p.so
···
           (eg. adding python modules for scripts that would require them, etc.)
           on https://nixos.org/nixpkgs/manual/#sec-weechat .
         '';
-        license = stdenv.lib.licenses.gpl3;
-        maintainers = with stdenv.lib.maintainers; [ lovek323 lheckemann ];
-        platforms = stdenv.lib.platforms.unix;
+        license = lib.licenses.gpl3;
+        maintainers = with lib.maintainers; [ lovek323 lheckemann ];
+        platforms = lib.platforms.unix;
       };
     }

pkgs/applications/networking/irc/wraith/default.nix

···
 { stdenv, fetchurl, openssl }:
 
 with stdenv;
-with stdenv.lib;
+with lib;
 
 mkDerivation rec {
   pname = "wraith";

pkgs/applications/networking/maestral-qt/default.nix

···
     maestral
     packaging
     pyqt5
-  ] ++ stdenv.lib.optionals (pythonOlder "3.9") [
+  ] ++ lib.optionals (pythonOlder "3.9") [
     importlib-resources
   ];
 
···
     "\${qtWrapperArgs[@]}"
 
     # Add the installed directories to the python path so the daemon can find them
-    "--prefix" "PYTHONPATH" ":" "${stdenv.lib.concatStringsSep ":" (map (p: p + "/lib/${python3.libPrefix}/site-packages") (python3.pkgs.requiredPythonModules python3.pkgs.maestral.propagatedBuildInputs))}"
+    "--prefix" "PYTHONPATH" ":" "${lib.concatStringsSep ":" (map (p: p + "/lib/${python3.libPrefix}/site-packages") (python3.pkgs.requiredPythonModules python3.pkgs.maestral.propagatedBuildInputs))}"
     "--prefix" "PYTHONPATH" ":" "${python3.pkgs.maestral}/lib/${python3.libPrefix}/site-packages"
   ];
 

pkgs/applications/networking/mailreaders/aerc/default.nix

···
 
   postFixup = ''
     wrapProgram $out/bin/aerc --prefix PATH ":" \
-      "$out/share/aerc/filters:${stdenv.lib.makeBinPath [ ncurses ]}"
+      "$out/share/aerc/filters:${lib.makeBinPath [ ncurses ]}"
     wrapProgram $out/share/aerc/filters/html --prefix PATH ":" \
-      ${stdenv.lib.makeBinPath [ w3m dante ]}
+      ${lib.makeBinPath [ w3m dante ]}
   '';
 
   meta = with lib; {

pkgs/applications/networking/mailreaders/claws-mail/default.nix

···
-{ config, fetchurl, stdenv, wrapGAppsHook, autoreconfHook
+{ lib, config, fetchurl, stdenv, wrapGAppsHook, autoreconfHook
 , curl, dbus, dbus-glib, enchant, gtk2, gnutls, gnupg, gpgme, gumbo
 , libarchive, libcanberra-gtk2, libetpan, libnotify, libsoup, libxml2, networkmanager
 , openldap, perl, pkgconfig, poppler, python, shared-mime-info
···
 , enableSpellcheck ? false
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "claws-mail";

pkgs/applications/networking/mailreaders/claws-mail/gtk3.nix

···
-{ config, fetchgit, stdenv, wrapGAppsHook, autoreconfHook, bison, flex
+{ lib, config, fetchgit, stdenv, wrapGAppsHook, autoreconfHook, bison, flex
 , curl, dbus, dbus-glib, enchant, gtk3, gnutls, gnupg, gpgme
 , libarchive, libcanberra-gtk3, libetpan, libnotify, libsoup, libxml2, networkmanager
 , openldap, perl, pkgconfig, poppler, python, shared-mime-info, webkitgtk
···
 , enableSpellcheck ? false
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "claws-mail-gtk3";

pkgs/applications/networking/mailreaders/evolution/evolution-ews/default.nix

···
   version = "3.36.5";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "0h1wz4hxsasihdvvsaxnmzka4afjw7603gn0qcw8rxpw114ib1bl";
   };
 

pkgs/applications/networking/mailreaders/imapfilter.nix

···
-{ stdenv, fetchFromGitHub, openssl, lua, pcre2 }:
+{ lib, stdenv, fetchFromGitHub, openssl, lua, pcre2 }:
 
 stdenv.mkDerivation rec {
   pname = "imapfilter";
···
   meta = {
     homepage = "https://github.com/lefcha/imapfilter";
     description = "Mail filtering utility";
-    license = stdenv.lib.licenses.mit;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = with stdenv.lib.maintainers; [ doronbehar ];
+    license = lib.licenses.mit;
+    platforms = lib.platforms.unix;
+    maintainers = with lib.maintainers; [ doronbehar ];
   };
 }

pkgs/applications/networking/mailreaders/lumail/default.nix

···
     sed -e "s|^#\!\(.*/perl.*\)$|#\!\1$perlFlags|" -i perl.d/imap-proxy
   '';
 
-  buildFlags = stdenv.lib.optional debugBuild "lumail2-debug";
+  buildFlags = lib.optional debugBuild "lumail2-debug";
 
   installPhase = ''
     mkdir -p $out/bin || true

pkgs/applications/networking/mailreaders/mailcheck/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   pname = "mailcheck";
···
   meta = {
     description = "Simple command line tool to check for new messages";
     homepage    = "http://mailcheck.sourceforge.net/";
-    license     = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ kovirobi ];
-    platforms   = stdenv.lib.platforms.linux;
+    license     = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ kovirobi ];
+    platforms   = lib.platforms.linux;
     inherit version;
 
     longDescription = ''

pkgs/applications/networking/mailreaders/mailpile/default.nix

···
 
   postInstall = ''
     wrapProgram $out/bin/mailpile \
-      --prefix PATH ":" "${stdenv.lib.makeBinPath [ gnupg1orig openssl ]}" \
+      --prefix PATH ":" "${lib.makeBinPath [ gnupg1orig openssl ]}" \
       --set-default MAILPILE_SHARED "$out/share/mailpile"
   '';
 

pkgs/applications/networking/mailreaders/msgviewer/default.nix

···
     rmdir $dir/${uname}
     cat <<_EOF > $out/bin/msgviewer
     #!${runtimeShell} -eu
-    exec ${stdenv.lib.getBin jre}/bin/java -jar $dir/MSGViewer.jar "\$@"
+    exec ${lib.getBin jre}/bin/java -jar $dir/MSGViewer.jar "\$@"
     _EOF
     chmod 755 $out/bin/msgviewer
   '';

pkgs/applications/networking/mailreaders/mutt/default.nix

···
-{ stdenv, fetchurl, fetchpatch, ncurses, which, perl
+{ lib, stdenv, fetchurl, fetchpatch, ncurses, which, perl
 , gdbm ? null
 , openssl ? null
 , cyrus_sasl ? null
···
 assert gpgSupport   -> gnupg      != null;
 assert gpgmeSupport -> gpgme      != null && openssl != null;
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "mutt";

pkgs/applications/networking/mailreaders/notbit/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig,
+{ lib, stdenv, fetchFromGitHub, autoreconfHook, pkgconfig,
   gettext, openssl
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation {
   pname = "notbit";

pkgs/applications/networking/mailreaders/notmuch/default.nix

···
-{ fetchurl, fetchgit, stdenv
+{ fetchurl, fetchgit, lib, stdenv
 , pkgconfig, gnupg
 , xapian, gmime, talloc, zlib
 , doxygen, perl, texinfo
···
 , withEmacs ? true
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   version = "0.31";
···
   makeFlags = [ "V=1" ];
 
 
-  outputs = [ "out" "man" "info" ] ++ stdenv.lib.optional withEmacs "emacs";
+  outputs = [ "out" "man" "info" ] ++ lib.optional withEmacs "emacs";
 
   preCheck = let
     test-database = fetchurl {
···
 
   installTargets = [ "install" "install-man" "install-info" ];
 
-  postInstall = stdenv.lib.optionalString withEmacs ''
+  postInstall = lib.optionalString withEmacs ''
     moveToOutput bin/notmuch-emacs-mua $emacs
   '';
 

pkgs/applications/networking/mailreaders/notmuch/muchsync.nix

···
-{ stdenv, fetchurl
+{ lib, stdenv, fetchurl
 , notmuch, openssl, pkgconfig, sqlite, xapian, zlib
 }:
 stdenv.mkDerivation rec {
···
   meta = {
     description = "Synchronize maildirs and notmuch databases";
     homepage = "http://www.muchsync.org/";
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = with stdenv.lib.maintainers; [];
-    license = stdenv.lib.licenses.gpl2Plus;
+    platforms = lib.platforms.unix;
+    maintainers = with lib.maintainers; [];
+    license = lib.licenses.gpl2Plus;
   };
 }

pkgs/applications/networking/mailreaders/sylpheed/default.nix

···
-{ stdenv, fetchurl, pkgconfig, gtk2, openssl ? null, gpgme ? null
+{ lib, stdenv, fetchurl, pkgconfig, gtk2, openssl ? null, gpgme ? null
 , gpgSupport ? true, sslSupport ? true }:
 
 assert gpgSupport -> gpgme != null;
 assert sslSupport -> openssl != null;
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "sylpheed";

pkgs/applications/networking/mailreaders/thunderbird-bin/68.nix

···
 
   systemLocale = config.i18n.defaultLocale or "en-US";
 
-  defaultSource = stdenv.lib.findFirst (sourceMatches "en-US") {} sources;
+  defaultSource = lib.findFirst (sourceMatches "en-US") {} sources;
 
-  source = stdenv.lib.findFirst (sourceMatches systemLocale) defaultSource sources;
+  source = lib.findFirst (sourceMatches systemLocale) defaultSource sources;
 
   name = "thunderbird-bin-${version}";
 in
···
 
   phases = "unpackPhase installPhase";
 
-  libPath = stdenv.lib.makeLibraryPath
+  libPath = lib.makeLibraryPath
     [ stdenv.cc.cc
       alsaLib
       at-spi2-atk
···
       nspr
       nss
       pango
-    ] + ":" + stdenv.lib.makeSearchPathOutput "lib" "lib64" [
+    ] + ":" + lib.makeSearchPathOutput "lib" "lib64" [
       stdenv.cc.cc
     ];
 
···
       free = false;
       url = "http://www.mozilla.org/en-US/foundation/trademarks/policy/";
     };
-    maintainers = with stdenv.lib.maintainers; [ ];
+    maintainers = with lib.maintainers; [ ];
     platforms = platforms.linux;
     knownVulnerabilities = [ "Support ended around Semptember 2020." ];
   };

pkgs/applications/networking/n8n/node-composition.nix

···
 
 let
   nodeEnv = import ./node-env.nix {
-    inherit (pkgs) stdenv python2 utillinux runCommand writeTextFile;
+    inherit (pkgs) lib stdenv python2 utillinux runCommand writeTextFile;
     inherit nodejs;
     libtool = if pkgs.stdenv.isDarwin then pkgs.darwin.cctools else null;
   };
···
 import ./node-packages.nix {
   inherit (pkgs) fetchurl fetchgit;
   inherit nodeEnv;
-}
+}

pkgs/applications/networking/n8n/node-env.nix

···
 # This file originates from node2nix
 
-{stdenv, nodejs, python2, utillinux, libtool, runCommand, writeTextFile}:
+{lib, stdenv, nodejs, python2, utillinux, libtool, runCommand, writeTextFile}:
 
 let
   python = if nodejs ? python then nodejs.python else python2;
···
     };
 
   includeDependencies = {dependencies}:
-    stdenv.lib.optionalString (dependencies != [])
-      (stdenv.lib.concatMapStrings (dependency:
+    lib.optionalString (dependencies != [])
+      (lib.concatMapStrings (dependency:
         ''
           # Bundle the dependencies of the package
           mkdir -p node_modules
···
       cd "$DIR/${packageName}"
       ${includeDependencies { inherit dependencies; }}
       cd ..
-      ${stdenv.lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
+      ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
     '';
 
   pinpointDependencies = {dependencies, production}:
···
     ''
       node ${pinpointDependenciesFromPackageJSON} ${if production then "production" else "development"}
 
-      ${stdenv.lib.optionalString (dependencies != [])
+      ${lib.optionalString (dependencies != [])
         ''
           if [ -d node_modules ]
           then
               cd node_modules
-              ${stdenv.lib.concatMapStrings (dependency: pinpointDependenciesOfPackage dependency) dependencies}
+              ${lib.concatMapStrings (dependency: pinpointDependenciesOfPackage dependency) dependencies}
               cd ..
           fi
         ''}
···
           cd "${packageName}"
           ${pinpointDependencies { inherit dependencies production; }}
           cd ..
-          ${stdenv.lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
+          ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
       fi
     '';
 
···
         cd "${packageName}"
         runHook preRebuild
 
-        ${stdenv.lib.optionalString bypassCache ''
-          ${stdenv.lib.optionalString reconstructLock ''
+        ${lib.optionalString bypassCache ''
+          ${lib.optionalString reconstructLock ''
             if [ -f package-lock.json ]
             then
                 echo "WARNING: Reconstruct lock option enabled, but a lock file already exists!"
···
           node ${addIntegrityFieldsScript}
         ''}
 
-        npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${stdenv.lib.optionalString production "--production"} rebuild
+        npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${lib.optionalString production "--production"} rebuild
 
         if [ "''${dontNpmInstall-}" != "1" ]
         then
             # NPM tries to download packages even when they already exist if npm-shrinkwrap is used.
             rm -f npm-shrinkwrap.json
 
-            npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${stdenv.lib.optionalString production "--production"} install
+            npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${lib.optionalString production "--production"} install
         fi
     '';
 
···
     stdenv.mkDerivation ({
       name = "node_${name}-${version}";
       buildInputs = [ tarWrapper python nodejs ]
-        ++ stdenv.lib.optional (stdenv.isLinux) utillinux
-        ++ stdenv.lib.optional (stdenv.isDarwin) libtool
+        ++ lib.optional (stdenv.isLinux) utillinux
+        ++ lib.optional (stdenv.isDarwin) libtool
         ++ buildInputs;
 
       inherit nodejs;
···
         name = "node-dependencies-${name}-${version}";
 
         buildInputs = [ tarWrapper python nodejs ]
-          ++ stdenv.lib.optional (stdenv.isLinux) utillinux
-          ++ stdenv.lib.optional (stdenv.isDarwin) libtool
+          ++ lib.optional (stdenv.isLinux) utillinux
+          ++ lib.optional (stdenv.isDarwin) libtool
           ++ buildInputs;
 
         inherit dontStrip; # Stripping may fail a build for some package deployments
···
           # Create fake package.json to make the npm commands work properly
           cp ${src}/package.json .
           chmod 644 package.json
-          ${stdenv.lib.optionalString bypassCache ''
+          ${lib.optionalString bypassCache ''
             if [ -f ${src}/package-lock.json ]
             then
                 cp ${src}/package-lock.json .
···
 
           # Go to the parent folder to make sure that all packages are pinpointed
           cd ..
-          ${stdenv.lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
+          ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
 
           ${prepareAndInvokeNPM { inherit packageName bypassCache reconstructLock npmFlags production; }}
 
           # Expose the executables that were installed
           cd ..
-          ${stdenv.lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
+          ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
 
           mv ${packageName} lib
           ln -s $out/lib/node_modules/.bin $out/bin
···
     stdenv.mkDerivation {
       name = "node-shell-${name}-${version}";
 
-      buildInputs = [ python nodejs ] ++ stdenv.lib.optional (stdenv.isLinux) utillinux ++ buildInputs;
+      buildInputs = [ python nodejs ] ++ lib.optional (stdenv.isLinux) utillinux ++ buildInputs;
       buildCommand = ''
         mkdir -p $out/bin
         cat > $out/bin/shell <<EOF
···
 
       # Provide the dependencies in a development shell through the NODE_PATH environment variable
       inherit nodeDependencies;
-      shellHook = stdenv.lib.optionalString (dependencies != []) ''
+      shellHook = lib.optionalString (dependencies != []) ''
         export NODE_PATH=${nodeDependencies}/lib/node_modules
         export PATH="${nodeDependencies}/bin:$PATH"
       '';
     };
 in
 {
-  buildNodeSourceDist = stdenv.lib.makeOverridable buildNodeSourceDist;
-  buildNodePackage = stdenv.lib.makeOverridable buildNodePackage;
-  buildNodeShell = stdenv.lib.makeOverridable buildNodeShell;
+  buildNodeSourceDist = lib.makeOverridable buildNodeSourceDist;
+  buildNodePackage = lib.makeOverridable buildNodePackage;
+  buildNodeShell = lib.makeOverridable buildNodeShell;
 }

pkgs/applications/networking/n8n/node-packages.nix

···
     bypassCache = true;
     reconstructLock = true;
   };
-}
+}

pkgs/applications/networking/netperf/default.nix

···
-{ libsmbios, stdenv, autoreconfHook, fetchFromGitHub }:
+{ libsmbios, lib, stdenv, autoreconfHook, fetchFromGitHub }:
 
 stdenv.mkDerivation {
   pname = "netperf";
···
     sha256 = "1wbbgdvhadd3qs3afv6i777argdpcyxkwz4yv6aqp223n8ki6dm8";
   };
 
-  buildInputs = stdenv.lib.optional (with stdenv.hostPlatform; isx86 && isLinux) libsmbios;
+  buildInputs = lib.optional (with stdenv.hostPlatform; isx86 && isLinux) libsmbios;
   nativeBuildInputs = [ autoreconfHook ];
   autoreconfPhase = ''
     autoreconf -i -I src/missing/m4
···
     homepage = "http://www.netperf.org/netperf/";
     license = "Hewlett-Packard BSD-like license";
 
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.mmlb ];
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.mmlb ];
   };
 }

pkgs/applications/networking/nntp-proxy/default.nix

···
-{ stdenv, fetchFromGitHub, libconfig, pkgconfig, libevent, openssl }:
+{ lib, stdenv, fetchFromGitHub, libconfig, pkgconfig, libevent, openssl }:
 
 stdenv.mkDerivation {
   pname = "nntp-proxy";
···
   meta = {
     description = "Simple NNTP proxy with SSL support";
     homepage = "https://github.com/nieluj/nntp-proxy";
-    license = stdenv.lib.licenses.gpl2Plus;
-    maintainers = [ stdenv.lib.maintainers.fadenb ];
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.gpl2Plus;
+    maintainers = [ lib.maintainers.fadenb ];
+    platforms = lib.platforms.all;
   };
 }

pkgs/applications/networking/offrss/default.nix

···
   '';
 
   buildInputs = [ curl libmrss ]
-    ++ stdenv.lib.optional (stdenv.hostPlatform == stdenv.buildPlatform) podofo
-    ++ stdenv.lib.optional (!stdenv.isLinux) libiconv;
+    ++ lib.optional (stdenv.hostPlatform == stdenv.buildPlatform) podofo
+    ++ lib.optional (!stdenv.isLinux) libiconv;
 
   configurePhase = ''
     substituteInPlace Makefile \
       --replace '$(CC) $(CFLAGS) $(LDFLAGS)' '$(CXX) $(CFLAGS) $(LDFLAGS)'
-  '' + stdenv.lib.optionalString (!stdenv.isLinux) ''
+  '' + lib.optionalString (!stdenv.isLinux) ''
     sed 's/#EXTRA/EXTRA/' -i Makefile
-  '' + stdenv.lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
+  '' + lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
     sed 's/^PDF/#PDF/' -i Makefile
   '';
 
···
     description = "Offline RSS/Atom reader";
     license = licenses.agpl3Plus;
     maintainers = with maintainers; [ viric ];
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/networking/openbazaar/client.nix

···
   postFixup = ''
     makeWrapper ${electron}/bin/electron $out/bin/${pname} \
       --add-flags $out/share/${pname}/resources/app \
-      --prefix LD_LIBRARY_PATH : "${stdenv.lib.makeLibraryPath [ gcc-unwrapped.lib ]}"
+      --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ gcc-unwrapped.lib ]}"
   '';
 
   meta = with lib; {

pkgs/applications/networking/openbazaar/default.nix

···
     install -D $src $out/bin/openbazaard
   '';
 
-  postFixup = stdenv.lib.optionalString (!stdenv.isDarwin) ''
+  postFixup = lib.optionalString (!stdenv.isDarwin) ''
     patchelf \
       --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
       $out/bin/openbazaard

pkgs/applications/networking/pjsip/default.nix

···
   ];
 
   buildInputs = [ openssl libsamplerate ]
-    ++ stdenv.lib.optional stdenv.isLinux alsaLib
-    ++ stdenv.lib.optional stdenv.isDarwin AppKit;
+    ++ lib.optional stdenv.isLinux alsaLib
+    ++ lib.optional stdenv.isDarwin AppKit;
 
   preConfigure = ''
     export LD=$CC
   '' # Fixed on master, remove with 2.11
-     + stdenv.lib.optionalString stdenv.isDarwin ''
+     + lib.optionalString stdenv.isDarwin ''
     NIX_CFLAGS_COMPILE+=" -framework Security"
   '';
 

pkgs/applications/networking/resilio-sync/default.nix

···
     i686-linux = "i386";
     aarch64-linux = "arm64";
   }.${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");
-  libPath = stdenv.lib.makeLibraryPath [ stdenv.cc.libc ];
+  libPath = lib.makeLibraryPath [ stdenv.cc.libc ];
 
 in stdenv.mkDerivation rec {
   pname = "resilio-sync";

pkgs/applications/networking/siproxd/default.nix

···
-{ stdenv, fetchurl, libosip }:
+{ lib, stdenv, fetchurl, libosip }:
 
 stdenv.mkDerivation rec {
   name = "siproxd-0.8.2";
···
   meta = {
     homepage = "http://siproxd.sourceforge.net/";
     description = "A masquerading SIP Proxy Server";
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; linux;
-    license = stdenv.lib.licenses.gpl2Plus;
+    maintainers = with lib.maintainers; [viric];
+    platforms = with lib.platforms; linux;
+    license = lib.licenses.gpl2Plus;
   };
 }

pkgs/applications/networking/soulseek/nicotine-plus/default.nix

···
-{ stdenv, fetchFromGitHub, python27Packages, geoip }:
+{ lib, stdenv, fetchFromGitHub, python27Packages, geoip }:
 
-with stdenv.lib;
+with lib;
 
 python27Packages.buildPythonApplication {
   pname = "nicotine-plus";

pkgs/applications/networking/super-productivity/default.nix

···
 
   version = "1.10.45";
 
-  rpath = stdenv.lib.makeLibraryPath [
+  rpath = lib.makeLibraryPath [
     alsaLib
     atk
     cairo

pkgs/applications/networking/tcpkali/default.nix

···
-{stdenv, autoreconfHook, fetchFromGitHub, bison}:
+{lib, stdenv, autoreconfHook, fetchFromGitHub, bison}:
 
 let version = "1.1.1"; in
 
···
   buildInputs = [ bison];
   meta = {
     description = "High performance TCP and WebSocket load generator and sink";
-    license = stdenv.lib.licenses.bsd2;
+    license = lib.licenses.bsd2;
     inherit (src.meta) homepage;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = with stdenv.lib.maintainers; [ ethercrow ];
+    platforms = lib.platforms.linux;
+    maintainers = with lib.maintainers; [ ethercrow ];
   };
 }

pkgs/applications/networking/termius/default.nix

···
     maintainers = with maintainers; [ Br1ght0ne th0rgal ];
     platforms = [ "x86_64-linux" ];
   };
-}
+}

pkgs/applications/office/antiword/default.nix

···
-{ fetchurl, stdenv }:
+{ lib, fetchurl, stdenv }:
 
 let
   name = "antiword-0.37";
···
   meta = {
     homepage = "http://www.winfield.demon.nl/";
     description = "Convert MS Word documents to plain text or PostScript";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
 
-    maintainers = [ stdenv.lib.maintainers.peti ];
-    platforms = with stdenv.lib.platforms; linux ++ darwin;
+    maintainers = [ lib.maintainers.peti ];
+    platforms = with lib.platforms; linux ++ darwin;
   };
 }

pkgs/applications/office/beancount/bean-add.nix

···
-{ stdenv, fetchFromGitHub, python3Packages }:
+{ lib, stdenv, fetchFromGitHub, python3Packages }:
 
 stdenv.mkDerivation {
   name = "bean-add-2018-01-08";
···
     # The (only) source file states:
     #   License: "Do what you feel is right, but don't be a jerk" public license.
 
-    maintainers = with stdenv.lib.maintainers; [ matthiasbeyer ];
+    maintainers = with lib.maintainers; [ matthiasbeyer ];
   };
 }
 

pkgs/applications/office/bookworm/default.nix

···
   # These programs are expected in PATH from the source code and scripts
   preFixup = ''
     gappsWrapperArgs+=(
-      --prefix PATH : "${stdenv.lib.makeBinPath [ unzip unar poppler_utils html2text coreutils curl gnugrep ]}"
+      --prefix PATH : "${lib.makeBinPath [ unzip unar poppler_utils html2text coreutils curl gnugrep ]}"
       --prefix PATH : $out/bin
     )
   '';

pkgs/applications/office/docear/default.nix

···
 
     # The wrapper ensures oraclejre is used
     makeWrapper ${runtimeShell} $out/bin/docear \
-      --set _JAVA_OPTIONS "${stdenv.lib.optionalString antialiasFont ''-Dswing.aatext=TRUE -Dawt.useSystemAAFontSettings=on''}" \
+      --set _JAVA_OPTIONS "${lib.optionalString antialiasFont ''-Dswing.aatext=TRUE -Dawt.useSystemAAFontSettings=on''}" \
       --set JAVA_HOME ${oraclejre.home} \
       --add-flags "$out/share/docear.sh"
 

pkgs/applications/office/fava/default.nix

···
-{ stdenv, python3, beancount }:
+{ lib, stdenv, python3, beancount }:
 
 let
   inherit (python3.pkgs) buildPythonApplication fetchPypi;
···
   meta = {
     homepage = "https://beancount.github.io/fava";
     description = "Web interface for beancount";
-    license = stdenv.lib.licenses.mit;
-    maintainers = with stdenv.lib.maintainers; [ matthiasbeyer ];
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ matthiasbeyer ];
   };
 }

pkgs/applications/office/gnucash/default.nix

···
-{ fetchurl, stdenv, pkgconfig, makeWrapper, cmake, gtest
+{ fetchurl, lib, stdenv, pkgconfig, makeWrapper, cmake, gtest
 , boost, icu, libxml2, libxslt, gettext, swig, isocodes, gtk3, glibcLocales
 , webkitgtk, dconf, hicolor-icon-theme, libofx, aqbanking, gwenhywfar, libdbi
 , libdbiDrivers, guile, perl, perlPackages
···
       --prefix XDG_DATA_DIRS : "${hicolor-icon-theme}/share" \
       --prefix PERL5LIB ":" "$PERL5LIB" \
       --set GNC_DBD_DIR ${libdbiDrivers}/lib/dbd \
-      --prefix GIO_EXTRA_MODULES : "${stdenv.lib.getLib dconf}/lib/gio/modules"
+      --prefix GIO_EXTRA_MODULES : "${lib.getLib dconf}/lib/gio/modules"
   '';
 
   # TODO: The following tests FAILED:
···
       accounting principles to ensure balanced books and accurate reports.
     '';
 
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
     homepage = "http://www.gnucash.org/";
 
-    maintainers = [ stdenv.lib.maintainers.peti stdenv.lib.maintainers.domenkozar ];
-    platforms = stdenv.lib.platforms.gnu ++ stdenv.lib.platforms.linux;
+    maintainers = [ lib.maintainers.peti lib.maintainers.domenkozar ];
+    platforms = lib.platforms.gnu ++ lib.platforms.linux;
   };
 }

pkgs/applications/office/gnumeric/default.nix

···
   version = "1.12.48";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/${pname}/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/${pname}/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "14556b0vyxdvdwjlin0rv7jk0vq4nplbmvp9j89bhkfk84xf7k2p";
   };
 
···
 
   meta = with lib; {
     description = "The GNOME Office Spreadsheet";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
     homepage = "http://projects.gnome.org/gnumeric/";
     platforms = platforms.unix;
     maintainers = [ maintainers.vcunat ];

pkgs/applications/office/impressive/default.nix

···
 
       homepage = "http://impressive.sourceforge.net/";
 
-      license = stdenv.lib.licenses.gpl2;
+      license = lib.licenses.gpl2;
 
       maintainers = with lib.maintainers; [ lheckemann ];
-      platforms = stdenv.lib.platforms.mesaPlatforms;
+      platforms = lib.platforms.mesaPlatforms;
     };
   }

pkgs/applications/office/jabref/default.nix

···
   buildInputs = [ gsettings-desktop-schemas ] ++ systemLibs;
 
   systemLibs = [ gtk3 zlib libX11 libXext libXi libXrender libXtst libGL alsaLib libav cairo freetype pango gdk-pixbuf glib ];
-  systemLibPaths = stdenv.lib.makeLibraryPath systemLibs;
+  systemLibPaths = lib.makeLibraryPath systemLibs;
 
   installPhase = ''
     mkdir -p $out/share/java $out/share/icons
···
     for f in $out/lib/runtime/bin/j*; do
       patchelf \
         --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-        --set-rpath "${ stdenv.lib.makeLibraryPath [ zlib ]}:$out/lib/runtime/lib:$out/lib/runtime/lib/server" $f
+        --set-rpath "${ lib.makeLibraryPath [ zlib ]}:$out/lib/runtime/lib:$out/lib/runtime/lib/server" $f
     done
 
     for f in $out/lib/runtime/lib/*.so; do

pkgs/applications/office/jameica/default.nix

···
   inherit name version;
 
   nativeBuildInputs = [ ant jdk makeWrapper ];
-  buildInputs = stdenv.lib.optionals stdenv.isLinux [ gtk2 glib xorg.libXtst ]
-                ++ stdenv.lib.optional stdenv.isDarwin Cocoa;
+  buildInputs = lib.optionals stdenv.isLinux [ gtk2 glib xorg.libXtst ]
+                ++ lib.optional stdenv.isDarwin Cocoa;
 
   src = fetchFromGitHub {
     owner = "willuhn";
···
 
     makeWrapper ${jre}/bin/java $out/bin/jameica \
       --add-flags "-cp $out/share/java/jameica.jar:$out/share/${name}/* ${
-        stdenv.lib.optionalString stdenv.isDarwin ''-Xdock:name="Jameica" -XstartOnFirstThread''
+        lib.optionalString stdenv.isDarwin ''-Xdock:name="Jameica" -XstartOnFirstThread''
       } de.willuhn.jameica.Main" \
-      --prefix LD_LIBRARY_PATH : ${stdenv.lib.makeLibraryPath buildInputs} \
+      --prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath buildInputs} \
       --run "cd $out/share/java/"
   '';
 

pkgs/applications/office/keepnote/default.nix

···
-{ stdenv, fetchurl, python2Packages }:
+{ lib, stdenv, fetchurl, python2Packages }:
 
 python2Packages.buildPythonApplication {
   name = "keepnote-0.7.8";
···
   meta = {
     description = "Note taking application";
     homepage = "http://keepnote.org";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
   };
 }

pkgs/applications/office/ledger-autosync/default.nix

···
     pycparser
     secretstorage
     six
-  ] ++ stdenv.lib.optional useLedger ledger
-    ++ stdenv.lib.optional useHledger hledger;
+  ] ++ lib.optional useLedger ledger
+    ++ lib.optional useHledger hledger;
 
   # Checks require ledger as a python package,
   # ledger does not support python3 while ledger-autosync requires it.

pkgs/applications/office/ledger-web/gemset.nix

···
     };
     version = "2.0.9";
   };
-}
+}

pkgs/applications/office/libreoffice/src-fresh/override.nix

···
-{ stdenv, kdeIntegration, ... }:
+{ lib, stdenv, kdeIntegration, ... }:
 attrs:
 {
   postConfigure = attrs.postConfigure + ''
     sed -e '/CPPUNIT_TEST(Import_Export_Import);/d' -i './sw/qa/inc/swmodeltestbase.hxx'
   '';
   configureFlags = attrs.configureFlags ++ [
-    (stdenv.lib.enableFeature kdeIntegration "kf5")
+    (lib.enableFeature kdeIntegration "kf5")
   ];
 }

pkgs/applications/office/libreoffice/src-still/override.nix

···
-{ stdenv, kdeIntegration, fetchpatch, ... }:
+{ lib, stdenv, kdeIntegration, fetchpatch, ... }:
 attrs:
 {
   patches = attrs.patches or [ ] ++ [
···
   postConfigure = attrs.postConfigure + ''
     sed -e '/CPPUNIT_TEST(Import_Export_Import);/d' -i './sw/qa/extras/inc/swmodeltestbase.hxx'
   '';
-  configureFlags = stdenv.lib.remove "--without-system-qrcodegen"
+  configureFlags = lib.remove "--without-system-qrcodegen"
   (attrs.configureFlags ++ [
-    (stdenv.lib.enableFeature kdeIntegration "kde5")
+    (lib.enableFeature kdeIntegration "kde5")
   ]);
   meta = attrs.meta // { description = "Comprehensive, professional-quality productivity suite (Still/Stable release)"; };
 }

pkgs/applications/office/marp/default.nix

···
 
   postFixup = ''
     patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
-      --set-rpath "${atomEnv.libPath}:${stdenv.lib.makeLibraryPath [ libXScrnSaver gtk2 ]}:$out/lib/marp" \
+      --set-rpath "${atomEnv.libPath}:${lib.makeLibraryPath [ libXScrnSaver gtk2 ]}:$out/lib/marp" \
       $out/bin/Marp
   '';
 

pkgs/applications/office/mendeley/default.nix

···
 
     interpreter=$(patchelf --print-interpreter $(readlink -f $(which patchelf)))
     patchelf --set-interpreter $interpreter \
-             --set-rpath ${stdenv.lib.makeLibraryPath deps}:$out/lib \
+             --set-rpath ${lib.makeLibraryPath deps}:$out/lib \
              $out/bin/mendeleydesktop
 
     wrapQtApp $out/bin/mendeleydesktop \
       --add-flags "--unix-distro-build" \
-      ${stdenv.lib.optionalString autorunLinkHandler # ignore errors installing the link handler
+      ${lib.optionalString autorunLinkHandler # ignore errors installing the link handler
       ''--run "$out/bin/install-mendeley-link-handler.sh $out/bin/mendeleydesktop ||:"''}
 
     # Remove bundled qt bits
···
 
     # Patch up link handler script
     wrapProgram $out/bin/install-mendeley-link-handler.sh \
-      --prefix PATH ':' ${stdenv.lib.makeBinPath [ which gconf desktop-file-utils ] }
+      --prefix PATH ':' ${lib.makeBinPath [ which gconf desktop-file-utils ] }
   '';
 
   dontStrip = true;

pkgs/applications/office/mmex/default.nix

···
-{ stdenv, fetchgit, sqlite, wxGTK30, gettext, wrapGAppsHook }:
+{ lib, stdenv, fetchgit, sqlite, wxGTK30, gettext, wrapGAppsHook }:
 
 
 let
···
     meta = {
       description = "Easy-to-use personal finance software";
       homepage = "https://www.moneymanagerex.org/";
-      license = stdenv.lib.licenses.gpl2Plus;
-      maintainers = with stdenv.lib.maintainers; [viric];
-      platforms = with stdenv.lib.platforms; linux;
+      license = lib.licenses.gpl2Plus;
+      maintainers = with lib.maintainers; [viric];
+      platforms = with lib.platforms; linux;
     };
   }

pkgs/applications/office/moneyplex/default.nix

···
 , runtimeShell }:
 
 let
-  libPath = stdenv.lib.makeLibraryPath [
+  libPath = lib.makeLibraryPath [
     stdenv.cc.cc zlib glib gdk-pixbuf gtk2 cairo pango libX11 atk openssl
   ];
 
···
     if [ ! -d "\$MDIR/pcsc" ]; then
         ${coreutils}/bin/mkdir -p \$MDIR/pcsc
     fi
-    if [ ! -e "\$MDIR/pcsc/libpcsclite.so.1" ] || [ ! \`${coreutils}/bin/readlink -f "\$MDIR/pcsc/libpcsclite.so.1"\` -ef "${stdenv.lib.getLib pcsclite}/lib/libpcsclite.so.1" ]; then
-        ${coreutils}/bin/ln -sf "${stdenv.lib.getLib pcsclite}/lib/libpcsclite.so.1" "\$MDIR/pcsc/libpcsclite.so.1"
+    if [ ! -e "\$MDIR/pcsc/libpcsclite.so.1" ] || [ ! \`${coreutils}/bin/readlink -f "\$MDIR/pcsc/libpcsclite.so.1"\` -ef "${lib.getLib pcsclite}/lib/libpcsclite.so.1" ]; then
+        ${coreutils}/bin/ln -sf "${lib.getLib pcsclite}/lib/libpcsclite.so.1" "\$MDIR/pcsc/libpcsclite.so.1"
     fi
 
 

pkgs/applications/office/notes-up/default.nix

···
   ];
 
   # Whether to build with contractor support (Pantheon specific)
-  cmakeFlags = stdenv.lib.optional (!withPantheon) "-Dnoele=yes";
+  cmakeFlags = lib.optional (!withPantheon) "-Dnoele=yes";
 
   passthru = {
     updateScript = nix-update-script {
···
 
   meta = with lib; {
     description = "Markdown notes editor and manager designed for elementary OS"
-    + stdenv.lib.optionalString withPantheon " - built with Contractor support";
+    + lib.optionalString withPantheon " - built with Contractor support";
     homepage = "https://github.com/Philip-Scott/Notes-up";
     license = licenses.gpl2;
     maintainers = with maintainers; [ davidak worldofpeace ];

pkgs/applications/office/portfolio/default.nix

···
     categories = "Office;";
   };
 
-  runtimeLibs = stdenv.lib.makeLibraryPath [ gtk3 webkitgtk ];
+  runtimeLibs = lib.makeLibraryPath [ gtk3 webkitgtk ];
 in
 stdenv.mkDerivation rec {
   pname = "PortfolioPerformance";

pkgs/applications/office/qnotero/default.nix

···
-{ stdenv, fetchFromGitHub, python3Packages, wrapQtAppsHook }:
+{ lib, stdenv, fetchFromGitHub, python3Packages, wrapQtAppsHook }:
 
 python3Packages.buildPythonPackage rec {
   pname = "qnotero";
···
   meta = {
     description = "Quick access to Zotero references";
     homepage = "http://www.cogsci.nl/software/qnotero";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.nico202 ];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.nico202 ];
   };
 }

pkgs/applications/office/scribus/default.nix

···
-{ stdenv, fetchurl, pkgconfig, freetype, lcms, libtiff, libxml2
+{ lib, stdenv, fetchurl, pkgconfig, freetype, lcms, libtiff, libxml2
 , libart_lgpl, qt4, python2, cups, fontconfig, libjpeg
 , zlib, libpng, xorg, cairo, podofo, hunspell, boost, cmake, imagemagick, ghostscript }:
 
···
   '';
 
   meta = {
-    maintainers = [ stdenv.lib.maintainers.marcweber ];
-    platforms = stdenv.lib.platforms.linux;
+    maintainers = [ lib.maintainers.marcweber ];
+    platforms = lib.platforms.linux;
     description = "Desktop Publishing (DTP) and Layout program for Linux";
     homepage = "https://www.scribus.net";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
   };
 }

pkgs/applications/office/softmaker/generic.nix

···
     extraWrapperArgs = ''
       --set LD_PRELOAD "${libredirect}/lib/libredirect.so" \
       --set NIX_REDIRECTS "/bin/ls=${coreutils}/bin/ls" \
-      --prefix PATH : "${stdenv.lib.makeBinPath [ coreutils gnugrep util-linux which ]}"
+      --prefix PATH : "${lib.makeBinPath [ coreutils gnugrep util-linux which ]}"
     '';
   in ''
     runHook preInstall

pkgs/applications/office/timetrap/gemset.nix

···
     };
     version = "1.15.2";
   };
-}
+}

pkgs/applications/office/todo.txt-cli/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 let
   version = "2.12.0";
 in stdenv.mkDerivation {
···
   meta = {
     description = "Simple plaintext todo list manager";
     homepage = "http://todotxt.com";
-    license = stdenv.lib.licenses.gpl3;
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.gpl3;
+    platforms = lib.platforms.all;
   };
 }

pkgs/applications/office/tryton/default.nix

···
-{ stdenv
+{ lib, stdenv
 , python3Packages
 , pkgconfig
 , librsvg
···
 , wrapGAppsHook
 }:
 
-with stdenv.lib;
+with lib;
 
 python3Packages.buildPythonApplication rec {
   pname = "tryton";

pkgs/applications/office/tudu/default.nix

···
 
   buildInputs = [ ncurses ];
 
-  preConfigure = stdenv.lib.optionalString stdenv.cc.isClang ''
+  preConfigure = lib.optionalString stdenv.cc.isClang ''
     substituteInPlace configure \
       --replace 'echo "main()' 'echo "int main()'
   '';

pkgs/applications/office/wordgrinder/default.nix

···
     "OBJDIR=$TMP/wg-build"
   ];
 
-  preBuild = stdenv.lib.optionalString stdenv.isLinux ''
+  preBuild = lib.optionalString stdenv.isLinux ''
     makeFlagsArray+=('XFT_PACKAGE=--cflags={} --libs={-lX11 -lXft}')
   '';
 
···
     ncurses
     readline
     zlib
-  ] ++ stdenv.lib.optionals stdenv.isLinux [
+  ] ++ lib.optionals stdenv.isLinux [
     libXft
   ];
 
   # To be able to find <Xft.h>
-  NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.isLinux "-I${libXft.dev}/include/X11";
+  NIX_CFLAGS_COMPILE = lib.optionalString stdenv.isLinux "-I${libXft.dev}/include/X11";
 
   # Binaries look for LuaFileSystem library (lfs.so) at runtime
   postInstall = ''
     wrapProgram $out/bin/wordgrinder --set LUA_CPATH "${lua52Packages.luafilesystem}/lib/lua/5.2/lfs.so";
-  '' + stdenv.lib.optionalString stdenv.isLinux ''
+  '' + lib.optionalString stdenv.isLinux ''
     wrapProgram $out/bin/xwordgrinder --set LUA_CPATH "${lua52Packages.luafilesystem}/lib/lua/5.2/lfs.so";
   '';
 
···
     homepage = "https://cowlark.com/wordgrinder";
     license = licenses.mit;
     maintainers = with maintainers; [ matthiasbeyer ];
-    platforms = with stdenv.lib.platforms; linux ++ darwin;
+    platforms = with lib.platforms; linux ++ darwin;
   };
 }

pkgs/applications/office/wpsoffice/default.nix

···
-{ stdenv
+{ lib, stdenv
 , mkDerivation
 , fetchurl
 , autoPatchelfHook
···
   unpackCmd = "dpkg -x $src .";
   sourceRoot = ".";
 
-  postUnpack = stdenv.lib.optionalString (version == "11.1.0.9505") ''
+  postUnpack = lib.optionalString (version == "11.1.0.9505") ''
     # distribution is missing libjsapiservice.so, so we should not let
     # autoPatchelfHook fail on the following dead libraries
     rm opt/kingsoft/wps-office/office6/{libjsetapi.so,libjswppapi.so,libjswpsapi.so}
···
     homepage = "http://wps-community.org/";
     platforms = [ "x86_64-linux" ];
     hydraPlatforms = [];
-    license = stdenv.lib.licenses.unfreeRedistributable;
-    maintainers = with stdenv.lib.maintainers; [ mlatus th0rgal ];
+    license = lib.licenses.unfreeRedistributable;
+    maintainers = with lib.maintainers; [ mlatus th0rgal ];
   };
 
   buildInputs = with xorg; [
···
     done
   '';
 
-  runtimeLibPath = stdenv.lib.makeLibraryPath [
+  runtimeLibPath = lib.makeLibraryPath [
     cups.lib
   ];
 

pkgs/applications/office/zotero/default.nix

···
   dontStrip = true;
   dontPatchELF = true;
 
-  libPath = stdenv.lib.makeLibraryPath
+  libPath = lib.makeLibraryPath
     [ stdenv.cc.cc
       atk
       cairo
···
       nspr
       nss
       pango
-    ] + ":" + stdenv.lib.makeSearchPathOutput "lib" "lib64" [
+    ] + ":" + lib.makeSearchPathOutput "lib" "lib64" [
       stdenv.cc.cc
     ];
 
···
 
   preFixup = ''
     gappsWrapperArgs+=(
-      --prefix PATH : ${stdenv.lib.makeBinPath [ coreutils ]}
+      --prefix PATH : ${lib.makeBinPath [ coreutils ]}
     )
   '';
 

pkgs/applications/radio/cubicsdr/default.nix

···
   buildInputs = [ fftw hamlib libpulseaudio libGL libX11 liquid-dsp soapysdr-with-plugins wxGTK31-gtk3 ];
 
   cmakeFlags = [ "-DUSE_HAMLIB=ON" ]
-    ++ stdenv.lib.optional enableDigitalLab "-DENABLE_DIGITAL_LAB=ON";
+    ++ lib.optional enableDigitalLab "-DENABLE_DIGITAL_LAB=ON";
 
   meta = with lib; {
     homepage = "https://cubicsdr.com";

pkgs/applications/radio/direwolf/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, alsaLib, espeak, glibc, gpsd
+{ lib, stdenv, fetchFromGitHub, cmake, alsaLib, espeak, glibc, gpsd
 , hamlib, perl, python, udev }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "direwolf";

pkgs/applications/radio/dsd/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [
     mbelib libsndfile itpp
-  ] ++ stdenv.lib.optionals portaudioSupport [ portaudio ];
+  ] ++ lib.optionals portaudioSupport [ portaudio ];
 
   doCheck = true;
   preCheck = ''

pkgs/applications/radio/fldigi/default.nix

···
-{ stdenv, fetchurl, hamlib, fltk14, libjpeg, libpng, portaudio, libsndfile,
+{ lib, stdenv, fetchurl, hamlib, fltk14, libjpeg, libpng, portaudio, libsndfile,
   libsamplerate, libpulseaudio, libXinerama, gettext, pkgconfig, alsaLib }:
 
 stdenv.mkDerivation rec {
···
   meta = {
     description = "Digital modem program";
     homepage = "https://sourceforge.net/projects/fldigi/";
-    license = stdenv.lib.licenses.gpl3Plus;
-    maintainers = with stdenv.lib.maintainers; [ relrod ftrvxmtrx ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3Plus;
+    maintainers = with lib.maintainers; [ relrod ftrvxmtrx ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/radio/fllog/default.nix

···
-{ stdenv
+{ lib
+, stdenv
 , fetchurl
 , fltk13
 , libjpeg
···
   meta = {
     description = "Digital modem log program";
     homepage = "https://sourceforge.net/projects/fldigi/";
-    license = stdenv.lib.licenses.gpl3Plus;
-    maintainers = with stdenv.lib.maintainers; [ dysinger ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3Plus;
+    maintainers = with lib.maintainers; [ dysinger ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/radio/flmsg/default.nix

···
-{ stdenv
+{ lib
+, stdenv
 , fetchurl
 , fltk13
 , libjpeg
···
   meta = {
     description = "Digital modem message program";
     homepage = "https://sourceforge.net/projects/fldigi/";
-    license = stdenv.lib.licenses.gpl3Plus;
-    maintainers = with stdenv.lib.maintainers; [ dysinger ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3Plus;
+    maintainers = with lib.maintainers; [ dysinger ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/radio/flrig/default.nix

···
-{ stdenv
+{ lib
+, stdenv
 , fetchurl
 , fltk13
 , libjpeg
···
   meta = {
     description = "Digital modem rig control program";
     homepage = "https://sourceforge.net/projects/fldigi/";
-    license = stdenv.lib.licenses.gpl3Plus;
-    maintainers = with stdenv.lib.maintainers; [ dysinger ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3Plus;
+    maintainers = with lib.maintainers; [ dysinger ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/radio/flwrap/default.nix

···
-{ stdenv
+{ lib
+, stdenv
 , fetchurl
 , fltk13
 , libjpeg
···
   meta = {
     description = "Digital modem file transfer program";
     homepage = "https://sourceforge.net/projects/fldigi/";
-    license = stdenv.lib.licenses.gpl3Plus;
-    maintainers = with stdenv.lib.maintainers; [ dysinger ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3Plus;
+    maintainers = with lib.maintainers; [ dysinger ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/radio/gnuradio/3.7.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , fetchpatch
 , cmake
···
     };
     gr-audio = {
       runtime = []
-        ++ stdenv.lib.optionals stdenv.isLinux [ alsaLib libjack2 ]
-        ++ stdenv.lib.optionals stdenv.isDarwin [ CoreAudio ]
+        ++ lib.optionals stdenv.isLinux [ alsaLib libjack2 ]
+        ++ lib.optionals stdenv.isDarwin [ CoreAudio ]
       ;
       cmakeEnableFlag = "GR_AUDIO";
     };
···
   };
   shared = (import ./shared.nix {
     inherit
+      lib
       stdenv
       python
       removeReferencesTo
···
     # From some reason, if these are not set, libcodec2 and gsm are
     # not detected properly (slightly different then what's in
     # ./default.nix).
-    ++ stdenv.lib.optionals (hasFeature "gr-vocoder" features) [
+    ++ lib.optionals (hasFeature "gr-vocoder" features) [
       "-DLIBCODEC2_LIBRARIES=${codec2}/lib/libcodec2.so"
       "-DLIBCODEC2_INCLUDE_DIR=${codec2}/include"
       "-DLIBGSM_LIBRARIES=${gsm}/lib/libgsm.so"
···
   ;
   stripDebugList = shared.stripDebugList
     # gr-fcd feature was dropped in 3.8
-    ++ stdenv.lib.optionals (hasFeature "gr-fcd" features) [ "share/gnuradio/examples/fcd" ]
+    ++ lib.optionals (hasFeature "gr-fcd" features) [ "share/gnuradio/examples/fcd" ]
   ;
   preConfigure = ''
   ''
     # wxgui and pygtk are not looked up properly, so we force them to be
     # detected as found, if they are requested by the `features` attrset.
-    + stdenv.lib.optionalString (hasFeature "gr-wxgui" features) ''
+    + lib.optionalString (hasFeature "gr-wxgui" features) ''
       sed -i 's/.*wx\.version.*/set(WX_FOUND TRUE)/g' gr-wxgui/CMakeLists.txt
     ''
-    + stdenv.lib.optionalString (hasFeature "gnuradio-companion" features) ''
+    + lib.optionalString (hasFeature "gnuradio-companion" features) ''
       sed -i 's/.*pygtk_version.*/set(PYGTK_FOUND TRUE)/g' grc/CMakeLists.txt
     ''
     # If python-support is disabled, don't install volk's (git submodule)
···
     # NOTE: The same is done for 3.8, but we don't put this string in
     # ./shared.nix since on the next release of 3.8 it won't be needed there,
     # but it will be needed for 3.7, probably for ever.
-    + stdenv.lib.optionalString (!hasFeature "python-support" features) ''
+    + lib.optionalString (!hasFeature "python-support" features) ''
       sed -i -e "/python\/volk_modtool/d" volk/CMakeLists.txt
     ''
   ;

pkgs/applications/radio/gnuradio/ais.nix

···
 
   nativeBuildInputs = [ cmake makeWrapper pkg-config ];
   buildInputs = [ boost gnuradio cppunit gr-osmosdr log4cpp ]
-             ++ stdenv.lib.optionals pythonSupport [ python swig ];
+             ++ lib.optionals pythonSupport [ python swig ];
 
   postInstall = ''
     for prog in "$out"/bin/*; do

pkgs/applications/radio/gnuradio/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , fetchpatch
 , cmake
···
     };
     gr-audio = {
       runtime = []
-        ++ stdenv.lib.optionals stdenv.isLinux [ alsaLib libjack2 ]
-        ++ stdenv.lib.optionals stdenv.isDarwin [ CoreAudio ]
+        ++ lib.optionals stdenv.isLinux [ alsaLib libjack2 ]
+        ++ lib.optionals stdenv.isDarwin [ CoreAudio ]
       ;
       cmakeEnableFlag = "GR_AUDIO";
     };
···
   shared = (import ./shared.nix {
     inherit
       stdenv
+      lib
       python
       removeReferencesTo
       featuresInfo
···
     # From some reason, if these are not set, libcodec2 and gsm are not
     # detected properly. NOTE: qradiolink needs libcodec2 to be detected in
     # order to build, see https://github.com/qradiolink/qradiolink/issues/67
-    ++ stdenv.lib.optionals (hasFeature "gr-vocoder" features) [
+    ++ lib.optionals (hasFeature "gr-vocoder" features) [
       "-DLIBCODEC2_LIBRARIES=${codec2}/lib/libcodec2.so"
       "-DLIBCODEC2_INCLUDE_DIRS=${codec2}/include"
       "-DLIBCODEC2_HAS_FREEDV_API=ON"
···
   postInstall = shared.postInstall
     # This is the only python reference worth removing, if needed (3.7 doesn't
     # set that reference).
-    + stdenv.lib.optionalString (!hasFeature "python-support" features) ''
+    + lib.optionalString (!hasFeature "python-support" features) ''
       ${removeReferencesTo}/bin/remove-references-to -t ${python} $out/lib/cmake/gnuradio/GnuradioConfig.cmake
     ''
   ;
···
     # we'll need to package volk while able to tell it to install or not
     # install python referencing files. When we'll be there, this will help:
     # https://github.com/gnuradio/volk/pull/404
-    + stdenv.lib.optionalString (!hasFeature "python-support" features) ''
+    + lib.optionalString (!hasFeature "python-support" features) ''
       sed -i -e "/python\/volk_modtool/d" volk/CMakeLists.txt
     ''
   ;

pkgs/applications/radio/gnuradio/gsm.nix

···
   nativeBuildInputs = [ cmake pkg-config ];
   buildInputs = [
     boost gnuradio makeWrapper cppunit libosmocore gr-osmosdr log4cpp
-  ] ++ stdenv.lib.optionals pythonSupport [ python swig ];
+  ] ++ lib.optionals pythonSupport [ python swig ];
 
   postInstall = ''
     for prog in "$out"/bin/*; do

pkgs/applications/radio/gnuradio/limesdr.nix

···
   nativeBuildInputs = [
     cmake
     pkgconfig
-  ] ++ stdenv.lib.optionals pythonSupport [ swig ];
+  ] ++ lib.optionals pythonSupport [ swig ];
 
   buildInputs = [
     boost gnuradio limesuite log4cpp
-  ] ++ stdenv.lib.optionals pythonSupport [ python ];
+  ] ++ lib.optionals pythonSupport [ python ];
 
 
   meta = with lib; {

pkgs/applications/radio/gnuradio/nacl.nix

···
   nativeBuildInputs = [ cmake pkg-config ];
   buildInputs = [
     boost gnuradio uhd makeWrapper libsodium cppunit log4cpp
-  ] ++ stdenv.lib.optionals pythonSupport [ python swig ];
+  ] ++ lib.optionals pythonSupport [ python swig ];
 
   postInstall = ''
     for prog in "$out"/bin/*; do

pkgs/applications/radio/gnuradio/osmosdr.nix

···
   nativeBuildInputs = [ cmake makeWrapper pkg-config ];
   buildInputs = [
     boost log4cpp airspy gnuradio hackrf libbladeRF rtl-sdr uhd
-  ] ++ stdenv.lib.optionals stdenv.isLinux [ soapysdr-with-plugins ]
-    ++ stdenv.lib.optionals pythonSupport [ python swig python.pkgs.cheetah ];
+  ] ++ lib.optionals stdenv.isLinux [ soapysdr-with-plugins ]
+    ++ lib.optionals pythonSupport [ python swig python.pkgs.cheetah ];
 
   postInstall = ''
     for prog in "$out"/bin/*; do

pkgs/applications/radio/gnuradio/rds.nix

···
   nativeBuildInputs = [ cmake pkg-config ];
   buildInputs = [
     boost gnuradio makeWrapper log4cpp
-  ] ++ stdenv.lib.optionals pythonSupport [ python swig ];
+  ] ++ lib.optionals pythonSupport [ python swig ];
 
   postInstall = ''
     for prog in "$out"/bin/*; do

pkgs/applications/radio/gnuradio/shared.nix

···
-{ stdenv
+{ lib, stdenv
 , python
 , qt
 , gtk
···
 , fetchSubmodules
 }:
 
-let
-  lib = stdenv.lib;
-in rec {
+rec {
   version = builtins.concatStringsSep "." (
     lib.attrVals [ "major" "minor" "patch" ] versionAttr
   );

pkgs/applications/radio/gnuradio/wrapper.nix

···
-{ stdenv
+{ lib
+, stdenv
 , unwrapped
 , makeWrapper
 # For lndir
···
   pythonPkgs = extraPythonPackages
     # Add the extraPackages as python modules as well
     ++ (builtins.map unwrapped.python.pkgs.toPythonModule extraPackages)
-    ++ stdenv.lib.flatten (stdenv.lib.mapAttrsToList (
+    ++ lib.flatten (lib.mapAttrsToList (
       feat: info: (
         if unwrapped.hasFeature feat unwrapped.features then
           (if builtins.hasAttr "pythonRuntime" info then info.pythonRuntime else [])
···
           []
       )
       ) unwrapped.featuresInfo)
-    ++ stdenv.lib.optionals (unwrapped.hasFeature "python-support" unwrapped.features) [
+    ++ lib.optionals (unwrapped.hasFeature "python-support" unwrapped.features) [
       # Add unwrapped itself as a python module
       (unwrapped.python.pkgs.toPythonModule unwrapped)
     ]
   ;
   python3Env = unwrapped.python.withPackages(ps: pythonPkgs);
 
-  name = (stdenv.lib.appendToName "wrapped" unwrapped).name;
+  name = (lib.appendToName "wrapped" unwrapped).name;
   makeWrapperArgs = builtins.concatStringsSep " " ([
   ]
     # Emulating wrapGAppsHook & wrapQtAppsHook working together
-    ++ stdenv.lib.optionals (
+    ++ lib.optionals (
       (unwrapped.hasFeature "gnuradio-companion" unwrapped.features)
       || (unwrapped.hasFeature "gr-qtgui" unwrapped.features)
       ) [
···
       "--prefix" "XDG_DATA_DIRS" ":" "${hicolor-icon-theme}/share"
       # Needs to run `gsettings` on startup, see:
       # https://www.mail-archive.com/[e-mail]/msg1764890.html
-      "--prefix" "PATH" ":" "${stdenv.lib.getBin glib}/bin"
+      "--prefix" "PATH" ":" "${lib.getBin glib}/bin"
     ]
-    ++ stdenv.lib.optionals (unwrapped.hasFeature "gnuradio-companion" unwrapped.features) [
+    ++ lib.optionals (unwrapped.hasFeature "gnuradio-companion" unwrapped.features) [
       "--set" "GDK_PIXBUF_MODULE_FILE" "${librsvg}/${gdk-pixbuf.moduleDir}.cache"
-      "--prefix" "GIO_EXTRA_MODULES" ":" "${stdenv.lib.getLib dconf}/lib/gio/modules"
+      "--prefix" "GIO_EXTRA_MODULES" ":" "${lib.getLib dconf}/lib/gio/modules"
       "--prefix" "XDG_DATA_DIRS" ":" "${unwrapped.gtk}/share"
       "--prefix" "XDG_DATA_DIRS" ":" "${unwrapped.gtk}/share/gsettings-schemas/${unwrapped.gtk.name}"
-      "--prefix" "GI_TYPELIB_PATH" ":" "${stdenv.lib.makeSearchPath "lib/girepository-1.0" [
+      "--prefix" "GI_TYPELIB_PATH" ":" "${lib.makeSearchPath "lib/girepository-1.0" [
         unwrapped.gtk
         gsettings-desktop-schemas
         atk
···
         at-spi2-core
       ]}"
     ]
-    ++ stdenv.lib.optionals (extraPackages != []) [
-      "--prefix" "GRC_BLOCKS_PATH" ":" "${stdenv.lib.makeSearchPath "share/gnuradio/grc/blocks" extraPackages}"
+    ++ lib.optionals (extraPackages != []) [
+      "--prefix" "GRC_BLOCKS_PATH" ":" "${lib.makeSearchPath "share/gnuradio/grc/blocks" extraPackages}"
     ]
-    ++ stdenv.lib.optionals (unwrapped.hasFeature "gr-qtgui" unwrapped.features)
+    ++ lib.optionals (unwrapped.hasFeature "gr-qtgui" unwrapped.features)
       # 3.7 builds with qt4
       (if unwrapped.versionAttr.major == "3.8" then
         [
           "--prefix" "QT_PLUGIN_PATH" ":"
-          "${stdenv.lib.getBin unwrapped.qt.qtbase}/${unwrapped.qt.qtbase.qtPluginPrefix}"
+          "${lib.getBin unwrapped.qt.qtbase}/${unwrapped.qt.qtbase.qtPluginPrefix}"
           "--prefix" "QML2_IMPORT_PATH" ":"
-          "${stdenv.lib.getBin unwrapped.qt.qtbase}/${unwrapped.qt.qtbase.qtQmlPrefix}"
+          "${lib.getBin unwrapped.qt.qtbase}/${unwrapped.qt.qtbase.qtQmlPrefix}"
         ]
       else
         # TODO: Add here qt4 related environment for 3.7?

pkgs/applications/radio/gqrx/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [
     qtbase qtsvg gnuradio boost gr-osmosdr rtl-sdr hackrf
-  ] ++ stdenv.lib.optionals pulseaudioSupport [ libpulseaudio ];
+  ] ++ lib.optionals pulseaudioSupport [ libpulseaudio ];
 
   postInstall = ''
     install -vD $src/gqrx.desktop -t "$out/share/applications/"

pkgs/applications/radio/minimodem/default.nix

···
-{ stdenv, fetchFromGitHub, pkgconfig, autoconf, automake, libtool
+{ lib, stdenv, fetchFromGitHub, pkgconfig, autoconf, automake, libtool
 , fftw, fftwSinglePrec, alsaLib, libsndfile, libpulseaudio
 }:
 
···
     Caller-ID.
     '';
     homepage = "http://www.whence.com/minimodem/";
-    license = stdenv.lib.licenses.gpl3Plus;
-    platforms = with stdenv.lib.platforms; linux;
-    maintainers = with stdenv.lib.maintainers; [ relrod ];
+    license = lib.licenses.gpl3Plus;
+    platforms = with lib.platforms; linux;
+    maintainers = with lib.maintainers; [ relrod ];
   };
 }
 

pkgs/applications/radio/qsstv/default.nix

···
     description = "Qt-based slow-scan TV and fax";
     homepage = "http://users.telenet.be/on4qz/";
     platforms = platforms.linux;
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = with stdenv.lib.maintainers; [ hax404 ];
+    license = lib.licenses.gpl3;
+    maintainers = with lib.maintainers; [ hax404 ];
   };
 }
 

pkgs/applications/radio/rtl-sdr/default.nix

···
   #   /etc/udev/rules.d/, and there is no option to install elsewhere. So install
   #   rules manually.
   # * Propagate libusb-1.0 dependency in pkg-config file.
-  postInstall = stdenv.lib.optionalString stdenv.isLinux ''
+  postInstall = lib.optionalString stdenv.isLinux ''
     mkdir -p "$out/etc/udev/rules.d/"
     cp ../rtl-sdr.rules "$out/etc/udev/rules.d/99-rtl-sdr.rules"
 

pkgs/applications/radio/uhd/default.nix

···
 
 let
   onOffBool = b: if b then "ON" else "OFF";
-  inherit (stdenv.lib) optionals;
+  inherit (lib) optionals;
 in
 
 stdenv.mkDerivation rec {
···
     # TODO: Check if this still needed
     # ABI differences GCC 7.1
     # /nix/store/wd6r25miqbk9ia53pp669gn4wrg9n9cj-gcc-7.3.0/include/c++/7.3.0/bits/vector.tcc:394:7: note: parameter passing for argument of type 'std::vector<uhd::range_t>::iterator {aka __gnu_cxx::__normal_iterator<uhd::range_t*, std::vector<uhd::range_t> >}' changed in GCC 7.1
-    ++ [ (stdenv.lib.optionalString stdenv.isAarch32 "-DCMAKE_CXX_FLAGS=-Wno-psabi") ]
+    ++ [ (lib.optionalString stdenv.isAarch32 "-DCMAKE_CXX_FLAGS=-Wno-psabi") ]
   ;
 
   # Python + Mako are always required for the build itself but not necessary for runtime.

pkgs/applications/video/aegisub/default.nix

···
-{ config
+{ lib
+, config
 , stdenv
 , fetchurl
 , fetchpatch
···
 assert pulseaudioSupport -> (libpulseaudio != null);
 assert portaudioSupport -> (portaudio != null);
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation
  rec {
   pname = "aegisub";
···
     intltool
   ];
 
-  buildInputs = with stdenv.lib; [
+  buildInputs = with lib; [
     libX11
     wxGTK
     fontconfig

pkgs/applications/video/avidemux/default.nix

···
     ++ lib.optional withVPX libvpx;
 
   buildCommand = let
-    qtVersion = "5.${stdenv.lib.versions.minor qtbase.version}";
+    qtVersion = "5.${lib.versions.minor qtbase.version}";
     wrapWith = makeWrapper: filename:
       "${makeWrapper} ${filename} --set ADM_ROOT_DIR $out --prefix LD_LIBRARY_PATH : ${libXext}/lib";
     wrapQtApp = wrapWith "wrapQtApp";
···
 
     ${wrapProgram "$out/bin/avidemux3_cli"}
 
-    ${stdenv.lib.optionalString withQT ''
+    ${lib.optionalString withQT ''
       ${wrapQtApp "$out/bin/avidemux3_qt5"}
       ${wrapQtApp "$out/bin/avidemux3_jobs_qt5"}
     ''}

pkgs/applications/video/avxsynth/default.nix

···
 }:
 
 let
-  inherit (stdenv.lib) enableFeature optional;
+  inherit (lib) enableFeature optional;
 in
 
 stdenv.mkDerivation {

pkgs/applications/video/ccextractor/default.nix

···
-{ stdenv, fetchFromGitHub, pkgconfig, cmake
+{ lib, stdenv, fetchFromGitHub, pkgconfig, cmake
 , glew, glfw3, leptonica, libiconv, tesseract3, zlib }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   pname = "ccextractor";
   version = "0.88";
···
 
   nativeBuildInputs = [ pkgconfig cmake ];
 
-  buildInputs = [ glew glfw3 leptonica tesseract3 zlib ] ++ stdenv.lib.optional (!stdenv.isLinux) libiconv;
+  buildInputs = [ glew glfw3 leptonica tesseract3 zlib ] ++ lib.optional (!stdenv.isLinux) libiconv;
 
   meta = {
     homepage = "https://www.ccextractor.org";

pkgs/applications/video/cinelerra/default.nix

···
-{ stdenv, fetchFromGitHub, autoconf, automake, libtool
+{ lib, stdenv, fetchFromGitHub, autoconf, automake, libtool
 , pkgconfig, faad2, faac, a52dec, alsaLib, fftw, lame, libavc1394
 , libiec61883, libraw1394, libsndfile, libvorbis, libogg, libjpeg
 , libtiff, freetype, mjpegtools, x264, gettext, openexr
···
   meta = {
     description = "Video Editor";
     homepage = "http://www.cinelerra.org";
-    maintainers = [ stdenv.lib.maintainers.marcweber ];
-    license = stdenv.lib.licenses.gpl2;
+    maintainers = [ lib.maintainers.marcweber ];
+    license = lib.licenses.gpl2;
   };
 }

pkgs/applications/video/clipgrab/default.nix

···
   buildInputs = [ ffmpeg_3 qtbase qtdeclarative qtlocation qtquickcontrols2 qtwebchannel qtwebengine ];
   nativeBuildInputs = [ qmake qttools ];
 
-  postPatch = stdenv.lib.optionalString (ffmpeg_3 != null) ''
+  postPatch = lib.optionalString (ffmpeg_3 != null) ''
   substituteInPlace converter_ffmpeg.cpp \
     --replace '"ffmpeg"' '"${ffmpeg_3.bin}/bin/ffmpeg"' \
     --replace '"ffmpeg ' '"${ffmpeg_3.bin}/bin/ffmpeg '

pkgs/applications/video/coriander/default.nix

···
-{stdenv, fetchurl, pkgconfig, glib, gtk2, libgnomeui, libXv, libraw1394, libdc1394
+{ lib, stdenv, fetchurl, pkgconfig, glib, gtk2, libgnomeui, libXv, libraw1394, libdc1394
 , SDL, automake, GConf }:
 
 stdenv.mkDerivation {
···
 
   nativeBuildInputs = [ pkgconfig ];
   buildInputs = [ glib gtk2 libgnomeui libXv libraw1394 libdc1394 SDL GConf ];
-  
+
   meta = {
     homepage = "https://damien.douxchamps.net/ieee1394/coriander/";
     description = "GUI for controlling a Digital Camera through the IEEE1394 bus";
-    license = stdenv.lib.licenses.gpl3Plus;
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl3Plus;
+    maintainers = with lib.maintainers; [viric];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/video/dvd-slideshow/default.nix

···
   meta = {
     description = "Suite of command line programs that creates a slideshow-style video from groups of pictures";
     homepage = "http://dvd-slideshow.sourceforge.net/wiki/Main_Page";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.robbinch ];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.robbinch ];
   };
 }

pkgs/applications/video/dvdbackup/default.nix

···
-{ stdenv, fetchurl, fetchpatch, libdvdread, libdvdcss, dvdauthor }:
+{ lib, stdenv, fetchurl, fetchpatch, libdvdread, libdvdcss, dvdauthor }:
 
 stdenv.mkDerivation rec {
   version = "0.4.2";
···
   meta = {
     description = "A tool to rip video DVDs from the command line";
     homepage = "http://dvdbackup.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl3Plus;
-    maintainers = [ stdenv.lib.maintainers.bradediger ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3Plus;
+    maintainers = [ lib.maintainers.bradediger ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/video/dvdstyler/default.nix

···
 , dbusSupport ? true, dbus ? null
 , makeWrapper }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
 
   pname = "dvdstyler";

pkgs/applications/video/epgstation/default.nix

···
-{ stdenv
+{ lib
+, stdenv
 , fetchFromGitHub
 , common-updater-scripts
 , genericUpdater
···
 
       makeWrapper ${nodejs}/bin/npm $out/bin/epgstation \
        --run "cd $out/lib/node_modules/EPGStation" \
-       --prefix PATH : ${stdenv.lib.makeBinPath runtimeDeps}
+       --prefix PATH : ${lib.makeBinPath runtimeDeps}
 
       popd
     '';
···
 pkg // {
   name = "${pname}-${version}";
 
-  meta = with stdenv.lib; pkg.meta // {
+  meta = with lib; pkg.meta // {
     maintainers = with maintainers; [ midchildan ];
 
     # NOTE: updateScript relies on this being correct

pkgs/applications/video/filebot/default.nix

···
       --replace 'APP_DATA="$FILEBOT_HOME/data/$(id -u)"' 'APP_DATA=''${XDG_DATA_HOME:-$HOME/.local/share}/filebot/data' \
       --replace '$FILEBOT_HOME/data/.license' '$APP_DATA/.license'
     wrapProgram $out/opt/filebot.sh \
-      --prefix PATH : ${stdenv.lib.makeBinPath [ openjdk11 ]}
+      --prefix PATH : ${lib.makeBinPath [ openjdk11 ]}
     # Expose the binary in bin to make runnable.
     ln -s $out/opt/filebot.sh $out/bin/filebot
   '';

pkgs/applications/video/kino/default.nix

···
 #AMR-WB float support      no
 #AMR-WB IF2 support        no
 
-{ stdenv, fetchurl, gtk2, libglade, libxml2, libraw1394, libsamplerate, libdv
+{ lib, stdenv, fetchurl, gtk2, libglade, libxml2, libraw1394, libsamplerate, libdv
 , pkgconfig, perlPackages, libavc1394, libiec61883, libXv, gettext
 , libX11, glib, cairo, intltool, ffmpeg, libv4l
 }:
···
   meta = {
       description = "Non-linear DV editor for GNU/Linux";
       homepage = "http://www.kinodv.org/";
-      license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
+      license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/video/kodi/plugins.nix

···
 , python2Packages, expat, glib, nspr, nss, openssl
 , libssh, libarchive, lzma, bzip2, lz4, lzo }:
 
-with stdenv.lib;
+with lib;
 
 let self = rec {
 

pkgs/applications/video/kodi/wrapper.nix

···
         --prefix PYTHONPATH : ${kodi.pythonPackages.makePythonPath plugins} \
         --prefix KODI_HOME : $out/share/kodi \
         --prefix LD_LIBRARY_PATH ":" "${lib.makeLibraryPath
-          (stdenv.lib.concatMap
+          (lib.concatMap
             (plugin: plugin.extraRuntimeDependencies or []) plugins)}"
     done
   '';

pkgs/applications/video/lightworks/default.nix

···
-{ stdenv, fetchurl, dpkg, makeWrapper, buildFHSUserEnv
+{ lib, stdenv, fetchurl, dpkg, makeWrapper, buildFHSUserEnv
 , gtk3, gdk-pixbuf, cairo, libjpeg_original, glib, pango, libGLU
 , nvidia_cg_toolkit, zlib, openssl, portaudio
 }:
 let
-  fullPath = stdenv.lib.makeLibraryPath [
+  fullPath = lib.makeLibraryPath [
     stdenv.cc.cc
     gtk3
     gdk-pixbuf
···
   meta = {
     description = "Professional Non-Linear Video Editor";
     homepage = "https://www.lwks.com/";
-    license = stdenv.lib.licenses.unfree;
-    maintainers = [ stdenv.lib.maintainers.antonxy ];
+    license = lib.licenses.unfree;
+    maintainers = [ lib.maintainers.antonxy ];
     platforms = [ "x86_64-linux" ];
   };
 }

pkgs/applications/video/lxdvdrip/default.nix

···
-{ stdenv, fetchurl, libdvdread }:
+{ lib, stdenv, fetchurl, libdvdread }:
 
 stdenv.mkDerivation rec {
   name = "lxdvdrip-1.76";
···
 
   buildInputs = [ libdvdread ];
 
-  meta = { 
+  meta = {
     description = "Command line tool to make a copy from a video DVD for private use";
     homepage = "https://sourceforge.net/projects/lxdvdrip";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/video/makemkv/default.nix

···
 
   qtWrapperArgs =
     let
-      binPath = stdenv.lib.makeBinPath [ jre_headless ];
-    in stdenv.lib.optionals withJava [
+      binPath = lib.makeBinPath [ jre_headless ];
+    in lib.optionals withJava [
       ''--prefix PATH : ${binPath}''
     ];
 

pkgs/applications/video/mkvtoolnix/default.nix

···
 
 assert withGUI -> qtbase != null && qtmultimedia != null && wrapQtAppsHook != null;
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   pname = "mkvtoolnix";

pkgs/applications/video/mplayer/default.nix

···
-{ config, stdenv, fetchurl, pkgconfig, freetype, yasm, ffmpeg_3
+{ config, lib, stdenv, fetchurl, pkgconfig, freetype, yasm, ffmpeg_3
 , aalibSupport ? true, aalib ? null
 , fontconfigSupport ? true, fontconfig ? null, freefont_ttf ? null
 , fribidiSupport ? true, fribidi ? null
···
       cp -prv * $out
     '';
 
-    meta.license = stdenv.lib.licenses.unfree;
+    meta.license = lib.licenses.unfree;
   } else null;
 
   crossBuild = stdenv.hostPlatform != stdenv.buildPlatform;
···
 
   depsBuildBuild = [ buildPackages.stdenv.cc ];
   nativeBuildInputs = [ pkgconfig yasm ];
-  buildInputs = with stdenv.lib;
+  buildInputs = with lib;
     [ freetype ffmpeg_3 ]
     ++ optional aalibSupport aalib
     ++ optional fontconfigSupport fontconfig
···
     ;
 
   configurePlatforms = [ ];
-  configureFlags = with stdenv.lib; [
+  configureFlags = with lib; [
     "--enable-freetype"
     (if fontconfigSupport then "--enable-fontconfig" else "--disable-fontconfig")
     (if x11Support then "--enable-x11 --enable-gl" else "--disable-x11 --disable-gl")
···
     echo CONFIG_MPEGAUDIODSP=yes >> config.mak
   '';
 
-  NIX_LDFLAGS = with stdenv.lib; toString (
+  NIX_LDFLAGS = with lib; toString (
        optional  fontconfigSupport "-lfontconfig"
     ++ optional  fribidiSupport "-lfribidi"
     ++ optionals x11Support [ "-lX11" "-lXext" ]
     ++ [ "-lfreetype" ]
   );
 
-  installTargets = [ "install" ] ++ stdenv.lib.optional x11Support "install-gui";
+  installTargets = [ "install" ] ++ lib.optional x11Support "install-gui";
 
   enableParallelBuilding = true;
 
   # Provide a reasonable standard font when not using fontconfig. Maybe we should symlink here.
-  postInstall = stdenv.lib.optionalString (!fontconfigSupport)
+  postInstall = lib.optionalString (!fontconfigSupport)
     ''
       mkdir -p $out/share/mplayer
       cp ${freefont_ttf}/share/fonts/truetype/FreeSans.ttf $out/share/mplayer/subfont.ttf
···
     description = "A movie player that supports many video formats";
     homepage = "http://mplayerhq.hu";
     license = "GPL";
-    maintainers = [ stdenv.lib.maintainers.eelco ];
+    maintainers = [ lib.maintainers.eelco ];
     platforms = [ "i686-linux" "x86_64-linux" "x86_64-darwin" ];
   };
 }

pkgs/applications/video/mpv/default.nix

···
 , zimgSupport        ? true,           zimg          ? null
 }:
 
-with stdenv.lib;
+with lib;
 
 let
   available = x: x != null;
···
     (enableFeature waylandSupport  "wayland")
     (enableFeature stdenv.isLinux  "dvbin")
   ] # Disable whilst Swift isn't supported
-    ++ stdenv.lib.optional (!swiftSupport) "--disable-macos-cocoa-cb";
+    ++ lib.optional (!swiftSupport) "--disable-macos-cocoa-cb";
 
   nativeBuildInputs = [
     addOpenGLRunpath docutils perl pkgconfig python3 wafHook which

pkgs/applications/video/natron/default.nix

···
       functionalities to Adobe After Effects and Nuke by The Foundry.
     '';
     homepage = "https://natron.fr/";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     maintainers = [ maintainers.puffnfresh ];
     platforms = platforms.linux;
     broken = true;

pkgs/applications/video/obs-studio/default.nix

···
 }:
 
 let
-  inherit (stdenv.lib) optional optionals;
+  inherit (lib) optional optionals;
 
 in mkDerivation rec {
   pname = "obs-studio";
···
         --prefix "LD_LIBRARY_PATH" : "${xorg.libX11.out}/lib:${libvlc}/lib"
   '';
 
-  postFixup = stdenv.lib.optionalString stdenv.isLinux ''
+  postFixup = lib.optionalString stdenv.isLinux ''
       addOpenGLRunpath $out/lib/lib*.so
       addOpenGLRunpath $out/lib/obs-plugins/*.so
   '';

pkgs/applications/video/ogmtools/default.nix

···
-{ stdenv, fetchurl, libogg, libvorbis, libdvdread }:
+{ lib, stdenv, fetchurl, libogg, libvorbis, libdvdread }:
 
 stdenv.mkDerivation rec {
   name = "ogmtools-1.5";
···
       tool for extracting chapter information from DVD.
     '';
     homepage = "https://www.bunkus.org/videotools/ogmtools/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/video/olive-editor/default.nix

···
     frei0r
     opencolorio
     qtmultimedia
-  ] ++ stdenv.lib.optional stdenv.isDarwin CoreFoundation;
+  ] ++ lib.optional stdenv.isDarwin CoreFoundation;
 
   meta = with lib; {
     description = "Professional open-source NLE video editor";

pkgs/applications/video/omxplayer/default.nix

···
-{ stdenv, fetchurl
+{ lib, stdenv, fetchurl
 , raspberrypifw, pcre, boost, freetype, zlib
 }:
 
 let
   ffmpeg = stdenv.mkDerivation rec {
     name = "ffmpeg-1.1.3";
-    
+
     src = fetchurl {
       url = "http://www.ffmpeg.org/releases/${name}.tar.bz2";
       sha256 = "03s1zsprz5p6gjgwwqcf7b6cvzwwid6l8k7bamx9i0f1iwkgdm0j";
     };
-    
+
     configurePlatforms = [];
     configureFlags = [
       "--arch=${stdenv.hostPlatform.parsed.cpu.name}"
-    ] ++ stdenv.lib.optionals stdenv.hostPlatform.isAarch32 [
+    ] ++ lib.optionals stdenv.hostPlatform.isAarch32 [
       # TODO be better with condition
       "--cpu=arm1176jzf-s"
     ] ++ [
···
       "--disable-debug"
       "--arch=${stdenv.hostPlatform.parsed.cpu.name}"
       "--target_os=${stdenv.hostPlatform.parsed.kernel.name}"
-    ] ++ stdenv.lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
+    ] ++ lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
       "--cross-prefix=${stdenv.cc.targetPrefix}"
       "--enable-cross-compile"
     ];
···
   meta = {
     homepage = "https://github.com/huceke/omxplayer";
     description = "Commandline OMX player for the Raspberry Pi";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.arm;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.arm;
   };
 }

pkgs/applications/video/openshot-qt/default.nix

···
     wrapProgram $out/bin/openshot-qt \
   ''
   # Fix toolbar icons on Darwin
-  + stdenv.lib.optionalString stdenv.isDarwin ''
-      --suffix QT_PLUGIN_PATH : "${stdenv.lib.getBin qtsvg}/lib/qt-5.12.7/plugins" \
+  + lib.optionalString stdenv.isDarwin ''
+      --suffix QT_PLUGIN_PATH : "${lib.getBin qtsvg}/lib/qt-5.12.7/plugins" \
   ''
   + ''
       "''${gappsWrapperArgs[@]}" \

pkgs/applications/video/openshot-qt/libopenshot-audio.nix

···
-{ stdenv, fetchFromGitHub, pkgconfig, cmake, doxygen
+{ lib, stdenv, fetchFromGitHub, pkgconfig, cmake, doxygen
 , alsaLib, libX11, libXft, libXrandr, libXinerama, libXext, libXcursor
 , zlib, AGL, Cocoa, Foundation
 }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   pname = "libopenshot-audio";
   version = "0.2.0";

pkgs/applications/video/openshot-qt/libopenshot.nix

···
-{ stdenv, fetchFromGitHub, fetchpatch
+{ lib, stdenv, fetchFromGitHub, fetchpatch
 , pkgconfig, cmake, doxygen
 , libopenshot-audio, imagemagick, ffmpeg_3
 , swig, python3
···
 , llvmPackages
 }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   pname = "libopenshot";
   version = "0.2.5";

pkgs/applications/video/p2pvc/default.nix

···
-{ stdenv, pkgconfig, fetchFromGitHub, opencv2, ncurses, portaudio }:
+{ lib, stdenv, pkgconfig, fetchFromGitHub, opencv2, ncurses, portaudio }:
 
 stdenv.mkDerivation {
   name = "p2pvc";
···
   meta = {
     description = "A point to point color terminal video chat";
     homepage = "https://github.com/mofarrell/p2pvc";
-    license = stdenv.lib.licenses.mit;
-    maintainers = with stdenv.lib.maintainers; [ trino ];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ trino ];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/video/peek/default.nix

···
   '';
 
   preFixup = ''
-    gappsWrapperArgs+=(--prefix PATH : ${stdenv.lib.makeBinPath [ which ffmpeg_3 gifski ]})
+    gappsWrapperArgs+=(--prefix PATH : ${lib.makeBinPath [ which ffmpeg_3 gifski ]})
   '';
 
   passthru = {

pkgs/applications/video/pitivi/default.nix

···
   format = "other";
 
   src = fetchurl {
-    url = "mirror://gnome/sources/pitivi/${stdenv.lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
+    url = "mirror://gnome/sources/pitivi/${lib.versions.majorMinor version}/${pname}-${version}.tar.xz";
     sha256 = "0hzvv4wia4rk0kvq16y27imq2qd4q5lg3vx99hdcjdb1x3zqqfg0";
   };
 

pkgs/applications/video/qstopmotion/default.nix

···
       animation to different video formats such as mpeg or avi.
     '';
 
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
     maintainers = [ maintainers.leenaars ];
     broken = stdenv.isAarch64;
-    platforms = stdenv.lib.platforms.gnu ++ stdenv.lib.platforms.linux;
+    platforms = lib.platforms.gnu ++ lib.platforms.linux;
   };
 }

pkgs/applications/video/quvi/library.nix

···
-{ stdenv, fetchurl, pkgconfig, lua5, curl, quvi_scripts, libproxy, libgcrypt, glib }:
+{ lib, stdenv, fetchurl, pkgconfig, lua5, curl, quvi_scripts, libproxy, libgcrypt, glib }:
 
 stdenv.mkDerivation rec {
   pname = "libquvi";
···
   meta = {
     description = "Web video downloader";
     homepage = "http://quvi.sf.net";
-    license = stdenv.lib.licenses.lgpl21Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.lgpl21Plus;
+    platforms = lib.platforms.linux;
     maintainers = [ ];
   };
 }

pkgs/applications/video/quvi/scripts.nix

···
-{stdenv, fetchurl, pkgconfig}:
+{lib, stdenv, fetchurl, pkgconfig}:
 
 stdenv.mkDerivation rec {
   pname = "quvi-scripts";
···
   meta = {
     description = "Web video downloader";
     homepage = "http://quvi.sf.net";
-    license = stdenv.lib.licenses.lgpl21Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.lgpl21Plus;
+    platforms = lib.platforms.linux;
     maintainers = [ ];
   };
 }

pkgs/applications/video/quvi/tool.nix

···
-{stdenv, fetchurl, pkgconfig, lua5, curl, quvi_scripts, libquvi, lua5_sockets, glib, makeWrapper}:
+{lib, stdenv, fetchurl, pkgconfig, lua5, curl, quvi_scripts, libquvi, lua5_sockets, glib, makeWrapper}:
 
 stdenv.mkDerivation rec {
   pname = "quvi";
···
   meta = {
     description = "Web video downloader";
     homepage = "http://quvi.sf.net";
-    license = stdenv.lib.licenses.lgpl21Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.lgpl21Plus;
+    platforms = lib.platforms.linux;
     maintainers = [ ];
   };
 }

pkgs/applications/video/shotcut/default.nix

···
 , common-updater-scripts
 }:
 
-assert stdenv.lib.versionAtLeast mlt.version "6.22.1";
+assert lib.versionAtLeast mlt.version "6.22.1";
 
 mkDerivation rec {
   pname = "shotcut";
···
 
   NIX_CFLAGS_COMPILE = "-I${mlt.dev}/include/mlt++ -I${mlt.dev}/include/mlt";
   qmakeFlags = [
-    "QMAKE_LRELEASE=${stdenv.lib.getDev qttools}/bin/lrelease"
+    "QMAKE_LRELEASE=${lib.getDev qttools}/bin/lrelease"
     "SHOTCUT_VERSION=${version}"
     "DEFINES+=SHOTCUT_NOUPGRADE"
   ];
···
   qtWrapperArgs = [
     "--prefix FREI0R_PATH : ${frei0r}/lib/frei0r-1"
     "--prefix LADSPA_PATH : ${ladspaPlugins}/lib/ladspa"
-    "--prefix LD_LIBRARY_PATH : ${stdenv.lib.makeLibraryPath [ jack1 SDL2 ]}"
+    "--prefix LD_LIBRARY_PATH : ${lib.makeLibraryPath [ jack1 SDL2 ]}"
     "--prefix PATH : ${mlt}/bin"
   ];
 

pkgs/applications/video/sub-batch/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , rustPlatform
 }:
···
 
   cargoSha256 = "sha256-l+BTF9PGb8bG8QHhNCoBsrsVX8nlRjPlaea1ESFfMW0=";
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Match and rename subtitle files to video files and perform other batch operations on subtitle files";
     homepage = "https://github.com/kl/sub-batch";
     license = licenses.mit;

pkgs/applications/video/subdl/default.nix

···
-{ stdenv, fetchFromGitHub, python3 }:
+{ lib, stdenv, fetchFromGitHub, python3 }:
 
 stdenv.mkDerivation {
   name = "subdl-0.0pre.2017.11.06";
···
   meta = {
     homepage = "https://github.com/alexanderwink/subdl";
     description = "A command-line tool to download subtitles from opensubtitles.org";
-    platforms = stdenv.lib.platforms.all;
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = [ stdenv.lib.maintainers.exfalso ];
+    platforms = lib.platforms.all;
+    license = lib.licenses.gpl3;
+    maintainers = [ lib.maintainers.exfalso ];
   };
 
   buildInputs = [ python3 ];
 
   installPhase = ''
     install -vD subdl $out/bin/subdl
-  '';  
+  '';
 }

pkgs/applications/video/subtitleeditor/default.nix

···
-{ stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, intltool, file,
+{ lib, stdenv, fetchFromGitHub, autoreconfHook, pkgconfig, intltool, file,
   desktop-file-utils, enchant, gtk3, gtkmm3, gst_all_1, hicolor-icon-theme,
   libsigcxx, libxmlxx, xdg_utils, isocodes, wrapGAppsHook
 }:
···
       makes it easier to synchronise subtitles to voices.
       '';
     homepage = "http://kitone.github.io/subtitleeditor/";
-    license = stdenv.lib.licenses.gpl3Plus;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.plcplc ];
+    license = lib.licenses.gpl3Plus;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.plcplc ];
   };
 }

pkgs/applications/video/tartube/default.nix

···
   doCheck = false;
 
   makeWrapperArgs = [
-    "--prefix PATH : ${stdenv.lib.makeBinPath [ youtube-dl ]}"
+    "--prefix PATH : ${lib.makeBinPath [ youtube-dl ]}"
   ];
 
   meta = with lib; {

pkgs/applications/video/vcs/default.nix

···
-{ stdenv, fetchurl, makeWrapper
+{ lib, stdenv, fetchurl, makeWrapper
 , coreutils, ffmpeg, gawk, gnugrep, gnused, imagemagick, mplayer, util-linux
 , dejavu_fonts
 }:
-with stdenv.lib;
+with lib;
 let
   version = "1.13.4";
   runtimeDeps = [ coreutils ffmpeg gawk gnugrep gnused imagemagick mplayer util-linux ];

pkgs/applications/video/vdr/plugins.nix

···
     buildInputs = oldAttr.buildInputs ++ [ ncurses ];
   });
 
-  inherit (stdenv.lib.genAttrs [
+  inherit (lib.genAttrs [
     "epgtableid0" "hello" "osddemo" "pictures" "servicedemo" "status" "svdrpdemo"
   ] mkPlugin);
 

pkgs/applications/video/vlc/default.nix

···
 # If your firewall is enabled, make sure to have something like:
 #   networking.firewall.allowedTCPPorts = [ 8010 ];
 
-with stdenv.lib;
+with lib;
 
 assert (withQt5 -> qtbase != null && qtsvg != null && qtx11extras != null && wrapQtAppsHook != null);
 

pkgs/applications/video/w_scan/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   pname = "w_scan";
···
   meta = {
     description = "Small CLI utility to scan DVB and ATSC transmissions";
     homepage = "http://wirbel.htpc-forum.de/w_scan/index_en.html";
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.nico202 ] ;
-    license = stdenv.lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.nico202 ] ;
+    license = lib.licenses.gpl2;
   };
 }

pkgs/applications/video/webtorrent_desktop/default.nix

···
 }:
 
   let
-    rpath = stdenv.lib.makeLibraryPath ([
+    rpath = lib.makeLibraryPath ([
     alsaLib
     atk
     at-spi2-core

pkgs/applications/video/wxcam/default.nix

···
     sha256 = "1765bvc65fpzn9ycnnj5hais9xkx9v0sm6a878d35x54bpanr859";
   };
 
-  buildInputs = with stdenv.lib;
+  buildInputs = with lib;
   [ pkgconfig intltool libX11 libXv libSM gtk libglade wxGTK perlPackages.XMLParser xvidcore mjpegtools alsaLib libv4l cimg ];
 
   NIX_CFLAGS_COMPILE="-I ${cimg}/include/cimg";

pkgs/applications/video/xawtv/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchurl
 , ncurses
 , libjpeg
···
 
   meta = {
     description = "TV application for Linux with apps and tools such as a teletext browser";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     homepage = "https://www.kraxel.org/blog/linux/xawtv/";
-    maintainers = with stdenv.lib.maintainers; [ domenkozar ];
-    platforms = stdenv.lib.platforms.linux;
+    maintainers = with lib.maintainers; [ domenkozar ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/video/xscast/default.nix

···
     patchShebangs $out/bin
 
     wrapProgram "$out/bin/xscast" \
-      --prefix PATH : ${stdenv.lib.makeBinPath [ ffmpeg_3 dzen2 xorg.xwininfo xorg.xinput xorg.xmodmap imagemagick ]}
+      --prefix PATH : ${lib.makeBinPath [ ffmpeg_3 dzen2 xorg.xwininfo xorg.xinput xorg.xmodmap imagemagick ]}
 
     runHook postInstall
   '';

pkgs/applications/video/xvidcap/default.nix

···
   meta = with lib; {
     description = "Screencast video catpuring tool";
     homepage = "http://xvidcap.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     platforms = platforms.linux;
   };
 }

pkgs/applications/virtualization/8086tiny/default.nix

···
     sha256 = "00aydg8f28sgy8l3rd2a7jvp56lx3b63hhak43p7g7vjdikv495w";
   };
 
-  buildInputs = with stdenv.lib;
+  buildInputs = with lib;
   optionals localBios [ nasm ]
   ++  optionals sdlSupport [ SDL ];
-  
+
   bios = localBios;
-  
+
   builder = ./builder.sh;
 
   meta = with lib; {

pkgs/applications/virtualization/OVMF/default.nix

···
   meta = {
     description = "Sample UEFI firmware for QEMU and KVM";
     homepage = "https://github.com/tianocore/tianocore.github.io/wiki/OVMF";
-    license = stdenv.lib.licenses.bsd2;
+    license = lib.licenses.bsd2;
     platforms = ["x86_64-linux" "i686-linux" "aarch64-linux" "x86_64-darwin"];
   };
 }

pkgs/applications/virtualization/bochs/default.nix

···
-{ stdenv, fetchurl
+{ lib, stdenv, fetchurl
 , pkgconfig, libtool
 , gtk2, libGLU, libGL, readline, libX11, libXpm
 , docbook_xml_dtd_45, docbook_xsl
···
 assert wgetSupport -> (wget != null);
 assert curlSupport -> (curl != null);
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
 
   pname = "bochs";

pkgs/applications/virtualization/charliecloud/default.nix

···
-{ stdenv, fetchFromGitHub, python3, python3Packages, docker, autoreconfHook, coreutils, makeWrapper, gnused, gnutar, gzip, findutils, sudo, nixosTests }:
+{ lib, stdenv, fetchFromGitHub, python3, python3Packages, docker, autoreconfHook, coreutils, makeWrapper, gnused, gnutar, gzip, findutils, sudo, nixosTests }:
 
 stdenv.mkDerivation rec {
 
···
   # Here we wrap those deps so they are resolved inside nixpkgs.
   postInstall = ''
     for file in $out/bin/* ; do \
-      wrapProgram $file --prefix PATH : ${stdenv.lib.makeBinPath [ coreutils docker gnused gnutar gzip findutils sudo ]}
+      wrapProgram $file --prefix PATH : ${lib.makeBinPath [ coreutils docker gnused gnutar gzip findutils sudo ]}
     done
   '';
 
···
       on offer.
     '';
     homepage = "https://hpc.github.io/charliecloud";
-    license = stdenv.lib.licenses.asl20;
-    maintainers = [ stdenv.lib.maintainers.bzizou ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.asl20;
+    maintainers = [ lib.maintainers.bzizou ];
+    platforms = lib.platforms.linux;
   };
 
 }

pkgs/applications/virtualization/conmon/default.nix

···
 
   nativeBuildInputs = [ pkg-config ];
   buildInputs = [ glib systemd ]
-  ++ stdenv.lib.optionals (!stdenv.hostPlatform.isMusl) [ glibc glibc.static ];
+  ++ lib.optionals (!stdenv.hostPlatform.isMusl) [ glibc glibc.static ];
 
   # manpage requires building the vendored go-md2man
   makeFlags = [ "bin/conmon" ];

pkgs/applications/virtualization/cri-o/default.nix

···
     libseccomp
     libselinux
     lvm2
-  ] ++ stdenv.lib.optionals (glibc != null) [ glibc glibc.static ];
+  ] ++ lib.optionals (glibc != null) [ glibc glibc.static ];
 
   BUILDTAGS = "apparmor seccomp selinux containers_image_openpgp containers_image_ostree_stub";
   buildPhase = ''

pkgs/applications/virtualization/docker-compose/default.nix

···
     ipaddress jsonschema requests six texttable websocket_client
     docopt cached-property paramiko distro python-dotenv
   ] ++
-    stdenv.lib.optional (pythonOlder "3.4") enum34 ++
-    stdenv.lib.optional (pythonOlder "3.2") functools32;
+    lib.optional (pythonOlder "3.4") enum34 ++
+    lib.optional (pythonOlder "3.2") functools32;
 
   postPatch = ''
     # Remove upper bound on requires, see also

pkgs/applications/virtualization/docker/gc.nix

···
     cp docker-gc $out/bin
     chmod +x $out/bin/docker-gc
     wrapProgram $out/bin/docker-gc \
-        --prefix PATH : "${stdenv.lib.makeBinPath [ docker coreutils procps gnused findutils gnugrep ]}"
+        --prefix PATH : "${lib.makeBinPath [ docker coreutils procps gnused findutils gnugrep ]}"
   '';
 
   meta = {

pkgs/applications/virtualization/driver/win-pvdrivers/default.nix

···
 
   buildPhase =
     let unpack = x: "tar xf $src/${x}.tar; mkdir -p x86/${x} amd64/${x}; cp ${x}/x86/* x86/${x}/.; cp ${x}/x64/* amd64/${x}/.";
-    in stdenv.lib.concatStringsSep "\n" (map unpack ["xenbus" "xeniface" "xenvif" "xennet" "xenvbd"]);
+    in lib.concatStringsSep "\n" (map unpack ["xenbus" "xeniface" "xenvif" "xennet" "xenvbd"]);
 
   installPhase = ''
     mkdir -p $out

pkgs/applications/virtualization/driver/win-virtio/default.nix

···
                 {input="viorng"; output="viorng";}
                ];
     in
-      stdenv.lib.concatStringsSep "\n" ((map (copy "amd64" "w8.1") virtio) ++ (map (copy "x86" "w8.1") virtio));
+      lib.concatStringsSep "\n" ((map (copy "amd64" "w8.1") virtio) ++ (map (copy "x86" "w8.1") virtio));
 
   meta = with lib; {
     description = "Windows VirtIO Drivers";

pkgs/applications/virtualization/gvisor/default.nix

···
 
       # Needed for the 'runsc do' subcomand
       wrapProgram $out/bin/runsc \
-        --prefix PATH : ${stdenv.lib.makeBinPath [ iproute iptables procps ]}
+        --prefix PATH : ${lib.makeBinPath [ iproute iptables procps ]}
     '';
   };
 

pkgs/applications/virtualization/podman/default.nix

···
 
   nativeBuildInputs = [ pkg-config go-md2man installShellFiles ];
 
-  buildInputs = stdenv.lib.optionals stdenv.isLinux [
+  buildInputs = lib.optionals stdenv.isLinux [
     btrfs-progs
     gpgme
     libapparmor
···
     make docs
   '';
 
-  installPhase = stdenv.lib.optionalString stdenv.isDarwin ''
+  installPhase = lib.optionalString stdenv.isDarwin ''
     mv bin/{podman-remote,podman}
   '' + ''
     install -Dm555 bin/podman $out/bin/podman

pkgs/applications/virtualization/qboot/default.nix

···
-{ stdenv, meson, ninja, fetchFromGitHub, nixosTests }:
+{ lib, stdenv, meson, ninja, fetchFromGitHub, nixosTests }:
 
 stdenv.mkDerivation {
   name = "qboot-20200423";
···
   meta = {
     description = "A simple x86 firmware for booting Linux";
     homepage = "https://github.com/bonzini/qboot";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ tstrobel ];
+    license = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ tstrobel ];
     platforms = ["x86_64-linux" "i686-linux"];
   };
 }

pkgs/applications/virtualization/qemu/default.nix

···
 , nixosTestRunner ? false
 }:
 
-with stdenv.lib;
+with lib;
 let
   audio = optionalString alsaSupport "alsa,"
     + optionalString pulseSupport "pa,"
···
 stdenv.mkDerivation rec {
   version = "5.1.0";
   pname = "qemu"
-    + stdenv.lib.optionalString xenSupport "-xen"
-    + stdenv.lib.optionalString hostCpuOnly "-host-cpu-only"
-    + stdenv.lib.optionalString nixosTestRunner "-for-vm-tests";
+    + lib.optionalString xenSupport "-xen"
+    + lib.optionalString hostCpuOnly "-host-cpu-only"
+    + lib.optionalString nixosTestRunner "-for-vm-tests";
 
   src = fetchurl {
     url= "https://download.qemu.org/qemu-${version}.tar.xz";
···
     ++ optional smartcardSupport "--enable-smartcard"
     ++ optional spiceSupport "--enable-spice"
     ++ optional usbredirSupport "--enable-usb-redir"
-    ++ optional (hostCpuTargets != null) "--target-list=${stdenv.lib.concatStringsSep "," hostCpuTargets}"
+    ++ optional (hostCpuTargets != null) "--target-list=${lib.concatStringsSep "," hostCpuTargets}"
     ++ optional stdenv.isDarwin "--enable-cocoa"
     ++ optional stdenv.isDarwin "--enable-hvf"
     ++ optional stdenv.isLinux "--enable-linux-aio"

pkgs/applications/virtualization/qtemu/default.nix

···
     install -D -t $out/bin qtemu
 
     # make sure that the qemu-* executables are found
-    wrapProgram $out/bin/qtemu --prefix PATH : ${stdenv.lib.makeBinPath [ qemu ]}
+    wrapProgram $out/bin/qtemu --prefix PATH : ${lib.makeBinPath [ qemu ]}
 
     runHook postInstall
   '';

pkgs/applications/virtualization/singularity/default.nix

···
     cd go/src/github.com/sylabs/singularity
 
     patchShebangs .
-    sed -i 's|defaultPath := "[^"]*"|defaultPath := "${stdenv.lib.makeBinPath propagatedBuildInputs}"|' cmd/internal/cli/actions.go
+    sed -i 's|defaultPath := "[^"]*"|defaultPath := "${lib.makeBinPath propagatedBuildInputs}"|' cmd/internal/cli/actions.go
 
     ./mconfig -V ${version} -p $out --localstatedir=/var
 
···
     chmod 755 $out/libexec/singularity/bin/starter-suid
 
     # Explicitly configure paths in the config file
-    sed -i 's|^# mksquashfs path =.*$|mksquashfs path = ${stdenv.lib.makeBinPath [squashfsTools]}/mksquashfs|' $out/etc/singularity/singularity.conf
-    sed -i 's|^# cryptsetup path =.*$|cryptsetup path = ${stdenv.lib.makeBinPath [cryptsetup]}/cryptsetup|' $out/etc/singularity/singularity.conf
+    sed -i 's|^# mksquashfs path =.*$|mksquashfs path = ${lib.makeBinPath [squashfsTools]}/mksquashfs|' $out/etc/singularity/singularity.conf
+    sed -i 's|^# cryptsetup path =.*$|cryptsetup path = ${lib.makeBinPath [cryptsetup]}/cryptsetup|' $out/etc/singularity/singularity.conf
 
     runHook postInstall
   '';

pkgs/applications/virtualization/spice-vdagent/default.nix

···
-{stdenv, fetchurl, pkgconfig, alsaLib, spice-protocol, glib,
+{lib, stdenv, fetchurl, pkgconfig, alsaLib, spice-protocol, glib,
  libpciaccess, libxcb, libXrandr, libXinerama, libXfixes, dbus, libdrm,
  systemd}:
 stdenv.mkDerivation rec {
···
        * Multiple displays
     '';
     homepage = "https://www.spice-space.org/";
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = [ stdenv.lib.maintainers.aboseley ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3;
+    maintainers = [ lib.maintainers.aboseley ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/virtualization/tinyemu/default.nix

···
-{ stdenv, fetchurl, openssl, curl, SDL }:
+{ lib, stdenv, fetchurl, openssl, curl, SDL }:
 
 stdenv.mkDerivation rec {
   pname = "tinyemu";
···
     homepage = "https://bellard.org/tinyemu/";
     description = "A system emulator for the RISC-V and x86 architectures";
     longDescription = "TinyEMU is a system emulator for the RISC-V and x86 architectures. Its purpose is to be small and simple while being complete.";
-    license = with stdenv.lib.licenses; [ mit bsd2 ];
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = with stdenv.lib.maintainers; [ jhhuh ];
+    license = with lib.licenses; [ mit bsd2 ];
+    platforms = lib.platforms.linux;
+    maintainers = with lib.maintainers; [ jhhuh ];
   };
 }

pkgs/applications/virtualization/virt-manager/default.nix

···
 , cpio, e2fsprogs, findutils, gzip
 }:
 
-with stdenv.lib;
+with lib;
 
 python3Packages.buildPythonApplication rec {
   pname = "virt-manager";

pkgs/applications/virtualization/virt-viewer/default.nix

···
-{ stdenv, fetchurl, pkgconfig, intltool, shared-mime-info, wrapGAppsHook
+{ lib, stdenv, fetchurl, pkgconfig, intltool, shared-mime-info, wrapGAppsHook
 , glib, gsettings-desktop-schemas, gtk-vnc, gtk3, libvirt, libvirt-glib, libxml2, vte
 , spiceSupport ? true
 , spice-gtk ? null, spice-protocol ? null, libcap ? null, gdbm ? null
···
 assert spiceSupport ->
   spice-gtk != null && spice-protocol != null && libcap != null && gdbm != null;
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
   baseName = "virt-viewer";

pkgs/applications/virtualization/virtinst/default.nix

···
-{ stdenv, fetchurl, python2Packages, intltool, libxml2Python }:
+{ lib, stdenv, fetchurl, python2Packages, intltool, libxml2Python }:
 
-with stdenv.lib;
+with lib;
 
 let version = "0.600.4"; in
 
···
 
   meta = {
     homepage = "http://virt-manager.org";
-    license = stdenv.lib.licenses.gpl2Plus;
-    maintainers = with stdenv.lib.maintainers; [qknight];
+    license = lib.licenses.gpl2Plus;
+    maintainers = with lib.maintainers; [qknight];
     description = "Command line tool which provides an easy way to provision operating systems into virtual machines";
-    platforms = with stdenv.lib.platforms; linux;
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/applications/virtualization/virtualbox/default.nix

···
 , enable32bitGuests ? true
 }:
 
-with stdenv.lib;
+with lib;
 
 let
   python = python3;

pkgs/applications/virtualization/virtualbox/guest-additions/default.nix

···
 
 let
   version = virtualbox.version;
-  xserverVListFunc = builtins.elemAt (stdenv.lib.splitVersion xorg.xorgserver.version);
+  xserverVListFunc = builtins.elemAt (lib.splitVersion xorg.xorgserver.version);
 
   # Forced to 1.18 in <nixpkgs/nixos/modules/services/x11/xserver.nix>
   # as it even fails to build otherwise.  Still, override this even here,

pkgs/applications/virtualization/x11docker/default.nix

···
-{ stdenv, fetchFromGitHub, makeWrapper, nx-libs, xorg, getopt, gnugrep, gawk, ps, mount, iproute }:
+{ lib, stdenv, fetchFromGitHub, makeWrapper, nx-libs, xorg, getopt, gnugrep, gawk, ps, mount, iproute }:
 stdenv.mkDerivation rec {
   pname = "x11docker";
   version = "6.6.2";
···
   installPhase = ''
     install -D x11docker "$out/bin/x11docker";
     wrapProgram "$out/bin/x11docker" \
-      --prefix PATH : "${stdenv.lib.makeBinPath [ getopt gnugrep gawk ps mount iproute nx-libs xorg.xdpyinfo xorg.xhost xorg.xinit ]}"
+      --prefix PATH : "${lib.makeBinPath [ getopt gnugrep gawk ps mount iproute nx-libs xorg.xdpyinfo xorg.xhost xorg.xinit ]}"
   '';
 
   meta = {
     description = "Run graphical applications with Docker";
     homepage = "https://github.com/mviereck/x11docker";
-    license = stdenv.lib.licenses.mit;
-    maintainers = with stdenv.lib.maintainers; [ jD91mZM2 ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ jD91mZM2 ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/applications/virtualization/xen/4.10.nix

···
-{ stdenv, callPackage, fetchurl, fetchpatch, fetchgit
+{ lib, stdenv, callPackage, fetchurl, fetchpatch, fetchgit
 , ocaml-ng
 , withInternalQemu ? true
 , withInternalTraditionalQemu ? true
···
 assert withInternalSeabios -> !withSeabios;
 assert withInternalOVMF -> !withOVMF;
 
-with stdenv.lib;
+with lib;
 
 # Patching XEN? Check the XSAs at
 # https://xenbits.xen.org/xsa/

pkgs/applications/virtualization/xen/generic.nix

···
 config:
-{ stdenv, cmake, pkg-config, which
+{ lib, stdenv, cmake, pkg-config, which
 
 # Xen
 , bison, bzip2, checkpolicy, dev86, figlet, flex, gettext, glib
···
 
 , ...} @ args:
 
-with stdenv.lib;
+with lib;
 
 let
   #TODO: fix paths instead
···
                     + "\nIncludes:\n"
                     + withXenfiles (name: x: ''* ${name}: ${x.meta.description or "(No description)"}.'');
     platforms = [ "x86_64-linux" ];
-    maintainers = with stdenv.lib.maintainers; [ eelco tstrobel oxij ];
-    license = stdenv.lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ eelco tstrobel oxij ];
+    license = lib.licenses.gpl2;
   } // (config.meta or {});
 } // removeAttrs config [ "xenfiles" "buildInputs" "patches" "postPatch" "meta" ])