Qt
This section describes the differences between Nix expressions for Qt
libraries and applications and Nix expressions for other C++ software. Some
knowledge of the latter is assumed. There are primarily two problems which
the Qt infrastructure is designed to address: ensuring consistent versioning
of all dependencies and finding dependencies at runtime.
Nix expression for a Qt package (<filename>default.nix</filename>)
{ mkDerivation, lib, qtbase }:
mkDerivation {
pname = "myapp";
version = "1.0";
buildInputs = [ qtbase ];
}
Import mkDerivation and Qt (such as
qtbase modules directly. Do not
import Qt package sets; the Qt versions of dependencies may not be
coherent, causing build and runtime failures.
Use mkDerivation instead of
stdenv.mkDerivation. mkDerivation is
a wrapper around stdenv.mkDerivation which applies some
Qt-specific settings. This deriver accepts the same arguments as
stdenv.mkDerivation; refer to
for details.
To use another deriver instead of stdenv.mkDerivation,
use mkDerivationWith:
mkDerivationWith myDeriver {
# ...
}
If you cannot use mkDerivationWith, please refer to
.
mkDerivation accepts the same arguments as
stdenv.mkDerivation, such as
buildInputs.
Locating runtime dependencies
Qt applications need to be wrapped to find runtime dependencies. If you
cannot use mkDerivation or
mkDerivationWith above, include
wrapQtAppsHook in nativeBuildInputs:
stdenv.mkDerivation {
# ...
nativeBuildInputs = [ wrapQtAppsHook ];
}
Entries added to qtWrapperArgs are used to modify the
wrappers created by wrapQtAppsHook. The entries are passed
as arguments to .
mkDerivation {
# ...
qtWrapperArgs = [ ''--prefix PATH : /path/to/bin'' ];
}
Set dontWrapQtApps to stop applications from being wrapped
automatically. It is required to wrap applications manually with
wrapQtApp, using the syntax of
:
mkDerivation {
# ...
dontWrapQtApps = true;
preFixup = ''
wrapQtApp "$out/bin/myapp" --prefix PATH : /path/to/bin
'';
}
wrapQtAppsHook ignores files that are non-ELF
executables. This means that scripts won't be automatically wrapped so
you'll need to manually wrap them as previously mentioned. An example of
when you'd always need to do this is with Python applications that use PyQT.
Libraries are built with every available version of Qt. Use the
meta.broken attribute to disable the package for
unsupported Qt versions:
mkDerivation {
# ...
# Disable this library with Qt < 5.9.0
meta.broken = builtins.compareVersions qtbase.version "5.9.0" < 0;
}
Adding a library to Nixpkgs
Add a Qt library to all-packages.nix by adding it to
the collection inside mkLibsForQt5. This ensures that the
library is built with every available version of Qt as needed.
Adding a Qt library to <filename>all-packages.nix</filename>
{
# ...
mkLibsForQt5 = self: with self; {
# ...
mylib = callPackage ../path/to/mylib {};
};
# ...
}
Adding an application to Nixpkgs
Add a Qt application to all-packages.nix using
libsForQt5.callPackage instead of the usual
callPackage. The former ensures that all dependencies are
built with the same version of Qt.
Adding a Qt application to <filename>all-packages.nix</filename>
{
# ...
myapp = libsForQt5.callPackage ../path/to/myapp/ {};
# ...
}