Merge pull request #108300 from siraben/parallel-cmake

treewide: remove enableParallelBuilding = true if using cmake

pkgs/applications/audio/cantata/default.nix

···
 
   nativeBuildInputs = [ cmake pkgconfig qttools ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = lib.flatten [
     (fstats withTaglib        [ "TAGLIB" "TAGLIB_EXTRAS" ])
     (fstats withReplaygain    [ "FFMPEG" "MPG123" "SPEEXDSP" ])

pkgs/applications/audio/clementine/default.nix

···
       "-DSPOTIFY_BLOB=OFF"
     ];
 
-    enableParallelBuilding = true;
-
     passthru.unfree = unfree;
 
     postInstall = ''
···
         ln -s "${free}/share/$dir" "$out/share/$dir"
       done
     '';
-    enableParallelBuilding = true;
+
     meta = with stdenv.lib; {
       homepage = "https://www.clementine-player.org";
       description = "Spotify integration for Clementine";

pkgs/applications/audio/csound/default.nix

···
   # version and remove fluidsynth 1.x from nixpkgs again.
   version = "6.15.0";
 
-  enableParallelBuilding = true;
-
   hardeningDisable = [ "format" ];
 
   src = fetchFromGitHub {

pkgs/applications/audio/kid3/default.nix

···
     export DOCBOOKDIR="${docbook_xsl}/xml/xsl/docbook/"
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A simple and powerful audio tag editor";
     longDescription = ''

pkgs/applications/audio/lmms/default.nix

···
   ];
 
   cmakeFlags = [ "-DWANT_QT5=ON" ];
-  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     description = "DAW similar to FL Studio (music production software)";

pkgs/applications/audio/qmmp/default.nix

···
       libsamplerate
     ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Qt-based audio player that looks like Winamp";
     homepage = "http://qmmp.ylsoftware.com/";

pkgs/applications/audio/radiotray-ng/default.nix

···
     "-DBUILD_TESTS=${if doCheck then "ON" else "OFF"}"
   ];
 
-  enableParallelBuilding = true;
-
   checkInputs = [ gtest ];
   doCheck = !stdenv.isAarch64; # single failure that I can't explain
 

pkgs/applications/audio/rosegarden/default.nix

···
     alsaLib
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://www.rosegardenmusic.com/";
     description = "Music composition and editing environment";

pkgs/applications/audio/soundkonverter/default.nix

···
       stripLen = 1;
     })
   ];
-  enableParallelBuilding = true;
+
   nativeBuildInputs = [ cmake extra-cmake-modules pkgconfig kdelibs4support makeWrapper ];
   propagatedBuildInputs = [ libkcddb kconfig kconfigwidgets ki18n kdelibs4support kio solid kwidgetsaddons kxmlgui qtbase phonon];
   buildInputs = [ taglib ] ++ runtimeDeps;

pkgs/applications/audio/traverso/default.nix

···
 
   cmakeFlags = [ "-DWANT_PORTAUDIO=1" "-DWANT_PULSEAUDIO=1" "-DWANT_MP3_ENCODE=1" "-DWANT_LV2=0" ];
 
