Nova Flow OS
KDE Developer Platform
KDE Developer Platform
  • KDE Developer Platform
    • Getting started
      • Building KDE software
        • KDE software
        • Where to find the development team
        • Learning more
        • Choose what to work on
        • Source code cross-referencing
        • Installing build dependencies
        • Set up a development environment
        • Building KDE software with kdesrc-build
        • Basic troubleshooting
        • Tips and tricks
        • IDE Configuration
          • Setting up an IDE for KDE development
          • Visual Studio Code
          • Qt Creator
          • Kate
          • KDevelop
          • CLion
          • Sublime Text
        • Building KDE software manually
        • Building KDE software with distrobox and podman
      • Kirigami
        • KDE is ours
        • Setting up and getting started
        • Explaining pages
        • Layouts, ListViews, and Cards
        • Adding actions
        • Adding a dialog
        • Using separate files
        • Next steps
        • Colors and themes in Kirigami
        • Typography
        • Actions based components
        • Page rows and page stacks
        • Scrollable pages and list views
        • Cards
        • Drawers
        • Chips
        • Dialog types
        • Controls and interactive elements
        • Form layouts
        • Inline messages
        • Action toolbars
        • Progress bars and indicators
        • List views
        • Understanding CMakeLists
        • Figuring out main.cpp
        • Connect logic to your QML user interface
        • Connect models to your QML user interface
        • About page
        • Introduction to Kirigami Addons
        • FormCard About pages
        • Form delegates in your settings pages
      • KXmlGui
        • Getting started with KXmlGui
        • Hello World!
        • Creating the main window
        • Using actions
        • Saving and loading
        • Command line interface
      • Python with Kirigami
        • Apps with QML and Python
        • Your first Python + Kirigami application
        • Creating a Python package
        • Creating a Flatpak
      • Common programming mistakes
      • Adding a new KDE project
    • Features
      • Icons
      • Configuration
        • The KConfig Framework
        • Introduction to KConfig
        • Using KConfig XT
        • KDE Frameworks 6 porting guide
        • Settings module (KCM) development
        • KConfigDialog
      • D-Bus
        • What is D-Bus practically useful for?
        • Introduction to D-Bus
        • Accessing D-Bus interfaces
        • Intermediate D-Bus
        • Creating D-Bus interfaces
        • Using custom types with D-Bus
        • D-Bus autostart services
      • Create your own mouse cursor theme
      • Session management
      • Archives
      • Desktop file
      • KAuth
        • Privilege Escalation
        • Using actions in your applications
      • KIdleTime
      • Akonadi: personal information management
        • Debugging Akonadi Resources
        • Using Akonadi in applications
      • Concurrent programming
      • Solid
      • Sonnet
    • Plasma themes and plugins
      • Getting started
      • Plasma Widget tutorial
        • How to create a plasmoid
        • Setup
        • Porting Plasmoids to KF6
        • Testing
        • QML
        • Plasma's QML API
        • Widget Properties
        • Configuration
        • Translations / i18n
        • Examples
        • C++ API
      • KWin Effects
      • Plasma Desktop scripting
        • Javascript Interaction With Plasma Shells
        • Templates
        • Examples
        • API documentation
        • Configuration keys
      • Plasma Style tutorial
        • Creating a Plasma Style quickstart
        • Understanding Plasma Styles
        • SVG elements and Inkscape
        • Background SVG format
        • System and accent colors
        • Theme elements reference
        • Porting themes to Plasma 5
        • Porting themes to Plasma 6
      • Aurorae window decorations
      • KWin scripting tutorial
        • Quick start
        • KWin scripting API
      • Wallpapers
      • Plasma comic
        • Tutorial
        • Testing and debugging
        • Examples
      • Create a custom Window Switcher
      • KRunner C++ Plugin
        • Basic Anatomy of a Runner
        • KRunner metadata format
    • Applications
      • Creating sensor faces
      • Dolphin
        • Creating Dolphin service menus
      • Kate
        • Kate plugin tutorial
      • KMines
        • Making a KMines theme
      • Writing tests
        • Appium automation testing
    • Packaging
      • Android
        • KDE on Android
        • Building applications for Android
        • Packaging and publishing applications for Android
        • Publishing on Google Play
          • Introduction
          • Packaging your app
          • Adding your app to Google Play
          • Publishing your app
          • Releasing new versions of old apps
        • Porting applications to Android
          • Basic porting
          • Making applications run well on Android
          • Metadata
      • Windows
        • Packaging and publishing applications for Windows
        • Publish your app in the Microsoft Store
          • Packaging your app for the Microsoft Store
          • Submitting your app to the Microsoft Store
      • Plasma Mobile
        • KDE on mobile devices
        • Porting a new device to Plasma Mobile
        • KDE Telephony stack
          • General Overview
          • Kernel layer
          • System daemons
            • General overview
            • Developing Telephony functionality
            • ModemManager Telephony functions
          • Session daemons
          • QML declarative plugin layer
          • KDE application layer
        • Execute applications
      • Distributing KDE software as Flatpak
        • Your first Flatpak
        • Extending your package
        • Nightly Flatpaks and Flathub
        • Testing your Flatpak
    • System administration
      • Shell scripting with KDE dialogs
      • Kiosk: Simple configuration management for large deployment
        • Abstract
        • Introduction to Kiosk
        • Kiosk keys
    • Contribute to the documentation
    • About
      • Readme
      • License
        • Creative Commons Attribution-ShareAlike 4.0 International
        • GNU General Public License 3.0 or later
