pkgs/games: stdenv.lib -> lib

pkgs/games/abbaye-des-morts/default.nix

···
 
   makeFlags = [ "PREFIX=$(out)" "DESTDIR=" ];
 
-  preBuild = stdenv.lib.optionalString stdenv.cc.isClang
+  preBuild = lib.optionalString stdenv.cc.isClang
     ''
       substituteInPlace Makefile \
         --replace -fpredictive-commoning ""

pkgs/games/adom/default.nix

···
 
   inherit (xorg) libXext libX11;
 
-  lpath = "${stdenv.cc.cc.lib}/lib64:" + stdenv.lib.makeLibraryPath [
+  lpath = "${stdenv.cc.cc.lib}/lib64:" + lib.makeLibraryPath [
       zlib libmad libpng12 libcaca libXext libX11 libGLU libGL alsaLib libpulseaudio];
 
 in

pkgs/games/alephone/default.nix

···
       '';
 
       meta = alephone.meta // {
-        license = stdenv.lib.licenses.free;
+        license = lib.licenses.free;
         hydraPlatforms = [ ];
       } // meta;
     });

pkgs/games/andyetitmoves/default.nix

···
-{ stdenv, fetchurl, libvorbis, libogg, libtheora, SDL, libXft, SDL_image, zlib, libX11, libpng, openal, runtimeShell, requireFile, commercialVersion ? false }:
+{ lib, stdenv, fetchurl, libvorbis, libogg, libtheora, SDL, libXft, SDL_image, zlib, libX11, libpng, openal, runtimeShell, requireFile, commercialVersion ? false }:
 
 let plainName = "andyetitmoves";
     version   = "1.2.2";
···
 
     homepage = "http://www.andyetitmoves.net/";
 
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
 
-    maintainers = with stdenv.lib.maintainers; [bluescreen303];
+    maintainers = with lib.maintainers; [bluescreen303];
   };
 }

pkgs/games/arena/default.nix

···
-{ stdenv, fetchurl, gtk2-x11, glib, pango, cairo, atk, gdk-pixbuf, libX11 }:
+{ lib, stdenv, fetchurl, gtk2-x11, glib, pango, cairo, atk, gdk-pixbuf, libX11 }:
 
 # Arena is free software in the sense of "free beer" but not as in "free
 # speech". We can install it as we please, but we cannot re-distribute it in
···
 
 let
 
-  inherit (stdenv.lib) makeLibraryPath;
+  inherit (lib) makeLibraryPath;
   libDir = "lib64";
 
 in
···
       UCI protocol I, II. Furthermore, compatible to Chess960, DGT electronic
       chess board & DGT clocks and much more.
     '';
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
     platforms = ["x86_64-linux"];
-    hydraPlatforms = stdenv.lib.platforms.none;
+    hydraPlatforms = lib.platforms.none;
   };
 
 }

pkgs/games/arx-libertatis/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, zlib, boost
+{ lib, stdenv, fetchFromGitHub, cmake, zlib, boost
 , openal, glm, freetype, libGLU, SDL2, epoxy
 , dejavu_fonts, inkscape, optipng, imagemagick
 , withCrashReporter ? !stdenv.isDarwin
···
 ,   gdb  ? null
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation {
   pname = "arx-libertatis";

pkgs/games/assaultcube/default.nix

···
-{ fetchFromGitHub, stdenv, makeDesktopItem, openal, pkgconfig, libogg,
+{ fetchFromGitHub, lib, stdenv, makeDesktopItem, openal, pkgconfig, libogg,
   libvorbis, SDL, SDL_image, makeWrapper, zlib, file,
   client ? true, server ? true }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
 
···
     homepage = "https://assault.cubers.net";
     maintainers = [ ];
     platforms = platforms.linux; # should work on darwin with a little effort.
-    license = stdenv.lib.licenses.zlib;
+    license = lib.licenses.zlib;
   };
 }

pkgs/games/astromenace/default.nix

···
-{ fetchurl, stdenv, cmake, xlibsWrapper, libGLU, libGL, SDL, openal, freealut, libogg, libvorbis, runtimeShell }:
+{ fetchurl, lib, stdenv, cmake, xlibsWrapper, libGLU, libGL, SDL, openal, freealut, libogg, libvorbis, runtimeShell }:
 
 stdenv.mkDerivation rec {
   version = "1.3.2";
···
   meta = {
     description = "Hardcore 3D space shooter with spaceship upgrade possibilities";
     homepage = "https://www.viewizard.com/";
-    license = stdenv.lib.licenses.gpl3;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/azimuth/default.nix

···
-{ stdenv, fetchFromGitHub, SDL, which, installTool ? false }:
+{ lib, stdenv, fetchFromGitHub, SDL, which, installTool ? false }:
 
 stdenv.mkDerivation rec {
   pname = "azimuth";
···
       bosses to tangle with.
     '';
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
     homepage = "https://mdsteele.games/azimuth/index.html";
-    maintainers = with stdenv.lib.maintainers; [ marius851000 ];
-    platforms = stdenv.lib.platforms.linux;
+    maintainers = with lib.maintainers; [ marius851000 ];
+    platforms = lib.platforms.linux;
   };
 
 }

pkgs/games/ball-and-paddle/default.nix

···
-{ fetchurl, stdenv, SDL, SDL_image, SDL_mixer, SDL_ttf, guile, gettext }:
+{ fetchurl, lib, stdenv, SDL, SDL_image, SDL_mixer, SDL_ttf, guile, gettext }:
 
 stdenv.mkDerivation rec {
   name = "ballandpaddle-0.8.1";
···
       with Guile.  Follow the example level sets and the documentation.
     '';
 
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
 
     homepage = "https://www.gnu.org/software/ballandpaddle/";
 
     maintainers = [ ];
 
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
 
-    hydraPlatforms = stdenv.lib.platforms.linux; # sdl-config times out on darwin
+    hydraPlatforms = lib.platforms.linux; # sdl-config times out on darwin
   };
 }

pkgs/games/beret/default.nix

···
   buildInputs = [ SDL SDL_image SDL_ttf SDL_mixer ];
 
   NIX_CFLAGS_COMPILE = "-I${SDL.dev}/include/SDL";
-  NIX_CFLAGS_LINK = stdenv.lib.optionalString (!stdenv.isDarwin) "-lgcc_s";
-  NIX_LDFLAGS = stdenv.lib.optionalString stdenv.isDarwin
+  NIX_CFLAGS_LINK = lib.optionalString (!stdenv.isDarwin) "-lgcc_s";
+  NIX_LDFLAGS = lib.optionalString stdenv.isDarwin
     "-framework CoreFoundation -framework OpenGL -framework Cocoa";
 
   patches = [ ./use-home-dir.patch ];

pkgs/games/bitsnbots/default.nix

···
-{ stdenv, fetchurl, SDL, lua, libGLU, libGL }:
+{ lib, stdenv, fetchurl, SDL, lua, libGLU, libGL }:
 
 stdenv.mkDerivation rec {
   name = "bitsnbots-20111230";
···
   meta = {
     description = "Simple puzzle game with moving robots";
     homepage = "http://moikmellah.org/blog/?page_id=19";
-    license = stdenv.lib.licenses.gpl3Plus;
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl3Plus;
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/games/blackshades/default.nix

···
-{stdenv, fetchsvn, SDL, libGLU, libGL, openal, libvorbis, freealut, SDL_image}:
+{lib, stdenv, fetchsvn, SDL, libGLU, libGL, openal, libvorbis, freealut, SDL_image}:
 
 stdenv.mkDerivation {
   name = "blackshades-svn-110";
···
   meta = {
     homepage = "http://icculus.org/blackshades/";
     description = "Protect the VIP";
-    license = stdenv.lib.licenses.free;
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.free;
+    maintainers = with lib.maintainers; [viric];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/games/blobby/default.nix

···
-{ stdenv, fetchurl, SDL2, SDL2_image, libGLU, libGL, cmake, physfs, boost, zip, zlib, pkg-config }:
+{ lib, stdenv, fetchurl, SDL2, SDL2_image, libGLU, libGL, cmake, physfs, boost, zip, zlib, pkg-config }:
 
 stdenv.mkDerivation rec {
   pname = "blobby-volley";
···
     chmod a+x "$out/bin/blobby"
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = ''A blobby volleyball game'';
     license = licenses.bsd3;
     platforms = platforms.linux;

pkgs/games/bsdgames/default.nix

···
-{ stdenv, fetchurl, ncurses, openssl, flex, bison, less, miscfiles }:
+{ lib, stdenv, fetchurl, ncurses, openssl, flex, bison, less, miscfiles }:
 
 stdenv.mkDerivation {
   name = "bsd-games-2.17";
···
   meta = {
     homepage = "http://www.t2-project.org/packages/bsd-games.html";
     description = "Ports of all the games from NetBSD-current that are free";
-    license = stdenv.lib.licenses.free;
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.free;
+    maintainers = with lib.maintainers; [viric];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/games/cataclysm-dda/common.nix

···
 }:
 
 let
-  inherit (stdenv.lib) optionals optionalString;
+  inherit (lib) optionals optionalString;
 
   cursesDeps = [ gettext ncurses ]
     ++ optionals stdenv.isDarwin [ CoreFoundation ];

pkgs/games/chessdb/default.nix

···
-{ stdenv, fetchurl, tcl, tk, libX11, makeWrapper }:
+{ lib, stdenv, fetchurl, tcl, tk, libX11, makeWrapper }:
 
 stdenv.mkDerivation {
   name = "chessdb-3.6.19-beta-1";
-  
+
   src = fetchurl {
     url = "mirror://sourceforge/chessdb/ChessDB-3.6.19-beta-1.tar.gz";
     sha256 = "0brc3wln3bxp979iqj2w1zxpfd0pch8zzazhdmwf7acww4hrsz62";
···
   meta = {
     homepage = "http://chessdb.sourceforge.net/";
     description = "A free chess database";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/chiaki/default.nix

···
     qtsvg
     protobuf
     SDL2
-  ] ++ stdenv.lib.optionals stdenv.isLinux [
+  ] ++ lib.optionals stdenv.isLinux [
     libevdev
     udev
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [
+  ] ++ lib.optionals stdenv.isDarwin [
     qtmacextras
   ];
 

pkgs/games/chocolate-doom/default.nix

···
-{ stdenv, autoreconfHook, pkgconfig, SDL2, SDL2_mixer, SDL2_net, fetchFromGitHub }:
+{ lib, stdenv, autoreconfHook, pkgconfig, SDL2, SDL2_mixer, SDL2_net, fetchFromGitHub }:
 
 stdenv.mkDerivation rec {
   pname = "chocolate-doom";
···
   meta = {
     homepage = "http://chocolate-doom.org/";
     description = "A Doom source port that accurately reproduces the experience of Doom as it was played in the 1990s";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.unix;
-    hydraPlatforms = stdenv.lib.platforms.linux; # darwin times out
-    maintainers = with stdenv.lib.maintainers; [ MP2E ];
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.unix;
+    hydraPlatforms = lib.platforms.linux; # darwin times out
+    maintainers = with lib.maintainers; [ MP2E ];
   };
 }

pkgs/games/ckan/default.nix

···
 
   buildInputs = [ makeWrapper mono ];
 
-  libraries = stdenv.lib.makeLibraryPath [ gtk2 curl ];
+  libraries = lib.makeLibraryPath [ gtk2 curl ];
 
   buildPhase = "true";
 

pkgs/games/cockatrice/default.nix

···
-{ stdenv, fetchFromGitHub, mkDerivation, cmake, protobuf
+{ lib, stdenv, fetchFromGitHub, mkDerivation, cmake, protobuf
 , qtbase, qtmultimedia, qttools, qtwebsockets, wrapQtAppsHook
 }:
 
···
   meta = {
     homepage = "https://github.com/Cockatrice/Cockatrice";
     description = "A cross-platform virtual tabletop for multiplayer card games";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ evanjs ];
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ evanjs ];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/games/construo/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchurl
 , libX11
 , zlib
···
   };
 
   buildInputs = [ libX11 zlib xorgproto ]
-    ++ stdenv.lib.optional (libGL != null) libGL
-    ++ stdenv.lib.optional (libGLU != null) libGLU
-    ++ stdenv.lib.optional (freeglut != null) freeglut;
+    ++ lib.optional (libGL != null) libGL
+    ++ lib.optional (libGLU != null) libGLU
+    ++ lib.optional (freeglut != null) freeglut;
 
   preConfigure = ''
     substituteInPlace src/Makefile.in \
···
   meta = {
     description = "Masses and springs simulation game";
     homepage = "http://fs.fsf.org/construo/";
-    license = stdenv.lib.licenses.gpl3;
+    license = lib.licenses.gpl3;
   };
 }

pkgs/games/crack-attack/default.nix

···
-{ stdenv, fetchurl, pkgconfig, gtk2, freeglut, SDL, SDL_mixer, libGLU, libGL, libXi, libXmu }:
+{ lib, stdenv, fetchurl, pkgconfig, gtk2, freeglut, SDL, SDL_mixer, libGLU, libGL, libXi, libXmu }:
 
 stdenv.mkDerivation {
   name = "crack-attack-1.1.14";
···
   meta = {
     description = "A fast-paced puzzle game inspired by the classic Super NES title Tetris Attack!";
     homepage = "https://www.nongnu.org/crack-attack/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.piotr ];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.piotr ];
   };
 }

pkgs/games/crafty/default.nix

···
-{ stdenv, fetchurl, unzip }:
+{ lib, stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation rec {
   pname = "crafty";
···
   meta = {
     homepage = "http://www.craftychess.com/";
     description = "Chess program developed by Dr. Robert M. Hyatt";
-    license = stdenv.lib.licenses.unfree;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.jwiegley ];
+    license = lib.licenses.unfree;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.jwiegley ];
   };
 }

pkgs/games/crispy-doom/default.nix

···
-{ stdenv, autoreconfHook, pkgconfig, SDL2, SDL2_mixer, SDL2_net, fetchFromGitHub, python }:
+{ lib, stdenv, autoreconfHook, pkgconfig, SDL2, SDL2_mixer, SDL2_net, fetchFromGitHub, python }:
 
 stdenv.mkDerivation rec {
   pname = "crispy-doom";
···
       Crispy Doom is a limit-removing enhanced-resolution Doom source port based on Chocolate Doom.
       Its name means that 640x400 looks \"crisp\" and is also a slight reference to its origin.
     '';
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = with stdenv.lib.maintainers; [ neonfuz ];
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.unix;
+    maintainers = with lib.maintainers; [ neonfuz ];
   };
 }

pkgs/games/crrcsim/default.nix

···
-{ stdenv, fetchurl, libGLU, libGL, SDL, SDL_mixer, plib, libjpeg }:
+{ lib, stdenv, fetchurl, libGLU, libGL, SDL, SDL_mixer, plib, libjpeg }:
 let
   version = "0.9.13";
 in
···
 
   meta = {
     description = "A model-airplane flight simulator";
-    maintainers = with stdenv.lib.maintainers; [ raskin ];
+    maintainers = with lib.maintainers; [ raskin ];
     platforms = [ "i686-linux" "x86_64-linux" ];
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
   };
 }

pkgs/games/cutemaze/default.nix

···
 
   buildInputs = [ qtsvg ];
 
-  postInstall = stdenv.lib.optionalString stdenv.isDarwin ''
+  postInstall = lib.optionalString stdenv.isDarwin ''
     mkdir -p $out/Applications
     mv CuteMaze.app $out/Applications
   '';

pkgs/games/cuyo/default.nix

···
-{ stdenv, fetchurl, SDL, SDL_mixer, zlib }:
+{ lib, stdenv, fetchurl, SDL, SDL_mixer, zlib }:
 
 stdenv.mkDerivation {
   pname = "cuyo";
   version = "2.1.0";
-  
+
   src = fetchurl {
      url = "https://download.savannah.gnu.org/releases/cuyo/cuyo-2.1.0.tar.gz";
      sha256 = "17yqv924x7yvwix7yz9jdhgyar8lzdhqvmpvv0any8rdkajhj23c";
      };
 
   buildInputs = [ SDL SDL_mixer zlib ];
-     
+
   meta = {
      homepage = "http://karimmi.de/cuyo";
      description = "Stacking blocks game, with different rules for each level";
-     license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+     license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
-  
+
 }

pkgs/games/dhewm3/default.nix

···
   meta = with lib; {
     homepage = "https://github.com/dhewm/dhewm3";
     description = "Doom 3 port to SDL";
-    license = stdenv.lib.licenses.gpl3;
+    license = lib.licenses.gpl3;
     maintainers = with maintainers; [ MP2E ];
     platforms = with platforms; linux;
   };

pkgs/games/domination/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchsvn
 # jdk8 is needed for building, but the game runs on newer jres as well
 , jdk8
···
     install -Dm644 build/game/resources/icon.png $out/share/pixmaps/domination.png
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "http://domination.sourceforge.net/";
     downloadPage = "http://domination.sourceforge.net/download.shtml";
     description = "A game that is a bit like the board game Risk or RisiKo";

pkgs/games/eboard/default.nix

···
-{ stdenv, fetchurl, perl, pkgconfig, gtk2 }:
+{ lib, stdenv, fetchurl, perl, pkgconfig, gtk2 }:
 
 stdenv.mkDerivation {
   name = "eboard-1.1.1";
···
   meta = {
     homepage = "http://www.bergo.eng.br/eboard/";
     description = "Chess interface for Unix-like systems";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/eduke32/default.nix

···
   buildInputs = [ alsaLib flac gtk2 libvorbis libvpx libGL libGLU SDL2 SDL2_mixer ];
 
   nativeBuildInputs = [ makeWrapper pkgconfig ]
-    ++ stdenv.lib.optional (stdenv.hostPlatform.system == "i686-linux") nasm;
+    ++ lib.optional (stdenv.hostPlatform.system == "i686-linux") nasm;
 
   postPatch = ''
     substituteInPlace source/build/src/glbuild.cpp \

pkgs/games/egoboo/default.nix

···
-{ stdenv, fetchurl, libGLU, libGL, SDL, SDL_mixer, SDL_image, SDL_ttf }:
+{ lib, stdenv, fetchurl, libGLU, libGL, SDL, SDL_mixer, SDL_image, SDL_ttf }:
 
 stdenv.mkDerivation rec {
   # pf5234 (a developer?) at freenode #egoboo told me that I better use 2.7.3 until
···
     description = "3D dungeon crawling adventure";
 
     homepage = "http://www.freedink.org/";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
 
     # I take it out of hydra as it does not work as well as I'd like
-    # maintainers = [ stdenv.lib.maintainers.bjg ];
-    # platforms = stdenv.lib.platforms.all;
+    # maintainers = [ lib.maintainers.bjg ];
+    # platforms = lib.platforms.all;
   };
 }

pkgs/games/endgame-singularity/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchurl
 , fetchFromGitHub
 , unzip
···
       rev = "v${version}";
       sha256 = "0ndrnxwii8lag6vrjpwpf5n36hhv223bb46d431l9gsigbizv0hl";
     })
-  ] ++ stdenv.lib.optional enableDefaultMusicPack (
+  ] ++ lib.optional enableDefaultMusicPack (
     fetchurl {
       url = "http://www.emhsoft.com/singularity/endgame-singularity-music-007.zip";
       sha256 = "0vf2qaf66jh56728pq1zbnw50yckjz6pf6c6qw6dl7vk60kkqnpb";
···
   propagatedBuildInputs = with python3.pkgs; [ pygame numpy polib ];
 
   # Add the music
-  postInstall = stdenv.lib.optionalString enableDefaultMusicPack ''
+  postInstall = lib.optionalString enableDefaultMusicPack ''
     cp -R "../endgame-singularity-music-007" \
           "$(echo $out/lib/python*/site-packages/singularity)/music"
           # ↑ we cannot glob on [...]/music, it doesn't exist yet
···
       A simulation of a true AI. Go from computer to computer, pursued by the
       entire world. Keep hidden, and you might have a chance
     '';
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ fgaz ];
+    license = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ fgaz ];
   };
 }

pkgs/games/enyo-doom/default.nix

···
-{ mkDerivation, stdenv, fetchFromGitLab, cmake, qtbase }:
+{ mkDerivation, lib, stdenv, fetchFromGitLab, cmake, qtbase }:
 
 mkDerivation rec {
   pname = "enyo-doom";
···
   meta = {
     homepage = "https://gitlab.com/sdcofer70/enyo-doom";
     description = "Frontend for Doom engines";
-    license = stdenv.lib.licenses.gpl3Plus;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.tadfisher ];
+    license = lib.licenses.gpl3Plus;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.tadfisher ];
   };
 }