-  enableParallelBuilding = true;
   hardeningDisable = [ "format" ];
 
   meta = with stdenv.lib; {

pkgs/applications/blockchains/bitcoin-abc.nix

···
     find ./. -type f -iname "*.sh" -exec chmod +x {} \;
   '';
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Peer-to-peer electronic cash system (Cash client)";
     longDescription= ''

pkgs/applications/blockchains/dero.nix

···
   nativeBuildInputs = [ cmake pkgconfig ];
   buildInputs = [ boost miniupnpc openssl lmdb unbound readline ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "Secure, private blockchain with smart contracts based on Monero";
     homepage = "https://dero.io/";

pkgs/applications/blockchains/masari.nix

···
   nativeBuildInputs = [ cmake pkgconfig ];
   buildInputs = [ boost miniupnpc openssl lmdb unbound readline ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "scalability-focused, untraceable, secure, and fungible cryptocurrency using the RingCT protocol";
     homepage = "https://www.getmasari.org/";

pkgs/applications/blockchains/sumokoin.nix

···
     "-DLMDB_INCLUDE=${lmdb}/include"
   ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "A fork of Monero and a truely fungible cryptocurrency";
     homepage = "https://www.sumokoin.org/";

pkgs/applications/editors/aseprite/default.nix

···
     rm -rf "$out"/include "$out"/lib
   '';
 
-  enableParallelBuilding = true;
-
   passthru = { inherit skia; };
 
   meta = with lib; {

pkgs/applications/editors/neovim/default.nix

···
     ];
 
     dontFixCmake = true;
-    enableParallelBuilding = true;
 
     buildInputs = [
       gperf

pkgs/applications/editors/neovim/qt.nix

···
 
     nativeBuildInputs = [ cmake doxygen ];
 
-    enableParallelBuilding = true;
-
     preCheck = ''
       # The GUI tests require a running X server, disable them
       sed -i ../test/CMakeLists.txt \

pkgs/applications/editors/rstudio/default.nix

···
       popd
     '';
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [ "-DRSTUDIO_TARGET=Desktop" "-DQT_QMAKE_EXECUTABLE=$NIX_QT5_TMP/bin/qmake" ];
 
   desktopItem = makeDesktopItem {

pkgs/applications/editors/sigil/default.nix

···
        ''${qtWrapperArgs[@]}
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Free, open source, multi-platform ebook (ePub) editor";
     homepage = "https://github.com/Sigil-Ebook/Sigil/";

pkgs/applications/editors/texmacs/default.nix

···
     sha256 = "04585hdh98fvyhj4wsxf69xal2wvfa6lg76gad8pr6ww9abi5105";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake pkgconfig ];
   buildInputs = [
     guile_1_8

pkgs/applications/graphics/antimony/default.nix

···
       "-DGITBRANCH=${gitBranch}"
     ];
 
-    enableParallelBuilding = true;
-
     meta = with stdenv.lib; {
       description = "A computer-aided design (CAD) tool from a parallel universe";
       homepage    = "https://github.com/mkeeter/antimony";

pkgs/applications/graphics/digikam/default.nix

···
     threadweaver
   ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DENABLE_MYSQLSUPPORT=1"
     "-DENABLE_INTERNALMYSQL=1"

pkgs/applications/graphics/hugin/default.nix

···
   # disable installation of the python scripting interface
   cmakeFlags = [ "-DBUILD_HSI:BOOl=OFF" ];
 
-  enableParallelBuilding = true;
-
   NIX_CFLAGS_COMPILE = "-I${ilmbase.dev}/include/OpenEXR";
 
   postInstall = ''

pkgs/applications/graphics/kgraphviewer/default.nix

···
     kconfig kinit kio kparts kwidgetsaddons
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A Graphviz dot graph viewer for KDE";
     license     = licenses.gpl2;

pkgs/applications/graphics/meshlab/default.nix

···
   #     |
   hardeningDisable = [ "format" ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "A system for processing and editing 3D triangular meshes";
     homepage = "https://www.meshlab.net/";

pkgs/applications/graphics/nomacs/default.nix

···
     sha256 = "1bq7bv4p7w67172y893lvpk90d6fgdpnylynbj2kn8m2hs6khya4";
   };
 
-  enableParallelBuilding = true;
-
   setSourceRoot = ''
     sourceRoot=$(echo */ImageLounge)
   '';

pkgs/applications/graphics/photivo/default.nix

···
 
   buildInputs = [ qt4 fftw graphicsmagick_q16 lcms2 lensfun libjpeg exiv2 liblqr1 ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     platforms = platforms.linux;
     license = licenses.gpl3;

pkgs/applications/graphics/photoqt/default.nix

···
     export MAGICK_LOCATION="${graphicsmagick}/include/GraphicsMagick"
   '';
 
-  enableParallelBuilding = true;
-
   meta = {
     homepage = "https://photoqt.org/";
     description = "Simple, yet powerful and good looking image viewer";

pkgs/applications/graphics/rawtherapee/default.nix

···
     echo "set(HG_VERSION $version)" > $sourceRoot/ReleaseInfo.cmake
   '';
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "RAW converter and digital photo processing software";
     homepage = "http://www.rawtherapee.com/";

pkgs/applications/graphics/renderdoc/default.nix

···
     addOpenGLRunpath $out/lib/librenderdoc.so
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A single-frame graphics debugger";
     homepage = "https://renderdoc.org/";

pkgs/applications/graphics/scantailor/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ qt4 libjpeg libtiff boost ];
 
-  enableParallelBuilding = true;
-
   meta = {
     homepage = "http://scantailor.org/";
     description = "Interactive post-processing tool for scanned pages";

pkgs/applications/graphics/solvespace/default.nix

···
     json_c fontconfig gtkmm3 pangomm glew libGLU
     xorg.libpthreadstubs xorg.libXdmcp pcre
   ];
-  enableParallelBuilding = true;
 
   preConfigure = ''
     patch CMakeLists.txt <<EOF

pkgs/applications/misc/albert/default.nix

···
 
   buildInputs = [ qtbase qtdeclarative qtsvg qtx11extras muparser python3 qtcharts ];
 
-  enableParallelBuilding = true;
-
   # We don't have virtualbox sdk so disable plugin
   cmakeFlags = [ "-DBUILD_VIRTUALBOX=OFF" "-DCMAKE_INSTALL_LIBDIR=libs" ];
 

pkgs/applications/misc/blender/default.nix

···
   # libstdc++ in our RPATH. Sigh.
   NIX_LDFLAGS = optionalString cudaSupport "-rpath ${stdenv.cc.cc.lib}/lib";
 
-  enableParallelBuilding = true;
-
   blenderExecutable =
     placeholder "out" + (if stdenv.isDarwin then "/Blender.app/Contents/MacOS/Blender" else "/bin/blender");
   # --python-expr is used to workaround https://developer.blender.org/T74304

pkgs/applications/misc/elf-dissector/default.nix

···
 
   buildInputs = [ kitemmodels libiberty libelf libdwarf libopcodes ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     homepage = "https://invent.kde.org/sdk/elf-dissector";
     description = "Tools for inspecting, analyzing and optimizing ELF files";

pkgs/applications/misc/far2l/default.nix

···
 
   stripDebugList = [ "bin" "share" ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "An orthodox file manager";
     homepage = "https://github.com/elfmz/far2l";

pkgs/applications/misc/gammu/default.nix

···
   ++ optionals dbiSupport [ libdbi libdbiDrivers ]
   ++ optionals postgresSupport [ postgresql ];
 
-  enableParallelBuilding = true;
-
   meta = {
     homepage = "https://wammu.eu/gammu/";
     description = "Command line utility and library to control mobile phones";

pkgs/applications/misc/lenmus/default.nix

···
     sha256 = "1n639xr1qxx6rhqs0c6sjxp3bv8cwkmw1vfk1cji7514gj2a9v3p";
   };
 
-  enableParallelBuilding = true;
-
   patches = [
     (fetchpatch {
       url = "https://github.com/lenmus/lenmus/commit/421760d84694a0e6e72d0e9b1d4fd30a7e129c6f.patch";

pkgs/applications/misc/opentx/default.nix

···
     sha256 = "1pp3k1802gl1rji98clv17wj0619dliq821mpi4446lk22q692yq";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake gcc-arm-embedded python3Packages.pillow ];
 
   buildInputs = [ qtbase qtmultimedia qttranslations SDL ];

pkgs/applications/misc/prusa-slicer/default.nix

···
   pname = "prusa-slicer";
   version = "2.2.0";
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [
     cmake
     pkgconfig

pkgs/applications/misc/pwsafe/default.nix

···
     "-DNO_GTEST=ON"
     "-DCMAKE_CXX_FLAGS=-I${yubikey-personalization}/include/ykpers-1"
   ];
-  enableParallelBuilding = true;
 
   postPatch = ''
     # Fix perl scripts used during the build.

pkgs/applications/misc/qlandkartegt/default.nix

···
     "-DEXIF_INCLUDE_DIRS=${libexif}/include"
   ];
 
-  enableParallelBuilding = true;
-
   postPatch = ''
     substituteInPlace ConfigureChecks.cmake \
       --replace \$\{PLUGIN_INSTALL_DIR\} "${garmindev}/lib/qlandkartegt"

pkgs/applications/misc/qlandkartegt/garmindev.nix

···
 
   buildInputs = [ libusb-compat-0_1 ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "http://www.qlandkarte.org/";
     description = "Garmin Device Drivers for QlandkarteGT";

pkgs/applications/misc/qolibri/default.nix

···
     libeb lzo qtbase qtmultimedia qttools qtwebengine
   ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     homepage = "https://github.com/ludios/qolibri";
     description = "EPWING reader for viewing Japanese dictionaries";

pkgs/applications/misc/qsyncthingtray/default.nix

···
     runHook postInstall
   '';
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     homepage = "https://github.com/sieren/QSyncthingTray/";
     description = "A Traybar Application for Syncthing written in C++";

pkgs/applications/misc/slade/default.nix

···
   nativeBuildInputs = [ cmake pkgconfig zip ];
   buildInputs = [ wxGTK gtk2 sfml fluidsynth curl freeimage ftgl glew ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Doom editor";
     homepage = "http://slade.mancubus.net/";

pkgs/applications/misc/slade/git.nix

···
   nativeBuildInputs = [ cmake pkgconfig zip ];
   buildInputs = [ wxGTK gtk2 sfml fluidsynth curl freeimage ftgl glew ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Doom editor";
     homepage = "http://slade.mancubus.net/";

pkgs/applications/misc/subsurface/default.nix

···
     "-DNO_PRINTING=OFF"
   ];
 
-  enableParallelBuilding = true;
-
   passthru = { inherit version libdc googlemaps; };
 
   meta = with stdenv.lib; {

pkgs/applications/misc/tasksh/default.nix

···
   pname = "tasksh";
   version = "1.2.0";
 
-  enableParallelBuilding = true;
-
   src = fetchurl {
     url = "https://taskwarrior.org/download/${pname}-${version}.tar.gz";
     sha256 = "1z8zw8lld62fjafjvy248dncjk0i4fwygw0ahzjdvyyppx4zjhkf";

pkgs/applications/misc/timewarrior/default.nix

···
   pname = "timewarrior";
   version = "1.4.2";
 
-  enableParallelBuilding = true;
-
   src = fetchFromGitHub {
     owner = "GothenburgBitFactory";
     repo = "timewarrior";

pkgs/applications/misc/xsuspender/default.nix

···
   nativeBuildInputs = [ cmake pkgconfig makeWrapper ];
   buildInputs = [ glib libwnck3 ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     wrapProgram $out/bin/xsuspender \
       --prefix PATH : "${makeBinPath [ procps ]}"

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

···
     wrapQtAppsHook
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "QtWebEngine based cross-platform web browser";
     homepage    = "https://community.kde.org/Incubator/Projects/Falkon";

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

···
   #see issue https://github.com/zeek/zeek/issues/804 to modify hardlinking duplicate files.
   inherit preConfigure;
 
-  enableParallelBuilding = true;
-
   patches = stdenv.lib.optionals stdenv.cc.isClang [
     # Fix pybind c++17 build with Clang. See: https://github.com/pybind/pybind11/issues/1604
     (fetchpatch {

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

···
     qtbase qtmultimedia qtx11extras qtwebengine
     libidn qca-qt5 libXScrnSaver hunspell
   ];
-  enableParallelBuilding = true;
 
   meta = with lib; {
     homepage = "https://psi-im.org";

pkgs/applications/networking/instant-messengers/telegram/tdesktop/default.nix

···
     pcre xorg.libpthreadstubs xorg.libXdmcp util-linux libselinux libsepol epoxy at-spi2-core libXtst
   ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-Ddisable_autoupdate=ON"
     # We're allowed to used the API ID of the Snap package:

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

···
     ./0001-common-Disable-enum-type-stream-operators-for-Qt-5.1.patch
   ];
 
-  enableParallelBuilding = true;
-
   # Prevent ``undefined reference to `qt_version_tag''' in SSL check
   NIX_CFLAGS_COMPILE = "-DQT_NO_VERSION_TAGGING=1";
 

pkgs/applications/networking/owncloud-client/default.nix

···
     "-DNO_SHIBBOLETH=1"
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Synchronise your ownCloud with your computer using this desktop client";
     homepage = "https://owncloud.org";

pkgs/applications/networking/p2p/eiskaltdcpp/default.nix

···
     "-DWITH_LUASCRIPTS=ON"
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A cross-platform program that uses the Direct Connect and ADC protocols";
     homepage = "https://github.com/eiskaltdcpp/eiskaltdcpp";

pkgs/applications/networking/p2p/ktorrent/default.nix

···
     libktorrent taglib libgcrypt kplotting
   ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "KDE integrated BtTorrent client";
     homepage    = "https://www.kde.org/applications/internet/ktorrent/";

pkgs/applications/networking/p2p/qbittorrent/default.nix

···
     else "qbittorrent-nox"
   } --prefix PATH : ${makeBinPath [ python3 ]}";
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Featureful free software BitTorrent client";
     homepage    = "https://www.qbittorrent.org/";

pkgs/applications/networking/sniffers/wireshark/default.nix

···
     cp ../wiretap/*.h $dev/include/wiretap
   '');
 
-  enableParallelBuilding = true;
-
   dontFixCmake = true;
 
   shellHook = ''

pkgs/applications/office/gnucash/default.nix

···
   '';
   doCheck = false;
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Personal and small-business financial-accounting application";
 

pkgs/applications/office/kmymoney/default.nix

···
   # Hidden dependency that wasn't included in CMakeLists.txt:
   NIX_CFLAGS_COMPILE = "-I${kitemmodels.dev}/include/KF5";
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [
     doxygen extra-cmake-modules graphviz kdoctools python2
     python3Packages.wrapPython wrapQtAppsHook

pkgs/applications/office/ledger/default.nix

···
 
   nativeBuildInputs = [ cmake texinfo ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DCMAKE_INSTALL_LIBDIR=lib"
     "-DBUILD_DOCS:BOOL=ON"

pkgs/applications/office/scribus/default.nix

···
     sha256 = "0bq433myw6h1siqlsakxv6ghb002rp3mfz5k12bg68s0k6skn992";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ pkgconfig cmake ];
   buildInputs = with xorg;
     [ freetype lcms libtiff libxml2 libart_lgpl qt4

pkgs/applications/office/scribus/unstable.nix

···
     sha256 = "sha256-1CV2lVOc+kDerYq9rwTFHjTU10vK1aLJNNCObp1Dt6s=";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [
     cmake
     pkgconfig

pkgs/applications/radio/dsd/default.nix

···
     mbelib libsndfile itpp
   ] ++ stdenv.lib.optionals portaudioSupport [ portaudio ];
 
-  enableParallelBuilding = true;
-
   doCheck = true;
   preCheck = ''
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH''${LD_LIBRARY_PATH:+:}$PWD

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

···
 , gflags
 , gnuradio
 , orc
-, pkgconfig
+, pkg-config
 , pythonPackages
 , uhd
 , log4cpp
···
     sha256 = "0a3k47fl5dizzhbqbrbmckl636lznyjby2d2nz6fz21637hvrnby";
   };
 
+  nativeBuildInputs = [ cmake pkg-config ];
   buildInputs = [
     armadillo
     boost.dev
-    cmake
     glog
     gmock
     openssl.dev
     gflags
     gnuradio
     orc
-    pkgconfig
     pythonPackages.Mako
     pythonPackages.six
 
···
     pugixml
     protobuf
   ];
-
-  enableParallelBuilding = true;
 
   cmakeFlags = [
     "-DGFlags_ROOT_DIR=${gflags}/lib"

pkgs/applications/radio/gnuradio/ais.nix

···
     done
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Gnuradio block for ais";
     homepage = "https://github.com/bistromath/gr-ais";

pkgs/applications/radio/gnuradio/gsm.nix

···
     done
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Gnuradio block for gsm";
     homepage = "https://github.com/ptrkrysik/gr-gsm";

pkgs/applications/radio/gnuradio/limesdr.nix

···
   ] ++ stdenv.lib.optionals pythonSupport [ python ];
 
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Gnuradio source and sink blocks for LimeSDR";
     homepage = "https://wiki.myriadrf.org/Gr-limesdr_Plugin_for_GNURadio";

pkgs/applications/radio/gnuradio/nacl.nix

···
     done
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Gnuradio block for encryption";
     homepage = "https://github.com/stwunsch/gr-nacl";

pkgs/applications/radio/gnuradio/osmosdr.nix

···
     done
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Gnuradio block for OsmoSDR and rtl-sdr";
     homepage = "https://sdr.osmocom.org/trac/wiki/GrOsmoSDR";

pkgs/applications/radio/gnuradio/rds.nix

···
     done
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Gnuradio block for radio data system";
     homepage = "https://github.com/bastibl/gr-rds";

pkgs/applications/radio/gqrx/default.nix

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

pkgs/applications/radio/svxlink/default.nix

···
     "-DRTLSDR_INCLUDE_DIRS=${rtl-sdr}/include"
     "../src"
   ];
-  enableParallelBuilding = true;
   dontWrapQtApps = true;
 
   nativeBuildInputs = [ cmake pkgconfig doxygen groff wrapQtAppsHook ];

pkgs/applications/radio/uhd/default.nix

···
     sha256 = "1fir1a13ac07mqhm4sr34cixiqj2difxq0870qv1wr7a7cbfw6vp";
   };
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DENABLE_LIBUHD=ON"
     "-DENABLE_USB=ON"

pkgs/applications/radio/welle-io/default.nix

···
     "-DRTLSDR=true" "-DSOAPYSDR=true"
   ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "A DAB/DAB+ Software Radio";
     homepage = "https://www.welle.io/";

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

···
                  "-DEZMINC_BUILD_MRFSEG=TRUE"
                  "-DEZMINC_BUILD_DD=TRUE" ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://github.com/BIC-MNI/${pname}";
     description = "Collection of Perl and shell scripts for processing MINC files";

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

···
 
   cmakeFlags = [ "-DANTS_SUPERBUILD=FALSE" "-DUSE_VTK=TRUE" ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     for file in $out/bin/*; do
       wrapProgram $file --set ANTSPATH "$out/bin"

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

···
     sha256 = "1cncfwhyhmg18n970lkn6yvp0i74ajznsl8dqz00asqfzmg681n1";
   };
 
-  enableParallelBuilding = true;
   nativeBuildInputs = [ cmake git ];
   buildInputs = [ libyamlcpp ];
 

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

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ zlib ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "An ultra-fast single-node solution for large and complex metagenomics assembly via succinct de Bruijn graph";
     license     = licenses.gpl3;

pkgs/applications/science/biology/messer-slim/default.nix

···
 { stdenv, fetchurl, cmake, gcc, gcc-unwrapped }:
 
 stdenv.mkDerivation rec {
-  version = "3.2.1"; 
+  version = "3.2.1";
   pname = "messer-slim";
 
   src = fetchurl {
     url = "https://github.com/MesserLab/SLiM/archive/v${version}.tar.gz";
     sha256 = "1j3ssjvxpsc21mmzj59kwimglz8pdazi5w6wplmx11x744k77wa1";
   };
-
-  enableParallelBuilding = true;
 
   nativeBuildInputs = [ cmake gcc gcc-unwrapped ];
 
-  cmakeFlags = [ "-DCMAKE_AR=${gcc-unwrapped}/bin/gcc-ar" 
+  cmakeFlags = [ "-DCMAKE_AR=${gcc-unwrapped}/bin/gcc-ar"
                  "-DCMAKE_RANLIB=${gcc-unwrapped}/bin/gcc-ranlib" ];
 
   meta = {
···
      platforms = stdenv.lib.platforms.all;
   };
 }
-

pkgs/applications/science/biology/minc-tools/default.nix

···
     done
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://github.com/BIC-MNI/minc-tools";
     description = "Command-line utilities for working with MINC files";

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

···
 
   nativeBuildInputs = [ cmake ];
   buildInputs = [ zlib ];
-  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     homepage = "http://cmictig.cs.ucl.ac.uk/wiki/index.php/NiftyReg";

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

···
 
   nativeBuildInputs = [ cmake ];
   buildInputs = [ eigen zlib ];
-  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     homepage = "http://cmictig.cs.ucl.ac.uk/research/software/software-nifty/niftyseg";

pkgs/applications/science/biology/obitools/obitools3.nix

···
 
   doCheck = true;
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib ; {
     description = "Management of analyses and data in DNA metabarcoding";
     homepage = "https://git.metabarcoding.org/obitools/obitools3";

pkgs/applications/science/chemistry/d-seams/default.nix

···
     sha256 = "03zhhl9vhi3rhc3qz1g3zb89jksgpdlrk15fcr8xcz8pkj6r5b1i";
   };
 
-  enableParallelBuilding = true;
   nativeBuildInputs = [ cmake lua luaPackages.luafilesystem ];
   buildInputs = [ fmt rang libyamlcpp eigen catch2 boost gsl liblapack blas ];
 

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

···
     openssh
   ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DOPENMP=ON"
     "-DGA=ON"

pkgs/applications/science/electronics/appcsxcad/default.nix

···
     rm $out/bin/AppCSXCAD.sh
   '';
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "Minimal Application using the QCSXCAD library";
     homepage = "https://github.com/thliebig/AppCSXCAD";

pkgs/applications/science/electronics/caneda/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ qtbase qttools qtsvg qwt ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Open source EDA software focused on easy of use and portability";
     homepage = "http://caneda.org";

pkgs/applications/science/electronics/csxcad/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A C++ library to describe geometrical objects";
     homepage = "https://github.com/thliebig/CSXCAD";

pkgs/applications/science/electronics/dsview/default.nix

···
     python3
   ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "A GUI program for supporting various instruments from DreamSourceLab, including logic analyzer, oscilloscope, etc";
     homepage = "https://www.dreamsourcelab.com/";

pkgs/applications/science/electronics/openems/default.nix

···
       -o $out/share/openEMS/matlab/h5readatt_octave.oct
   '';
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "Open Source Electromagnetic Field Solver";
     homepage = "http://openems.de/index.php/Main_Page.html";

pkgs/applications/science/logic/abc/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ readline ];
 
-  enableParallelBuilding = true;
   installPhase = "mkdir -p $out/bin && mv abc $out/bin";
 
   # needed by yosys

pkgs/applications/science/logic/cvc4/default.nix

···
     "-DCMAKE_BUILD_TYPE=Production"
   ];
 
-
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A high-performance theorem prover and SMT solver";
     homepage    = "http://cvc4.cs.stanford.edu/web/";

pkgs/applications/science/logic/fast-downward/default.nix

···
   cmakeFlags =
     lib.optional osi.withCplex [ "-DDOWNWARD_CPLEX_ROOT=${cplex}/cplex" ];
 
-  enableParallelBuilding = true;
-
   configurePhase = ''
     python build.py release
   '';

pkgs/applications/science/logic/lean/default.nix

···
 
   nativeBuildInputs = [ cmake ];
   buildInputs = [ gmp ];
-  enableParallelBuilding = true;
 
   cmakeDir = "../src";
 

pkgs/applications/science/logic/stp/default.nix

···
     )
   '';
 
-  # seems to build fine now, may revert if concurrency does become an issue
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Simple Theorem Prover";
     maintainers = with maintainers; [ ];

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

···
     (flag "OpenCV" opencvSupport)
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A toolbox which offers a wide range of efficient and unified machine learning methods";
     homepage = "http://shogun-toolbox.org/";

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

···
     sha256 = "104jp3cm823i3cdph7hgsnj6l77ygbwsy35mdmzhmsi4jxprd9j3";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake doxygen ];
 
   cmakeFlags =

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

···
     done
   '';
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     # Newer cub is included with cudatoolkit now and it breaks the build.
     # https://github.com/Microsoft/CNTK/issues/3191

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

···
     rm "$out"/lib/*.a
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Lightweight, Portable, Flexible Distributed/Mobile Deep Learning with Dynamic, Mutation-aware Dataflow Dep Scheduler";
     homepage = "https://mxnet.incubator.apache.org/";

pkgs/applications/science/misc/openmodelica/default.nix

···
 
   hardeningDisable = [ "format" ];
 
-  enableParallelBuilding = true;
-
   patchPhase = ''
     cp -fv ${fakegit}/bin/checkout-git.sh libraries/checkout-git.sh
     cp -fv ${fakegit}/bin/checkout-svn.sh libraries/checkout-svn.sh

pkgs/applications/science/misc/openmvs/default.nix

···
 
   dontUseCmakeBuildDir = true;
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A library for computer-vision scientists and especially targeted to the Multi-View Stereo reconstruction community";
     homepage = "http://cdcseacave.github.io/openMVS/";

pkgs/applications/science/misc/root/5.nix

···
   ]
   ++ stdenv.lib.optional stdenv.isDarwin "-DOPENGL_INCLUDE_DIR=${OpenGL}/Library/Frameworks";
 
-  enableParallelBuilding = true;
-
   setupHook = ./setup-hook.sh;
 
   meta = with stdenv.lib; {

pkgs/applications/science/misc/root/default.nix

···
     "-Druntime_cxxmodules=OFF"
   ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     for prog in rootbrowse rootcp rooteventselector rootls rootmkdir rootmv rootprint rootrm rootslimtree; do
       wrapProgram "$out/bin/$prog" \

pkgs/applications/science/misc/simgrid/default.nix

···
     EOW
   '';
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Framework for the simulation of distributed applications";
     longDescription = ''

pkgs/applications/science/physics/elmerfem/default.nix

···
     ./fix-cmake.patch
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://elmerfem.org/";
     description = "A finite element software for multiphysical problems";

pkgs/applications/video/kodi/default.nix

···
         repo  = name;
         inherit rev sha256;
       };
-      enableParallelBuilding = true;
     } // attrs');
 
   ffmpeg = kodiDependency rec {
···
       "-DCORE_PLATFORM_NAME=gbm"
       "-DGBM_RENDER_SYSTEM=gles"
     ];
-
-    enableParallelBuilding = true;
 
     # 14 tests fail but the biggest issue is that every test takes 30 seconds -
     # I'm guessing there is a thing waiting to time out

pkgs/data/themes/kde2/default.nix

···
   };
 
   outputs = [ "out" "dev" ];
-  enableParallelBuilding = true;
 
   nativeBuildInputs = [ cmake extra-cmake-modules ];
 

pkgs/data/themes/qtcurve/default.nix

···
     sha256 = "XP9VTeiVIiMm5mkXapCKWxfcvaYCkhY3S5RXZNR3oWo=";
   };
 
-  enableParallelBuilding = true;
-
   patches = [
     # Remove unnecessary constexpr, this is not allowed in C++14
     (fetchpatch {

pkgs/desktops/xfce/thunar-plugins/dropbox/default.nix

···
     gtk3
   ];
 
-  enableParallelBuilding = true;
-
   passthru.updateScript = xfce.updateScript {
     inherit pname version;
     attrPath = "xfce.thunar-dropbox-plugin";

pkgs/development/compilers/glslang/default.nix

···
   };
 
   nativeBuildInputs = [ cmake python3 bison jq ];
-  enableParallelBuilding = true;
 
   postPatch = ''
     cp --no-preserve=mode -r "${localSpirv-tools.src}" External/spirv-tools

pkgs/development/compilers/julia/1.0.nix

···
     openspecfun pcre2
   ]);
 
-  enableParallelBuilding = true;
-
   doCheck = !stdenv.isDarwin;
   checkTarget = "testall";
   # Julia's tests require read/write access to $HOME

pkgs/development/compilers/julia/1.3.nix

···
     openspecfun pcre2 lapack
   ];
 
-  enableParallelBuilding = true;
-
   # Other versions of Julia pass the tests, but we are not sure why these fail.
   doCheck = false;
   checkTarget = "testall";

pkgs/development/compilers/julia/1.5.nix

···
     openspecfun pcre2 lapack
   ];
 
-  enableParallelBuilding = true;
-
   # Julia's tests require read/write access to $HOME
   preCheck = ''
     export HOME="$NIX_BUILD_TOP"

pkgs/development/compilers/ldc/generic.nix

···
   pname = "ldc";
   inherit version;
 
-  enableParallelBuilding = true;
-
   src = fetchurl {
     url = "https://github.com/ldc-developers/ldc/releases/download/v${version}/ldc-${version}-src.tar.gz";
     sha256 = ldcSha256;

pkgs/development/compilers/llvm/10/clang/default.nix

···
       rm $out/bin/c-index-test
     '';
 
-    enableParallelBuilding = true;
-
     passthru = {
       isClang = true;
       inherit llvm;

pkgs/development/compilers/llvm/10/compiler-rt.nix

···
     ln -s $out/lib/*/clang_rt.crtend_shared-*.o $out/lib/crtendS.o
   '';
 
-  enableParallelBuilding = true;
 }

pkgs/development/compilers/llvm/10/libc++/default.nix

···
       "-DLIBCXX_ENABLE_EXCEPTIONS=OFF"
     ] ++ stdenv.lib.optional (!enableShared) "-DLIBCXX_ENABLE_SHARED=OFF";
 
-  enableParallelBuilding = true;
-
   passthru = {
     isLLVM = true;
   };

pkgs/development/compilers/llvm/10/libunwind.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = stdenv.lib.optional (!enableShared) "-DLIBUNWIND_ENABLE_SHARED=OFF";
 }

pkgs/development/compilers/llvm/10/lld.nix

···
 
   outputs = [ "out" "dev" ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     moveToOutput include "$dev"
     moveToOutput lib "$dev"

pkgs/development/compilers/llvm/10/lldb.nix

···
     "-DSPHINX_OUTPUT_HTML=OFF"
   ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     # Editor support
     # vscode:

pkgs/development/compilers/llvm/10/llvm.nix

···
 
   checkTarget = "check-all";
 
-  enableParallelBuilding = true;
-
   requiredSystemFeatures = [ "big-parallel" ];
   meta = {
     description = "Collection of modular and reusable compiler and toolchain technologies";

pkgs/development/compilers/llvm/10/openmp.nix

···
   nativeBuildInputs = [ cmake perl ];
   buildInputs = [ llvm ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Components required to build an executable OpenMP program";
     homepage    = "https://openmp.llvm.org/";

pkgs/development/compilers/llvm/11/clang/default.nix

···
       rm $out/bin/c-index-test
     '';
 
-    enableParallelBuilding = true;
-
     passthru = {
       isClang = true;
       inherit llvm;

pkgs/development/compilers/llvm/11/compiler-rt.nix

···
     ln -s $out/lib/*/clang_rt.crtend_shared-*.o $out/lib/crtendS.o
   '';
 
-  enableParallelBuilding = true;
 }

pkgs/development/compilers/llvm/11/libc++/default.nix

···
       "-DLIBCXX_ENABLE_EXCEPTIONS=OFF"
     ] ++ stdenv.lib.optional (!enableShared) "-DLIBCXX_ENABLE_SHARED=OFF";
 
-  enableParallelBuilding = true;
-
   passthru = {
     isLLVM = true;
   };

pkgs/development/compilers/llvm/11/libunwind.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = stdenv.lib.optional (!enableShared) "-DLIBUNWIND_ENABLE_SHARED=OFF";
 }

pkgs/development/compilers/llvm/11/lld.nix

···
 
   outputs = [ "out" "dev" ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     moveToOutput include "$dev"
     moveToOutput lib "$dev"

pkgs/development/compilers/llvm/11/lldb.nix

···
     "-DSPHINX_OUTPUT_HTML=OFF"
   ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     # Editor support
     # vscode:

pkgs/development/compilers/llvm/11/llvm.nix

···
 
   checkTarget = "check-all";
 
-  enableParallelBuilding = true;
-
   requiredSystemFeatures = [ "big-parallel" ];
   meta = {
     description = "Collection of modular and reusable compiler and toolchain technologies";

pkgs/development/compilers/llvm/11/openmp.nix

···
   nativeBuildInputs = [ cmake perl ];
   buildInputs = [ llvm ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Components required to build an executable OpenMP program";
     homepage    = "https://openmp.llvm.org/";

pkgs/development/compilers/llvm/5/clang/default.nix

···
       rm $out/bin/c-index-test
     '';
 
-    enableParallelBuilding = true;
-
     passthru = {
       isClang = true;
       inherit llvm;

pkgs/development/compilers/llvm/5/compiler-rt.nix

···
     ln -s $out/lib/*/clang_rt.crtend_shared-*.o $out/lib/linux/crtendS.o
   '';
 
-  enableParallelBuilding = true;
 }

pkgs/development/compilers/llvm/5/libc++/default.nix

···
     "-DLIBCXX_CXX_ABI=libcxxabi"
   ] ++ stdenv.lib.optional stdenv.hostPlatform.isMusl "-DLIBCXX_HAS_MUSL_LIBC=1";
 
-  enableParallelBuilding = true;
-
   passthru = {
     isLLVM = true;
   };

pkgs/development/compilers/llvm/5/lld.nix

···
 
   outputs = [ "out" "dev" ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     moveToOutput include "$dev"
     moveToOutput lib "$dev"

pkgs/development/compilers/llvm/5/lldb.nix

···
     "-DLLDB_CODESIGN_IDENTITY=" # codesigning makes nondeterministic
   ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     mkdir -p $out/share/man/man1
     cp ../docs/lldb.1 $out/share/man/man1/

pkgs/development/compilers/llvm/5/llvm.nix

···
 
   checkTarget = "check-all";
 
-  enableParallelBuilding = true;
-
   requiredSystemFeatures = [ "big-parallel" ];
   meta = {
     description = "Collection of modular and reusable compiler and toolchain technologies";

pkgs/development/compilers/llvm/5/openmp.nix

···
   nativeBuildInputs = [ cmake perl ];
   buildInputs = [ llvm ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Components required to build an executable OpenMP program";
     homepage    = "https://openmp.llvm.org/";

pkgs/development/compilers/llvm/6/clang/default.nix

···
       rm $out/bin/c-index-test
     '';
 
-    enableParallelBuilding = true;
-
     passthru = {
       isClang = true;
       inherit llvm;

pkgs/development/compilers/llvm/6/compiler-rt.nix

···
     ln -s $out/lib/*/clang_rt.crtend_shared-*.o $out/lib/linux/crtendS.o
   '';
 
-  enableParallelBuilding = true;
 }

pkgs/development/compilers/llvm/6/libc++/default.nix

···
     "-DLIBCXX_CXX_ABI=libcxxabi"
   ] ++ stdenv.lib.optional stdenv.hostPlatform.isMusl "-DLIBCXX_HAS_MUSL_LIBC=1";
 
-  enableParallelBuilding = true;
-
   passthru = {
     isLLVM = true;
   };

pkgs/development/compilers/llvm/6/lld.nix

···
 
   outputs = [ "out" "dev" ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     moveToOutput include "$dev"
     moveToOutput lib "$dev"

pkgs/development/compilers/llvm/6/lldb.nix

···
     "-DLLDB_CODESIGN_IDENTITY=" # codesigning makes nondeterministic
   ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     mkdir -p $out/share/man/man1
     cp ../docs/lldb.1 $out/share/man/man1/

pkgs/development/compilers/llvm/6/llvm.nix

···
 
   checkTarget = "check-all";
 
-  enableParallelBuilding = true;
-
   requiredSystemFeatures = [ "big-parallel" ];
   meta = {
     description = "Collection of modular and reusable compiler and toolchain technologies";

pkgs/development/compilers/llvm/6/openmp.nix

···
   nativeBuildInputs = [ cmake perl ];
   buildInputs = [ llvm ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Components required to build an executable OpenMP program";
     homepage    = "https://openmp.llvm.org/";

pkgs/development/compilers/llvm/7/clang/default.nix

···
       rm $out/bin/c-index-test
     '';
 
-    enableParallelBuilding = true;
-
     passthru = {
       isClang = true;
       inherit llvm;

pkgs/development/compilers/llvm/7/compiler-rt.nix

···
     ln -s $out/lib/*/clang_rt.crtend_shared-*.o $out/lib/linux/crtendS.o
   '';
 
-  enableParallelBuilding = true;
 }

pkgs/development/compilers/llvm/7/libc++/default.nix

···
   ] ++ stdenv.lib.optional stdenv.hostPlatform.isMusl "-DLIBCXX_HAS_MUSL_LIBC=1"
   ++ stdenv.lib.optional (!enableShared) "-DLIBCXX_ENABLE_SHARED=OFF" ;
 
-  enableParallelBuilding = true;
-
   passthru = {
     isLLVM = true;
   };

pkgs/development/compilers/llvm/7/lld.nix

···
 
   outputs = [ "out" "dev" ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     moveToOutput include "$dev"
     moveToOutput lib "$dev"

pkgs/development/compilers/llvm/7/lldb.nix

···
 
   NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.cc.isClang "-I${libxml2.dev}/include/libxml2";
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     mkdir -p $out/share/man/man1
     cp ../docs/lldb.1 $out/share/man/man1/

pkgs/development/compilers/llvm/7/llvm.nix

···
 
   checkTarget = "check-all";
 
-  enableParallelBuilding = true;
-
   requiredSystemFeatures = [ "big-parallel" ];
   meta = {
     description = "Collection of modular and reusable compiler and toolchain technologies";

pkgs/development/compilers/llvm/7/openmp.nix

···
   nativeBuildInputs = [ cmake perl ];
   buildInputs = [ llvm ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Components required to build an executable OpenMP program";
     homepage    = "https://openmp.llvm.org/";

pkgs/development/compilers/llvm/8/clang/default.nix

···
       rm $out/bin/c-index-test
     '';
 
-    enableParallelBuilding = true;
-
     passthru = {
       isClang = true;
       inherit llvm;

pkgs/development/compilers/llvm/8/compiler-rt.nix

···
     ln -s $out/lib/*/clang_rt.crtend_shared-*.o $out/lib/crtendS.o
   '';
 
-  enableParallelBuilding = true;
 }

pkgs/development/compilers/llvm/8/libc++/default.nix

···
       "-DLIBCXX_ENABLE_EXCEPTIONS=OFF"
     ] ++ stdenv.lib.optional (!enableShared) "-DLIBCXX_ENABLE_SHARED=OFF";
 
-  enableParallelBuilding = true;
-
   passthru = {
     isLLVM = true;
   };

pkgs/development/compilers/llvm/8/libunwind.nix

···
     })
   ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = stdenv.lib.optional (!enableShared) "-DLIBUNWIND_ENABLE_SHARED=OFF";
 }

pkgs/development/compilers/llvm/8/lld.nix

···
 
   outputs = [ "out" "dev" ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     moveToOutput include "$dev"
     moveToOutput lib "$dev"

pkgs/development/compilers/llvm/8/lldb.nix

···
     "-DLLDB_CODESIGN_IDENTITY=" # codesigning makes nondeterministic
   ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     mkdir -p $out/share/man/man1
     cp ../docs/lldb.1 $out/share/man/man1/

pkgs/development/compilers/llvm/8/llvm.nix

···
 
   checkTarget = "check-all";
 
-  enableParallelBuilding = true;
-
   requiredSystemFeatures = [ "big-parallel" ];
   meta = {
     description = "Collection of modular and reusable compiler and toolchain technologies";

pkgs/development/compilers/llvm/8/openmp.nix

···
   nativeBuildInputs = [ cmake perl ];
   buildInputs = [ llvm ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Components required to build an executable OpenMP program";
     homepage    = "https://openmp.llvm.org/";

pkgs/development/compilers/llvm/9/clang/default.nix

···
       rm $out/bin/c-index-test
     '';
 
-    enableParallelBuilding = true;
-
     passthru = {
       isClang = true;
       inherit llvm;

pkgs/development/compilers/llvm/9/compiler-rt.nix

···
     ln -s $out/lib/*/clang_rt.crtbegin_shared-*.o $out/lib/crtbeginS.o
     ln -s $out/lib/*/clang_rt.crtend_shared-*.o $out/lib/crtendS.o
   '';
-
-  enableParallelBuilding = true;
 }

pkgs/development/compilers/llvm/9/libc++/default.nix

···
       "-DLIBCXX_ENABLE_EXCEPTIONS=OFF"
     ] ++ stdenv.lib.optional (!enableShared) "-DLIBCXX_ENABLE_SHARED=OFF";
 
-  enableParallelBuilding = true;
-
   passthru = {
     isLLVM = true;
   };

pkgs/development/compilers/llvm/9/libunwind.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = stdenv.lib.optional (!enableShared) "-DLIBUNWIND_ENABLE_SHARED=OFF";
 }

pkgs/development/compilers/llvm/9/lld.nix

···
 
   outputs = [ "out" "dev" ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     moveToOutput include "$dev"
     moveToOutput lib "$dev"

pkgs/development/compilers/llvm/9/lldb.nix

···
     "-DLLVM_EXTERNAL_LIT=${lit}/bin/lit"
   ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     # man page
     mkdir -p $out/share/man/man1

pkgs/development/compilers/llvm/9/llvm.nix

···
 
   checkTarget = "check-all";
 
-  enableParallelBuilding = true;
-
   requiredSystemFeatures = [ "big-parallel" ];
   meta = {
     description = "Collection of modular and reusable compiler and toolchain technologies";

pkgs/development/compilers/llvm/9/openmp.nix

···
   nativeBuildInputs = [ cmake perl ];
   buildInputs = [ llvm ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Components required to build an executable OpenMP program";
     homepage    = "https://openmp.llvm.org/";

pkgs/development/compilers/lobster/default.nix

···
     ];
 
   preConfigure = "cd dev";
-  enableParallelBuilding = true;
 
   passthru = {
     tests.can-run-hello-world = callPackage ./test-can-run-hello-world.nix {};

pkgs/development/compilers/mono/llvm.nix

···
     "-DLLVM_BINUTILS_INCDIR=${libbfd.dev}/include"
   ] ++ stdenv.lib.optional (!isDarwin) "-DBUILD_SHARED_LIBS=ON";
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Collection of modular and reusable compiler and toolchain technologies - Mono build";
     homepage    = "http://llvm.org/";

pkgs/development/compilers/nextpnr/default.nix

···
     ++ (lib.optional enableGui qtbase)
     ++ (lib.optional stdenv.cc.isClang llvmPackages.openmp);
 
-  enableParallelBuilding = true;
   cmakeFlags =
     [ "-DCURRENT_GIT_VERSION=${lib.substring 0 7 (lib.elemAt srcs 0).rev}"
       "-DARCH=generic;ice40;ecp5"

pkgs/development/compilers/ponyc/default.nix

···
     ++ stdenv.lib.optionals stdenv.isDarwin [ "bits=64" ]
     ++ stdenv.lib.optionals (stdenv.isDarwin && (!lto)) [ "lto=no" ];
 
-  enableParallelBuilding = true;
-
   doCheck = true;
 
   NIX_CFLAGS_COMPILE = [ "-Wno-error=redundant-move" "-Wno-error=implicit-fallthrough" ];

pkgs/development/compilers/squeak/default.nix

···
     unix/cmake/configure --prefix=$out --enable-mpg-{mmx,pthreads}
   '';
 
-  enableParallelBuilding = true;
-
   hardeningDisable = [ "format" ];
 
   meta = with stdenv.lib; {

pkgs/development/interpreters/supercollider/default.nix

···
-{ stdenv, mkDerivation, fetchurl, cmake, pkgconfig, alsaLib
+{ stdenv, fetchurl, cmake, pkgconfig, alsaLib
 , libjack2, libsndfile, fftw, curl, gcc
 , libXt, qtbase, qttools, qtwebengine
 , readline, qtwebsockets, useSCEL ? false, emacs
···
 let optional = stdenv.lib.optional;
 in
 
-mkDerivation rec {
+stdenv.mkDerivation rec {
   pname = "supercollider";
   version = "3.11.2";
 
···
   ];
 
   nativeBuildInputs = [ cmake pkgconfig qttools ];
-
-  enableParallelBuilding = true;
 
   buildInputs = [
     gcc libjack2 libsndfile fftw curl libXt qtbase qtwebengine qtwebsockets readline ]

pkgs/development/libraries/alembic/default.nix

···
   nativeBuildInputs = [ unzip cmake ];
   buildInputs = [ openexr hdf5-threadsafe ];
 
-  enableParallelBuilding = true;
-
   buildPhase = ''
     cmake -DUSE_HDF5=ON -DCMAKE_INSTALL_PREFIX=$out/ -DUSE_TESTS=OFF .
 

pkgs/development/libraries/arrayfire/default.nix

···
     export CUDA_PATH="${cudatoolkit}"
   '';
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [
     cmake
     pkgconfig

pkgs/development/libraries/audio/mbelib/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   doCheck = true;
   preCheck = ''
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH''${LD_LIBRARY_PATH:+:}$PWD

pkgs/development/libraries/avro-c++/default.nix

···
     substituteInPlace test/buffertest.cc --replace "BOOST_MESSAGE" "BOOST_TEST_MESSAGE"
   '';
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "A C++ library which implements parts of the Avro Specification";
     homepage = "https://avro.apache.org/";

pkgs/development/libraries/avro-c/default.nix

···
 
   buildInputs = [ jansson zlib ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A C library which implements parts of the Avro Specification";
     homepage = "https://avro.apache.org/";

pkgs/development/libraries/beignet/default.nix

···
 
   patches = [ ./clang_llvm.patch ];
 
-  enableParallelBuilding = true;
-
   postPatch = ''
     substituteInPlace CMakeLists.txt --replace /etc/OpenCL/vendors "\''${CMAKE_INSTALL_PREFIX}/etc/OpenCL/vendors"
     patchShebangs src/git_sha1.sh
···
     preConfigure = ''
       cd utests
     '';
-
-    enableParallelBuilding = true;
 
     nativeBuildInputs = [
       cmake

pkgs/development/libraries/boringssl/default.nix

···
   };
 
   nativeBuildInputs = [ cmake perl go ];
-  enableParallelBuilding = true;
 
   makeFlags = [ "GOCACHE=$(TMPDIR)/go-cache" ];
 

pkgs/development/libraries/bullet/default.nix

···
     "-DBUILD_UNIT_TESTS=OFF"
   ];
 
-  enableParallelBuilding = true;
-
   NIX_CFLAGS_COMPILE = stdenv.lib.optionalString stdenv.cc.isClang
     "-Wno-error=argument-outside-range -Wno-error=c++11-narrowing";
 

pkgs/development/libraries/bullet/roboschool-fork.nix

···
     "-DBUILD_UNIT_TESTS=OFF"
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A professional free 3D Game Multiphysics Library";
     longDescription = ''

pkgs/development/libraries/c-blosc/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A blocking, shuffling and loss-less compression library";
     homepage = "https://www.blosc.org";

pkgs/development/libraries/cpp-hocon/default.nix

···
 
   buildInputs = [ boost curl leatherman ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     inherit (src.meta) homepage;
     description = "A C++ port of the Typesafe Config library";

pkgs/development/libraries/criterion/default.nix

···
     fetchSubmodules = true;
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake pkg-config ];
 
   buildInputs = [

pkgs/development/libraries/curlpp/default.nix

···
 
   buildInputs = [ curl ];
   nativeBuildInputs = [ cmake ];
-  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     homepage = "https://www.curlpp.org/";

pkgs/development/libraries/dlib/default.nix

···
     "-DUSE_DLIB_USE_CUDA=${if cudaSupport then "1" else "0"}"
     "-DUSE_AVX_INSTRUCTIONS=${if avxSupport then "yes" else "no"}" ];
 
-  enableParallelBuilding = true;
   nativeBuildInputs = [ cmake pkgconfig ];
   buildInputs = [ libpng libjpeg ] ++ lib.optional guiSupport libX11;
 

pkgs/development/libraries/doctest/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://github.com/onqtam/doctest";
     description = "The fastest feature-rich C++11/14/17/20 single-header testing framework";

pkgs/development/libraries/double-conversion/default.nix

···
     rm BUILD
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Binary-decimal and decimal-binary routines for IEEE doubles";
     homepage = "https://github.com/google/double-conversion";

pkgs/development/libraries/draco/default.nix

···
     sha256 = "14ln4la52x38pf8syr7i5v4vd65ya4zij8zj5kgihah03cih0qcd";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake ];
 
   cmakeFlags = [

pkgs/development/libraries/drumstick/default.nix

···
 
   outputs = [ "out" "dev" "man" ];
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [
     cmake docbook_xml_dtd_45 docbook_xml_dtd_45 docbook_xsl doxygen pkg-config wrapQtAppsHook
   ];

pkgs/development/libraries/eccodes/default.nix

···
                  "-DENABLE_ECCODES_OMP_THREADS=${if enableOpenMPThreads then "ON" else "OFF"}"
                ];
 
-  enableParallelBuilding = true;
-
   doCheck = true;
 
   # Only do tests that don't require downloading 120MB of testdata

pkgs/development/libraries/fcppt/default.nix

···
 
   cmakeFlags = [ "-DCMAKE_SKIP_BUILD_RPATH=false" "-DENABLE_BOOST=true" "-DENABLE_EXAMPLES=true" "-DENABLE_CATCH=true" "-DENABLE_TEST=true" ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Freundlich's C++ toolkit";
     longDescription = ''

pkgs/development/libraries/flatbuffers/default.nix

···
   '';
 
   nativeBuildInputs = [ cmake ];
-  enableParallelBuilding = true;
 
   cmakeFlags = [ "-DFLATBUFFERS_BUILD_TESTS=${if doCheck then "ON" else "OFF"}" ];
 

pkgs/development/libraries/freeglut/default.nix

···
                  "-DFREEGLUT_BUILD_STATIC:BOOL=OFF"
                ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Create and manage windows containing OpenGL contexts";
     longDescription = ''

pkgs/development/libraries/freetds/default.nix

···
 
   nativeBuildInputs = [ autoreconfHook pkgconfig ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Libraries to natively talk to Microsoft SQL Server and Sybase databases";
     homepage    = "https://www.freetds.org";

pkgs/development/libraries/gbenchmark/default.nix

···
     chmod -R u+w googletest
   '';
 
-  enableParallelBuilding = true;
   doCheck = true;
 
   meta = with stdenv.lib; {

pkgs/development/libraries/git2/default.nix

···
 
   propagatedBuildInputs = stdenv.lib.optional (!stdenv.isLinux) libiconv;
 
-  enableParallelBuilding = true;
-
   doCheck = false; # hangs. or very expensive?
 
   meta = {

pkgs/development/libraries/glfw/3.x.nix

···
     sha256 = "0b5lsxz1xkzip7fvbicjkxvg5ig8gbhx1zrlhandqc0rpk56bvyw";
   };
 
-  enableParallelBuilding = true;
-
   propagatedBuildInputs = [ libGL ];
 
   nativeBuildInputs = [ cmake ]

pkgs/development/libraries/hotpatch/default.nix

···
     sha256 = "169vdh55wsbn6fl58lpzqx64v6ifzh7krykav33x1d9hsk98qjqh";
   };
 
-  enableParallelBuilding = true;
   doCheck = true;
 
   nativeBuildInputs = [ cmake ];

pkgs/development/libraries/itk/4.x.nix

···
     "-DModule_ITKReview=ON"
   ];
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake xz ];
   buildInputs = [ libX11 libuuid vtk_7 ] ++ stdenv.lib.optionals stdenv.isDarwin [ Cocoa ];
 

pkgs/development/libraries/itk/default.nix

···
     "-DModule_ITKReview=ON"
   ];
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake xz makeWrapper ];
   buildInputs = [ libX11 libuuid vtk_7 ] ++ stdenv.lib.optionals stdenv.isDarwin [ Cocoa ];
 

pkgs/development/libraries/kmsxx/default.nix

···
     sha256 = "0xz4m9bk0naawxwpx5cy1j3cm6c8c9m5y551csk88y88x1g0z0xh";
   };
 
-  enableParallelBuilding = true;
-
   cmakeFlags = stdenv.lib.optional (!withPython) "-DKMSXX_ENABLE_PYTHON=OFF";
 
   nativeBuildInputs = [ cmake pkgconfig ];

pkgs/development/libraries/kpmcore/default.nix

···
 
   nativeBuildInputs = [ extra-cmake-modules ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     maintainers = with lib.maintainers; [ peterhoeg ];
     # The build requires at least Qt 5.14:

pkgs/development/libraries/leatherman/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ boost curl ruby ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://github.com/puppetlabs/leatherman/";
     description = "A collection of C++ and CMake utility libraries";

pkgs/development/libraries/libechonest/default.nix

···
   nativeBuildInputs = [ cmake doxygen ];
   buildInputs = [ qt4 qjson ];
 
-  enableParallelBuilding = true;
   doCheck = false; # requires network access
 
   meta = {

pkgs/development/libraries/libgaminggear/default.nix

···
     gtk2 libcanberra libnotify pcre sqlite xorg.libXdmcp xorg.libpthreadstubs
   ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DINSTALL_CMAKE_MODULESDIR=lib/cmake"
     "-DINSTALL_PKGCONFIGDIR=lib/pkgconfig"

pkgs/development/libraries/libjson-rpc-cpp/default.nix

···
   nativeBuildInputs = [ cmake pkg-config ];
   buildInputs = [ jsoncpp argtable curl libmicrohttpd doxygen catch ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "C++ framework for json-rpc (json remote procedure call)";
     homepage = "https://github.com/cinemast/libjson-rpc-cpp";

pkgs/development/libraries/libktorrent/default.nix

···
 
   propagatedBuildInputs = [ gmp boost ];
 
-  enableParallelBuilding = true;
-
   passthru = {
     inherit mainVersion;
   };

pkgs/development/libraries/libnabo/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ eigen boost ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DEIGEN_INCLUDE_DIR=${eigen}/include/eigen3"
   ];

pkgs/development/libraries/libnats-c/default.nix

···
   buildInputs = [ libsodium openssl protobuf protobufc ];
 
   separateDebugInfo = true;
-  enableParallelBuilding = true;
   outputs = [ "out" "dev" ];
 
   meta = with stdenv.lib; {

pkgs/development/libraries/libpointmatcher/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ eigen boost libnabo ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DEIGEN_INCLUDE_DIR=${eigen}/include/eigen3"
   ];

pkgs/development/libraries/libressl/default.nix

···
       substituteInPlace ./tls/tls_config.c --replace '"/etc/ssl/cert.pem"' '"${cacert}/etc/ssl/certs/ca-bundle.crt"'
     '';
 
-    enableParallelBuilding = true;
-
     outputs = [ "bin" "dev" "out" "man" "nc" ];
 
     postFixup = ''

pkgs/development/libraries/librime/default.nix

···
 
   buildInputs = [ boost glog leveldb marisa opencc libyamlcpp gmock ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage    = "https://rime.im/";
     description = "Rime Input Method Engine, the core library";

pkgs/development/libraries/libtins/default.nix

···
     "--with-boost=${boost.dev}"
   ];
 
-  enableParallelBuilding = true;
   doCheck = true;
   preCheck = ''
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH''${LD_LIBRARY_PATH:+:}$PWD${placeholder "out"}/lib

pkgs/development/libraries/libtoxcore/default.nix

···
 
     nativeBuildInputs = [ cmake pkgconfig ];
 
-    enableParallelBuilding = true;
-
     doCheck = false; # hangs, tries to access the net?
     checkInputs = [ check ];
 

pkgs/development/libraries/libunarr/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://github.com/selmf/unarr";
     description = "A lightweight decompression library with support for rar, tar and zip archives";

pkgs/development/libraries/libwhereami/default.nix

···
 
   buildInputs = [ boost curl leatherman ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     inherit (src.meta) homepage;
     description = "Library to report hypervisor information from inside a VM";

pkgs/development/libraries/medfile/default.nix

···
     sha256 = "1khzclkrd1yn9mz3g14ndgpsbj8j50v8dsjarcj6kkn9zgbbazc4";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake ];
   buildInputs = [ hdf5 ];
 

pkgs/development/libraries/metal/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Single-header C++11 library designed to make you love template metaprogramming";
     homepage = "https://github.com/brunocodutra/metal";

pkgs/development/libraries/mimalloc/default.nix

···
   };
 
   nativeBuildInputs = [ cmake ninja ];
-  enableParallelBuilding = true;
   cmakeFlags = stdenv.lib.optional secureBuild [ "-DMI_SECURE=ON" ];
 
   postInstall = let

pkgs/development/libraries/mlt/qt-5.nix

···
 
   CXXFLAGS = "-std=c++11";
 
-  enableParallelBuilding = true;
-
   qtWrapperArgs = [
     "--prefix FREI0R_PATH : ${frei0r}/lib/frei0r-1"
     "--prefix LADSPA_PATH : ${ladspaPlugins}/lib/ladspa"

pkgs/development/libraries/msgpack/generic.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
-  cmakeFlags = []
-    ++ stdenv.lib.optional (stdenv.hostPlatform != stdenv.buildPlatform)
-                           "-DMSGPACK_BUILD_EXAMPLES=OFF"
-    ;
+  cmakeFlags = stdenv.lib.optional (stdenv.hostPlatform != stdenv.buildPlatform) "-DMSGPACK_BUILD_EXAMPLES=OFF";
 
   meta = with stdenv.lib; {
     description = "MessagePack implementation for C and C++";

pkgs/development/libraries/ngt/default.nix

···
   NIX_ENFORCE_NO_NATIVE=! enableAVX;
   __AVX2__ = if enableAVX then 1 else 0;
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://github.com/yahoojapan/NGT";
     description = "Nearest Neighbor Search with Neighborhood Graph and Tree for High-dimensional Data";

pkgs/development/libraries/nlohmann_json/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DBuildTests=${if doCheck then "ON" else "OFF"}"
     "-DJSON_MultipleHeaders=ON"

pkgs/development/libraries/nuspell/default.nix

···
 
   outputs = [ "out" "lib" "dev" "man" ];
 
-  enableParallelBuilding = true;
-
   postPatch = ''
     rm -rf external/Catch2
     ln -sf ${catch2.src} external/Catch2

pkgs/development/libraries/nvidia-texture-tools/default.nix

···
     moveToOutput lib "$lib"
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "A set of cuda-enabled texture tools and compressors";
     homepage = "https://github.com/castano/nvidia-texture-tools";

pkgs/development/libraries/ogrepaged/default.nix

···
 
   cmakeFlags = [ "-DPAGEDGEOMETRY_BUILD_SAMPLES=OFF" ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Paged Geometry for Ogre3D";
     homepage = "https://github.com/RigsOfRods/ogre-paged";

pkgs/development/libraries/opae/default.nix

···
   '';
 
   cmakeFlags = [ "-DBUILD_ASE=1" ];
-  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     description = "Open Programmable Acceleration Engine SDK";

pkgs/development/libraries/openbr/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "Open Source Biometric Recognition";
     homepage = "http://openbiometrics.org/";

pkgs/development/libraries/opencollada/default.nix

···
 
   propagatedBuildInputs = [ libxml2 pcre ];
 
-  enableParallelBuilding = true;
-
   patchPhase = ''
     patch -p1 < ${./pcre.patch}
   '' + lib.optionalString stdenv.isDarwin ''

pkgs/development/libraries/opencv/3.x.nix

···
     "-DEIGEN_INCLUDE_PATH=${eigen}/include/eigen3"
   ];
 
-  enableParallelBuilding = true;
-
   postBuild = lib.optionalString enableDocs ''
     make doxygen
   '';

pkgs/development/libraries/opencv/4.x.nix

···
     "-DOPENCV_SKIP_PYTHON_LOADER=ON"
   ];
 
-  enableParallelBuilding = true;
-
   postBuild = lib.optionalString enableDocs ''
     make doxygen
   '';

pkgs/development/libraries/opencv/default.nix

···
     (opencvFlag "GSTREAMER" enableGStreamer)
   ];
 
-  enableParallelBuilding = true;
-
   hardeningDisable = [ "bindnow" "relro" ];
 
   # Fix pkgconfig file that gets broken with multiple outputs

pkgs/development/libraries/opensubdiv/default.nix

···
       "-DCUDA_HOST_COMPILER=${cudatoolkit.cc}/bin/cc"
     ];
 
-  enableParallelBuilding = true;
-
   postInstall = "rm $out/lib/*.a";
 
   meta = {

pkgs/development/libraries/openxr-loader/default.nix

···
 
   nativeBuildInputs = [ cmake python3 ];
   buildInputs = [ libX11 libXxf86vm libXrandr vulkan-headers libGL ];
-  enableParallelBuilding = true;
 
   cmakeFlags = [ "-DBUILD_TESTS=OFF" ];
 

pkgs/development/libraries/pangolin/default.nix

···
   ]
   ++ lib.optionals stdenv.isDarwin [ Carbon Cocoa ];
 
-  enableParallelBuilding = true;
-
   # The tests use cmake's findPackage to find the installed version of
   # pangolin, which isn't what we want (or available).
   doCheck = false;

pkgs/development/libraries/partio/default.nix

···
   nativeBuildInputs = [ unzip cmake doxygen ];
   buildInputs = [ freeglut libGLU libGL zlib swig python xorg.libXi xorg.libXmu ];
 
-  enableParallelBuilding = true;
-
   buildPhase = ''
     make partio
 

pkgs/development/libraries/pcl/default.nix

···
     sha256 = "1cli2rxqsk6nxp36p5mgvvahjz8hm4fb68yi8cf9nw4ygbcvcwb1";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ pkgconfig cmake ];
   buildInputs = [ qhull flann boost eigen libusb1 libpcap
                   libpng vtk qtbase libXt ]

pkgs/development/libraries/physfs/default.nix

···
     buildInputs = [ zlib ]
       ++ stdenv.lib.optionals stdenv.isDarwin [ darwin.apple_sdk.frameworks.Foundation ];
 
-    enableParallelBuilding = true;
-
     patchPhase = ''
       sed s,-Werror,, -i CMakeLists.txt
     '';

pkgs/development/libraries/physics/geant4/default.nix

···
     "-DINVENTOR_LIBRARY_RELEASE=${coin3d}/lib/libCoin.so"
   ];
 
-  enableParallelBuilding = true;
   nativeBuildInputs =  [ cmake ];
 
   buildInputs = [ libGLU xlibsWrapper libXmu ]

pkgs/development/libraries/poco/default.nix

···
     "-DPOCO_UNBUNDLED=ON"
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://pocoproject.org/";
     description = "Cross-platform C++ libraries with a network/internet focus";

pkgs/development/libraries/precice/default.nix

···
 
   nativeBuildInputs = [ cmake gcc ];
   buildInputs = [ boost eigen libxml2 openmpi python3 python3.pkgs.numpy ];
-  enableParallelBuilding = true;
 
   meta = {
     description = "preCICE stands for Precise Code Interaction Coupling Environment";

pkgs/development/libraries/qca2/default.nix

···
   buildInputs = [ openssl qt ]
     ++ stdenv.lib.optional stdenv.isDarwin darwin.apple_sdk.frameworks.Security;
 
-  enableParallelBuilding = true;
-
   # tells CMake to use this CA bundle file if it is accessible
   preConfigure = ''
     export QC_CERTSTORE_PATH=/etc/ssl/certs/ca-certificates.crt

pkgs/development/libraries/qt-5/modules/qtbase.nix

···
         ]
     );
 
-  enableParallelBuilding = true;
-
   postInstall =
     # Move selected outputs.
     ''

pkgs/development/libraries/range-v3/default.nix

···
   doCheck = !stdenv.isAarch64;
   checkTarget = "test";
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Experimental range library for C++11/14/17";
     homepage = "https://github.com/ericniebler/range-v3";

pkgs/development/libraries/science/biology/mirtk/default.nix

···
     install -Dm644 -t "$out/share/bash-completion/completions/mirtk" share/completion/bash/mirtk
   '';
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake gtest ];
   buildInputs = [ boost eigen python vtk zlib tbb ];
 

pkgs/development/libraries/science/electronics/qcsxcad/default.nix

···
     qtbase
   ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "Qt library for CSXCAD";
     homepage = "https://github.com/thliebig/QCSXCAD";

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

···
   '';
 
   doCheck = false;
-  enableParallelBuilding = true;
 
   meta = {
     homepage = "https://caffe2.ai/";

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

···
     "-DGTEST_DIR:PATH=${gtest.src}/googletest"
   ];
 
-  enableParallelBuilding = true;
-
   doCheck = true;
 
   checkPhase = ''

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

···
 
   doCheck = true;
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     inherit version;
     description = "Linear Algebra PACKage";

pkgs/development/libraries/science/math/or-tools/default.nix

···
     python.pkgs.protobuf python.pkgs.six
   ];
 
-  enableParallelBuilding = true;
-
   outputs = [ "out" "python" ];
 
   meta = with stdenv.lib; {

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

···
   nativeBuildInputs = [ cmake openssh ];
   buildInputs = [ mpi gfortran blas lapack ];
 
-  enableParallelBuilding = true;
-
   doCheck = true;
 
   preConfigure = ''

pkgs/development/libraries/simgear/default.nix

···
                   libICE libSM libXt libXmu libGLU libGL boost zlib libjpeg freealut
                   openscenegraph openal expat apr curl ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Simulation construction toolkit";
     homepage = "https://gitorious.org/fg/simgear";

pkgs/development/libraries/telepathy/qt/default.nix

···
   # On 0.9.7, they do not even build with QT4
   cmakeFlags = stdenv.lib.optional (!doCheck) "-DENABLE_TESTS=OFF";
 
-  enableParallelBuilding = true;
   doCheck = false; # giving up for now
 
   meta = with stdenv.lib; {

pkgs/development/libraries/tiledb/default.nix

···
     gtest
   ];
 
-  enableParallelBuilding = true;
-
   buildInputs = [
     catch2
     zlib

pkgs/development/libraries/vc/0.7.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   postPatch = ''
     sed -i '/OptimizeForArchitecture()/d' cmake/VcMacros.cmake
     sed -i '/AutodetectHostArchitecture()/d' print_target_architecture.cmake

pkgs/development/libraries/vc/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   postPatch = ''
     sed -i '/OptimizeForArchitecture()/d' cmake/VcMacros.cmake
     sed -i '/AutodetectHostArchitecture()/d' print_target_architecture.cmake

pkgs/development/libraries/vigra/default.nix

···
             ++ stdenv.lib.optionals (stdenv.hostPlatform.system == "x86_64-linux")
                   [ "-DCMAKE_CXX_FLAGS=-fPIC" "-DCMAKE_C_FLAGS=-fPIC" ];
 
-  enableParallelBuilding = true;
-
   # fails with "./test_watersheds3d: error while loading shared libraries: libvigraimpex.so.11: cannot open shared object file: No such file or directory"
   doCheck = false;
 

pkgs/development/libraries/vmmlib/default.nix

···
   buildInputs = [ boost lapack ]
     ++ stdenv.lib.optionals stdenv.isDarwin [ Accelerate CoreGraphics CoreVideo ];
 
-  enableParallelBuilding = true;
-
   doCheck = !stdenv.isDarwin;
 
   checkTarget = "test";

pkgs/development/libraries/vtk/generic.nix

···
     sed -i 's/fprintf(output, shift)/fprintf(output, "%s", shift)/g' ./ThirdParty/libxml2/vtklibxml2/xpath.c
   '';
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "Open source libraries for 3D computer graphics, image processing and visualization";
     homepage = "https://www.vtk.org/";

pkgs/development/libraries/vulkan-loader/default.nix

···
 
   nativeBuildInputs = [ pkgconfig cmake ];
   buildInputs = [ python3 xlibsWrapper libxcb libXrandr libXext wayland ];
-  enableParallelBuilding = true;
 
   preConfigure = ''
     substituteInPlace loader/vulkan.pc.in \

pkgs/development/libraries/vxl/default.nix

···
     "-DCMAKE_C_FLAGS=-fPIC"
   ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "C++ Libraries for Computer Vision Research and Implementation";
     homepage = "http://vxl.sourceforge.net/";

pkgs/development/libraries/wt/default.nix

···
         inherit sha256;
       };
 
-      enableParallelBuilding = true;
-
       nativeBuildInputs = [ cmake pkg-config ];
       buildInputs = [
         boost doxygen qt48Full libharu

pkgs/development/libraries/x265/default.nix

···
   buildLib = has12Bit: stdenv.mkDerivation rec {
     name = "libx265-${if has12Bit then "12" else "10"}-${version}";
     inherit src;
-    enableParallelBuilding = true;
 
     postPatch = ''
       sed -i 's/unknown/${version}/g' source/cmake/version.cmake
···
 stdenv.mkDerivation rec {
   pname = "x265";
   inherit version src;
-
-  enableParallelBuilding = true;
 
   postPatch = ''
     sed -i 's/unknown/${version}/g' source/cmake/version.cmake

pkgs/development/libraries/xgboost/default.nix

···
     sha256 = "1zs15k9crkiq7bnr4gqq53mkn3w8z9dq4nwlavmfcr5xr5gw2pw4";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake ] ++ lib.optional stdenv.isDarwin llvmPackages.openmp;
 
   buildInputs = lib.optional cudaSupport cudatoolkit

pkgs/development/libraries/zeromq/4.x.nix

···
   nativeBuildInputs = [ cmake asciidoc pkg-config ];
   buildInputs = [ libsodium ];
 
-  enableParallelBuilding = true;
-
   doCheck = false; # fails all the tests (ctest)
 
   cmakeFlags = stdenv.lib.optional enableDrafts "-DENABLE_DRAFTS=ON";

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

···
 
   checkInputs = [ pytest more-itertools ];
 
-  enableParallelBuilding = true;
   dontUseCmakeConfigure = true;
 }

pkgs/development/python-modules/hoomd-blue/default.nix

···
   propagatedBuildInputs = [ python.pkgs.numpy ]
    ++ stdenv.lib.optionals withMPI [ python.pkgs.mpi4py ];
 
-  enableParallelBuilding = true;
-
   dontAddPrefix = true;
   cmakeFlags = [
        "-DENABLE_MPI=${onOffBool withMPI}"

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

···
     Mako
   ];
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake ];
 
   buildInputs = [

pkgs/development/python-modules/pyside/apiextractor.nix

···
     sha256 = "1zj8yrxy08iv1pk38djxw3faimm226w6wmi0gm32w4yczblylwz3";
   };
 
-  enableParallelBuilding = true;
-
   outputs = [ "out" "dev" ];
 
   preConfigure = ''

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

···
     sha256 = "90f2d736e2192ac69e5a2ac798fce2b5f7bf179269daa2ec262986d488c3b0f7";
   };
 
-  enableParallelBuilding = true;
-
   outputs = [ "out" "dev" ];
 
   preConfigure = ''

pkgs/development/python-modules/pyside/generatorrunner.nix

···
     sha256 = "0vzk3cp0pfbhd921r8f1xkcz96znla39dhj074k623x9k26lj2sj";
   };
 
-  enableParallelBuilding = true;
-
   outputs = [ "out" "dev" ];
 
   preConfigure = ''

pkgs/development/python-modules/pyside/shiboken.nix

···
     sha256 = "0x2lyg52m6a0vn0665pgd1z1qrydglyfxxcggw6xzngpnngb6v5v";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake pkg-config pysideApiextractor pysideGeneratorrunner sphinx qt4 ];
 
   buildInputs = [ python libxml2 libxslt ];

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

···
     ln -s ${numpy.cfg} site.cfg
   '';
 
-  enableParallelBuilding = true;
-
   checkPhase = ''
     runHook preCheck
     pushd dist

pkgs/development/tools/analysis/kcov/default.nix

···
 
   buildInputs = [ zlib curl elfutils python libiberty libopcodes ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Code coverage tester for compiled programs, Python scripts and shell scripts";
 

pkgs/development/tools/analysis/retdec/default.nix

···
     substituteInPlace scripts/retdec-unpacker.py --replace "'upx'" "'${upx}/bin/upx'"
   '';
 
-  enableParallelBuilding = true;
-
   doInstallCheck = true;
   installCheckPhase = ''
     ${python3.interpreter} "$out/bin/retdec-tests-runner.py"

pkgs/development/tools/analysis/snowman/default.nix

···
     export sourceRoot=$sourceRoot/src
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Native code to C/C++ decompiler";
     homepage = "http://derevenets.com/";

pkgs/development/tools/bloaty/default.nix

···
 
   buildInputs = [ zlib ];
 
-  enableParallelBuilding = true;
-
   doCheck = true;
 
   installPhase = ''

pkgs/development/tools/boomerang/default.nix

···
   nativeBuildInputs = [ cmake bison flex ];
   buildInputs = [ qtbase capstone ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     homepage = "https://github.com/BoomerangDecompiler/boomerang";
     license = licenses.bsd3;

pkgs/development/tools/misc/cli11/default.nix

···
     sed -i '/TrueFalseTest/d' tests/CMakeLists.txt
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Command line parser for C++11";
     homepage = "https://github.com/CLIUtils/CLI11";

pkgs/development/tools/misc/creduce/default.nix

···
       lscpu ${util-linux}/bin/lscpu
   '';
 
-
-  enableParallelBuilding = true;
-
   postInstall = ''
     wrapProgram $out/bin/creduce --prefix PERL5LIB : "$PERL5LIB"
   '';

pkgs/development/tools/misc/kdbg/default.nix

···
   nativeBuildInputs = [ cmake extra-cmake-modules makeWrapper ];
   buildInputs = [ qt5.qtbase ki18n kconfig kiconthemes kxmlgui kwindowsystem ];
 
-  enableParallelBuilding = true;
-
-
   postInstall = ''
     wrapProgram $out/bin/kdbg --prefix QT_PLUGIN_PATH : ${qtbase}/${qtbase.qtPluginPrefix}
   '';

pkgs/development/tools/misc/uncrustify/default.nix

···
 
   nativeBuildInputs = [ cmake python ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Source code beautifier for C, C++, C#, ObjectiveC, D, Java, Pawn and VALA";
     homepage = "http://uncrustify.sourceforge.net/";

pkgs/development/tools/rtags/default.nix

···
            LIBCLANG_LIBDIR="${llvmPackages.clang.cc}/lib"
   '';
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "C/C++ client-server indexer based on clang";
     homepage = "https://github.com/andersbakken/rtags";

pkgs/development/tools/spirv-tools/default.nix

···
     rev = "v${version}";
     sha256 = "00b7xgyrcb2qq63pp3cnw5q1xqx2d9rfn65lai6n6r89s1vh3vg6";
   };
-  enableParallelBuilding = true;
 
   nativeBuildInputs = [ cmake python3 ];
 

pkgs/development/tools/trellis/default.nix

···
     # TODO: should this be in stdenv instead?
     "-DCMAKE_INSTALL_DATADIR=${placeholder "out"}/share"
   ];
-  enableParallelBuilding = true;
 
   preConfigure = with builtins; ''
     rmdir database && ln -sfv ${elemAt srcs 1} ./database

pkgs/development/tools/vulkan-validation-layers/default.nix

···
     wayland
   ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DGLSLANG_INSTALL_DIR=${localGlslang}"
     "-DSPIRV_HEADERS_INSTALL_DIR=${localSpirvHeaders}"

pkgs/games/arx-libertatis/default.nix

···
     "-DImageMagick_mogrify_EXECUTABLE=${imagemagick.out}/bin/mogrify"
   ];
 
-  enableParallelBuilding = true;
   dontWrapQtApps = true;
 
   postInstall = ''

pkgs/games/dhewm3/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ SDL2 libGLU libGL zlib libjpeg libogg libvorbis openal curl ];
 
-  enableParallelBuilding = true;
-
   hardeningDisable = [ "format" ];
 
   meta = with stdenv.lib; {

pkgs/games/dwarf-fortress/dfhack/default.nix

···
       ln -s ${ruby}/lib/libruby-*.so $out/hack/libruby.so
     '';
 
-    enableParallelBuilding = true;
   };
 in
 

pkgs/games/dwarf-fortress/unfuck.nix

···
     install -D -m755 ../build/libgraphics.so $out/lib/libgraphics.so
   '';
 
-  enableParallelBuilding = true;
-
   # Breaks dfhack because of inlining.
   hardeningDisable = [ "fortify" ];
 

pkgs/games/enyo-doom/default.nix

···
 
   buildInputs = [ qtbase ];
 
-  enableParallelBuilding = true;
-
   meta = {
     homepage = "https://gitlab.com/sdcofer70/enyo-doom";
     description = "Frontend for Doom engines";

pkgs/games/eternity-engine/default.nix

···
   nativeBuildInputs = [ cmake makeWrapper ];
   buildInputs = [ libGL SDL SDL_mixer SDL_net ];
 
-  enableParallelBuilding = true;
-
   installPhase = ''
     install -Dm755 source/eternity $out/lib/eternity/eternity
     cp -r $src/base $out/lib/eternity/base

pkgs/games/flightgear/default.nix

···
     "--set FG_ROOT ${data}/share/FlightGear"
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Flight simulator";
     maintainers = with maintainers; [ raskin ];

pkgs/games/freeorion/default.nix

···
   };
 
   buildInputs = [
-	(boost168.override { enablePython = true; })
+    (boost168.override { enablePython = true; })
     SDL2 python2 freetype openal libogg libvorbis zlib libpng libtiff libjpeg libGLU libGL glew ];
 
   nativeBuildInputs = [ cmake doxygen graphviz makeWrapper ];
-
-  enableParallelBuilding = true;
-
-  patches = [
-  ];
 
   postInstall = ''
     mkdir -p $out/fixpaths

pkgs/games/gzdoom/default.nix

···
       zmusic
     ];
 
-    enableParallelBuilding = true;
-
     NIX_CFLAGS_LINK = "-lopenal -lfluidsynth";
 
     installPhase = ''

pkgs/games/katago/default.nix

···
       --prefix LD_LIBRARY_PATH : "/run/opengl-driver/lib"
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Go engine modeled after AlphaGo Zero";
     homepage    = "https://github.com/lightvector/katago";

pkgs/games/leela-zero/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Go engine modeled after AlphaGo Zero";
     homepage    = "https://github.com/gcp/leela-zero";

pkgs/games/mudlet/default.nix

···
   WITH_FONTS = "NO";
   WITH_UPDATER = "NO";
 
-  enableParallelBuilding = true;
-
   installPhase =  ''
     mkdir -pv $out/lib
     cp 3rdparty/edbee-lib/edbee-lib/qslog/lib/libQsLog.so $out/lib

pkgs/games/multimc/default.nix

···
   nativeBuildInputs = [ cmake file makeWrapper ];
   buildInputs = [ qtbase jdk zlib ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [ "-DMultiMC_LAYOUT=lin-system" ];
 
   postInstall = ''

pkgs/games/odamex/default.nix

···
   nativeBuildInputs = [ cmake pkgconfig ];
   buildInputs = [ SDL SDL_mixer SDL_net wxGTK30 ];
 
-  enableParallelBuilding = true;
-
   meta = {
     homepage = "http://odamex.net/";
     description = "A client/server port for playing old-school Doom online";

pkgs/games/openclonk/default.nix

···
     ln -sv ${soundtrack_src} $out/share/games/openclonk/Music.ocg
   '';
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake pkgconfig ];
 
   buildInputs = [

pkgs/games/openjk/default.nix

···
   };
 
   dontAddPrefix = true;
-  enableParallelBuilding = true;
 
   nativeBuildInputs = [ makeWrapper cmake ];
   buildInputs = [ libjpeg zlib libpng libGL SDL2 ];

pkgs/games/openmw/default.nix

···
     sha256 = "0rm32zsmxvr6b0jjihfj543skhicbw5kg6shjx312clhlm035w2x";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake pkg-config ];
   buildInputs = [ boost ffmpeg_3 bullet mygui openscenegraph_ SDL2 unshield openal libXt qtbase ];
 

pkgs/games/openrct2/default.nix

···
     "-DDOWNLOAD_TITLE_SEQUENCES=OFF"
   ];
 
-  enableParallelBuilding = true;
-
   preFixup = "ln -s $out/share/openrct2 $out/bin/data";
 
   meta = with stdenv.lib; {

pkgs/games/openspades/default.nix

···
     cp $notoFont $out/share/games/openspades/Resources/
   '';
 
-  enableParallelBuilding = true;
-
   NIX_CFLAGS_LINK = "-lopenal";
 
   meta = with stdenv.lib; {

pkgs/games/quake2/yquake2/default.nix

···
       sha256 = "1dszbvxlh1npq4nv9s4wv4lcyfgb01k92ncxrrczsxy1dddg86pp";
     };
 
-    enableParallelBuilding = true;
-
     nativeBuildInputs = [ cmake ];
 
     buildInputs = [ SDL2 libGL curl ]

pkgs/games/quake2/yquake2/games.nix

···
       rev = "${lib.toUpper id}_${builtins.replaceStrings ["."] ["_"] version}";
     };
 
-    enableParallelBuilding = true;
-
     nativeBuildInputs = [ cmake ];
 
     installPhase = ''

pkgs/games/rigsofrods/default.nix

···
     sha256 = "0cb1il7qm45kfhh6h6jwfpxvjlh2dmg8z1yz9kj4d6098myf2lg4";
   };
 
-  enableParallelBuilding = true;
-
   installPhase = ''
     sed -e "s@/usr/local/lib/OGRE@${ogre}/lib/OGRE@" -i ../tools/linux/binaries/plugins.cfg
     mkdir -p $out/share/rigsofrods

pkgs/games/riko4/default.nix

···
     };
     buildInputs = [ SDL2 libGLU ];
     nativeBuildInputs = [ cmake ];
-    enableParallelBuilding = true;
 
     meta = with stdenv.lib; {
       homepage = "https://github.com/grimfang4/sdl-gpu";
···
     EOF
     chmod +x $out/bin/riko4
   '';
-
-  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     homepage = "https://github.com/incinirate/Riko4";

pkgs/games/solarus/default.nix

···
     openal libmodplug libvorbis
     qtbase glm ];
 
-  enableParallelBuilding = true;
-
   preFixup = ''
     mkdir $lib/
     mv $out/lib $lib

pkgs/games/spring/springlobby.nix

···
     })
   ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     wrapProgram $out/bin/springlobby \
       --prefix PATH : "${spring}/bin" \

pkgs/games/stepmania/default.nix

···
     ln -s $out/stepmania-5.1/stepmania $out/bin/stepmania
   '';
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     homepage = "https://www.stepmania.com/";
     description = "Free dance and rhythm game for Windows, Mac, and Linux";

pkgs/games/super-tux-kart/default.nix

···
     wrapProgram $out/bin/supertuxkart --set-default SUPERTUXKART_ASSETS_DIR "${assets}"
   '';
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "A Free 3D kart racing game";
     longDescription = ''

pkgs/games/the-butterfly-effect/default.nix

···
     qt5.qtbase qt5.qtsvg qt5.qttranslations box2d which cmake
     gettext
   ];
-  enableParallelBuilding = true;
 
   installPhase = ''
     make DESTDIR=.. install

pkgs/games/warsow/engine.nix

···
 
   cmakeFlags = [ "-DQFUSION_GAME=Warsow" ];
 
-  enableParallelBuilding = true;
-
   installPhase = ''
     mkdir -p $out/lib
     cp -r libs $out/lib/warsow

pkgs/games/wesnoth/default.nix

···
 
   cmakeFlags = [ "-DENABLE_TOOLS=${if enableTools then "ON" else "OFF"}" ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "The Battle for Wesnoth, a free, turn-based strategy game with a fantasy theme";
     longDescription = ''

pkgs/games/widelands/default.nix

···
     mkdir -p "$out/share/applications/"
     cp -v "../debian/org.widelands.widelands.desktop" "$out/share/applications/"
   '';
-
-  enableParallelBuilding = true;
 }

pkgs/games/zandronum/default.nix

···
     then [ "-DSERVERONLY=ON" ]
     else [ "-DFMOD_LIBRARY=${fmod}/lib/libfmodex.so" ]);
 
-  enableParallelBuilding = true;
-
   hardeningDisable = [ "format" ];
 
   installPhase = ''

pkgs/games/zdoom/default.nix

···
 
   sourceRoot = ".";
 
-  enableParallelBuilding = true;
-
   NIX_CFLAGS_LINK = [ "-lopenal" "-lfluidsynth" ];
 
   preConfigure = ''

pkgs/games/zdoom/zdbsp.nix

···
 
   nativeBuildInputs = [cmake unzip];
   buildInputs = [zlib];
-  sourceRoot = ".";
-  enableParallelBuilding = true;
+
   installPhase = ''
     install -Dm755 zdbsp $out/bin/zdbsp
   '';

pkgs/misc/apulse/default.nix

···
     sha256 = "1p6fh6ah5v3qz7dxhcsixx38bxg44ypbim4m03bxk3ls5i9xslmn";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ cmake pkgconfig ];
 
   buildInputs = [ alsaLib glib ];

pkgs/misc/dumb/default.nix

···
 stdenv.mkDerivation rec {
   pname = "dumb";
   version = "2.0.3";
-  enableParallelBuilding = true;
+
   nativeBuildInputs = [ cmake ];
   buildInputs = [ allegro SDL2 ];
 

pkgs/misc/emulators/citra/default.nix

···
     sha256 = "0c1zn1f84h4f6n6p0aqz905yvv5qpdmkj2z58yla6bfgbzabfyrj";
   };
 
-  enableParallelBuilding = true;
   nativeBuildInputs = [ cmake ];
   buildInputs = [ SDL2 qtbase qtmultimedia boost ];
 

pkgs/misc/emulators/dolphin-emu/default.nix

···
     "-DENABLE_LTO=True"
   ];
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [
     pkgconfig
     cmake

pkgs/misc/emulators/dolphin-emu/master.nix

···
     sha256 = "0vv3ahk6zdx2hx5diq4jkhl289wjybqcr4lwinrkfiywb83hcabg";
   };
 
-  enableParallelBuilding = true;
   nativeBuildInputs = [ cmake pkgconfig ]
   ++ lib.optional stdenv.isLinux wrapQtAppsHook;
 

pkgs/misc/emulators/emulationstation/default.nix

···
     install -D ../emulationstation $out/bin/emulationstation
   '';
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "A flexible emulator front-end supporting keyboardless navigation and custom system themes";
     homepage = "https://emulationstation.org";

pkgs/misc/emulators/melonDS/default.nix

···
     sha256 = "0m45m1ch0az8l3d3grjbqvi5vvydbffxwka9w3k3qiia50m7fnph";
   };
 
-  enableParallelBuilding = true;
   nativeBuildInputs = [ cmake pkgconfig wrapGAppsHook ];
   buildInputs = [
     SDL2

pkgs/misc/emulators/mgba/default.nix

···
     sha256 = "0nqj4bnn5c2z1bq4bnbw1wznc0wpmq4sy3w8pipd6n6620b9m4qq";
   };
 
-  enableParallelBuilding = true;
   nativeBuildInputs = [ wrapQtAppsHook pkgconfig cmake ];
 
   buildInputs = [

pkgs/misc/emulators/retroarch/cores.nix

···
         --add-flags "-L $COREDIR/${d2u core}_libretro${stdenv.hostPlatform.extensions.sharedLibrary} $@"
     '';
 
-    enableParallelBuilding = true;
-
     passthru = {
       inherit (a) core;
       libretroCore = "/lib/retroarch/cores";

pkgs/misc/emulators/rpcs3/default.nix

···
     ++ lib.optional alsaSupport alsaLib
     ++ lib.optional waylandSupport wayland;
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "PS3 emulator/debugger";
     homepage = "https://rpcs3.net/";

pkgs/misc/lightspark/default.nix

···
     pango lzma nasm llvm glibmm
   ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "Open source Flash Player implementation";
     homepage = "https://lightspark.github.io/";

pkgs/os-specific/linux/bpftrace/default.nix

···
     sha256 = "0y4qgm2cpccrsm20rnh92hqplddqsc5q5zhw9nqn2igm3h9i0z7h";
   };
 
-  enableParallelBuilding = true;
-
   buildInputs = with llvmPackages;
     [ llvm clang-unwrapped
       kernel elfutils libelf bcc

pkgs/os-specific/linux/roccat-tools/default.nix

···
   nativeBuildInputs = [ cmake pkgconfig gettext ];
   buildInputs = [ dbus dbus-glib libgaminggear libgudev lua ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DUDEVDIR=\${out}/lib/udev/rules.d"
     "-DCMAKE_MODULE_PATH=${libgaminggear.dev}/lib/cmake"

pkgs/servers/domoticz/default.nix

···
     cp -r ${minizip-src}/* $sourceRoot/extern/minizip
   '';
 
-  enableParallelBuilding = true;
-
   buildInputs = [
     openssl
     python3

pkgs/servers/foundationdb/cmake.nix

···
           ++ lib.optional useClang [ llvmPackages.lld ];
 
         separateDebugInfo = true;
-        enableParallelBuilding = true;
         dontFixCmake = true;
 
         cmakeFlags =
···
         # fix up the use of the very weird and custom 'fdb_install' command by just
         # replacing it with cmake's ordinary version.
         postPatch = ''
-          for x in bindings/c/CMakeLists.txt fdbserver/CMakeLists.txt fdbmonitor/CMakeLists.txt fdbbackup/CMakeLists.txt fdbcli/CMakeLists.txt; do 
+          for x in bindings/c/CMakeLists.txt fdbserver/CMakeLists.txt fdbmonitor/CMakeLists.txt fdbbackup/CMakeLists.txt fdbcli/CMakeLists.txt; do
             substituteInPlace $x --replace 'fdb_install' 'install'
           done
         '';

pkgs/servers/http/h2o/default.nix

···
 
   outputs = [ "out" "man" "dev" "lib" ];
 
-  enableParallelBuilding = true;
   nativeBuildInputs = [ pkgconfig cmake ninja ];
   buildInputs = [ openssl libuv zlib ];
 

pkgs/servers/nosql/arangodb/default.nix

···
       "-DASM_OPTIMIZATIONS=${if stdenv.hostPlatform.sse4_2Support then "ON" else "OFF"}"
     ];
 
-    enableParallelBuilding = true;
-
     meta = with lib; {
       homepage = "https://www.arangodb.com";
       description = "A native multi-model database with flexible data models for documents, graphs, and key-values";

pkgs/servers/sql/mariadb/connector-c/default.nix

···
   propagatedBuildInputs = [ curl openssl zlib ];
   buildInputs = [ libiconv ];
 
-  enableParallelBuilding = true;
-
   postInstall = ''
     moveToOutput bin/mariadb_config "$dev"
   '';

pkgs/servers/sql/mariadb/default.nix

···
     rm -r $out/share/aclocal
   '';
 
-  enableParallelBuilding = true;
-
   passthru.mysqlVersion = "5.7";
 
   passthru.tests = {

pkgs/servers/tmate-ssh-server/default.nix

···
 
   buildInputs = [ libtool zlib openssl libevent ncurses ruby msgpack libssh ];
   nativeBuildInputs = [ autoreconfHook cmake pkgconfig ];
-  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     homepage    = "https://tmate.io/";

pkgs/servers/ttyd/default.nix

···
 
   nativeBuildInputs = [ pkgconfig cmake xxd ];
   buildInputs = [ openssl libwebsockets json_c libuv zlib ];
-  enableParallelBuilding = true;
 
   outputs = [ "out" "man" ];
 

pkgs/servers/tvheadend/default.nix

···
 
   nativeBuildInputs = [ cmake makeWrapper pkgconfig ];
 
-  enableParallelBuilding = true;
-
   NIX_CFLAGS_COMPILE = [ "-Wno-error=format-truncation" "-Wno-error=stringop-truncation" ];
 
   # disable dvbscan, as having it enabled causes a network download which
···
   meta = with stdenv.lib; {
     description = "TV streaming server";
     longDescription = ''
-	Tvheadend is a TV streaming server and recorder for Linux, FreeBSD and Android
+        Tvheadend is a TV streaming server and recorder for Linux, FreeBSD and Android
         supporting DVB-S, DVB-S2, DVB-C, DVB-T, ATSC, IPTV, SAT>IP and HDHomeRun as input sources.
-	Tvheadend offers the HTTP (VLC, MPlayer), HTSP (Kodi, Movian) and SAT>IP streaming.'';
+        Tvheadend offers the HTTP (VLC, MPlayer), HTSP (Kodi, Movian) and SAT>IP streaming.'';
     homepage = "https://tvheadend.org";
     license = licenses.gpl3;
     platforms = platforms.unix;

pkgs/servers/xmpp/biboumi/default.nix

···
     cp $louiz_catch/single_include/catch.hpp tests/
   '';
 
-  enableParallelBuilding = true;
   doCheck = true;
 
   meta = with stdenv.lib; {

pkgs/servers/zoneminder/default.nix

···
 
   nativeBuildInputs = [ cmake makeWrapper pkgconfig ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DWITH_SYSTEMD=ON"
     "-DZM_LOGDIR=/var/log/${dirName}"

pkgs/shells/fish/default.nix

···
       tee -a $out/share/fish/__fish_build_paths.fish < ${fishPreInitHooks}
     '';
 
-    enableParallelBuilding = true;
-
     meta = with lib; {
       description = "Smart and user-friendly command line shell";
       homepage = "http://fishshell.com/";

pkgs/tools/X11/nx-libs/default.nix

···
   NIX_CFLAGS_COMPILE = [ "-I${libtirpc.dev}/include/tirpc" ];
   NIX_LDFLAGS = [ "-ltirpc" ];
 
-  enableParallelBuilding = true;
-
   postPatch = ''
     patchShebangs .
     find . -type f -name Makefile -exec sed -i 's|^\(SHELL:=\)/bin/bash$|\1${stdenv.shell}|g' {} \;

pkgs/tools/X11/virtualgl/lib.nix

···
       --replace "LD_PRELOAD=libgefaker" "LD_PRELOAD=$out/lib/libgefaker"
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "http://www.virtualgl.org/";
     description = "X11 GL rendering in a remote computer with full 3D hw acceleration";

pkgs/tools/admin/tigervnc/default.nix

···
 
   propagatedBuildInputs = xorg.xorgserver.propagatedBuildInputs;
 
-  enableParallelBuilding = true;
-
   meta = {
     homepage = "https://tigervnc.org/";
     license = stdenv.lib.licenses.gpl2Plus;

pkgs/tools/archivers/innoextract/default.nix

···
 
   nativeBuildInputs = [ cmake makeWrapper ];
 
-  enableParallelBuilding = true;
-
   # we need unar to for multi-archive extraction
   postFixup = stdenv.lib.optionalString withGog ''
     wrapProgram $out/bin/innoextract \

pkgs/tools/backup/httrack/qt.nix

···
 
   nativeBuildInputs = [ cmake makeWrapper pkgconfig ];
 
-  enableParallelBuilding = true;
-
   prePatch = ''
     substituteInPlace cmake/HTTRAQTFindHttrack.cmake \
       --replace /usr/include/httrack/ ${httrack}/include/httrack/

pkgs/tools/compression/zopfli/default.nix

···
     cp $src/src/zopfli/*.h $dev/include/
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     inherit (src.meta) homepage;
     description = "Very good, but slow, deflate or zlib compression";

pkgs/tools/filesystems/ceph/default.nix

···
       test -f $out/bin/ceph-volume
     '';
 
-    enableParallelBuilding = true;
-
     outputs = [ "out" "lib" "dev" "doc" "man" ];
 
     doCheck = false; # uses pip to install things from the internet

pkgs/tools/filesystems/cryfs/default.nix

···
 
   buildInputs = [ boost cryptopp curl fuse openssl ];
 
-  enableParallelBuilding = true;
-
   cmakeFlags = [
     "-DCRYFS_UPDATE_CHECKS:BOOL=FALSE"
     "-DBoost_USE_STATIC_LIBS:BOOL=FALSE" # this option is case sensitive

pkgs/tools/filesystems/encfs/default.nix

···
       "-DINSTALL_LIBENCFS=ON"
     ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     description = "An encrypted filesystem in user-space via FUSE";
     homepage = "https://vgough.github.io/encfs";

pkgs/tools/filesystems/securefs/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ fuse ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     inherit (src.meta) homepage;
     description = "Transparent encryption filesystem";

pkgs/tools/graphics/appleseed/default.nix

···
       "-DUSE_SSE=ON"
       "-DUSE_SSE42=ON"
   ];
-  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     description = "Open source, physically-based global illumination rendering engine";

pkgs/tools/graphics/vulkan-tools-lunarg/default.nix

···
     done
   '';
 
-  enableParallelBuilding = true;
-
   # Same as vulkan-validation-layers
   libraryPath = lib.strings.makeLibraryPath [ vulkan-loader ];
   dontPatchELF = true;

pkgs/tools/graphics/vulkan-tools/default.nix

···
 
   nativeBuildInputs = [ cmake pkgconfig ];
   buildInputs = [ python3 vulkan-headers vulkan-loader xlibsWrapper libxcb libXrandr wayland ];
-  enableParallelBuilding = true;
 
   libraryPath = lib.strings.makeLibraryPath [ vulkan-loader ];
 

pkgs/tools/inputmethods/fcitx-engines/fcitx-rime/default.nix

···
        --replace ${fcitx} $out
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     isFcitxEngine = true;
     homepage      = "https://github.com/fcitx/fcitx-rime";

pkgs/tools/misc/flameshot/default.nix

···
   nativeBuildInputs = [ cmake qttools qtsvg ];
   buildInputs = [ qtbase ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "Powerful yet simple to use screenshot software";
     homepage = "https://github.com/flameshot-org/flameshot";

pkgs/tools/misc/fltrdr/default.nix

···
 
   buildInputs = [ icu openssl ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://octobanana.com/software/fltrdr";
     description = "A TUI text reader for the terminal";

pkgs/tools/misc/heimdall/default.nix

···
     install -m644 ../OSX/README.txt $out/share/doc/heimdall/README.osx
   '';
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage    = "http://www.glassechidna.com.au/products/heimdall/";
     description = "A cross-platform tool suite to flash firmware onto Samsung Galaxy S devices";

pkgs/tools/misc/partition-manager/default.nix

···
     sha256 = "0jhggb4xksb0k0mj752n6pz0xmccnbzlp984xydqbz3hkigra1si";
   };
 
-  enableParallelBuilding = true;
-
   nativeBuildInputs = [ extra-cmake-modules kdoctools wrapGAppsHook wrapQtAppsHook ];
 
   # refer to kpmcore for the use of eject

pkgs/tools/misc/tmate/default.nix

···
 
   buildInputs = [ libtool zlib openssl libevent ncurses ruby msgpack libssh ];
   nativeBuildInputs = [ autoreconfHook cmake pkgconfig ];
-  enableParallelBuilding = true;
 
   meta = with stdenv.lib; {
     homepage    = "https://tmate.io/";

pkgs/tools/networking/pcapc/default.nix

···
 
   makeFlags = [ "PREFIX=$(out)" ];
 
-  enableParallelBuilding = true;
-
   doCheck = false;
 
   meta = with stdenv.lib; {

pkgs/tools/networking/pingtcp/default.nix

···
 
   nativeBuildInputs = [ cmake ];
 
-  enableParallelBuilding = true;
-
   doCheck = false;
 
   postInstall = ''

pkgs/tools/package-management/apt/default.nix

···
     "-DUSE_NLS=${if withNLS then "ON" else "OFF"}"
   ];
 
-  enableParallelBuilding = true;
-
   meta = with lib; {
     description = "Command-line package management tools used on Debian-based systems";
     homepage = "https://salsa.debian.org/apt-team/apt";

pkgs/tools/package-management/packagekit/qt.nix

···
 
   nativeBuildInputs = [ cmake pkgconfig qttools ];
 
-  enableParallelBuilding = true;
-
   meta = packagekit.meta // {
     description = "System to facilitate installing and updating packages - Qt";
   };

pkgs/tools/security/haka/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ swig wireshark check rsync libpcap gawk libedit pcre ];
 
-  enableParallelBuilding = true;
-
   meta = {
     description = "A collection of tools that allows capturing TCP/IP packets and filtering them based on Lua policy files";
     homepage = "http://www.haka-security.org/";

pkgs/tools/security/lastpass-cli/default.nix

···
     bash-completion curl openssl libxml2 libxslt
   ];
 
-  enableParallelBuilding = true;
-
   installTargets = [ "install" "install-doc" ];
 
   postInstall = ''

pkgs/tools/security/nmap/qt.nix

···
 
   buildInputs = [ qtbase qtscript qtwebengine ];
 
-  enableParallelBuilding = true;
-
   postPatch = ''
     substituteInPlace src/platform/digmanager.cpp \
       --replace '"dig"' '"${dnsutils}/bin/dig"'

pkgs/tools/system/facter/default.nix

···
   nativeBuildInputs = [ cmake ];
   buildInputs = [ boost cpp-hocon curl leatherman libwhereami libyamlcpp openssl ruby util-linux ];
 
-  enableParallelBuilding = true;
-
   meta = with stdenv.lib; {
     homepage = "https://github.com/puppetlabs/facter";
     description = "A system inventory tool";