Powered by GitBook
On this page
  • What we have built
  • Contributing to KDE projects
  • Learning more
  • The sky is the limit!
  1. KDE Developer Platform
  2. Getting started
  3. Kirigami

Next steps

What to do after finishing your first simple Kirigami application

PreviousUsing separate filesNextColors and themes in Kirigami

Last updated 8 months ago

What we have built

Over the past few tutorials you have built a basic but functional Kirigami application that lets you add, edit, and delete date countdowns. In doing so we have learned about Kirigami and QtQuick components, some of how QML works, basic application layouts, and more. Not bad at all!

You now have a grasp of the basics that make up many of KDE's most popular applications. You might be asking yourself: what now?

Well, don't worry: we have taken the time to provide some pointers as to where you can go from here.

Contributing to KDE projects

One of the best ways to improve your development skills is by putting them into practice. KDE's community is welcoming and always looking for more passionate developers!

We have several pieces of documentation that can help guide you towards becoming a contributor. We recommend you take a look at the developer-specific section of our which can help you learn more about the KDE Community's development workflow. We also recommend you take a look at our documentation for KDE's GitLab instance, called , as you will likely need to interact with it during the development process. The KDE Community interacts mainly through Matrix, and we also have that will guide you through setting up with your very own account.

Note

While interacting with others in the KDE Community, please make sure you abide by the .

With your newfound skills you are in a good position to begin contributing to Kirigami projects. Thankfully, many of KDE's most popular applications and components are built with this framework. Here are a list of projects you are welcome to help with.

Beginner-friendly Kirigami projects

Project
What it is
Links

A touch friendly calendar application designed for mobile devices.

An image viewer designed for desktop and touch devices.

A color contrast checker that tells you if your color combinations are accessible for people with color vision deficiencies.

An app to help you choose the license to go with your project.

A welcome app for the Plasma desktop that lets you create new pages with QML.

More complex Kirigami projects

Project
What it is
Links

An application that helps you find and install applications, games, and tools.

A music player that strives to be simple and nice to use.

A multi-platform app that allows your devices to communicate (eg: your phone and your computer).

A companion application for conference attendees.

A client for Matrix, the decentralized communication protocol for instant messaging.

Learning more

Not feeling quite ready yet? That's okay too.

Many of the projects listed above are invaluable learning resources. You can poke through the code and see how experienced developers have created fully-featured applications, and use these techniques yourself.

If you feel you need a more gentle approach, we have also compiled some resources we think you might find useful.

The backend and C++

While we have learned a lot about QML, we haven't really touched upon how to handle backend code all that much. This is, however, an essential facet of KDE application development.

C++/Qt with Kirigami

In the advanced section of this Kirigami documentation we have some pages that can help you get started:

Page
Topic

Learn all about CMake and how to compile your applications.

Getting to grips with the central C++ file that handles your application's initialisation.

Add advanced functionality to your Kirigami application and connect it to your UI.

Add an "About Page" to your UI.

Beginner C++ resources

If you are completely new to C++, there are numerous resources available throughout the web. Here are some that may be useful.

Resource
Topic

A comprehensive wikibook with C++ lessons and exercises

A set of C++ tutorials and other resources aimed at beginners

Tutorials to get to grips with C++

A reference site for C++

Creating classic KDE applications using QtWidgets

If you'd like to work on KDE applications such as Dolphin, Kontact, or Kate, you will need to learn how to use QtWidgets, which uses a completely different way of developing user interfaces with Qt. More complex KDE applications or applications that follow a traditional design tend to be built with QtWidgets.

More QML and QtQuick

The Qt project is extensive, and so are QML and QtQuick. There is a lot of functionality we haven't covered, but there is a lot of documentation we can pull from to find out more.

More Kirigami

This documentation includes a lot more about Kirigami. You can poke through some of the Components pages to find out more about some of the QML components that Kirigami provides for you to use.

The sky is the limit!

Don't be intimidated by all the material on here! No one starts off being able to create something like Plasma from scratch. But KDE is no multi-billion dollar company with a high barrier for entry (we have no five-round coding interviews!) and as long as you are nice, you will be welcomed.

Good luck!

Calindori

Koko

Kontrast

Licentia

Plasma Welcome

Discover

Elisa

KDE Connect

Kongress

NeoChat

We also provide a list of continuously updated resources to learn C++ in .

QtWidgets is somewhat more daunting to work with than QML (and much more C++ intensive!). Luckily, we have in the KDE Docs that will help you become more familiar with them.

If you want to look up what specific components do, look no further than

If you are looking for a more guided approach to learning, is a great place to start.

We recommend you also take a look at , an application designed by KDE developers to demonstrate Kirigami's tools and capabilities. It provides both interactive examples of Kirigami components as well as links to the source code of these examples so you can see how they were built.

Development Guide
Invent
a page on the community wiki
Code of Conduct
this wiki page
a set of tutorials
Qt's official QML documentation.
the QMLBook
Kirigami Gallery
KDE Apps page
KDE Invent page
Userbase page
KDE Invent page
KDE Apps page
KDE Invent page
KDE Apps page
KDE Invent page
KDE Invent page
KDE Apps page
KDE Userbase page
KDE Invent page
Home page
KDE Apps page
KDE Community Wiki page
KDE Invent page
Home page
KDE Community Wiki page
KDE Invent page
KDE Invent page
KDE Apps page
KDE Invent page
Understanding CMakeLists
Figuring out main.cpp
Connect logic to your QML user interface
About Page
Wikibooks C++
W3Schools C++
LearnCpp
cppreference