Get Involved/development

By joining the ranks of KDE developers, you will get to implement new features and defeat bugs both daunting and simple, all while collaborating to make coherent and stable releases. Developers collaborate in teams based on what area they are working in. These can be small teams working on a single application, up to large teams working on a group of related pieces of software. Many developers are in more than one team.

KDE runs or participates in several mentoring programs to help new developers, including an informal list of people who are willing to help newcomers get started. See the Mentoring page for more details.

New to C++/Qt software development?

Most KDE software is written in C++ using the Qt toolkit and KDE Frameworks. Though prior experience with these technologies or other programming languages is helpful, you don't need to be a C++ programmer to get started!

Note

The Qt wiki contains a list of online books for learning Qt programming. Qt also provides lots of examples you can look at. Information about KDE Frameworks can be found on the TechBase wiki, and a book is available. See also Guidelines and HOWTOs/Development

Set up a development environment

To build software, you need a development environment: a set of tools that allows you to access and edit source code, compile it into a form that the computer can run, and deploy it to a safe location. We will now go through the process of setting one up. To accomplish these tasks, you will need to enter commands using a terminal program, such as KDE's Konsole (any terminal program will suffice though).

Note

If you're not familiar with the command line interface, you can find a reasonable tutorial here. However advanced command-line skills are not required, and you will learn what you need along the way!

First you will need to use your operating system's package manager to install some basic tools:

• Arch/Antergos/Manjaro: sudo pacman -S git cmake dialog
• Fedora: sudo dnf install git cmake dialog
• KDE Neon/Kubuntu/Ubuntu/Debian: sudo apt install git cmake dialog
• openSUSE Leap & Tumbleweed: sudo zypper install git cmake dialog

Next, create a folder to hold all the source code repositories you're going to be downloading!

mkdir ~/kde
cd ~/kde

Manage dependencies

Every piece of software has dependencies: other pieces of software that they rely upon to provide functionality that they rely on. In order to compile any piece of software, you need to have its dependencies available.

Most Linux-based operating systems do not provide development packages that are up-to-date enough for working on KDE software, so we will compile all the KDE dependencies ourselves. To do this, we use a command-line tool called kdesrc-build to download, manage, and build KDE source code repositories. Let's set it up now:

git clone git://anongit.kde.org/kdesrc-build.git
cd kdesrc-build

We want to add kdesrc-build to your system's $PATH variable so you can access it from anywhere. Use a text editor to open ~/.bashrc file and add export PATH=~/kde/kdesrc-build:$PATH. Then save the file and close it.

Next, set up kdesrc-build using its built-in wizard. The default options should be ok, but feel free to customize anything:

./kdesrc-build-setup

Note

Do not quote or escape any file paths entered in the wizard

We use kdesrc-build to manage KDE dependencies, but most pieces of KDE software also depend on system libraries that are not owned or controlled by KDE. We use the operating system's package manager to get these.

Lets now do this to fetch the dependencies for a simple test project: extra-cmake-modules

• Arch/Antergos/Manjaro: sudo pacman -S extra-cmake-modules
• Fedora: sudo dnf builddep extra-cmake-modules
• KDE Neon/Kubuntu/Ubuntu/Debian sudo apt build-dep extra-cmake-modules
• openSUSE Leap & Tumbleweed: sudo zypper si -d extra-cmake-modules

Now let's use kdesrc-build to download, compile, and install

extra-cmake-modules

:

cd ~/kde
kdesrc-build extra-cmake-modules

Did that work? Great! Now let's build Dolphin.

Compile and install Dolphin

• Arch/Antergos/Manjaro: sudo pacman -S dolphin
• Fedora: sudo dnf builddep dolphin
• KDE Neon/Kubuntu/Ubuntu/Debian sudo apt build-dep dolphin
• openSUSE Leap & Tumbleweed: sudo zypper si -d dolphin

cd ~/kde
kdesrc-build dolphin

Did everything work? Fantastic, now let's run it!

Set up a runtime environment

In order to run the software that you've just compiled and installed, you need to set up your runtime environment: a method to run installed software from a particular location. The operating system sets one up automatically for any software installed to

/usr

, but since we've installed our custom-compiled software to

~/kde/usr

, we'll need to set up a runtime environment to let us run software from there. You on;y need to create this file once.

Copy the following text to a new file called ~/kde/.setup-env:

