Get Involved/development/More: Difference between revisions
→Build Qt: No need to repeat this section for different version. |
→kde-builder: The installation procedure is already covered in the setup environment page and in project readme |
||
Line 1: | Line 1: | ||
This page is the continuation with more advanced topics of the page [[Get_Involved/development]]. | This page is the continuation with more advanced topics of the page [[Get_Involved/development]]. | ||
== Develop in a Linux container == | == Develop in a Linux container == |
Revision as of 10:57, 8 February 2024
This page is the continuation with more advanced topics of the page Get_Involved/development.
Develop in a Linux container
When you start programming for KDE, it is recommended that you use kdesrc-build in your main operating system or in a virtual machine running on a rolling-release Linux distribution (Arch, openSUSE Tumbleweed, KDE neon) or running on e.g. the latest version of Fedora KDE Spin or Kubuntu.
As an alternative, you can run kdesrc-build in a Linux container (docker, podman, toolbx, distrobox).
Option 1. The KDE PIM Docker image
You can install Docker and the KDE PIM Docker image. It provides a development environment that is isolated from your day-to-day system. It is based on KDE Neon Unstable.
Option 2. distrobox
It is possible to start developing KDE software using container images that are able to see inside your home folder. This can be done using distrobox and podman.
First, install distrobox and podman from your distribution repositories:
- Debian/Ubuntu: sudo apt install distrobox podman
- openSUSE: sudo zypper install distrobox podman
- Fedora: sudo dnf install distrobox podman
- Arch: sudo pacman --sync distrobox podman
Building without kdesrc-build
You can build a single repository using the KDE Neon Unstable docker image. We will be using the plasma:unstable
image, which comes with the latest KDE software and libraries, and we will be using the minimal version, which requires you to install development libraries before compiling your projects.
After installing distrobox and podman, run the following to create a new distrobox container:
podman pull invent-registry.kde.org/neon/docker-images/plasma:unstable distrobox create --image invent-registry.kde.org/neon/docker-images/plasma:unstable
This will create a distrobox container named plasma-unstable.
Lastly, enter the generated container:
distrobox enter plasma-unstable
You can then just clone the desired repository in your home folder and build it while being inside the container. If any development libraries are missing, you can just install them the same way you would install on Debian/Ubuntu/KDE Neon:
sudo apt install packagename-dev
You can also use build-dep
to let apt install the required libraries for the program you will be compiling. For example, to install the development libraries for Kate, you can run:
sudo apt-get build-dep kate
Building with kdesrc-build
First, install distrobox and podman from your distribution repositories. Then run:
distrobox enter
This should create a container based on your current Linux OS and enter it. It is preferable to use one of the Linux distributions that is better suited for kdesrc-build, as mentioned in this wiki page, so if your distribution does not provide very up-to-date packages, you can download and use a different container image for your distrobox from Dockerhub. For example, with openSUSE Tumbleweed:
podman pull opensuse/tumbleweed distrobox create --image opensuse/tumbleweed --name tumbleweed distrobox enter tumbleweed
Then it's a matter of downloading and running kdesrc-build as detailed in Get_Involved/development/Set_up_a_development_environment:
mkdir -p ~/kde/src
cd ~/kde/src
git clone https://invent.kde.org/sdk/kdesrc-build.git
cd kdesrc-build
./kdesrc-build --initial-setup
source ~/.bashrc
From this point on, one important thing to bear in mind is that a distrobox container is transparent in its user space and containerized in its root space: when you are inside a distrobox container, you can see the content of system's home folder, but not your system's root folders, only the container's root folders. This means that you can install packages inside the container using root privileges and access those packages to compile your programs stored in your home, without ever installing those packages in your actual system!
You can take advantage of this by installing, for instance, Qt development packages used for kdesrc-build from inside the container. This way, it is not necessary to compile Qt with kdesrc-build. This is particularly convenient if you want to compile KDE software with Qt6 quickly.
Likewise, you should install the required dependencies from inside the distrobox rather than from your system's repositories. Then you can start compiling as usual.
After compiling your program with kdesrc-build from inside the distrobox, you can run it with kdesrc-build run
, and despite it originating from inside a container and using the libraries from the container, it will run just fine as a GUI application on your system!
The only few gotchas to using this method are:
- You cannot use a full Plasma Desktop session made from git.
- You will need qqc2-desktop-style and Breeze to show the correct theme for your applications.
- You will need the QtWayland library and its respective development package to run your applications natively on a Wayland session.
Other operating systems
Kubuntu 23.10
The default configuration of kdesrc-build requires Qt version 6.6. Kubuntu 23.10 has Qt version 6.4.2. It is recommended that you build Qt in Kubuntu or use a Linux OS that is better supported by kdesrc-build.
FreeBSD
Install the latest release of FreeBSD with KDE Plasma Desktop on your hardware computer or in a virtual machine.
Your user should be member of the "wheel" user group (e.g. this can be configured in the FreeBSD installer, when creating your user you can select additional user groups for your user). Your user should be able to use sudo:
pkg install sudo visudo # Uncomment the line: %wheel ALL=(ALL:ALL) ALL
Then set up kdesrc-build using the same procedure as when installing kdesrc-build on a Linux operating system. FreeBSD is currently supported by kdesrc-build. See https://www.youtube.com/watch?v=8MqBnb3Y9JU
Microsoft Windows
You can build and develop KDE projects using the Microsoft Windows operating system.
Apple macOS
You can build and develop KDE projects using the Apple macOS operating system.
What to do if CMake configure fails because a build dependency is missing
See https://community.kde.org/Get_Involved/development/Install_the_dependencies .
Advanced kdesrc-build
After you have edited a git repository and you want to build it, --no-src
will make sure that kdesrc-build
does not overwrite your local source code changes with the latest source code from the official git repository (remote "origin" / https://invent/kde.org).
--no-include-dependencies
only builds the git repository that you give as parameter to kdesrc-build
.
--debug
shows verbose output.
--refresh-build
forces a rebuild (not an incremental build) and a full reinstall.
E.g. you have edited kcalc. You run:
kdesrc-build kcalc --no-src --no-include-dependencies --refresh-build --debug |& tee ~/a.txt
For details, see:
kdesrc-build --help
Note: the resources below might not be up to date.
See the kdesrc-build manual, Readme #1, Readme #2, Document #3 for more kdesrc-build information and options.
kf6-qt6 vs. kf5-qt5
Many KDE git repositories can build correctly and run correctly using "kdesrc-build kf6-qt6".
The KDE git repositories that can build correctly and run correctly using "kdesrc-build kf6-qt6" have two long lived git branches:
- A long lived git branch that does not contain the deprecated symbols from kf5-qt5, named e.g. "master".
- And another long lived git branch for qt5-kf5, where the deprecated symbols still exist.
What is "kf6-qt6"? You just set up kdesrc-build following the procedure. The resulting kdesrc-build installation will be of type kf6-qt6. In kdesrc-buildrc in the "global" section you will have "branch-group kf6-qt6". The git repositories that have only one long lived git branch e.g. named "master" will use that. The git repositories that have a second long lived git branch, will use the git branch where the deprecated symbols do not exist e.g. named "master".
What is "kf5-qt5"? Follow the chapter "kdesrc-build Qt5". The resulting kdesrc-build installation will be of type kf5-qt5. In kdesrc-buildrc in the "global" section you will have "branch-group kf5-qt5". The git repositories that have only one long lived git branch e.g. named "master" will use that. The git repositories that have a second long lived git branch where the deprecated symbols still exist e.g. named "kf5" will use that.
Build Qt using kdesrc-build
If you cannot build the KDE frameworks using kdesrc-build
and the Qt provided by your Linux distribution is outdated, you might want to build it using kdesrc-build
.
In your configuration file use the qt-install-dir
option (in the global section) with non-empty value, for example:
global qt-install-dir ~/kde6/usr_qt branch-group kf6-qt6 end global
Then build it:
kdesrc-build qt6-set
If you want the same for Qt5, change branch-group
option and use qt5-set
instead of qt6-set
.
To compile Qt6 with Qt X11 Extras (which is a necessary library to compile KWindowSystem), you should enable XCB feature during compilation
kdesrc-build qt6-set --cmake-options="-DQT_FEATURE_xcb=ON"
After that, you can build other modules.
Two independent kdesrc-build configurations: kf6-qt6 and kf5-qt5
You can switch between configurations with --rc-file
command line option. Generate another config, make the changes for the source-dir
, build-dir
, install-dir
,
and other changes you want. Make sure you use different value for persistent-data-file
option, to not mix things up.
As an alternative, you can utilize custom variable to make switch from a single config:
global
_ver 5 # <-- Change this to switch
source-dir ~/kde${_ver}/src
build-dir ~/kde${_ver}/build
install-dir ~/kde${_ver}/usr
persistent-data-file ~/kde${_ver}/persistent-options.json
end global
include ~/.local/share/kdesrc-build/data/build-include/kf${_ver}-qt${_ver}.ksb
Other CPU architectures than x86_64/amd64 and x86
You can build and develop KDE projects using a Linux OS installed on an ARM architecture CPU.
kdesrc-build issues
See https://community.kde.org/Get_Involved/development/Install_the_dependencies
wayland-protocols is too old, e.g. "kdesrc-build kidletime" fails
mkdir -p ~/kde/misc && cd ~/kde/misc wget https://gitlab.freedesktop.org/wayland/wayland-protocols/-/releases/1.31/downloads/wayland-protocols-1.31.tar.xz tar -xJvf wayland-protocols-*.tar.xz && mv wayland-protocols-*/ wayland-protocols cd wayland-protocols meson setup builddir --prefix $HOME/kde/usr meson compile -C builddir meson install -C builddir
"kdesrc-build kpat" fails because of black-hole-solitaire
This happens on Debian/Ubuntu/Kubuntu. Because there is no Linux distribution binary package for https://github.com/shlomif/black-hole-solitaire.
Solution: append at the end of kdesrc-buildrc file:
options kpat cmake-options -DWITH_BH_SOLVER=OFF end options
libdisplay-info is not available
If your Linux OS does not have a package for libdisplay-info.
Append at the end of the file kdesrc-buildrc
:
module libdisplay-info repository https://gitlab.freedesktop.org/emersion/libdisplay-info.git end module