pkgs/games/eternity-engine/default.nix

···
-{ stdenv, cmake, libGL, SDL, SDL_mixer, SDL_net, fetchFromGitHub, makeWrapper }:
+{ lib, stdenv, cmake, libGL, SDL, SDL_mixer, SDL_net, fetchFromGitHub, makeWrapper }:
 
 stdenv.mkDerivation rec {
   pname = "eternity-engine";
···
   meta = {
     homepage = "http://doomworld.com/eternity";
     description = "New school Doom port by James Haley";
-    license = stdenv.lib.licenses.gpl3;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = with stdenv.lib.maintainers; [ MP2E ];
+    license = lib.licenses.gpl3;
+    platforms = lib.platforms.linux;
+    maintainers = with lib.maintainers; [ MP2E ];
   };
 }

pkgs/games/extremetuxracer/default.nix

···
-{ stdenv, fetchurl, libGLU, libGL, libX11, xorgproto, tcl, freeglut, freetype
+{ lib, stdenv, fetchurl, libGLU, libGL, libX11, xorgproto, tcl, freeglut, freetype
 , sfml, libXi
 , libXmu, libXext, libXt, libSM, libICE
 , libpng, pkgconfig, gettext, intltool
···
     longDescription = ''
       ExtremeTuxRacer - Tux lies on his belly and accelerates down ice slopes.
     '';
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
     homepage = "https://sourceforge.net/projects/extremetuxracer/";
-    maintainers = with stdenv.lib.maintainers; [ ];
-    platforms = with stdenv.lib.platforms; linux;
+    maintainers = with lib.maintainers; [ ];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/games/exult/default.nix

···
-{ stdenv, fetchurl, pkgconfig, SDL2, libogg, libvorbis, zlib, unzip }:
+{ lib, stdenv, fetchurl, pkgconfig, SDL2, libogg, libvorbis, zlib, unzip }:
 
 let
 
···
   meta = {
     homepage = "http://exult.sourceforge.net/";
     description = "A reimplementation of the Ultima VII game engine";
-    maintainers = [ stdenv.lib.maintainers.eelco ];
-    platforms = stdenv.lib.platforms.unix;
-    hydraPlatforms = stdenv.lib.platforms.linux; # darwin times out
-    license = stdenv.lib.licenses.gpl2Plus;
+    maintainers = [ lib.maintainers.eelco ];
+    platforms = lib.platforms.unix;
+    hydraPlatforms = lib.platforms.linux; # darwin times out
+    license = lib.licenses.gpl2Plus;
   };
 }

pkgs/games/ezquake/default.nix

···
     expat curl jansson libpng libjpeg libGLU libGL libXxf86vm pcre SDL2 vim speex
   ];
 
-  installPhase = with stdenv.lib; let
+  installPhase = with lib; let
     sys = last (splitString "-" stdenv.hostPlatform.system);
     arch = head (splitString "-" stdenv.hostPlatform.system);
   in ''

pkgs/games/factorio/default.nix

