Parch

Application development

Parch GNU/Linux ships two desktop faces: Plasma editions built on Qt6/KDE Frameworks, and GNOME/Hyprland/XFCE editions built on GTK. First-party apps already span both worlds and more, so this section starts from a simple question, which toolkit fits your app, and then walks each path end to end: code, desktop integration, localization, debugging, security, and packaging.

What Parch apps actually look like

The toolchain mapping below comes from the real repositories, not from a style preference. Pick the row that matches your project and read the matching guide.

Real Parch appLanguageToolkitLesson for your project
parch-welcomeRustgtk4-rs + libadwaitaFirst-run assistants, relm4-style structure
PKM (parch-kernel-manager)Python 3.9+GTK4 + libadwaita via PyGObject, VTE4 terminal, pkexec for privileged pacmanGUI plus privileged operations done safely
pastor (Parch Store)RustGTKStore-scale apps, packaging via cargo
gamehub, mirrorman, pordleRustvariousSmall focused utilities in Rust
parchdroid, Parch-Driver-ManagerPythonPyGObjectPython beyond the CLI
plasma-setupC++Qt6 + KF6Native Plasma configuration tools
systunerClightweightMinimal-dependency system tools

The distribution also carries plain command-line tools (parch-update among them) that need no GUI toolkit at all.

Choosing a toolkit

Use this table to narrow the choice in one look.

Your targetLanguage you wantProject sizeRecommended path
GNOME, Hyprland, XFCE editionsPythonsmall to mediumGTK4 + libadwaita via PyGObject
GNOME, Hyprland, XFCE editionsRustmedium to largegtk4-rs + libadwaita
Plasma editionsC++medium to largeQt6 + KDE Frameworks (KF6), CMake + ECM
Plasma editionsPythonsmall to mediumPySide6 or PyQt6, KF6 where needed
Any desktopanyanyFollow the GTK or Qt path, then keep desktop-specific chrome minimal
No GUI, scripting or system toolPython or RustsmallPlain CLI, see the Python and Rust pages

Three realities worth internalizing before you commit:

  1. Match the desktop of your target edition. A Plasma-native tool that imitates libadwaita chrome (or the reverse) reads as foreign. The platform integration page maps the same HIG intent onto both toolkits.
  2. Language follows the precedent, not the reverse. If you are contributing to an existing Parch app, it is Python, Rust, C++, or C already; keep it that way.
  3. A CLI is a legitimate Parch app. System tools with no window are easier to package, easier to localize, and easier to secure.

In this section

Choosing a toolkit

GTK4/libadwaita vs Qt6/KF6 vs TUI vs none: what each gives you natively.

GTK apps in Python

A complete libadwaita app from empty directory to packaged, the PKM way.

Qt and KDE apps

Qt6 + KF6 with CMake/ECM, KConfig, ki18n, and correct package names.

Rust apps

gtk4-rs + libadwaita, Cargo layout, and vendored PKGBUILD builds.

Python apps

CLIs, desktop integration, and packaging rules for Python on Parch.

Desktop integration

Desktop files, icons, portals, notifications, services, Wayland app ids.

Localization

gettext workflow, Persian specifics, and the Persian-at-release rule.

Debugging and profiling

Wayland debugging, GTK inspector, coredumpctl, valgrind, perf.

Security practices

polkit privilege separation, sandboxing, secrets, supply-chain hygiene.

Prerequisites for any path

  • A Parch or Arch-based system with the base-devel group installed: sudo pacman -S --needed base-devel git
  • The toolkit packages listed at the top of each guide.
  • For packaging what you build: the PKGBUILD reference and building packages pages.
  • For how the result should look and behave: the Parch HIG and the design tokens.
  • HIG: window, layout, RTL, and desktop-file rules every app follows.
  • Packaging: getting your app into world and Void.
  • Localization: the distribution-level translation story.
  • Security: the threat model your app is part of.
  • Reference: quick lookups while you code.

Continue in Application Development

Which toolkit should I useGTK4/libadwaita vs Qt6/KDE Frameworks vs terminal UI vs no GUI at all: what each path gives you on Parch and how to decide.GTK apps in PythonBuild a complete GTK4 and libadwaita application in Python, from an empty directory to a running, translatable, packageable app.Qt and KDE appsBuild a native Qt6 and KDE Frameworks 6 application in C++ with CMake and ECM, from an empty directory to an installed Plasma app.Rust appsBuild a GTK4 and libadwaita application in Rust with Cargo, then package it in a PKGBUILD with locked cargo dependencies, the parch-welcome stack.Python appsCommand-line tools and desktop apps in Python on Parch: argparse and rich, pytest, packaging with pacman dependencies and entry points, and the venv rules.Desktop integrationMaking any app feel native: desktop files, icons, MIME, notifications, services.Localization for appsWiring gettext, plural rules, and Persian support into an application.Debugging & profilingFinding out why an app or system misbehaves, on Wayland and off.App security practicesPrivilege separation, sandboxing, secrets, and dependency hygiene for Parch apps.