export KF5=$HOME/kde/usr
export QTDIR=/usr  
export CMAKE_PREFIX_PATH=$KF5:$CMAKE_PREFIX_PATH  
export XDG_DATA_DIRS=$KF5/share:$XDG_DATA_DIRS:/usr/share  
export XDG_CONFIG_DIRS=$KF5/etc/xdg:$XDG_CONFIG_DIRS:/etc/xdg  
export PATH=$KF5/bin:$QTDIR/bin:$PATH  
export QT_PLUGIN_PATH=$KF5/lib/plugins:$KF5/lib64/plugins:$KF5/lib/x86_64-linux-gnu/plugins:$QTDIR/plugins:$QT_PLUGIN_PATH  
# (lib64 instead of lib on some systems, like openSUSE)
export QML2_IMPORT_PATH=$KF5/lib/qml:$KF5/lib64/qml:$KF5/lib/x86_64-linux-gnu/qml:$QTDIR/qml  
export QML_IMPORT_PATH=$QML2_IMPORT_PATH  
export KDE_SESSION_VERSION=5  
export KDE_FULL_SESSION=true
export SASL_PATH=/usr/lib/sasl2:$KF5/lib/sasl2
# (lib64 instead of lib on some systems, like openSUSE)
PS1="(kdesrc) $PS1"

Run your custom-compiled software

Now source the ~/kde/.setup-env file every time you want to run your custom-compiled KDE software:

source ~/kde/.setup-env
~/kde/usr/bin/dolphin

Did it run? If so, then congratulations, you just compiled your own version of Dolphin from source code!

Choose what to do

Now that you can compile and deploy custom versions of KDE software, you can open your editor and get hacking! The code for the version of Dolphin hat you just built is located at cd ~/kde/build/kde/applications/dolphin/; other projects you use kdesrc-build to download will be in similar locations.

A good place to start is with a small bug or feature in an existing piece of software that affects you personally ("scratch your own itch"). Get in touch with the existing developers (see Communicating with the team, below) and they can help you out, by pointing you to the right place in the code and giving advice about how to tackle the problem

Try not to start by proposing or working on major features or significant design changes. These can be controversial, and the smoothest way to get going is by working on relatively non-controversial bug-fixes. Start slowly and build trust!

Here are some other ideas for starting points:

• Improve awkwardly-worded messages and labels that are written in English. This is a great way for non-programmers to contribute! If you can compile software and have a good grasp of English, you can make a big difference here.
• Work on Junior Jobs, which are small tasks that are suitable for beginners (both bugs and features).
• Work on Bugs related to KDE's Usability & Productivity initiative, many of which are small and easy.
• The English Breakfast Network searches out simple, common issues in code that should be fixed, and going through the problems on there can provide a good overview of the code.

Test your patch

At this point, you have a patch. Make sure the project still compiles and installs, and make sure the patch has the desired effect when you run the software. Now it's time to run the project's unit tests:

source ~/kde/.setup-env
cd ~/kde/build/kde/applications/dolphin/<project>
make test

If any test fails, that needs to be investigated and fixed before you can proceed. Once the tests pass, then run the software again to make sure it still behaves properly. If it doesn't, then go back and work on your patch some more, then re-compile and re-deploy, and test again, until the program does what you'd like it to do and all tests pass.

Submit your patch

Once you're happy with your patch and have verified that it does what you want, you need to send it to other KDE developers for review. KDE uses Phabricator for this. Learn how to submit a patch with Phabricator

Communicate with the team

There are several ways to get in touch with KDE developers, either generally or for a specific project. The two most important communications channels are:

• The #kde-devel freenode IRC channel, which is where KDE developers chat in real time about their work
• The kde-devel mailing list is the primary development mailing list. learn more about mailing lists.

Both of these are general KDE development communication channels, and you may get directed to a more appropriate place for the project you are interested in. There is a list of mailing lists if you want to find a mailing list for a specific team directly. Many teams have their own Telegram rooms, too.

You can also try looking for the team's section on the Main Page of this wiki. Many teams have information there for new contributors.

Next steps

After you have had several patches accepted, a KDE developer is likely to suggest you get a Developer account, which will allow you to commit directly to KDE projects. With very few limits on where you can commit, you will be expected to act responsibly. At this point, congratulations! You are officially a KDE developer!

You may also want to set up a more permanent or advanced development environment, which will be very handy to start working on KDE Frameworks or Plasma itself. See Guidelines and HOWTOs/Build from source