···
-{ stdenv, fetchurl, makeWrapper, makeDesktopItem
+{ lib, stdenv, fetchurl, makeWrapper, makeDesktopItem
 , alsaLib, libpulseaudio, libX11, libXcursor, libXinerama, libXrandr, libXi, libGL
 , libSM, libICE, libXext, factorio-utils
 , releaseType
···
 
 let
 
-  inherit (stdenv.lib) importJSON;
+  inherit (lib) importJSON;
 
   helpMsg = ''
 
···
       if !needsAuth then
         fetchurl { inherit name url sha256; }
       else
-        (stdenv.lib.overrideDerivation
+        (lib.overrideDerivation
           (fetchurl {
             inherit name url sha256;
             curlOpts = [
···
         version 1.0 in mid 2020.
       '';
       homepage = "https://www.factorio.com/";
-      license = stdenv.lib.licenses.unfree;
-      maintainers = with stdenv.lib.maintainers; [ Baughn elitak erictapen priegger lukegb ];
+      license = lib.licenses.unfree;
+      maintainers = with lib.maintainers; [ Baughn elitak erictapen priegger lukegb ];
       platforms = [ "x86_64-linux" ];
     };
   };
···
 
       buildInputs = [ makeWrapper libpulseaudio ];
 
-      libPath = stdenv.lib.makeLibraryPath [
+      libPath = lib.makeLibraryPath [
         alsaLib
         libpulseaudio
         libX11

pkgs/games/factorio/mods.nix

···
 # mods. It will eventually be replaced by a nixos-channel that will provide
 # derivations for most or all of the mods tracked through the official mod
 # manager site.
-{ stdenv, fetchurl
+{ lib, stdenv, fetchurl
 , factorio-utils
 , allRecommendedMods ? true
 , allOptionalMods ? false
 }:
-with stdenv.lib;
+with lib;
 let
   modDrv = factorio-utils.modDrv { inherit allRecommendedMods allOptionalMods; };
 in

pkgs/games/factorio/utils.nix

···
 # This file provides a top-level function that will be used by both nixpkgs and nixos
 # to generate mod directories for use at runtime by factorio.
-{ stdenv }:
-with stdenv.lib;
+{ lib, stdenv }:
+with lib;
 {
   mkModDirDrv = mods: # a list of mod derivations
     let

pkgs/games/fairymax/default.nix

···
-{stdenv, fetchurl}:
+{lib, stdenv, fetchurl}:
 stdenv.mkDerivation rec {
   pname = "fairymax";
   version = "4.8";
···
        and board sizes up to 12x8. A Linux port exists in the
        format of a debian package.
     '';
-    license = stdenv.lib.licenses.free ;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.free ;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.linux;
     homepage = "http://home.hccnet.nl/h.g.muller/dwnldpage.html";
   };
 }

pkgs/games/flare/engine.nix

···
 
   nativeBuildInputs = [ cmake ];
   buildInputs = [ SDL2 SDL2_image SDL2_mixer SDL2_ttf ]
-    ++ stdenv.lib.optional stdenv.isDarwin Cocoa;
+    ++ lib.optional stdenv.isDarwin Cocoa;
 
   meta = with lib; {
     description = "Free/Libre Action Roleplaying Engine";

pkgs/games/freecell-solver/default.nix

···
-{ stdenv, fetchurl, pkgconfig, cmake
+{ lib, stdenv, fetchurl, pkgconfig, cmake
 , perl, gmp, libtap, gperf
 , perlPackages, python3 }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
 
   pname = "freecell-solver";

pkgs/games/freeciv/default.nix

···
 }:
 
 let
-  inherit (stdenv.lib) optional optionals;
+  inherit (lib) optional optionals;
 
 in stdenv.mkDerivation rec {
   pname = "freeciv";

pkgs/games/freedink/default.nix

···
-{ stdenv, fetchurl, SDL, SDL_mixer, SDL_image, SDL_ttf, SDL_gfx
+{ lib, stdenv, fetchurl, SDL, SDL_mixer, SDL_image, SDL_ttf, SDL_gfx
 , pkgconfig, intltool, fontconfig, libzip, zip, zlib }:
 
 let
···
     '';
 
     homepage = "http://www.freedink.org/";
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = lib.licenses.gpl3Plus;
 
-    maintainers = [ stdenv.lib.maintainers.bjg ];
-    platforms = stdenv.lib.platforms.all;
-    hydraPlatforms = stdenv.lib.platforms.linux; # sdl-config times out on darwin
+    maintainers = [ lib.maintainers.bjg ];
+    platforms = lib.platforms.all;
+    hydraPlatforms = lib.platforms.linux; # sdl-config times out on darwin
   };
 }

pkgs/games/freedroidrpg/default.nix

···
   inherit version;
 
   src = fetchurl {
-    url = "ftp://ftp.osuosl.org/pub/freedroid/freedroidRPG-${stdenv.lib.versions.majorMinor version}/freedroidRPG-${version}.tar.gz";
+    url = "ftp://ftp.osuosl.org/pub/freedroid/freedroidRPG-${lib.versions.majorMinor version}/freedroidRPG-${version}.tar.gz";
     sha256 = "0n4kn38ncmcy3lrxmq8fjry6c1z50z4q1zcqfig0j4jb0dsz2va2";
   };
 
···
 
   buildInputs = [
     SDL SDL_image SDL_gfx SDL_mixer libogg libvorbis lua5_3 libjpeg libpng zlib
-  ] ++ stdenv.lib.optional stdenv.isDarwin libiconv;
+  ] ++ lib.optional stdenv.isDarwin libiconv;
 
   meta = with lib; {
     description = "Isometric 3D RPG similar to game Diablo";

pkgs/games/frozen-bubble/default.nix

···
-{ stdenv, fetchurl, perlPackages, pkgconfig, SDL, SDL_mixer, SDL_Pango, glib }:
+{ lib, stdenv, fetchurl, perlPackages, pkgconfig, SDL, SDL_mixer, SDL_Pango, glib }:
 
 perlPackages.buildPerlModule {
   pname = "frozen-bubble";
···
 
   meta = {
     description = "Puzzle with Bubbles";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = with stdenv.lib.maintainers; [ puckipedia ];
+    license = lib.licenses.gpl2;
+    maintainers = with lib.maintainers; [ puckipedia ];
   };
 }

pkgs/games/fsg/default.nix

···
-{ stdenv, fetchurl, gtk2, glib, pkgconfig, libGLU, libGL, wxGTK, libX11, xorgproto
+{ lib, stdenv, fetchurl, gtk2, glib, pkgconfig, libGLU, libGL, wxGTK, libX11, xorgproto
 , runtimeShell }:
 
 stdenv.mkDerivation {
···
 
   meta = {
     description = "Cellular automata engine tuned towards the likes of Falling Sand";
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.linux;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/galaxis/default.nix

···
-{ stdenv, fetchurl, ncurses, xmlto }:
+{ lib, stdenv, fetchurl, ncurses, xmlto }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
 
   pname = "galaxis";

pkgs/games/gargoyle/default.nix

···
     sha256 = "0w54avmbp4i4zps2rb4acmpa641s6wvwbrln4vbdhcz97fx48nzz";
   };
 
-  nativeBuildInputs = [ jam pkgconfig ] ++ stdenv.lib.optional stdenv.isDarwin cctools;
+  nativeBuildInputs = [ jam pkgconfig ] ++ lib.optional stdenv.isDarwin cctools;
 
   buildInputs = [ SDL SDL_mixer SDL_sound gtk2 ]
-    ++ stdenv.lib.optionals stdenv.isDarwin [ smpeg libvorbis ];
+    ++ lib.optionals stdenv.isDarwin [ smpeg libvorbis ];
 
   buildPhase = jamenv + "jam -j$NIX_BUILD_CORES";
 

pkgs/games/gav/default.nix

···
-{stdenv, fetchurl, SDL, SDL_image, SDL_mixer, SDL_net} :
+{lib, stdenv, fetchurl, SDL, SDL_image, SDL_mixer, SDL_net} :
 
 stdenv.mkDerivation {
   name = "gav-0.9.0";
···
   meta = {
     description = "Remake of AV Arcade Volleyball";
     homepage = "http://gav.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/gltron/default.nix

···
-{stdenv, fetchurl, SDL, libGLU, libGL, zlib, libpng, libvorbis, libmikmod, SDL_sound } :
+{lib, stdenv, fetchurl, SDL, libGLU, libGL, zlib, libpng, libvorbis, libmikmod, SDL_sound } :
 
 stdenv.mkDerivation rec {
   name = "gltron-0.70";
···
   meta = {
     homepage = "http://www.gltron.org/";
     description = "Game based on the movie Tron";
-    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/games/gmad/default.nix

···
-{ stdenv, fetchFromGitHub, premake4, bootil }:
+{ lib, stdenv, fetchFromGitHub, premake4, bootil }:
 
 stdenv.mkDerivation rec {
   name = "gmad-unstable-2015-04-16";
···
   meta = {
     description = "Garry's Mod Addon Creator and Extractor";
     homepage = "https://github.com/garrynewman/gmad";
-    license = stdenv.lib.licenses.unfree;
-    maintainers = [ stdenv.lib.maintainers.abigailbuccaneer ];
-    platforms = stdenv.lib.platforms.all;
+    license = lib.licenses.unfree;
+    maintainers = [ lib.maintainers.abigailbuccaneer ];
+    platforms = lib.platforms.all;
   };
 
   src = fetchFromGitHub {

pkgs/games/gnubg/default.nix

···
-{ stdenv, fetchurl, pkgconfig, glib, python, gtk2, readline }:
+{ lib, stdenv, fetchurl, pkgconfig, glib, python, gtk2, readline }:
 
 let version = "1.06.002"; in
 stdenv.mkDerivation {
···
 
   configureFlags = [ "--with-gtk" "--with--board3d" ];
 
-  meta = with stdenv.lib;
+  meta = with lib;
     { description = "World class backgammon application";
       homepage = "http://www.gnubg.org/";
       license = licenses.gpl3;

pkgs/games/gnuchess/default.nix

···
-{stdenv, fetchurl, flex, makeWrapper}:
+{lib, stdenv, fetchurl, flex, makeWrapper}:
 let
   s = # Generated upstream information
   rec {
···
   meta = {
     inherit (s) version;
     description = "GNU Chess engine";
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.unix;
-    license = stdenv.lib.licenses.gpl3Plus;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.unix;
+    license = lib.licenses.gpl3Plus;
   };
 }

pkgs/games/gnugo/default.nix

···
-{ stdenv, fetchurl }:
+{ lib, stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
   pname = "gnugo";
···
   meta = {
     description = "GNU Go - A computer go player";
     homepage = "https://www.gnu.org/software/gnugo/";
-    license = stdenv.lib.licenses.gpl3;
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl3;
+    platforms = lib.platforms.unix;
   };
 }

pkgs/games/gogui/default.nix

···
-{ fetchurl, stdenv, openjdk, unzip, makeWrapper }:
+{ fetchurl, lib, stdenv, openjdk, unzip, makeWrapper }:
 
 let
   version = "1.4.9";
···
     done
   '';
   meta = {
-    maintainers = [ stdenv.lib.maintainers.cleverca22 ];
+    maintainers = [ lib.maintainers.cleverca22 ];
     description = "A graphical user interface to programs that play the board game Go and support the Go Text Protocol such as GNU Go";
     homepage = "http://gogui.sourceforge.net/";
-    platforms = stdenv.lib.platforms.unix;
-    license = stdenv.lib.licenses.gpl3;
+    platforms = lib.platforms.unix;
+    license = lib.licenses.gpl3;
   };
 }

pkgs/games/gtetrinet/default.nix

···
-{ fetchFromGitHub, stdenv, autoreconfHook, intltool, pkgconfig, libgnome, libgnomeui, GConf }:
+{ fetchFromGitHub, lib, stdenv, autoreconfHook, intltool, pkgconfig, libgnome, libgnomeui, GConf }:
 
 stdenv.mkDerivation {
   name = "gtetrinet-0.7.11";
···
       that is played over the internet.
     '';
     homepage = "http://gtetrinet.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.chris-martin ];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.unix;
+    maintainers = [ lib.maintainers.chris-martin ];
   };
 }

pkgs/games/gtypist/default.nix

···
   };
 
   buildInputs = [ makeWrapper ncurses perl fortune ]
-   ++ stdenv.lib.optional stdenv.isDarwin libiconv;
+   ++ lib.optional stdenv.isDarwin libiconv;
 
   preFixup = ''
      wrapProgram "$out/bin/typefortune" \

pkgs/games/hawkthorne/default.nix

···
-{ fetchgit, stdenv, love, curl, zip }:
+{ fetchgit, lib, stdenv, love, curl, zip }:
 
 stdenv.mkDerivation {
   version = "0.12.1";
···
       Hawthorne's inheritance.
     '';
     homepage = "https://www.reddit.com/r/hawkthorne";
-    license = stdenv.lib.licenses.mit;
-    maintainers = with stdenv.lib.maintainers; [ campadrenalin ];
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ campadrenalin ];
     broken = true;
   };
 }

pkgs/games/icbm3d/default.nix

···
-{stdenv, fetchurl, libX11}:
+{lib, stdenv, fetchurl, libX11}:
 
 stdenv.mkDerivation {
   name = "icbm3d-0.4";
···
   meta = {
     homepage = "http://www.newbreedsoftware.com/icbm3d/";
     description = "3D vector-based clone of the atari game Missile Command";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/instead/default.nix

···
   meta = with lib; {
     description = "Simple text adventure interpreter for Unix and Windows";
     homepage = "https://instead.syscall.ru/";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = with stdenv.lib.platforms; linux;
+    license = lib.licenses.gpl2;
+    platforms = with lib.platforms; linux;
     maintainers = with maintainers; [ pSub ];
   };
 }

pkgs/games/jumpnbump/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitLab
 , fetchzip
 , SDL2, SDL2_mixer, SDL2_net
···
     wrapPythonPrograms
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "cute, true multiplayer platform game with bunnies";
     homepage    = "https://libregames.gitlab.io/jumpnbump/";
     license     = licenses.gpl2Plus;

pkgs/games/keeperrl/default.nix

···
 
   sourceRoot = "source";
 
-  srcs = [ free-src ] ++ stdenv.lib.optional unfree_assets assets;
+  srcs = [ free-src ] ++ lib.optional unfree_assets assets;
 
-  postUnpack = stdenv.lib.optionalString unfree_assets ''
+  postUnpack = lib.optionalString unfree_assets ''
     mv data $sourceRoot
   '';
 
···
 
     cp -r data_free $out/share
     cp -r data_contrib $out/share
-    ${stdenv.lib.optionalString unfree_assets "cp -r data $out/share"}
+    ${lib.optionalString unfree_assets "cp -r data $out/share"}
   '';
 
   meta = with lib; {

pkgs/games/kobodeluxe/default.nix

···
-{stdenv, fetchurl, SDL, SDL_image, libGLU, libGL} :
+{lib, stdenv, fetchurl, SDL, SDL_image, libGLU, libGL} :
 
 stdenv.mkDerivation {
   name = "kobodeluxe-0.5.1";
···
   meta = {
     homepage = "http://olofson.net/kobodl/";
     description = "Enhanced version of Akira Higuchi's game XKobo  for Un*x systems with X11";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/koboredux/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchFromGitHub
 , fetchpatch
 , requireFile
···
 , useProprietaryAssets ? true
 }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
   pname = "koboredux";
   version = "0.7.5.1";

pkgs/games/lbreakout2/default.nix

···
     license = licenses.gpl2;
     maintainers = [ maintainers.ciil ];
     platforms = platforms.unix;
-    hydraPlatforms = stdenv.lib.platforms.linux; # sdl-config times out on darwin
+    hydraPlatforms = lib.platforms.linux; # sdl-config times out on darwin
   };
 }

pkgs/games/liquidwar/5.nix

···
 
   buildInputs = [ allegro ];
 
-  configureFlags = stdenv.lib.optional stdenv.isx86_64 "--disable-asm";
+  configureFlags = lib.optional stdenv.isx86_64 "--disable-asm";
 
   hardeningDisable = [ "format" ];
 

pkgs/games/lugaru/default.nix

···
-{ stdenv, fetchFromGitLab, cmake, openal, pkgconfig, libogg,
+{ lib, stdenv, fetchFromGitLab, cmake, openal, pkgconfig, libogg,
   libvorbis, SDL2, makeWrapper, libpng, libjpeg_turbo, libGLU }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation rec {
 
···
     homepage = "https://osslugaru.gitlab.io";
     maintainers = [ ];
     platforms = platforms.linux;
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
   };
 }

pkgs/games/macopix/default.nix

···
-{ stdenv, fetchurl, pkgconfig, gtk, openssl }:
+{ lib, stdenv, fetchurl, pkgconfig, gtk, openssl }:
 
 stdenv.mkDerivation rec {
   name = "macopix-1.7.4";
···
   meta = {
     description = "Mascot Constructive Pilot for X";
     homepage = "http://rosegray.sakura.ne.jp/macopix/index-e.html";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/megaglest/default.nix

···
-{ stdenv, cmake, pkg-config, git, curl, SDL2, xercesc, openal, lua, libvlc
+{ lib, stdenv, cmake, pkg-config, git, curl, SDL2, xercesc, openal, lua, libvlc
 , libjpeg, wxGTK, cppunit, ftgl, glew, libogg, libvorbis, buildEnv, libpng
 , fontconfig, freetype, xorg, makeWrapper, bash, which, gnome3, libGLU, glib
 , fetchFromGitHub
···
     done
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "An entertaining free (freeware and free software) and open source cross-platform 3D real-time strategy (RTS) game";
     license = licenses.gpl3;
     homepage = "http://megaglest.org/";

pkgs/games/minecraft/default.nix

···
     categories = "Game;";
   };
 
-  envLibPath = stdenv.lib.makeLibraryPath [
+  envLibPath = lib.makeLibraryPath [
     curl
     libpulseaudio
     systemd
···
     libXxf86vm # needed only for versions <1.13
   ];
 
-  libPath = stdenv.lib.makeLibraryPath ([
+  libPath = lib.makeLibraryPath ([
     alsaLib
     atk
     cairo
···
     # Do not create `GPUCache` in current directory
     makeWrapper $out/opt/minecraft-launcher/minecraft-launcher $out/bin/minecraft-launcher \
       --prefix LD_LIBRARY_PATH : ${envLibPath} \
-      --prefix PATH : ${stdenv.lib.makeBinPath [ jre ]} \
-      --set JAVA_HOME ${stdenv.lib.getBin jre} \
+      --prefix PATH : ${lib.makeBinPath [ jre ]} \
+      --set JAVA_HOME ${lib.getBin jre} \
       --run "cd /tmp" \
       "''${gappsWrapperArgs[@]}"
   '';

pkgs/games/minetest/default.nix

···
 , leveldb, postgresql, hiredis, libiconv, OpenGL, OpenAL ? openal, Carbon, Cocoa
 }:
 
-with stdenv.lib;
+with lib;
 
 let
   boolToCMake = b: if b then "ON" else "OFF";

pkgs/games/moon-buggy/default.nix

···
-{stdenv, fetchurl, ncurses}:
+{lib, stdenv, fetchurl, ncurses}:
 
 stdenv.mkDerivation rec {
   baseName = "moon-buggy";
···
 
   meta = {
     description = ''A simple character graphics game where you drive some kind of car across the moon's surface'';
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [stdenv.lib.maintainers.rybern];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = [lib.maintainers.rybern];
+    platforms = lib.platforms.linux;
     homepage = "https://www.seehuhn.de/pages/moon-buggy";
   };
 }

pkgs/games/multimc/default.nix

···
 
 let
   jdk = jdk8;
-  libpath = with xorg; stdenv.lib.makeLibraryPath [ libX11 libXext libXcursor libXrandr libXxf86vm libpulseaudio ];
+  libpath = with xorg; lib.makeLibraryPath [ libX11 libXext libXcursor libXrandr libXxf86vm libpulseaudio ];
 in mkDerivation rec {
   pname = "multimc";
   version = "0.6.11";

pkgs/games/n2048/default.nix

···
-{stdenv, fetchurl, ncurses}:
+{lib, stdenv, fetchurl, ncurses}:
 let
-  s = 
+  s =
   rec {
     baseName = "n2048";
     version = "0.1";
···
   meta = {
     inherit (s) version;
     description = ''Console implementation of 2048 game'';
-    license = stdenv.lib.licenses.bsd2;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.bsd2;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.linux;
     homepage = "http://www.dettus.net/n2048/";
   };
 }

pkgs/games/naev/default.nix

···
-{ fetchurl, stdenv, SDL, openal, SDL_mixer, libxml2, pkgconfig, libvorbis
+{ lib, fetchurl, stdenv, SDL, openal, SDL_mixer, libxml2, pkgconfig, libvorbis
 , libpng, libGLU, libGL, makeWrapper, zlib, freetype }:
 
 let
···
   meta = {
     description = "2D action/rpg space game";
     homepage = "http://www.naev.org";
-    license = stdenv.lib.licenses.gpl3Plus;
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3Plus;
+    maintainers = with lib.maintainers; [viric];
+    platforms = lib.platforms.linux;
     hydraPlatforms = [];
   };
 }

pkgs/games/nethack/default.nix

···
 
   enableParallelBuilding = true;
 
-  preFixup = stdenv.lib.optionalString qtMode ''
+  preFixup = lib.optionalString qtMode ''
     wrapQtApp "$out/games/nethack"
   '';
 

pkgs/games/neverball/default.nix

···
-{ stdenv, fetchurl, SDL2, libGL, libpng, libjpeg, SDL2_ttf, libvorbis, gettext
+{ lib, stdenv, fetchurl, SDL2, libGL, libpng, libjpeg, SDL2_ttf, libvorbis, gettext
 , physfs }:
 
 stdenv.mkDerivation rec {
···
     homepage = "https://neverball.org/";
     description = "Tilt the floor to roll a ball";
     license = "GPL";
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = with stdenv.lib.platforms; linux;
+    maintainers = with lib.maintainers; [viric];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/games/nexuiz/default.nix

···
-{ stdenv, fetchurl
+{ lib, stdenv, fetchurl
 , # required for both
   unzip, zlib, curl, libjpeg, libpng, libvorbis, libtheora
 , libogg, libmodplug
···
 let
   version = "2.5.2";
 
-  version_short = stdenv.lib.replaceChars [ "." ] [ "" ] version;
+  version_short = lib.replaceChars [ "." ] [ "" ] version;
 in stdenv.mkDerivation {
   pname = "nexuiz";
   inherit version;
···
   meta = {
     description = "A free fast-paced first-person shooter";
     homepage = "http://www.alientrap.org/games/nexuiz";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/njam/default.nix

···
-{stdenv, fetchurl, SDL, SDL_image, SDL_mixer, SDL_net }:
+{lib, stdenv, fetchurl, SDL, SDL_image, SDL_mixer, SDL_net }:
 
 stdenv.mkDerivation {
   name = "njam-1.25";
···
   meta = {
     homepage = "http://trackballs.sourceforge.net/";
     description = "Cross-platform pacman-like game";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/nudoku/default.nix

···
   nativeBuildInputs = [ autoreconfHook pkgconfig gettext ];
   buildInputs = [ ncurses ];
 
-  configureFlags = stdenv.lib.optional stdenv.hostPlatform.isMusl "--disable-nls";
+  configureFlags = lib.optional stdenv.hostPlatform.isMusl "--disable-nls";
 
   meta = with lib; {
     description = "An ncurses based sudoku game";

pkgs/games/nxengine-evo/default.nix

···
-{ stdenv
+{ lib, stdenv
 , fetchpatch
 , fetchurl
 , cmake
···
 
   meta = {
     description = "A complete open-source clone/rewrite of the masterpiece jump-and-run platformer Doukutsu Monogatari (also known as Cave Story)";
-    license = with stdenv.lib.licenses; [
+    license = with lib.licenses; [
       gpl3                   # Game engine
       unfreeRedistributable  # Game assets, freeware
     ];
-    maintainers = [ stdenv.lib.maintainers.scubed2 ];
+    maintainers = [ lib.maintainers.scubed2 ];
     homepage = "https://github.com/nxengine/nxengine-evo";
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/odamex/default.nix

···
-{ stdenv, cmake, fetchurl, pkgconfig, SDL, SDL_mixer, SDL_net, wxGTK30 }:
+{ lib, stdenv, cmake, fetchurl, pkgconfig, SDL, SDL_mixer, SDL_net, wxGTK30 }:
 
 stdenv.mkDerivation rec {
   pname = "odamex";
···
   meta = {
     homepage = "http://odamex.net/";
     description = "A client/server port for playing old-school Doom online";
-    license = stdenv.lib.licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = with stdenv.lib.maintainers; [ MP2E ];
+    license = lib.licenses.gpl2;
+    platforms = lib.platforms.linux;
+    maintainers = with lib.maintainers; [ MP2E ];
   };
 }

pkgs/games/oilrush/default.nix

···
-{ stdenv, config, fetchurl, libX11, libXext, libXinerama, libXrandr
+{ lib, stdenv, config, fetchurl, libX11, libXext, libXinerama, libXrandr
 , libXrender, fontconfig, freetype, openal, runtimeShell }:
 
-let inherit (stdenv.lib) makeLibraryPath; in
+let inherit (lib) makeLibraryPath; in
 
 stdenv.mkDerivation {
   name = "oilrush";
···
       of Tower Defense.
     '';
     homepage = "http://oilrush-game.com/";
-    license = stdenv.lib.licenses.unfree;
-    #maintainers = with stdenv.lib.maintainers; [ astsmtl ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.unfree;
+    #maintainers = with lib.maintainers; [ astsmtl ];
+    platforms = lib.platforms.linux;
     hydraPlatforms = [];
   };
 

pkgs/games/openarena/default.nix

···
-{ fetchurl, makeWrapper, patchelf, pkgs, stdenv, SDL, libglvnd, libogg, libvorbis, curl, openal }:
+{ lib, fetchurl, makeWrapper, patchelf, pkgs, stdenv, SDL, libglvnd, libogg, libvorbis, curl, openal }:
 
 stdenv.mkDerivation {
   pname = "openarena";
···
   installPhase = let
     gameDir = "$out/openarena-$version";
     interpreter = "$(< \"$NIX_CC/nix-support/dynamic-linker\")";
-    libPath = stdenv.lib.makeLibraryPath [ SDL libglvnd libogg libvorbis curl openal ];
+    libPath = lib.makeLibraryPath [ SDL libglvnd libogg libvorbis curl openal ];
     arch = {
       "x86_64-linux" = "x86_64";
       "i386-linux" = "i386";
···
   meta = {
     description = "Crossplatform openarena client";
     homepage = "http://openarena.ws/";
-    maintainers = [ stdenv.lib.maintainers.wyvie ];
+    maintainers = [ lib.maintainers.wyvie ];
     platforms = [ "i386-linux" "x86_64-linux" ];
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
   };
 }

pkgs/games/openclonk/default.nix

···
 
   postInstall = ''
     mv -v $out/games/openclonk $out/bin/
-  '' + stdenv.lib.optionalString enableSoundtrack ''
+  '' + lib.optionalString enableSoundtrack ''
     ln -sv ${soundtrack_src} $out/share/games/openclonk/Music.ocg
   '';
 

pkgs/games/openlierox/default.nix

···
-{ stdenv, fetchurl, libX11, xorgproto, gd, SDL, SDL_image, SDL_mixer, zlib
+{ lib, stdenv, fetchurl, libX11, xorgproto, gd, SDL, SDL_image, SDL_mixer, zlib
 , libxml2, pkg-config, curl, cmake, libzip }:
 
 stdenv.mkDerivation {
···
   meta = {
     homepage = "http://openlierox.net";
     description = "Real-time game with Worms-like shooting";
-    license = stdenv.lib.licenses.lgpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.lgpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/openra/common.nix

···
 /*  The reusable code, and package attributes, between OpenRA engine packages (engine.nix)
     and out-of-tree mod packages (mod.nix).
 */
-{ stdenv, makeSetupHook, curl, unzip, dos2unix, pkgconfig, makeWrapper
+{ lib, stdenv, makeSetupHook, curl, unzip, dos2unix, pkgconfig, makeWrapper
 , lua, mono, dotnetPackages, python
 , libGL, freetype, openal, SDL2
 , zenity
 }:
 
-with stdenv.lib;
+with lib;
 
 let
   path = makeBinPath ([ mono python ] ++ optional (zenity != null) zenity);

pkgs/games/openra/engine.nix

···
     This package could be seen as providing a set of in-tree mods,
     while the `mod.nix` pacakges provide a single out-of-tree mod.
 */
-{ stdenv
+{ lib, stdenv
 , packageAttrs
 , patchEngine
 , wrapLaunchGame
 , engine
 }:
 
-with stdenv.lib;
+with lib;
 
 stdenv.mkDerivation (recursiveUpdate packageAttrs rec {
   name = "${pname}-${version}";

pkgs/games/openra/mod.nix

···
     The engine is relatively small and quick to build, so this is not much of a problem.
     Building a mod will result in a wrapper script that starts the mod inside the specified engine.
 */
-{ stdenv
+{ lib, stdenv
 , packageAttrs
 , patchEngine
 , wrapLaunchGame
···
 , engine
 }:
 
-with stdenv.lib;
+with lib;
 
 let
   engineSourceName = engine.src.name or "engine";

pkgs/games/openrw/default.nix

···
 
   buildInputs = [
     sfml libGLU libGL bullet glm libmad xlibsWrapper openal SDL2 boost ffmpeg_3
-  ] ++ stdenv.lib.optionals stdenv.isDarwin [ OpenAL Cocoa ];
+  ] ++ lib.optionals stdenv.isDarwin [ OpenAL Cocoa ];
 
   meta = with lib; {
     description = "Unofficial open source recreation of the classic Grand Theft Auto III game executable";

pkgs/games/openspades/default.nix

···
 
   buildInputs = [
     freetype SDL2 SDL2_image libGL zlib curl glew opusfile openal libogg
-  ] ++ stdenv.lib.optionals stdenv.hostPlatform.isDarwin [
+  ] ++ lib.optionals stdenv.hostPlatform.isDarwin [
     Cocoa
   ];
 

pkgs/games/openttd/default.nix

···
 
   nativeBuildInputs = [ pkgconfig which makeWrapper ];
   buildInputs = [ SDL2 libpng xz zlib freetype fontconfig libxdg_basedir ]
-    ++ stdenv.lib.optionals withFluidSynth [ fluidsynth soundfont-fluid ];
+    ++ lib.optionals withFluidSynth [ fluidsynth soundfont-fluid ];
 
   prefixKey = "--prefix-dir=";
 
···
   postInstall = ''
     mv $out/games/ $out/bin
 
-    ${stdenv.lib.optionalString withOpenGFX ''
+    ${lib.optionalString withOpenGFX ''
       cp ${opengfx}/* $out/share/games/openttd/baseset
     ''}
 
     mkdir -p $out/share/games/openttd/data
 
-    ${stdenv.lib.optionalString withOpenSFX ''
+    ${lib.optionalString withOpenSFX ''
       cp ${opensfx}/*.{obs,cat} $out/share/games/openttd/data
     ''}
 
     mkdir $out/share/games/openttd/baseset/openmsx
 
-    ${stdenv.lib.optionalString withOpenMSX ''
+    ${lib.optionalString withOpenMSX ''
       cp ${openmsx}/*.{obm,mid} $out/share/games/openttd/baseset/openmsx
     ''}
 
-    ${stdenv.lib.optionalString withFluidSynth ''
+    ${lib.optionalString withFluidSynth ''
       wrapProgram $out/bin/openttd \
         --add-flags -m \
         --add-flags extmidi:cmd=${playmidi}/bin/playmidi

pkgs/games/opentyrian/default.nix

···
-{stdenv, fetchurl, fetchzip, SDL, SDL_net}:
+{ lib, stdenv, fetchurl, fetchzip, SDL, SDL_net }:
 
 stdenv.mkDerivation rec {
   pname = "opentyrian";
···
     description = ''Open source port of the game "Tyrian"'';
     homepage = "https://bitbucket.org/opentyrian/opentyrian";
     # This does not account of Tyrian data.
-    # license = stdenv.lib.licenses.gpl2;
+    # license = lib.licenses.gpl2;
   };
 }

pkgs/games/openxcom/default.nix

···
-{stdenv, fetchFromGitHub, cmake, libGLU, libGL, zlib, openssl, libyamlcpp, boost
+{lib, stdenv, fetchFromGitHub, cmake, libGLU, libGL, zlib, openssl, libyamlcpp, boost
 , SDL, SDL_image, SDL_mixer, SDL_gfx }:
 
 let version = "1.0.0.2019.10.18"; in
···
     description = "Open source clone of UFO: Enemy Unknown";
     homepage = "https://openxcom.org";
     repositories.git = "https://github.com/SupSuper/OpenXcom.git";
-    maintainers = [ stdenv.lib.maintainers.cpages ];
-    platforms = stdenv.lib.platforms.linux;
-    license = stdenv.lib.licenses.gpl3;
+    maintainers = [ lib.maintainers.cpages ];
+    platforms = lib.platforms.linux;
+    license = lib.licenses.gpl3;
   };
 
 }

pkgs/games/papermc/default.nix

···
-{ stdenv, fetchurl, bash, jre }:
+{ lib, stdenv, fetchurl, bash, jre }:
 let
   mcVersion = "1.16.4";
   buildNum = "296";
···
   meta = {
     description = "High-performance Minecraft Server";
     homepage    = "https://papermc.io/";
-    license     = stdenv.lib.licenses.gpl3Only;
-    platforms   = stdenv.lib.platforms.unix;
-    maintainers = with stdenv.lib.maintainers; [ aaronjanse ];
+    license     = lib.licenses.gpl3Only;
+    platforms   = lib.platforms.unix;
+    maintainers = with lib.maintainers; [ aaronjanse ];
   };
 }

pkgs/games/pingus/default.nix

···
-{stdenv, fetchgit, cmake, SDL2, SDL2_image, boost, libpng, SDL2_mixer
+{lib, stdenv, fetchgit, cmake, SDL2, SDL2_image, boost, libpng, SDL2_mixer
 , pkgconfig, libGLU, libGL, git, jsoncpp }:
 stdenv.mkDerivation rec {
   pname = "pingus";
···
 
   meta = {
     description = ''A puzzle game with mechanics similar to Lemmings'';
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    license = stdenv.lib.licenses.gpl3;
+    platforms = lib.platforms.linux;
+    maintainers = [lib.maintainers.raskin];
+    license = lib.licenses.gpl3;
   };
 }

pkgs/games/planetaryannihilation/default.nix

···
     ln -s ${systemd}/lib/libudev.so.1 $out/lib/libudev.so.0
 
     patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" "$out/PA"
-    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" --set-rpath "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc.lib xorg.libXdamage xorg.libXfixes gtk2 glib stdenv.glibc.out "$out" xorg.libXext pango udev xorg.libX11 xorg.libXcomposite alsaLib atk nspr fontconfig cairo pango nss freetype gnome2.GConf gdk-pixbuf xorg.libXrender ]}:{stdenv.cc.cc.lib}/lib64:${stdenv.glibc.out}/lib64" "$out/host/CoherentUI_Host"
+    patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" --set-rpath "${lib.makeLibraryPath [ stdenv.cc.cc.lib xorg.libXdamage xorg.libXfixes gtk2 glib stdenv.glibc.out "$out" xorg.libXext pango udev xorg.libX11 xorg.libXcomposite alsaLib atk nspr fontconfig cairo pango nss freetype gnome2.GConf gdk-pixbuf xorg.libXrender ]}:{stdenv.cc.cc.lib}/lib64:${stdenv.glibc.out}/lib64" "$out/host/CoherentUI_Host"
 
-    wrapProgram $out/PA --prefix LD_LIBRARY_PATH : "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc.lib stdenv.glibc.out xorg.libX11 xorg.libXcursor gtk2 glib curl "$out" ]}:${stdenv.cc.cc.lib}/lib64:${stdenv.glibc.out}/lib64"
+    wrapProgram $out/PA --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ stdenv.cc.cc.lib stdenv.glibc.out xorg.libX11 xorg.libXcursor gtk2 glib curl "$out" ]}:${stdenv.cc.cc.lib}/lib64:${stdenv.glibc.out}/lib64"
 
     for f in $out/lib/*; do
-      patchelf --set-rpath "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc.lib curl xorg.libX11 stdenv.glibc.out xorg.libXcursor "$out" ]}:${stdenv.cc.cc.lib}/lib64:${stdenv.glibc.out}/lib64" $f
+      patchelf --set-rpath "${lib.makeLibraryPath [ stdenv.cc.cc.lib curl xorg.libX11 stdenv.glibc.out xorg.libXcursor "$out" ]}:${stdenv.cc.cc.lib}/lib64:${stdenv.glibc.out}/lib64" $f
     done
   '';
 
   meta = with lib; {
     homepage = "http://www.uberent.com/pa/";
     description = "Next-generation RTS that takes the genre to a planetary scale";
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
     platforms = platforms.linux;
     maintainers = [ maintainers.domenkozar ];
   };

pkgs/games/pokerth/default.nix

···
-{ mkDerivation, stdenv, fetchFromGitHub, runCommand, fetchpatch, patchutils, qmake, qtbase
+{ lib, mkDerivation, stdenv, fetchFromGitHub, runCommand, fetchpatch, patchutils, qmake, qtbase
 , SDL, SDL_mixer, boost, curl, gsasl, libgcrypt, libircclient, protobuf, sqlite
 , wrapQtAppsHook
 , tinyxml2, target ? "client" }:
-
-with stdenv.lib;
 
 let
   hiDPI = fetchpatch {
···
 
   enableParallelBuilding = true;
 
-  meta = {
+  meta = with lib; {
     homepage = "https://www.pokerth.net";
     description = "Poker game ${target}";
     license = licenses.gpl3;

pkgs/games/pong3d/default.nix

···
-{stdenv, fetchurl, libX11}:
+{lib, stdenv, fetchurl, libX11}:
 
 stdenv.mkDerivation {
   name = "3dpong-0.5";
···
   meta = {
     homepage = "http://www.newbreedsoftware.com/3dpong/";
     description = "One or two player 3d sports game based on Pong from Atari";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/prboom/default.nix

···
-{ stdenv, fetchurl, SDL, SDL_mixer, SDL_net
+{ lib, stdenv, fetchurl, SDL, SDL_mixer, SDL_net
 , libGLU ? null
 , libGL ? null
 , useOpenGL ? stdenv.hostPlatform == stdenv.buildPlatform
···
   };
 
   buildInputs = [ SDL SDL_mixer SDL_net ]
-    ++ stdenv.lib.optionals useOpenGL [ libGL libGLU ];
+    ++ lib.optionals useOpenGL [ libGL libGLU ];
 
   doCheck = stdenv.hostPlatform == stdenv.buildPlatform;
 
   configureFlags = [
-    (stdenv.lib.enableFeature useOpenGL "gl")
-    (stdenv.lib.enableFeature doCheck "sdltest")
-  ] ++ stdenv.lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
+    (lib.enableFeature useOpenGL "gl")
+    (lib.enableFeature doCheck "sdltest")
+  ] ++ lib.optionals (stdenv.hostPlatform != stdenv.buildPlatform) [
     "--disable-cpu-opt"
     "--without-x"
     "ac_cv_type_uid_t=yes"
     "ac_cv_type_gid_t=yes"
   ];
 
-  postInstall = stdenv.lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
+  postInstall = lib.optionalString (stdenv.hostPlatform != stdenv.buildPlatform) ''
     mv $out/games/ $out/bin
   '';
 }

pkgs/games/quake2/yquake2/wrapper.nix

···
   };
 
 in stdenv.mkDerivation {
-  name = "${name}-${stdenv.lib.getVersion yquake2}";
+  name = "${name}-${lib.getVersion yquake2}";
 
   nativeBuildInputs = [ makeWrapper ];
 

pkgs/games/quake3/wrapper/default.nix

···
 { stdenv, buildEnv, lib, libGL, ioquake3, makeWrapper }:
 
-{ paks, name ? (stdenv.lib.head paks).name, description ? "" }:
+{ paks, name ? (lib.head paks).name, description ? "" }:
 
 let
   libPath = lib.makeLibraryPath [ libGL stdenv.cc.cc ];

pkgs/games/quakespasm/default.nix

···
-{ stdenv, SDL, fetchurl, gzip, libvorbis, libmad }:
+{ lib, stdenv, SDL, fetchurl, gzip, libvorbis, libmad }:
 stdenv.mkDerivation rec {
   pname = "quakespasm";
   majorVersion = "0.93";
···
       and smoother mouse input - though no CD support.
     '';
 
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.m3tti ];
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.m3tti ];
   };
 }

pkgs/games/quantumminigolf/default.nix

···
-{stdenv, fetchurl, fftwSinglePrec, freetype, SDL, SDL_ttf}:
+{lib, stdenv, fetchurl, fftwSinglePrec, freetype, SDL, SDL_ttf}:
 let
   s = # Generated upstream information
   rec {
···
   meta = {
     inherit (s) version;
     description = ''Quantum mechanics-based minigolf-like game'';
-    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;
   };
 }

pkgs/games/r2mod_cli/default.nix

···
   makeFlags = [ "PREFIX=$(out)" ];
 
   postInstall = ''
-    wrapProgram $out/bin/r2mod --prefix PATH : "${stdenv.lib.makeBinPath [ jq p7zip ]}";
+    wrapProgram $out/bin/r2mod --prefix PATH : "${lib.makeBinPath [ jq p7zip ]}";
   '';
 
   meta = with lib; {

pkgs/games/racer/default.nix

···
-{ fetchurl, stdenv, allegro, libjpeg, makeWrapper }:
+{ fetchurl, lib, stdenv, allegro, libjpeg, makeWrapper }:
 
 stdenv.mkDerivation {
   name = "racer-1.1";
···
   meta = {
     description = "Car racing game";
     homepage = "http://hippo.nipax.cz/download.en.php";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/residualvm/default.nix

···
-{ stdenv, fetchurl, SDL, zlib, libmpeg2, libmad, libogg, libvorbis, flac, alsaLib
-, libGLSupported ? stdenv.lib.elem stdenv.hostPlatform.system stdenv.lib.platforms.mesaPlatforms
+{ lib, stdenv, fetchurl, SDL, zlib, libmpeg2, libmad, libogg, libvorbis, flac, alsaLib
+, libGLSupported ? lib.elem stdenv.hostPlatform.system lib.platforms.mesaPlatforms
 , openglSupport ? libGLSupported, libGLU, libGL ? null
 }:
 
 assert openglSupport -> libGL != null && libGLU != null;
-
-with stdenv.lib;
 
 stdenv.mkDerivation rec {
   version = "0.1.1";
···
   };
 
   buildInputs = [ stdenv SDL zlib libmpeg2 libmad libogg libvorbis flac alsaLib ]
-    ++ optionals openglSupport [ libGL libGLU ];
+    ++ lib.optionals openglSupport [ libGL libGLU ];
 
   configureFlags = [ "--enable-all-engines" ];
 
-  meta = {
+  meta = with lib; {
     description = "Interpreter for LucasArts' Lua-based 3D adventure games";
     homepage = "http://residualvm.org/";
     repositories.git = "https://github.com/residualvm/residualvm.git";
     license = licenses.gpl2;
-    platforms = stdenv.lib.platforms.linux;
+    platforms = platforms.linux;
   };
 }

pkgs/games/rftg/default.nix

···
-{ stdenv, fetchurl, gtk2, pkgconfig }:
+{ lib, stdenv, fetchurl, gtk2, pkgconfig }:
 
 stdenv.mkDerivation rec {
 
···
   meta = {
     homepage = "http://keldon.net/rftg/";
     description = "Implementation of the card game Race for the Galaxy, including an AI";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [ stdenv.lib.maintainers.falsifian ];
+    license = lib.licenses.gpl2;
+    maintainers = [ lib.maintainers.falsifian ];
   };
 
 }

pkgs/games/rigsofrods/default.nix

···
-{ fetchFromGitHub, stdenv, wxGTK30, freeimage, cmake, zziplib, libGLU, libGL, boost,
+{ fetchFromGitHub, lib, stdenv, wxGTK30, freeimage, cmake, zziplib, libGLU, libGL, boost,
   pkg-config, libuuid, openal, ogre, ois, curl, gtk2, mygui, unzip,
   angelscript, ogrepaged, mysocketw, libxcb
   }:
···
     libuuid openal ogre ois curl gtk2 mygui unzip angelscript
     ogrepaged mysocketw libxcb ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "3D simulator game where you can drive, fly and sail various vehicles";
     homepage = "http://rigsofrods.sourceforge.net/";
     license = licenses.gpl3;

pkgs/games/rili/default.nix

···
-{ stdenv, fetchurl, SDL_mixer, SDL, autoreconfHook }:
+{ lib, stdenv, fetchurl, SDL_mixer, SDL, autoreconfHook }:
 
 stdenv.mkDerivation {
   name = "ri_li-2.0.1";
···
 
   meta = {
     homepage = "http://ri-li.sourceforge.net";
-    license = stdenv.lib.licenses.gpl2Plus;
+    license = lib.licenses.gpl2Plus;
     description = "A children's train game";
     longDescription = ''
      Ri-li is an arcade game licensed under the GPL (General Public License).
 You drive a toy wood engine in many levels and you must collect all the coaches
 to win.
     '';
-    maintainers = with stdenv.lib.maintainers; [ jcumming ];
-    platforms = with stdenv.lib.platforms; linux;
+    maintainers = with lib.maintainers; [ jcumming ];
+    platforms = with lib.platforms; linux;
   };
 }

pkgs/games/robotfindskitten/default.nix

···
-{ stdenv, fetchurl, pkgconfig, ncurses }:
+{ lib, stdenv, fetchurl, pkgconfig, ncurses }:
 
-with stdenv.lib;
+with lib;
 stdenv.mkDerivation rec {
 
   pname = "robotfindskitten";

pkgs/games/scid-vs-pc/default.nix

···
   meta = with lib; {
     description = "Chess database with play and training functionality";
     homepage = "http://scidvspc.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     maintainers = [ maintainers.paraseba ];
-    platforms = stdenv.lib.platforms.linux;
+    platforms = lib.platforms.linux;
   };
 }
 

pkgs/games/scid/default.nix

···
-{ stdenv, fetchurl, tcl, tk, libX11, zlib, makeWrapper }:
+{ lib, stdenv, fetchurl, tcl, tk, libX11, zlib, makeWrapper }:
 
 stdenv.mkDerivation {
   pname = "scid";
···
   meta = {
     description = "Chess database with play and training functionality";
     homepage = "http://scid.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
   };
 }

pkgs/games/scrolls/default.nix

···
-{ stdenv, fetchurl, gcc
+{ lib, stdenv, fetchurl, gcc
 , libGLU, libX11, libXext, libXcursor, libpulseaudio
 }:
 stdenv.mkDerivation {
···
 
     platforms = [ "x86_64-linux" ];
 
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
   };
 
   src = fetchurl {
···
     sha256 = "ead1fd14988aa07041fedfa7f845c756cd5077a5a402d85bfb749cb669ececec";
   };
 
-  libPath = stdenv.lib.makeLibraryPath [
+  libPath = lib.makeLibraryPath [
     gcc
     libGLU
     libX11

pkgs/games/sil/default.nix

···
-{ stdenv, fetchzip, ncurses, libX11, libXaw, libXt, libXext, libXmu, makeWrapper, writeScript, ... }:
-let 
+{ lib, stdenv, fetchzip, ncurses, libX11, libXaw, libXt, libXext, libXmu, makeWrapper, writeScript, ... }:
+let
   setup = writeScript "setup" ''
     mkdir -p "$ANGBAND_PATH"
     # Copy all the data files into place
···
 
   prePatch = ''
     # Allow usage of ANGBAND_PATH
-    substituteInPlace config.h --replace "#define FIXED_PATHS" "" 
+    substituteInPlace config.h --replace "#define FIXED_PATHS" ""
   '';
 
   preConfigure = ''
···
     mkdir -p $out/bin
     cp sil $out/bin/sil
     # Wrap the program to set a user-local ANGBAND_PATH, and run the setup script to copy files into place
-    # We could just use the options for a user-local save and scores dir, but it tried to write to the 
+    # We could just use the options for a user-local save and scores dir, but it tried to write to the
     # lib directory anyway, so we might as well give everyone a copy
     wrapProgram $out/bin/sil \
       --run "set -u" \
···
   meta = {
     description = "A rouge-like game set in the first age of Middle-earth";
     longDescription = ''
-      A game of adventure set in the first age of Middle-earth, when the world still 
+      A game of adventure set in the first age of Middle-earth, when the world still
       rang with elven song and gleamed with dwarven mail.
 
-      Walk the dark halls of Angband.  Slay creatures black and fell.  Wrest a shining 
+      Walk the dark halls of Angband.  Slay creatures black and fell.  Wrest a shining
       Silmaril from Morgoth’s iron crown.
     '';
     homepage = "http://www.amirrorclear.net/flowers/game/sil/index.html";
-    license = stdenv.lib.licenses.gpl2;
-    maintainers = [ stdenv.lib.maintainers.michaelpj ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2;
+    maintainers = [ lib.maintainers.michaelpj ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/simutrans/default.nix

···
   # Choose your "paksets" of objects, images, text, music, etc.
   paksets = config.simutrans.paksets or "pak64 pak64.japan pak128 pak128.britain pak128.german";
 
-  result = with stdenv.lib; withPaks (
+  result = with lib; withPaks (
     if paksets == "*" then attrValues pakSpec # taking all
       else map (name: pakSpec.${name}) (splitString " " paksets)
   );
···
 
 
   # As of 2015/03, many packsets still didn't have a release for version 120.
-  pakSpec = stdenv.lib.mapAttrs
+  pakSpec = lib.mapAttrs
     (pakName: attrs: mkPak (attrs // {inherit pakName;}))
   {
     pak64 = {

pkgs/games/sm64ex/default.nix

···
   buildInputs = [ audiofile SDL2 hexdump ];
 
   makeFlags = [ "VERSION=${region}" ] ++ compileFlags
-    ++ stdenv.lib.optionals stdenv.isDarwin [ "OSX_BUILD=1" ];
+    ++ lib.optionals stdenv.isDarwin [ "OSX_BUILD=1" ];
 
   inherit baseRom;
 

pkgs/games/soldat-unstable/default.nix

···
-{ stdenv, fetchFromGitHub, fetchpatch, fpc, zip, makeWrapper
+{ lib, stdenv, fetchFromGitHub, fetchpatch, fpc, zip, makeWrapper
 , SDL2, freetype, physfs, openal, gamenetworkingsockets
 , xorg, autoPatchelfHook
 }:
···
       install -Dm644 client/play-regular.ttf -t $out/share/soldat
     '';
 
-    meta = with stdenv.lib; {
+    meta = with lib; {
       description = "Soldat's base game content";
       license = licenses.cc-by-40;
       platforms = platforms.all;
···
     done
   '';
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = "Soldat is a unique 2D (side-view) multiplayer action game";
     license = [ licenses.mit base.meta.license ];
     inherit (src.meta) homepage;

pkgs/games/speed-dreams/default.nix

···
-{ fetchurl, stdenv, libGLU, libGL, freeglut, libX11, plib, openal, freealut, libXrandr, xorgproto,
+{ fetchurl, lib, stdenv, libGLU, libGL, freeglut, libX11, plib, openal, freealut, libXrandr, xorgproto,
 libXext, libSM, libICE, libXi, libXt, libXrender, libXxf86vm, openscenegraph, expat,
 libpng, zlib, bash, SDL2, enet, libjpeg, cmake, pkgconfig, libvorbis, runtimeShell, curl }:
 
···
   meta = {
     description = "Car racing game - TORCS fork with more experimental approach";
     homepage = "http://speed-dreams.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2Plus;
-    maintainers = with stdenv.lib.maintainers; [raskin];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    maintainers = with lib.maintainers; [raskin];
+    platforms = lib.platforms.linux;
     hydraPlatforms = [];
   };
 }

pkgs/games/spring/default.nix

···
   buildInputs = [ lzma boost libdevil zlib p7zip openal libvorbis freetype SDL2
     xorg.libX11 xorg.libXcursor libGLU libGL glew curl
     systemd libunwind which minizip ]
-    ++ stdenv.lib.optional withAI jdk
-    ++ stdenv.lib.optional withAI python;
+    ++ lib.optional withAI jdk
+    ++ lib.optional withAI python;
 
   NIX_CFLAGS_COMPILE = "-fpermissive"; # GL header minor incompatibility
 
   postInstall = ''
     wrapProgram "$out/bin/spring" \
-      --prefix LD_LIBRARY_PATH : "${stdenv.lib.makeLibraryPath [ stdenv.cc.cc systemd ]}"
+      --prefix LD_LIBRARY_PATH : "${lib.makeLibraryPath [ stdenv.cc.cc systemd ]}"
   '';
 
   meta = with lib; {

pkgs/games/steam/steam.nix

···
 
   postInstall = ''
     rm $out/bin/steamdeps
-    ${stdenv.lib.optionalString traceDeps ''
+    ${lib.optionalString traceDeps ''
       cat > $out/bin/steamdeps <<EOF
       #!${runtimeShell}
       echo \$1 >> ${traceLog}

pkgs/games/tcl2048/default.nix

···
-{ stdenv, fetchurl, tcl, tcllib, runtimeShell }:
+{ lib, stdenv, fetchurl, tcl, tcllib, runtimeShell }:
 
 stdenv.mkDerivation {
   name = "tcl2048-0.4.0";
···
   meta = {
     homepage = "https://github.com/dbohdan/2048.tcl";
     description = "The game of 2048 implemented in Tcl";
-    license = stdenv.lib.licenses.mit;
-    platforms = stdenv.lib.platforms.all;
-    maintainers = with stdenv.lib.maintainers; [ dbohdan ];
+    license = lib.licenses.mit;
+    platforms = lib.platforms.all;
+    maintainers = with lib.maintainers; [ dbohdan ];
   };
 }

pkgs/games/teetertorture/default.nix

···
-{stdenv, fetchurl, SDL, SDL_image, SDL_mixer}:
+{ lib, stdenv, fetchurl, SDL, SDL_image, SDL_mixer }:
 
 stdenv.mkDerivation {
   name = "teeter-torture-20051018";
···
   meta = {
     homepage = "http://www.newbreedsoftware.com/teetertorture/";
     description = "Simple shooting game with your cannon is sitting atop a teeter totter";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/teeworlds/default.nix

···
-{ fetchFromGitHub, stdenv, cmake, pkgconfig, python3, alsaLib
+{ fetchFromGitHub, lib, stdenv, cmake, pkgconfig, python3, alsaLib
 , libX11, libGLU, SDL2, lua5_3, zlib, freetype, wavpack, icoutils
 , nixosTests
 }:
···
 
     homepage = "https://teeworlds.com/";
     license = "BSD-style, see `license.txt'";
-    maintainers = with stdenv.lib.maintainers; [ astsmtl ];
-    platforms = stdenv.lib.platforms.linux;
+    maintainers = with lib.maintainers; [ astsmtl ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/the-powder-toy/default.nix

···
-
 { lib, stdenv, fetchFromGitHub, scons, pkgconfig, SDL2, lua, fftwFloat,
   zlib, bzip2, curl, darwin }:
 
···
 
   nativeBuildInputs = [ scons pkgconfig ];
 
-  propagatedBuildInputs = stdenv.lib.optionals stdenv.isDarwin
+  propagatedBuildInputs = lib.optionals stdenv.isDarwin
     [ darwin.apple_sdk.frameworks.Cocoa ];
 
   buildInputs = [ SDL2 lua fftwFloat zlib bzip2 curl ];

pkgs/games/tibia/default.nix

···
-{ stdenv, fetchurl, glibc, libX11, runtimeShell, libGLU, libGL }:
+{ lib, stdenv, fetchurl, glibc, libX11, runtimeShell, libGLU, libGL }:
 
-with stdenv.lib;
 stdenv.mkDerivation {
   name = "tibia-10.90";
 
···
     cp -r * $out/res
 
     patchelf --set-interpreter ${glibc.out}/lib/ld-linux.so.2 \
-             --set-rpath ${stdenv.lib.makeLibraryPath [ stdenv.cc.cc libX11 libGLU libGL ]} \
+             --set-rpath ${lib.makeLibraryPath [ stdenv.cc.cc libX11 libGLU libGL ]} \
              "$out/res/Tibia"
 
     # We've patchelf'd the files. The main ‘Tibia’ binary is a bit
···
   meta = {
     description = "Top-down MMORPG set in a fantasy world";
     homepage = "http://tibia.com";
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
     platforms = ["i686-linux"];
-    maintainers = with stdenv.lib.maintainers; [ ];
+    maintainers = with lib.maintainers; [ ];
   };
 }

pkgs/games/tinyfugue/default.nix

···
-{ stdenv, fetchurl, ncurses, zlib
+{ lib, stdenv, fetchurl, ncurses, zlib
 , openssl ? null
 , sslSupport ? true
 }:
 
-with stdenv.lib;
+with lib;
 
 assert sslSupport -> openssl != null;
 

pkgs/games/torcs/default.nix

···
-{ fetchpatch, fetchurl, stdenv, libGLU, freeglut, libX11, plib, openal, freealut, libXrandr, xorgproto,
+{ fetchpatch, fetchurl, lib, stdenv, libGLU, freeglut, libX11, plib, openal, freealut, libXrandr, xorgproto,
 libXext, libSM, libICE, libXi, libXt, libXrender, libXxf86vm, libvorbis,
 libpng, zlib, makeWrapper }:
 
···
   meta = {
     description = "Car racing game";
     homepage = "http://torcs.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2Plus;
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    maintainers = with lib.maintainers; [viric];
+    platforms = lib.platforms.linux;
     hydraPlatforms = [];
   };
 }

pkgs/games/trackballs/default.nix

···
-{ stdenv, fetchFromGitHub, cmake, SDL2, SDL2_ttf, gettext, zlib, SDL2_mixer, SDL2_image, guile, libGLU, libGL }:
+{ lib, stdenv, fetchFromGitHub, cmake, SDL2, SDL2_ttf, gettext, zlib, SDL2_mixer, SDL2_image, guile, libGLU, libGL }:
 
 stdenv.mkDerivation rec {
   pname = "trackballs";
···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ zlib SDL2 SDL2_ttf SDL2_mixer SDL2_image guile gettext libGLU libGL ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     homepage = "https://trackballs.github.io/";
     description = "3D Marble Madness clone";
     platforms = platforms.linux;

pkgs/games/trigger/default.nix

···
-{ fetchurl, stdenv, runtimeShell, SDL2, freealut, SDL2_image, openal, physfs
+{ lib, fetchurl, stdenv, runtimeShell, SDL2, freealut, SDL2_image, openal, physfs
 , zlib, libGLU, libGL, glew, tinyxml-2 }:
 
 stdenv.mkDerivation rec {
···
   meta = {
     description = "A fast-paced single-player racing game";
     homepage = "http://trigger-rally.sourceforge.net/";
-    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/games/tuxpaint/default.nix

···
-{ stdenv, fetchurl, SDL, SDL_image, SDL_ttf, SDL_mixer, libpng,
+{ lib, stdenv, fetchurl, SDL, SDL_image, SDL_ttf, SDL_mixer, libpng,
   cairo, librsvg, gettext, libpaper, fribidi, pkgconfig, gperf, imagemagick }:
 
 stdenv.mkDerivation rec {
···
     mkdir -p $out/share/applications
     cp hildon/tuxpaint.xpm $out/share/pixmaps
     sed -e "s+Exec=tuxpaint+Exec=$out/bin/tuxpaint+" < src/tuxpaint.desktop > $out/share/applications/tuxpaint.desktop
- 
+
     # Install stamps
     tar xzf $stamps
     cd tuxpaint-stamps-2014.08.23
···
   meta = {
     description = "Open Source Drawing Software for Children";
     homepage = "http://www.tuxpaint.org/";
-    license = stdenv.lib.licenses.gpl3;
-    maintainers = with stdenv.lib.maintainers; [ woffs ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl3;
+    maintainers = with lib.maintainers; [ woffs ];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/ue4/default.nix

···
       ln -s ${lib.getAttr hash deps} .git/ue4-gitdeps/${prefix}/${hash}
     ''
   ) (lib.attrNames deps));
-  libPath = stdenv.lib.makeLibraryPath [
+  libPath = lib.makeLibraryPath [
     xorg.libX11 xorg.libXScrnSaver xorg.libXau xorg.libXcursor xorg.libXext
     xorg.libXfixes xorg.libXi xorg.libXrandr xorg.libXrender xorg.libXxf86vm
     xorg.libxcb
···
   meta = {
     description = "A suite of integrated tools for game developers to design and build games, simulations, and visualizations";
     homepage = "https://www.unrealengine.com/what-is-unreal-engine-4";
-    license = stdenv.lib.licenses.unfree;
-    platforms = stdenv.lib.platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.puffnfresh ];
+    license = lib.licenses.unfree;
+    platforms = lib.platforms.linux;
+    maintainers = [ lib.maintainers.puffnfresh ];
     broken = true;
   };
 }

pkgs/games/ue4demos/default.nix

···
-{ stdenv, fetchurl, unzip, patchelf, xorg, openal }:
+{ lib, stdenv, fetchurl, unzip, patchelf, xorg, openal }:
 
 let
   urls = file:
···
 
       nativeBuildInputs = [ unzip patchelf ];
 
-      rtdeps = stdenv.lib.makeLibraryPath
+      rtdeps = lib.makeLibraryPath
         [ xorg.libXxf86vm xorg.libXext openal ]
-        + ":" + stdenv.lib.makeSearchPathOutput "lib" "lib64" [ stdenv.cc.cc ];
+        + ":" + lib.makeSearchPathOutput "lib" "lib64" [ stdenv.cc.cc ];
 
       buildCommand =
       ''
···
         description = "Unreal Engine 4 Linux demos";
         homepage = "https://wiki.unrealengine.com/Linux_Demos";
         platforms = [ "x86_64-linux" ];
-        license = stdenv.lib.licenses.unfree;
+        license = lib.licenses.unfree;
       };
     };
 

pkgs/games/ufoai/default.nix

···
-{ stdenv, fetchurl, libtheora, xvidcore, libGLU, libGL, SDL, SDL_ttf, SDL_mixer
+{ lib, stdenv, fetchurl, libtheora, xvidcore, libGLU, libGL, SDL, SDL_ttf, SDL_mixer
 , curl, libjpeg, libpng, gettext, cunit, enableEditor?false }:
 
 stdenv.mkDerivation rec {
···
   preConfigure = ''tar xvf "${srcData}"'';
 
   configureFlags = [ "--enable-release" "--enable-sse" ]
-    ++ stdenv.lib.optional enableEditor "--enable-uforadiant";
+    ++ lib.optional enableEditor "--enable-uforadiant";
 
   buildInputs = [
     libtheora xvidcore libGLU libGL SDL SDL_ttf SDL_mixer
···
   meta = {
     homepage = "http://ufoai.org";
     description = "A squad-based tactical strategy game in the tradition of X-Com";
-    license = stdenv.lib.licenses.gpl2Plus;
-    maintainers = with stdenv.lib.maintainers; [viric];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    maintainers = with lib.maintainers; [viric];
+    platforms = lib.platforms.linux;
     hydraPlatforms = [];
   };
 }

pkgs/games/ultimatestunts/default.nix

···
-{stdenv, fetchurl, SDL, libGLU, libGL, SDL_image, freealut, openal, libvorbis,
+{lib, stdenv, fetchurl, SDL, libGLU, libGL, SDL_image, freealut, openal, libvorbis,
 pkgconfig}:
 
 stdenv.mkDerivation {
···
   meta = {
     homepage = "http://www.ultimatestunts.nl/";
     description = "Remake of the popular racing DOS-game Stunts";
-    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/games/ultrastardx/default.nix

···
       --subst-var-by libpcre_LIBNAME libpcre.so.1
   '';
 
-  preBuild = with stdenv.lib;
+  preBuild = with lib;
     let items = concatMapStringsSep " " (x: "-rpath ${getLib x}/lib") sharedLibs;
     in ''
       export NIX_LDFLAGS="$NIX_LDFLAGS ${items}"

pkgs/games/uqm/3dovideo.nix

···
 { stdenv, requireFile, writeText, fetchurl, haskellPackages }:
 
-with stdenv.lib;
+with lib;
 
 let
   makeSpin = num: let
···
     buildDepends = [ base binary bytestring filepath tar ];
 
     description = "Extract video files from a Star Control II 3DO image";
-    license = stdenv.lib.licenses.bsd3;
+    license = lib.licenses.bsd3;
   };
 
 in stdenv.mkDerivation {

pkgs/games/uqm/default.nix

···
           spin-offs, thereby making zillions more people happy!
     '';
     homepage = "http://sc2.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl2;
+    license = lib.licenses.gpl2;
     maintainers = with lib.maintainers; [ jcumming aszlig ];
     platforms = with lib.platforms; linux;
   };

pkgs/games/vdrift/default.nix

···
-{ stdenv, fetchFromGitHub, fetchsvn, pkgconfig, sconsPackages, libGLU, libGL, SDL2, SDL2_image
+{ lib, stdenv, fetchFromGitHub, fetchsvn, pkgconfig, sconsPackages, libGLU, libGL, SDL2, SDL2_image
 , libvorbis, bullet, curl, gettext, writeTextFile
 
 , data ? fetchsvn {
···
     meta = {
       description = "Car racing game";
       homepage = "http://vdrift.net/";
-      license = stdenv.lib.licenses.gpl2Plus;
-      maintainers = with stdenv.lib.maintainers; [viric];
-      platforms = stdenv.lib.platforms.linux;
+      license = lib.licenses.gpl2Plus;
+      maintainers = with lib.maintainers; [viric];
+      platforms = lib.platforms.linux;
     };
   };
   wrappedName = "vdrift-${version}-with-data-${toString data.rev}";

pkgs/games/vectoroids/default.nix

···
-{stdenv, fetchurl, SDL, SDL_image, SDL_mixer}:
+{lib, stdenv, fetchurl, SDL, SDL_image, SDL_mixer}:
 
 stdenv.mkDerivation {
   name = "vectoroids-1.1.0";
···
   meta = {
     homepage = "http://www.newbreedsoftware.com/vectoroids/";
     description = "Clone of the classic arcade game Asteroids by Atari";
-    license = stdenv.lib.licenses.gpl2Plus;
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/vessel/default.nix

···
   phases = "installPhase";
   ld_preload = ./isatty.c;
 
-  libPath = stdenv.lib.makeLibraryPath [ stdenv.cc.cc stdenv.cc.libc ]
-    + ":" + stdenv.lib.makeLibraryPath [ SDL libpulseaudio alsaLib ] ;
+  libPath = lib.makeLibraryPath [ stdenv.cc.cc stdenv.cc.libc ]
+    + ":" + lib.makeLibraryPath [ SDL libpulseaudio alsaLib ] ;
 
   installPhase = ''
     mkdir -p $out/libexec/strangeloop/vessel/

pkgs/games/vms-empire/default.nix

···
-{ stdenv, fetchurl, ncurses, xmlto }:
+{ lib, stdenv, fetchurl, ncurses, xmlto }:
 
-with stdenv.lib;
 stdenv.mkDerivation rec {
-
   pname = "vms-empire";
   version = "1.15";
 
···
 
   makeFlags = [ "DESTDIR=$(out)" ];
 
-  meta = {
+  meta = with lib; {
     description = "The ancestor of all expand/explore/exploit/exterminate games";
     longDescription = ''
       Empire is a simulation of a full-scale war between two emperors, the

pkgs/games/warzone2100/default.nix

···
 
   enableParallelBuilding = true;
 
-  postInstall = stdenv.lib.optionalString withVideos
+  postInstall = lib.optionalString withVideos
     "cp ${sequences_src} $out/share/warzone2100/sequences.wz";
 
   meta = with lib; {

pkgs/games/wesnoth/default.nix

···
 
   buildInputs = [ SDL2 SDL2_image SDL2_mixer SDL2_net SDL2_ttf pango gettext boost
                   libvorbis fribidi dbus libpng pcre openssl icu ]
-                ++ stdenv.lib.optionals stdenv.isDarwin [ Cocoa Foundation];
+                ++ lib.optionals stdenv.isDarwin [ Cocoa Foundation];
 
   cmakeFlags = [ "-DENABLE_TOOLS=${if enableTools then "ON" else "OFF"}" ];
 

pkgs/games/worldofgoo/default.nix

···
   sourceRoot = pname;
   phases = [ "unpackPhase installPhase" ];
 
-  libPath = stdenv.lib.makeLibraryPath [ stdenv.cc.cc.lib stdenv.cc.libc SDL2 SDL2_mixer
+  libPath = lib.makeLibraryPath [ stdenv.cc.cc.lib stdenv.cc.libc SDL2 SDL2_mixer
     libogg libvorbis ];
 
   unpackPhase = ''
-    # The game is distributed as a shell script, with a tar of mojosetup, and a 
+    # The game is distributed as a shell script, with a tar of mojosetup, and a
     # zip archive attached to the end. Therefore a simple unzip does the job.
     # However, to avoid unzip errors, we need to strip those out first.
     tail -c +421887 ${src} > ${src}.zip

pkgs/games/xboard/default.nix

···
-{stdenv, fetchurl, libX11, xorgproto, libXt, libXaw, libSM, libICE, libXmu
+{lib, stdenv, fetchurl, libX11, xorgproto, libXt, libXaw, libSM, libICE, libXmu
 , libXext, gnuchess, texinfo, libXpm, pkgconfig, librsvg, cairo, pango
 , gtk2
 }:
···
     inherit (s) version;
     description = ''GUI for chess engines'';
     homepage = "https://www.gnu.org/software/xboard/";
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.unix;
-    license = stdenv.lib.licenses.gpl3Plus;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.unix;
+    license = lib.licenses.gpl3Plus;
   };
 }

pkgs/games/xonotic/default.nix

···
       aims to become the best possible open-source FPS of its kind.
     '';
     homepage = "https://www.xonotic.org/";
-    license = stdenv.lib.licenses.gpl2Plus;
-    maintainers = with stdenv.lib.maintainers; [ astsmtl zalakain petabyteboy ];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus;
+    maintainers = with lib.maintainers; [ astsmtl zalakain petabyteboy ];
+    platforms = lib.platforms.linux;
   };
 
   desktopItem = makeDesktopItem {

pkgs/games/xpilot/bloodspilot-client.nix

···
-{ stdenv, fetchurl, libX11, SDL, libGLU, libGL, expat, zlib, SDL_ttf, SDL_image }:
+{ lib, stdenv, fetchurl, libX11, SDL, libGLU, libGL, expat, zlib, SDL_ttf, SDL_image }:
 
 stdenv.mkDerivation rec {
   version = "1.5.0";
···
   meta = {
     description = ''A multiplayer space combat game (client part)'';
     homepage = "http://bloodspilot.sf.net/";
-    license = stdenv.lib.licenses.gpl2Plus ;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.linux;
+    license = lib.licenses.gpl2Plus ;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.linux;
   };
 }

pkgs/games/xskat/default.nix

···
-{stdenv, fetchurl, libX11, imake, gccmakedep}:
+{lib, stdenv, fetchurl, libX11, imake, gccmakedep}:
 
 stdenv.mkDerivation rec {
   pname = "xskat";
···
 
   installTargets = [ "install" "install.man" ];
 
-  meta = with stdenv.lib; {
+  meta = with lib; {
     description = ''Famous german card game'';
     platforms = platforms.unix;
     license = licenses.free;

pkgs/games/xsnow/default.nix

···
-{ stdenv, fetchurl, libXt, libXpm, libXext, imake, gccmakedep }:
+{ lib, stdenv, fetchurl, libXt, libXpm, libXext, imake, gccmakedep }:
 
 stdenv.mkDerivation rec {
 
···
   meta = {
     description = "An X-windows application that will let it snow on the root, in between and on windows";
     homepage = "http://janswaal.home.xs4all.nl/Xsnow/";
-    license = stdenv.lib.licenses.unfree;
-    maintainers = [ stdenv.lib.maintainers.robberer ];
+    license = lib.licenses.unfree;
+    maintainers = [ lib.maintainers.robberer ];
   };
 }

pkgs/games/xsok/default.nix

···
-{stdenv, fetchurl, libX11, imake, libXt, libXaw, libXpm, libXext
+{lib, stdenv, fetchurl, libX11, imake, libXt, libXaw, libXpm, libXext
 , withNethackLevels ? true
 }:
 stdenv.mkDerivation rec {
···
 
   makeFlags = ["BINDIR=$(out)/bin"];
 
-  postInstall = stdenv.lib.optionalString withNethackLevels ''
+  postInstall = lib.optionalString withNethackLevels ''
     gzip < ${nethackLevels} > "$out/share/games/lib/xsok/Nethack.def.gz"
     echo Nethack > "$out/share/games/lib/xsok/gametypes"
   '';
···
   meta = {
     inherit version;
     description = "A generic Sokoban game for X11";
-    license = stdenv.lib.licenses.gpl2Plus;
-    maintainers = [stdenv.lib.maintainers.raskin];
-    platforms = stdenv.lib.platforms.unix;
+    license = lib.licenses.gpl2Plus;
+    maintainers = [lib.maintainers.raskin];
+    platforms = lib.platforms.unix;
     homepage = "https://tracker.debian.org/pkg/xsok";
   };
 }

pkgs/games/zandronum/fmod.nix

···
 { stdenv, lib, fetchurl, alsaLib, libpulseaudio, undmg }:
 
 let
-  bits = stdenv.lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux") "64";
+  bits = lib.optionalString (stdenv.hostPlatform.system == "x86_64-linux") "64";
   libPath = lib.makeLibraryPath [ stdenv.cc.cc alsaLib libpulseaudio ];
 
 in

pkgs/games/zandronum/sqlite.nix

···
   meta = {
     homepage = "http://www.sqlite.org/";
     description = "A single C code file, named sqlite3.c, that contains all C code for the core SQLite library and the FTS3 and RTREE extensions";
-    platforms = stdenv.lib.platforms.unix;
+    platforms = lib.platforms.unix;
     maintainers = [ lib.maintainers.lassulus ];
   };
 }

pkgs/games/zangband/default.nix

···
-{ stdenv, fetchurl, ncurses, flex, bison, autoconf, automake, m4, coreutils }:
+{ lib, stdenv, fetchurl, ncurses, flex, bison, autoconf, automake, m4, coreutils }:
 
 stdenv.mkDerivation rec {
   pname = "zangband";
···
 
   meta = {
     description = "Rogue-like game";
-    license = stdenv.lib.licenses.unfree;
+    license = lib.licenses.unfree;
     broken = true; # broken in runtime, will not get pass character generation
   };
 }

pkgs/games/zod/default.nix

···
-{ fetchurl, stdenv, unrar, unzip, SDL, SDL_image, SDL_ttf, SDL_mixer
+{ lib, fetchurl, stdenv, unrar, unzip, SDL, SDL_image, SDL_ttf, SDL_mixer
 , libmysqlclient, makeWrapper }:
 
 stdenv.mkDerivation {
···
   meta = {
     description = "Multiplayer remake of ZED";
     homepage = "http://zod.sourceforge.net/";
-    license = stdenv.lib.licenses.gpl3Plus; /* Says the web */
+    license = lib.licenses.gpl3Plus; /* Says the web */
   };
 }