Skip to content

Welcome to Planet KDE

This is a feed aggregator that collects what the contributors to the KDE community are writing on their respective blogs, in different languages

Thursday, 24 April 2025

Integrate QML Window's Background with the System's Color Palette

As a person who enjoys responsive designs, I like to resize apps and see how quickly the UI updates after the resize. If you're making an app with Qt Quick, you'll sometimes find that, as the window size increases, the UI will lag behind for one or more frames, revealing a white background on two of the window's edges, that usually looks out of place on desktop applications.

Blog_Resizing_Javier_Thumbnail-For-a-Correct-Background-Color-When-Resizing-1

Thumbnail: A window with a white border where there should be a background color.

Why is the color background revealed when the window size is increased?

This issue stems from the fact that Qt Quick windows will render a background color, white by default, before the position of elements is updated by the scene graph, which lags at least one frame behind the resize because it uses a frame buffer. If the default background is white, that means the QML window itself is not aware of your application's theme and that is intentional; after all, only desktop apps need to be aware of the background color used by native applications.

Qt Quick Controls, however, are theme aware, and that may include your platform's theme. This is why, when you make an app for Windows, if you set a Label against the application's default white background, it will look just fine. But when that app is moved to macOS or a Linux distribution with a dark theme, the label's text will be drawn with a light color to match that theme, and that will make it nearly impossible to read against the default white background.

One solution for that issue is to place these components against a control that extends through a large area, such as a Pane. Qt Quick Controls' theme awareness will ensure the right background color is used. However, controls are only drawn within the window, so when the window is resized, its true background color will seep through -- and that's the issue with which we're concerned. The correct solution is to set the window's background to the system's or the theme's background color, which will make the frame buffer's lag far less noticeable during resizing.

How to Make Qt Quick Window Backgrounds Aware of Your System's Theme

Setting a background color is as simple as assigning a value to the "color" property of the window, like so:

Window {
    color: "lightblue"
}

To have it match the background color of native apps, use QML's SystemPallete type, as follows:

import QtQuick
Window {
    color: systemPalette.window
    SystemPalette {
        id: systemPalette
    }
}

Here you can find the various default styles used by Qt Quick for each supported platform. By making use of SystemPalette, the appropriate background color for the current platform will be chosen.

It is important to note that, using SystemPalette, the background color will be chosen based on the current platform and not on which QML style has actually been applied, which may differ if your app makes use of a fixed style for all platforms.

Blog_Resizing_Javier_1-ezgif.com-optimize

Animation of a window resizing, letting the white background seep through a corner.

Blog_Resizing_Javier_2-ezgif.com-optimize

Animation of a window resizing. The background color is consistent with the theme at all times.

Platform Style vs. Fixed Style

As an alternative to following the platform's theme, you could provide a uniform experience for all platforms by enforcing one style for all. There are minor performance advantages to having a fixed style for all systems, but these only tend to matter on low-end embedded hardware, where every cycle counts. There you could use Compile-Time Style Selection, so the QML compiler knows which style is in use and can generate C++ code for bindings.

If you are creating a desktop application, your theming choice should be based, not on performance, but on the level of system integration and the user experience you wish to provide. A photography application might benefit from having a dark mode at all times so the picture colors can pop. An e-mail client, on the other hand, might do better integrating with the system's theme or allowing users to choose between a light theme and a dark theme. Light backgrounds generally provide better contrast, which makes them a good default choice for emails. However, users may prefer the system theme or a dark theme, if it's easier on their eyes.

Blog_Resizing_Javier_Screenshot_20250110_123920

A window from one OS, with a light theme. Its contents can be read just fine.

Blog_Resizing_Javier_Screenshot_20250110_123546

A window from a different OS, with a dark theme. Some of it contents cannot be read due to a lack of contrast.

Crafting Seamless and Theme-Aware Qt Quick Applications

By thoughtfully managing your Qt Quick application's window background color, you can significantly improve its responsiveness and aesthetic integration with the host platform. Whether you opt to align with the system's theme using SystemPalette or enforce a fixed style for uniformity, your choice should reflect the needs of your application and its users. Balancing system integration, performance, and user experience ensures your app not only looks great across platforms but also feels natural to use, providing a polished and professional result. With these tools and insights, you can create dynamic, theme-aware applications that stand out in usability and design.

The post Integrate QML Window's Background with the System's Color Palette appeared first on KDAB.

Wednesday, 23 April 2025

It’s been a bit over a week since the last foss-north conference. This year it really felt like the energy has returned after Covid. We’re back to double tracks and we had almost 200 attendees.

For those of you how don’t know, foss-north is an annual conference held every spring in Gothenburg, Sweden. It is split into a community day, and then two conference days.

The first conference was held back in 2016, to fill the void when fscons changed format. Given that we did two conferences back in 2020 (covid did not go away over the summer…) this was the 11th conference and the 10th year running. This was also the first conference run by the amazing Tobias. It feels good to see the event in his capable hands. He brings a lot of new energy into the organization!

Over the days there were lots of talks – and even a workshop. Carol Chen braved the demo ghosts and ran a hands-on session.

Also, we had cake!

A big thank you goes out to all the speakers, visitors and sponsors. You made this possible! I hope to see you all next year. Tobias has already booked the venue!

Monday, 21 April 2025

This week Plasma developers have descended on the lovely Austrian city of Graz! 🍦

During the 2025 Plasma Sprint in Graz we’ll be discussing a range of topic both for desktop and mobile. Of course there’ll also be a fair amount of hacking. If you are in the area, feel free to stop by at Grazer Linuxtage on Saturday April 26th where we will have a booth!

Hacking aggressively

Sunday, 20 April 2025

Akademy 2025 will be a hybrid event held simultaneously in Berlin, Germany, and Online.

Hundreds of participants from the global KDE community, the wider free and open source software community, local organisations and software companies will gather at this year's Akademy 2025 conference. The event will take place in Berlin and Online from Saturday, 6th September to Thursday, 11th September.

KDE developers, artists, designers, translators, users, writers, sponsors and supporters worldwide will meet face-to-face to discuss key technology issues, explore new ideas and strengthen KDE's innovative and dynamic culture.

Register now and join us for engaging talks, workshops, BoFs and coding sessions. Collaborate with your fellow KDE contributors to fix bugs, pioneer new features and immerse yourself in the world of open source.

For more information about the conference, visit the Akademy 2025 website.

Back in ye olde days there was a running gag that Plasma was all about clocks. With its then-new widget system you could add as many as you wanted, after all. Plasma included not only an analog and a digital clock, there was a binary clock, too, and my all-time favorite fuzzy clock that shows the current time in a colloquial textual way, such as “Quarter to seven”.

KClock main window, a sidebar with Time, Timers, Stopwatch, Alarms, Settings. The main content include an analog and digital clock at 18:45 CEST, a list of cities (Büsingen, Toronto, Adelaide) and the time in those cities.
KClock’s world clock main page

For Plasma Mobile, however, we needed not only a simple clock display but also an alarm clock that could schedule proper system wake ups. Additionally, for travelers a world clock would be nice, and why not have a simple timer and stopwatch as well. That’s KClock, a sexy little Kirigami-based clock app.

While the app that has been a part of KDE Gear since 2023 worked well on any form factor thanks to Kirigami, our convergent UI framework, there were a few desktop-specific features that I was missing and that I now added.

First of all, I created Desktop Actions for the relevant pages in the app. Just right-click its entry in Kickoff or the task bar and select Timer, Stopwatch, or Alarm. You can also type that into KRunner. For this purpose KClock was turned into a “unique application” which means it can only be launched once. This was easy by using KDBusService. It registers a DBus service for the application and when it is launched again, it will just raise the existing instance. By setting SingleMainWindow in its desktop file it tells the shell that it shouldn’t offer to “Open New Window”.

A launcher dock with various apps (Dolphin, Gwenview, Konsole, KWrite, and KClock). KClock entry has a green half-filled progress bar behind it. A context menu emerges from it with various actions, including Timers, Stopwatch, Alarms. Mouse cursor points at Stopwatch.
Jump directly to the feature you need. Also, a timer is running right now!

Alarms and timers are handled by a separate kclockd background process. It uses DBus activation to automatically launch whenever someone calls it. This made it the perfect candidate for a DBus KRunner plug-in. Once registered, typing into KRunner will call the daemon, thereby launching it, and ask for results for a given query. It lets you search for both timers and alarms, and start, stop, and reset them, without opening the main app.

The next logical step of improving the task bar experience is to show a progress bar. Using the Unity Launcher API it gradually fills its task bar entry as a timer progresses. Plasma has always allowed an application to set a number badge on another one. The use case: Akonadi’s mail fetcher agent should be able to set the unread mail count on KMail’s icon even if KMail wasn’t running. Starting from Plasma 6.4 this is now also allowed for progress indications. This way, KClock Daemon can set timer progress on a pinned KClock entry (should you have one), even when its window isn’t open or on a different virtual desktop.

If that wasn’t enough, it will also show a Plasma notification when a timer is running. Using the “resident” notification feature, KClock can keep the notification alive indefinitely and update it every second. The notification allows to pause, resume, reset the timer, or to add another minute. Clicking the popup launches KClock again, to allow further adjustments. From Plasma 6.4 it will be possible to minimize such persistent notifications, just as you can do with a file copy job. By default, this notification appears only when KClock isn’t running, for example when a timer was started through KRunner. However, there’s an option to always or never show the notification.

Notification popup from “Clock”, titled “Blog Test (Paused), 4:33 remaining”. Buttons: “+1 Minute”, “Reset”, “Resume” (the mouse cursor points at it)
Control a timer from notifications (also note the new minimize button!)

Speaking of options, I wired up the standard shortcut for preferences. In case you didn’t know, in most KDE applications you can press Ctrl+Shift+Comma to open its settings window. The search in the “Add New Location” dialog finally searches not only for timezone ID but also country and city name. Type “Canada” and get all the time zones it knows for Canada. The dialog also now indicates which items have already been added to the world clock. Its underlying model has further been optimized to merely update the indicator when adding/removing locations rather than reloading the entire timezone list.

The list of improvements goes on and on. Here’s a few miscellaneous items:

  • Buttons on the stop watch page no longer have a fixed size. This accomodates different translations. They also no longer move when the lap view appears.
  • Spin boxes in edit fields select all text when focused to facilitate typing a new value
  • Many controls gained tooltips or accessibility descriptions, and either get elided or wrap when there isn’t enough room
  • In addition to space for start/stop and return to add a lap, delete and backspace now reset the stopwatch, thereby allowing to fully control it with the keyboard alone
  • It’s now possible to edit a timer after it has been created
  • Restored the analog clock by fixing the Frameworks 6 port to KSvg
A wall with a bunch of analog clocks arranged next to each other, each onewith a neon tube ring of a different color. Above it a banner with the KDE logo and slogal “Be free to have multiple clocks.”
Be free to have multiple clocks. (KDE 4 promo material)

Last but not least, Qt is not just a fantastic graphical user interface toolkit, it is also handy for writing a daemon. It has an easy to use network stack, can talk virtually any IPC protocol, can play audio, and much more. However, because of its UI focus, it loads the platform integration by default. This includes KDE’s integration plug-in, styling, icon themes, etc. KClock Daemon on the other hand doesn’t show any user interface, it merely runs some timers, issues system notifications, and provides KRunner results. It was therefore possible to significantly reduce its RAM consumption by disabling “desktop settings awareness”.

KClock startup time was further reduced by cleaning up DBus communication and loading its pages on demand. On top of that, it now makes use of QML declarative type registration. Rather than registering types manually by calling qmlRegisterType you annotate the relevant classes with QML_ELEMENT. This allows it to introspect the types ahead of time and enables the use of qmlcachegen. This pre-compiles the QML files to byte code, speeding up the application. It also sets up the QML Linter (qmllint) which gave me a bunch of suggestions, of which I implemented many. Finally, I slightly optimized rendering by avoiding overdraw: rather than painting the default gray window color and then drawing the white view rectangle on top, the rectangle was removed and window color changed to white.

I hope you will enjoy having a fantastic clock app for your Plasma desktop now!

I love the Kate Text editor. I use it for pretty much all the programming projects I do. Kate has been around for long time now, about 20 years! At least earliest blog post for it I could find was written in 2004.

I wanted to go over my workflow with it, why I like it so much and hopefully get more people to try it out.

My Kate setup

How I set up my editor

Here's some settings I find important for my workflow. There's tons more settings to fiddle with, but most of the defaults suffice for me very well.

Plugins I use

Here's a list of the plugins I have enabled. Some of them are self-explanatory, some I will go more in detail later.

  • Build & Run
  • Color Picker
  • Colored Brackets
  • Document Preview
  • Docment Switcher
  • External Tools
  • Formatting
  • Git Blame
  • Kate Debugger
  • LSP Client
  • Open Link
  • Project Plugin
  • Search & Replace
  • Snippets
  • Terminal

Move and split views

In Kate, most views are in their own little tabs. You can right click these tabs and select "Own section" which splits them into their own areas. In the screenshot I provided at start, you can see my Projects and Git view being split like this, so they can both be open at the same time.

Context menu for splitting panels

Do note that these are saved per session, so sessions can have different splits.

Language server

In LSP Client settings, you can toggle multiple things I won't go into detail in here. What I do want to mention is the User Server Settings file, which can be edited from this menu. To override some defaults, you can just copy the default setting from the default tab, put it in your own settings tab and then just change the values.

Here's my LSP settings: dotfiles/kate/lspclient/settings.json

Debug adapters

Debugger settings work similarly to LSP setting, however you may have to restart Kate to recognize any new changes.

Here's my DAP settings: dotfiles/kate/debugger/dap.json

Formatters

For code formatting, there's also it's own setting menu, however as of writing this only the languages mentioned in default settings are supported.

If you want to tell formatter to stop autoformatting, you can set it like this, using clang-formatter as example:

{
  "clang-format": {
    "command": [
      "clang-format"
    ],
    "formatModifiedLinesOnly": true,
    "formatOnSave": false
  }
}

Here's my formatting settings: dotfiles/kate/formatting/settings.json

Shortcuts

Shortcuts are very personal thing and I encourage learning the defaults if at all possible. I have changed mine around a bit, for example Ctrl+Shift+Space for Quick Open and Ctrl+Space for Find action. More of these two later!

Path setting

Kate can't always find language servers for example, if it can't resolve your path. Use this path setting to load binaries from paths like ~/.local/bin. You can find this under Behavior settings at least on Kate 25.04.

Sessions

Sessions are basically group of projects. Do not treat sessions as projects themselves, that will only cause sadness.

I have separated my Work and Personal projects in their own sessions. This means that during work day, I can right click the Kate icon, select Work session, and then Kate will always open for me in that session until I choose Personal session.

In session settings I have set Kate to always open the last used session because of this.

I highly recommend this way of working. You could also have sessions for differently themed projects: Gamedev, web, etc..

Just make sure to create at least one session when starting out, then you can use that as a template for the other sessions in Kate session manager.

When I used to write more notes with Kate, I had it's own Notes session with both my Notes folder as a project folder and my blog.

Colorschemes

Kate uses KColorScheme library for it's colorscheme needs. You can very easily to copy a ready colorscheme and then start modifying your own changes on top of it.

You can also create a completely new colorscheme if you wish, like I have done here: Revontuli/Kate

The colorscheme files in the library are their own XML format which is not ideal IMO but it gets the job done. It would be awesome if Kate supported tree-sitter but so far I haven't heard anyone trying to implement that.

File quick switching

I mentioned this earlier in shortcuts section. If you're like me and have multiple projects open, you can use the Quick switcher and start typing the filename you need to open.

Quickswitcher being used

If you just want to open a specific project, you can type project bla and it will find that project for you from your project list.

This is why I have it bound to Ctrl+Shift+Space, so I can just press it and quickly find the file I need.

This is more interesting: Instead of searching for files, you can search for any action Kate has.

For example, if you want to look for terminal related actions, you can type "Terminal" and it lists everything plus any potential shortcuts.

Action search being used

Fun fact, you can use this in other KDE apps too, like Dolphin or Konsole! The default key combination for it is ctrl+alt+i but I use it so frequently I set it to ctrl+space.

Build and Run

The name of this plugin is a bit misleading IMO because it can do so much more than just build.

Build and run view

In essence, it's a command runner. You can give the command a name, then build command and run command.

For example in the above image, my game project has only one command called build which has build command odin build ./src -collection:src=src -debug -out:./build/ArtificialRage and run command odin run ./src -collection:src=src -debug -out:./build/ArtificialRage.

I can then just use the action search to build and run my game project.

For your projects, you can then add file called .kateproject.build in your project root folder, so Kate will pick that up. They're just JSON files that look like this:

{
    "target_sets": [
        {
            "cmake_config": "",
            "directory": "/home/akseli/Repositories/artificial-rage/",
            "loaded_via_cmake": false,
            "name": "artificial-rage",
            "targets": [
                {
                    "build_cmd": "odin build ./src -collection:src=src -debug -out:./build/ArtificialRage",
                    "name": "build",
                    "run_cmd": "odin run ./src -collection:src=src -debug -out:./build/ArtificialRage"
                }
            ]
        }
    ]
}

The .kateproject files can store much more information about the project, but they are not very user facing yet sadly. Something on my eternal to-do list.

Also when running the commands, there's "Output" tab that shows the results. It's basically view to your terminal, but if you encounter an error or warning, and the output panel can parse the file and location from it, you can click that item and it will open code at that position where the error/warning appeared.

Language server

As I mentioned above in the settings, Kate does have support for Language Server Protocol, as long as they're found from the path Kate looks for them and are configured properly. It's very much the same support one would expect in any modern editor.

One thing I do use a bunch thanks to it is looking for references to specific symbol, searching symbols across all my open projects and symbol overview.

Debugger

Kate has support for Debug Adapter Protocol, which is the lesser known cousin of Language Server Protocol.

This allows you to debug applications visually with breakpoints, check the stacktrace by using Locals and stack panel, and so on.

As long as the configuration is correct, debug adapter is found in path, and the executable, working directory, etc are given to Kate correctly, it can debug things rather well. The debugger plugin has undergone bunch of polish lately so it's rather good for my use, especially with my game projects.

Debugging my game

For bigger things like debugging whole Plasma desktop, I still use gdb in terminal.

Terminal

Speaking of terminal, the terminal is just Konsole running inside it's own view. The terminal can be made to follow the folder of the file you're editing, and it will share the settings with Konsole. You can also split the terminal from Kate if you need more views. Terminal tabs also work.

So it's essentially just Konsole embedded in Kate.

Git integration

The git integration in Kate is simple-but-works. You can diff, stage and discard lines/hunks directly from the editor (I use this a lot).

Git diffing

Then of course, you can stage and unstage, commit, push, pull etc. directly from Kate. As of writing this, you can't rebase yet, but for more complex tasks I tend to often use something like lazygit, which I highly recommend.

Git staging

All of this has inline git blame, so you can see per line who did what and where. This is very handy in projects with multiple devs.

Snippets

Kate has a snippet plugin that allows one to create simple or super complex snippets, for example for boilerplate.

Snippets tool

Here's example for my blog header snippet (don't mind the bad JS I wrote it very tired)

The snippet text, that will be pasted into a markdown file:

+++
title = "${title}"
date = ${justDate()}
aliases = ["/${dateUrl()}/${lowerFilename()}.html"]
[taxonomies]
tags = ["${tag}",]
+++

My ugly javascript mess for creating dynamic items:

function fileName() { return document.fileName(); }
function fileUrl() { return document.url(); }
function encoding() { return document.encoding(); }
function selection() { return view.selectedText(); }
function year() { return new Date().getFullYear(); }
function upper(x) { return x.toUpperCase(); }
function lower(x) { return x.toLowerCase(); }
function today() { 
    var date = new Date();
    return formatDate(date);
}
    
function padTo2Digits(num) {
  return num.toString().padStart(2, '0');
}

function getDateName(date){
    var names = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
    return names[date.getDay()];
}

// 2024-06-13 Thu 10:00
function formatDate(date) {
    var dateString =     [
      date.getFullYear(),
      padTo2Digits(date.getMonth() + 1),
      padTo2Digits(date.getDate()),
    ].join('-');
    
    var dayName = getDateName(date);
    
    var time =     [
      padTo2Digits(date.getHours()),
      padTo2Digits(date.getMinutes())
    ].join(':');
    
    var timeString = dateString + " " + dayName + " " + time;
  return timeString;
}

function justDate() {
    var date = new Date();
    var dateString =     [
      date.getFullYear(),
      padTo2Digits(date.getMonth() + 1),
      padTo2Digits(date.getDate()),
    ].join('-');
    return dateString;
}

function dateUrl() {
    var date = new Date();
    var dateString =     [
      date.getFullYear(),
      padTo2Digits(date.getMonth() + 1),
      padTo2Digits(date.getDate()),
    ].join('/');
    return dateString;
}

function lowerFilename() {
	return lower(fileName());
}

So yes, you can write Javascript to generate snippets for you, like here I've done with date and time, filename, etc.. It's super useful.

You can then use code-completion shortcut and type snippet-namespace:snippet-name and press enter, and it will run the snippet for you. You can make the snippets only appear for files in specific language.

It's a very very powerful tool for generating simple boilerplate code. Requires some upfront work but after that's done, it works wonders.

Here's also some of my markdown snippets: dotfiles/kate/Markdown Snippets.xml

But why do I love it so

Kate has basically all the features I need, out of the box, without having to download random extensions or plugins. Sometimes I just have to enable plugins, maybe write and change some configurations.. But when that's done, it's all just there and I can start using it.

I tend to back up my configs to my dotfiles git, so I can just in subsequent installs use them immediately.

Hang on, VSCode has all of this and more!

You're right, VSCode has a lot of these things too. However with VSCode I've noticed that you have to sometimes download whole language as an extension. Then, the extensions may clash with each other, especially if you have two extensions that do different things for the same thing: I remember having two CMake extensions where both had something I needed, but they both also overlap in some basic features, so it got very confusing.

That's probably all skill-issue of course. But I like that I don't have to download any extensions or plugins or whatever.. I can just import my settings and start working.

VSCode being electron and Microsoft doesn't really help my feelings either, especially since some of their extensions like C# and Python are proprietary, and they're working on more extensions to be like that:

So yeah, I rather use something like Kate that I know will be around for long time and won't turn into proprietary mush, nor try to tell me to use their newest "AI" slop tools.

Kate is very much the embodiment of KDE tagline: Simple by Default, Powerful when Needed. It does all I need and allows me to modify it as I need.

I've contributed to Kate bunch of times, and every time it has been nice. The maintainers of Kate are very lovely patient people who deal with my nonsense. :)

And that's why I love it so much: The people around it, the out of the box experience, the simplicity yet powerfulness..! ❤️

Give Kate a try today! :)

If you have any issues with it, report them on bugs.kde.org. You can also send wishlist items there. There is also wishlist of things on KDE Discuss, feel free to chat there about it or ask for help in general.

PS. For the modal text editor lovers, Kate does have Vi mode. I use it from time to time, but I prefer Kate as it is to be honest. For my terminal/modal editing needs I use Helix editor, but most of the time I'm using Kate.

Saturday, 19 April 2025

Welcome to a new issue of "This Week in Plasma"! Every week we cover the highlights of what's happening in the world of KDE Plasma and its associated apps like Discover, System Monitor, and more.

This was a busy week, with tons of new features, improvements, and bug fixes! Hopefully everyone will find something to like here:

Notable new Features

Plasma 6.4.0

System Monitor's Applications page now groups background services into a new "Background Services" item so you can see at a glance how the non-application parts of the system are using resources as well without having to switch pages. (Arjen Hiemstra, link 1 and link 2)

System Monitor window showing resources usage of apps and a "background Services" item

The Bluetooth widget now lets you configure it to display a badge with the number of connected devices. (Nate Graham, link 1, link 2, and link 3)

Bluetooth widget with "1" badge showing that many connected items, with a popup showing a menu item to enable or disable this feature

Frameworks 6.14

KRunner is now aware of some archaic units like furlongs and rods, so you can convert them to more modern units. (Nate Graham, link)

KRunner showing a conversion from rods to furlongs

Notable UI Improvements

Plasma 6.3.5

When adding a new printer, you now immediately have the option to set it as the default printer even if it's the only one added so far. This supports the use case where you're about to add another printer but want the first one to be the default. (Mike Noe, link)

Plasma 6.4.0

System Settings' Drawing Tablet page now shows a visualization of your stylus and its buttons so that it's easier for you to see how to configure it. (Joshua Goins, link)

System Settings' Drawing Tablet page now makes it easier to recover from mis-calibrating your tablet: now there's an auto-revert timer you need to explicitly dismiss, and a more prominent "reset" button if needed. (Joshua Goins, link)

System Settings' Recent Files page now uses standard grid item styling. (Nate Graham, link 1 and link 2)

Info Center now displays page load errors in a more humane way. (Nate Graham, link)

When you use the Task Manager's setting to make apps demanding attention not force an auto-hide panel to be visible, the config dialog will now show a message asking you to see if the app itself has an option to disable this behavior. Telegram Desktop does! (Nate Graham, link)



The portal-based open/save dialogs are now modal with their parent windows, just like non-portal versions already are. (Kai Uwe Broulik, link)

Discover, Info Center, and DrKonqi now respect your configured monospace font for their views that use monospaced text, rather than just using a fixed monospace font. (Noah Davis, link 1, link 2, link 3, link 4, and link 5)

Any password already typed into the login screen's password field is now cleared when switching users. (Nate Graham, link)

Opening a Plasma Vault now opens it in a new tab in Dolphin if it's not an activity-specific Vault in a multi-activity environment. In that case, a Dolphin window in another activity could get activated, which would close it immediately. (Nate Graham, link)

Frameworks 6.14

The common Kirigami.FormLayout component that's used throughout System Settings and many apps now has a more visually pleasing style when there's not enough horizontal space to display everything in its normal mode: now when it switches to narrow mode, the content column is centered and its width capped. This looks much better when the view is very wide, which is common especially in System Settings with using the system in a language other than English or Chinese. (Nate Graham, link)

System Settings Quick Settings window in German, showing narrow layout

Scrollable views throughout QML-based KDE software now play nice animations for horizontal mouse wheel scrolling too, not just vertical mouse wheel scrolling. (Noah Davis, link)

Notable Bug Fixes

Plasma 6.3.5

Fixed a KWin crash caused by GPU resets. (Xaver Hugl, link)

Fixed a regression accidentally introduced in Plasma 6.3.4 whereby the Activity Switcher sidebar would be mis-positioned on multi-screen setups. (Niccolò Venerandi, link 1 and link 2)

The Meta+P shortcut to open the screen chooser overlay now works when you're using Qt 6.8.3 or 6.9.0, which changed a few DBus things and broke it. (Kai Uwe Broulik, link)

The grid items on System Settings' Recent Files page no longer inappropriately highlight when the whole grid view is disabled. (Nate Graham, link)

When using reversed mode on a Task Manager widget on a vertical panel, the group dialog popups are no longer inappropriately rotated 180°. (Nate Graham, Link)

In Discover, Header text for offline upgrades is now displayed correctly at very narrow window widths. (Nate Graham, link)

Plasma 6.4.0

Dragging items on the Kickoff Application Launcher's Favorites grid to re-arrange them no longer sometimes launches them afterwards. (Noah Davis, link)

On Wayland, screen mirroring is now aware of differences in mirrored screens' aspect ratios, and letterboxes the screen content as needed. (Xaver Hugl, link)

The clipboard popup that appears when you press Meta+V no longer sometimes appears on the wrong screen on X11. (Fushan Wen, link)

The Plasma Desktop no longer shows the wrong context menu if you right-click very very rapidly after a left-click, or while holding down the left mouse button. (Nate Graham, link)

Fixed a case where a warning message on System Settings' Drawing Tablet page could overflow off the page. (Joshua Goins, link)

The Digital Clock widget's config dialog no longer inappropriately asks you to confirm or discard changed setting when you navigate away after enabling and and then disabling a calendar plugin, or vice versa. (Christoph Wolk, link)

On Wayland, the Task Switcher preview visualizations no longer open in the wrong location on the screen. (Ismael Asensio, link)

If you've enable notification popups for KWin alerts about apps hanging, their text is now displayed correctly. (Roke Julian Lockhart Beedell, link)

Frameworks 6.14

Fixed a regression I accidentally introduced in Frameworks 6.13 that made the Telegram Desktop app show a symbolic icon rather than a colorful one on the Task Manager for panels that are 38 pixels thick or less. (Leandro Guedes and Nate Graham, link 1 and link 2)

Titles of System Settings pages are once again pixel-perfect identical no matter if the pages are implemented using QtQuick or QtWidgets. (Ismael Asensio, link)

Fixed an issue affecting every scrollable view in QML-based KDE software that made it fail to play scroll animations when using certain non-default mouse wheel scroll speeds. (Noah Davis, link)

Fixed an issue in the built-in KRDP remote desktop server that caused scrolling to trigger the default top-left hotcorner effect when connecting using the "xfreerdp" app. (Jack Xu, link)

Other bug information of note:

Notable in Performance & Technical

Plasma 6.4.0

Implemented support for the "Single-pixel buffer" Wayland protocol, which improves efficiency for apps that use it. (Xaver Hugl, link)

The code that checks for screen rotation is now disabled while the screen is off, saving some energy especially for mobile devices. (Bhushan Shah, link)

Frameworks 6.14

KWallet is now just a wrapper around the cross-desktop "Secret Service" system, plus a thin compatibility layer for apps that haven't migrated to use Secret Service directly. Read more about this here! (Marco Martin, link)

How You Can Help

KDE has become important in the world, and your time and contributions have helped us get there. As we grow, we need your support to keep KDE sustainable.

You can help KDE by becoming an active community member and getting involved somehow. Each contributor makes a huge difference in KDE — you are not a number or a cog in a machine!

You don’t have to be a programmer, either. Many other opportunities exist:

You can also help us by making a donation! Any monetary contribution — however small — will help us cover operational costs, salaries, travel expenses for contributors, and in general just keep KDE bringing Free Software to the world.

To get a new Plasma feature or a bugfix mentioned here, feel free to push a commit to the relevant merge request on invent.kde.org.

Friday, 18 April 2025

This release includes new features and fixes for AdBlock, VerticalTabs, stability fixes, more usability features and translation updates.

General changes

  • Add input method hints to main input fields (url, search bar, etc.).
    • This allows on-screen keyboards to show more appropriate symbols or disable the auto correct feature.
  • Show the URL of bookmark and history items in statusbar when hovered over in the menu or sidebar (BUG: 448238)
  • Open all URLs in command line arguments (BUG: 413195), (Original author: abogical (Abdel-Rahman Abdel-Rahman))
  • Add “Preffer color scheme” option (BUG: 439891), (BUG: 497331)
  • Add option to add site permissions in preferences (BUG: 495391)
  • VerticalTabs: Override Alt+NUMBER keyboard shortcut
  • StatusBarIcon-Network: Restore online status detection
  • KDEIntegration: Fix KIO scheme handler (BUG: 491247)
  • Add option to block automatic popups
  • Qt 6.9 compatibility fixes

AdBlock

  • Add support for “rewrite” filter
  • Add support for remove rule with simple CSS selector
  • Ignore inactive hiding rules
  • Add support for “websocket” option
  • Rewrite Adblock Dialog (fixes crashes)
AdBlock dialog, Left: old version, Right: New version

Changelog

  • PyFalkon: port away from deprecated API (by Ilya K)
  • PyFalkon: Disable broken tests (by Juraj Oravec)
  • Update CHANGELOG for 25.04.0 release (by Juraj Oravec)
  • Fix crash when loading folder in bookmarks toolbar (by Juraj Oravec)
  • CI Flatpak - Add desktop notifications permission (by Justin Zobel)
  • CI Flatpak - Add kwallet6 dbus permission (by Justin Zobel)
  • CI Flatpak - Sort finish arguments (by Justin Zobel)
  • CI Flatpak - Update flatpak runtime (by Justin Zobel)
  • snapcraft: Fix crash by disabling webengine sandbox, we are already a (by Scarlett Moore)
  • CI: Add linux-qt6-next build (by Albert Astals Cid)
  • Add input method hints to input fields (by Juraj Oravec)
  • Select newly opened tabs from links and scripts (by Juraj Oravec)
  • Fix SiteSettings autotest (by Juraj Oravec)
  • Adblock: Add support for “rewrite” filter (by Juraj Oravec)
  • AdblockDialog: Add model for the tree view (by Juraj Oravec)
  • Adblock: Add support for remove rule (by Juraj Oravec)
  • Show history & bookmark url in menu on mouse hover (by Juraj Oravec)
  • Block automatic popups (by Juraj Oravec)
  • Use global settings for WebRTC on internal pages (by Juraj Oravec)
  • VerticalTabs Override Alt+NUMBER keyboard shortcut (by Juraj Oravec)
  • AdBlock: Ignore inactive hiding rules (by Juraj Oravec)
  • Adblock: Add support for “websocket” option (by Juraj Oravec)
  • AdblockDialog: Apply filter when tab changes (by Juraj Oravec)
  • SiteSettingsDialog: Add context description for “Set” button (by Juraj Oravec)
  • SBI-NetworkIcon - Restore online status detection (by Juraj Oravec)
  • Open all URLs in command line arguments (by Juraj Oravec)
  • Remove obsolete XSS Auditing option, has no effect (by Juraj Oravec)
  • CookieManager: Fix crash when removing while/black list items (by Juraj Oravec)
  • PyFalkon: Add missing Qz::ColorScheme enum type (by Juraj Oravec)
  • Add “Preffer color scheme” option (by Juraj Oravec)
  • Strip incorrect color iCCP profile from png images (by Juraj Oravec)
  • Preferences: Fix editing per site user agent (by Juraj Oravec)
  • Use angle backend for GPU acceleration on Qt 6.9+ (by Juraj Oravec)
  • Add missing default SiteSettings for intenal pages (by Juraj Oravec)
  • Add option to add site permissions in preferences (by Juraj Oravec)
  • PyFalkon: Remove warning about QCborStreamReader (by Juraj Oravec)
  • Update Changelog (by Juraj Oravec)
  • Port away from QLocale:Country related code (by Juraj Oravec)
  • B KIO scheme handler (by Juraj Oravec)
  • Add missing settings.endGroup() when needed (by Juraj Oravec)

Let’s go for my web review for the week 2025-16. This is a long one, I have a treasure trove of more than a thousand old links I’ve been sitting on and I’m starting to push a few of the oldies but goodies.


The Post-Developer Era

Tags: tech, ai, machine-learning, gpt, copilot, business, hiring

This matches what I see. For some tasks these can be helpful tools, but it definitely need a strong hand to steer them in the right direction and to know when to not use them. If you’re a junior you’d better invest in the craft rather than such tools. If you got experience, use with care and keep the ethical conundrum in mind.

https://www.joshwcomeau.com/blog/the-post-developer-era/


You cannot have our user’s data

Tags: tech, ai, machine-learning, gpt, copilot, copyright, criticism

Sourcehut pulled the trigger on their crawler deterrent. Good move, good explanations of the reasons too.

https://sourcehut.org/blog/2025-04-15-you-cannot-have-our-users-data/


Company apologizes after AI support agent invents policy that causes user uproar

Tags: tech, ai, machine-learning, gpt, business, funny

I willadmit it… I laughed. And that’s just one business risk among many.

https://arstechnica.com/ai/2025/04/cursor-ai-support-bot-invents-fake-policy-and-triggers-user-uproar/


Elon Musk’s xAI allegedly uses ‘illegal’ generators to power Colossus supercomputer facility

Tags: tech, ai, machine-learning, gpt, twitter, ecology, economics

I hope people using Grok enjoy their queries… Because they come with direct environmental and health consequences.

https://www.tomshardware.com/tech-industry/artificial-intelligence/elon-musks-xai-allegedly-powers-colossus-supercomputer-facility-using-illegal-generators


Why the climate promises of AI sound a lot like carbon offsets

Tags: tech, ai, machine-learning, gpt, ecology, economics, politics

Don’t confuse scenarios for predictions… Big climate improvements due to AI tomorrow after accepting lots of emissions today is just a belief. There’s nothing to back up it would really happen.

https://www.technologyreview.com/2025/04/10/1114912/why-the-climate-promises-of-ai-sound-a-lot-like-carbon-offsets/


These are not the same

Tags: tech, ai, machine-learning, gpt, copilot, surveillance, politics, economics

This is a question which I have been pondering for a while… what will be left when the generative AI bursts. And indeed it won’t be the models as they won’t age well. The conclusion of this article got a chill running down my spine. It’s indeed likely that the conclusion will be infrastructure for a bigger surveillance apparatus.

https://tante.cc/2025/04/15/these-are-not-the-same/


LAPD Publishes Crime Footage It Got From a Waymo Driverless Car

Tags: tech, automotive, surveillance

You like having surveillance camera roaming around town? Well, you’re covered…

https://www.404media.co/lapd-publishes-crime-footage-it-got-from-a-waymo-driverless-car/


Silicon Valley crosswalk buttons apparently hacked to imitate Musk, Zuckerberg voices

Tags: tech, hacking, politics, funny

This is definitely a funny hack. I wonder how long the people behind this knew about the vulnerability and waited for the right opportunity to do something with it.

https://www.paloaltoonline.com/technology/2025/04/12/silicon-valley-crosswalk-buttons-apparently-hacked-to-imitate-musk-zuckerberg-voices/


CVE Foundation

Tags: tech, security, politics

Maybe something good will come out of the political turmoil around the CVE Program. This would be nice to see it more independent indeed.

https://www.thecvefoundation.org/home


HTTP headers for the responsible developer

Tags: tech, http

A good tour of the important HTTP headers.

https://www.twilio.com/en-us/blog/a-http-headers-for-the-responsible-developer


Common shell script mistakes

Tags: tech, shell, scripting

Writing shell scripts is still a craft. Interesting traps are presented here. Also, now better have shellcheck around for any non trivial script.

https://www.pixelbeat.org/programming/shell_script_mistakes.html


When Life Gives You Java

Tags: tech, programming, java

A few interesting tricks to apply to Java code. Some I already did, but the proposed model for algebraic data types I might add to my bag of tricks.

https://oblac.rs/2025-04-15-when-life-gives-you-java/


An Introduction to Modern CMake

Tags: tech, buildsystems, cmake

Looks like a nice resource for CMake. The documentation for it isn’t always great especially for beginners, hopefully it should fill that gap.

https://cliutils.gitlab.io/modern-cmake/README.html


C++20 idioms for parameter packs

Tags: tech, programming, c++, metaprogramming

The language keeps evolving, this is a good reminder that some old idiom can be let go. Parameter packs still need some adjustments to become nicer though.

https://www.scs.stanford.edu/~dm/blog/param-pack.html


Raw loops for performance?

Tags: tech, c++, performance, maintenance, optimization

Nice little comparison of raw loops and ranges in C++. As always, measure before making assumptions… Unsurprisingly it ends up on the usual readability vs performance debate.

https://www.sandordargo.com/blog/2025/04/16/raw-loops-for-performance


The Salami Method

Tags: tech, c++, portability, architecture

Interesting architectural proposal for highly portable C++ based libraries.

http://videocortex.io/2017/salami-method/


Avoiding memory fragmentation in Rust with jemalloc

Tags: tech, system, memory, rust, c

If you forgot that the memory allocator can matter greatly depending on your workload.

https://kerkour.com/rust-jemalloc


Atomicless Concurrency

Tags: tech, cpu, hardware, multithreading

Nice trick for highly performance sensitive data structures. Making data CPU local instead of thread local you can make a mechanism which is especially cache friendly.

https://mcyoung.xyz/2023/03/29/rseq-checkout/


Performance Analysis and Tuning on Modern CPUs

Tags: tech, performance, optimization, book

Looks like a nice resource to get better at finding the root cause of performance regressions and optimising code.

https://products.easyperf.net/perf-book-2


Ramblings from Jessie: Setting the Record Straight: containers vs. Zones vs. Jails vs. VMs

Tags: tech, containers, linux, virtualization, security

A bit of a rant, but since it looks like people are still trying to consider all those technologies are equivalent… I think it’s good to have an explanation on what makes containers different.

https://blog.jessfraz.com/post/containers-zones-jails-vms/


Reflections on Unikernels

Tags: tech, kernel, system

They keep being fascinating to me. Nice reflections showing how they can impact regular systems as well. I wonder why OCaml seems to be so prevalent in that space though.

https://dave.recoil.org/unikernels/


Datastar - The hypermedia framework.

Tags: tech, web, frontend, htmx

Looks like an interesting alternative to HTMX to come. Might go further enough that it has the potential to displace things like React as well.

https://data-star.dev/


Bilinear interpolation on a quadrilateral using Barycentric coordinates

Tags: tech, graphics, gpu, shader, 3d, mathematics

Wow, very smart approach to solve discontinuity issues when quads are turned into triangles.

https://gpuopen.com/learn/bilinear-interpolation-quadrilateral-barycentric-coordinates/


Shadertoys ported to Rust GPU

Tags: tech, 3d, shader, graphics, rust

Interesting stuff. This should ease greatly sharing code between shaders and the host application, especially for data specification which is easy to get wrong.

https://rust-gpu.github.io/blog/2025/04/10/shadertoys/


WebGL + Rust: Basic Water Tutorial

Tags: tech, 3d, graphics, rust, web

Nice tutorial for rendering water. It gets more complex from there but this one is doing quite a lot already.

https://chinedufn.com/3d-webgl-basic-water-tutorial/


A flowing WebGL gradient, deconstructed

Tags: tech, graphics, shader

Very nice deep dive into the reasoning behind a wavy gradient effect. It shows the best effect have several layers of refinements and tricks. Each trick is explained separately nicely, this is a good read.

https://alexharri.com/blog/webgl-gradients


Don’t Compare Averages

Tags: tech, data, data-visualization

Just looking at averages is indeed quickly hiding patterns. Make sure distributions are visible in some fashion.

https://martinfowler.com/articles/dont-compare-averages.html


4 psychology principles every UX/UI designer should know

Tags: tech, ux, cognition

Important principles to have in mind for proper UX/UI designs. There are more of course, those are the bare minimum though.

https://uxdesign.cc/4-psychology-principles-every-ux-ui-designer-should-know-89876d3bb356


Why do AI company logos look like buttholes?

Tags: tech, design, marketing

It’s meant to be humorous, but this says something interesting about how design and marketing evolves.

https://velvetshark.com/ai-company-logos-that-look-like-buttholes


Software development topics I’ve changed my mind on after 10 years in the industry

Tags: tech, programming, craftsmanship

A list of opinions on our field. It’s personal and biased of course, so make that you want out of it. I agree with most I’d say. A couple are rather niche though.

https://chriskiehl.com/article/thoughts-after-10-years


Code As Documentation

Tags: tech, programming, engineering, documentation, codereview

A bit of a self-serving post towards the end. Still I like it because it clearly mention that it’s not about dropping all documentation in favor of the code (quite the contrary in fact, documentation is very much needed). It really is about treating code like documentation, putting the same care into it in terms of readability and understandability. If you wonder what code reviews are for… it’s also for this readability concern.

https://martinfowler.com/bliki/CodeAsDocumentation.html


Retrospective technique: “Retro Wedding”

Tags: tech, agile, retrospective

Interesting alternative retrospective format. The way of framing the questions might help get new ideas.

https://scalablenotions.wordpress.com/2014/05/15/retrospective-technique-retro-wedding/


Is your team cross-functional enough?

Tags: tech, team, management

Nice little exercise to quickly figure out if the skillset of a team properly matches their project.

https://blog.crisp.se/2009/02/27/henrikkniberg/1235769840000


Thoughts: XP Revisited

Tags: tech, agile, xp

A look back at XP practices with some interesting insights. This doubles as a good XP primer as well.

https://ronjeffries.com/articles/018-01ff/xp-revisited-1/


How to use Event Storming to introduce Domain Driven Design

Tags: tech, ddd, xp, architecture

Looks like a good set of tips of get more DDD practices in place without the badly understood vocabulary which usually comes with it.

https://philippe.bourgau.net/how-to-use-event-storming-to-introduce-domain-driven-design/


Starting Out - What works, how fast, and why?

Tags: tech, agile, coaching

How to get started with putting in place an Agile approach in a team? Clearly structure helps in the beginning. One caveat of the article though: don’t read this as having to respect a book to the letter forever, it’s merely a starting point.

https://ronjeffries.com/articles/017-08ff/starting-out/


The Agile Fluency Model

Tags: tech, agile

This model is probably still a better one than certifications or very heavy processes. Far from perfect of course, but at least it gives a compass to teams to see if they’re going in the right direction.

https://martinfowler.com/articles/agileFluency.html


Are You Running from Problems or Solving Them?

Tags: tech, project-management, management, problem-solving, decision-making

If you spend your time in dull meetings and then run like a headless chicken… it’s definitely a sign you should cut down on the meetings and keep only the ones focusing on solving actual problems.

https://www.jrothman.com/mpd/management/2014/05/are-you-running-from-problems-or-solving-them/


The dark side of the Moomins

Tags: culture, history

Are we sure the Moomins are really a cute tale? I always felt them slightly off, but indeed it goes much darker than I suspected.

https://www.newstatesman.com/culture/books/2025/04/dark-side-of-the-moomins-tove-jansson



Bye for now!

Since the 24.12 KDE Gear release we are shipping the client-side push notification infrastructure for applications such as NeoChat and Tokodon. For 25.08 this is receiving a major update to catch up with the evolving underlying specifications and standards.

Push Notifications

There is an older post describing this in more detail, but as a quick recap the following are the relevant components in a push notification system:

  • The end-user application (also “user agent”, “client”): This is the part of the application running on a user’s device and is the thing you generally interact with, e.g. a Mastondon or Matrix client.
  • The application server: The server-side part of the application that might want to notify its client about an important event, even if is that is not currently running. E.g. a Mastodon or Matrix server.
  • The push server: The server-side part of the push infrastructure. It’s what the application server sends its notification to, and it knows how to forward that to a client device.
  • The push distributor: The part of the push infrastructure running on the user’s device. It’s usually a background service with a continuous network connection to the push server and when receiving a notification it launches the corresponding application.

UnifiedPush specifies the interfaces between the application and the push infrastructure parts, and that’s what KDE’s push notification implementation is built upon.

The UnifiedPush specification has evolved since we started this, mainly to achieve compatibility with the Web Push standard (RFC 8030). That’s good as it gives us Web Push’s security features and allows us to use existing Web Push infrastructure. It also simplifies application development as there’s one less standard to worry about.

What this means for our implementation and for applications using our client library is listed below.

KUnifiedPush changes

New UnifedPush D-Bus specification

The new D-Bus interface specified by UnifiedPush mainly aims at making future changes easier in a backward compatible way but doesn’t change things conceptually. This allows us to make this fully transparent to applications, as this only affects the communication between the KUnifiedPush client library and the distributor.

Even better, both the client library and our distributor support both versions of the D-Bus interface, so old clients not using our client library will work with the latest version of our distributor, and so will applications using the latest version of KUnifiedPush when facing an old distributor.

Message encryption

An important addition is a standardized way for doing message encryption (RFC 8291), avoiding that applications had to come up with their own way of doing this, or worse, not using message encryption at all.

The KUnifiedPush client library supports this by generating, persisting and providing the necessary keys as well as by taking care of decrypting incoming messages accordingly.

There’s an example use here.

Implementing message encryption also exposed a small compatibility issue with the ntfy push server in some configurations, a fix for this is awaiting review upstream.

Voluntary Application Server Identification (VAPID) support

VAPID (RFC 8292) provides a mechanism to ensure that only the application server itself is sending push notifications to a client, not somebody else who happens to know the push endpoint.

Most of this happens between the application server and the push server, on the client we only have to do one thing: Pass the VAPID public key from the application server to the distributor.

In KUnifiedPush that’s done with a call to Connector::setVapidPublicKey, before calling Connector::registerClient. As the latter constraint can be somewhat cumbersome to ensure when the VAPID key first has to be retrieved from the application server, there’s an additional convenience method, Connector::setVapidPublicKeyRequired. If VAPID is set to required registering for push notification is internally delayed until the key is provided, making integration into existing code usually pretty straightforward.

You’ll find an example use here.

Message urgency

Another feature brought by Web Push is message urgency (RFC 8030 §5.3). The idea here is that a device can reduce the amount of received messages based on their urgency when energy or network resources are limited. So you’d get fewer wakeups when on mobile network with a low battery than when on Wi-Fi and connected to a charger.

This has no impact on the client side. On the distributor side we determine the current urgency threshold and communicate to the push servers in their respective protocols.

For now this is a rather theoretical exercise though, as we yet have to implement device sleeping/wakeup while waiting for push notifications to really make a difference regarding power consumption. Something to discuss at the upcoming Plasma (Mobile) Sprint in Graz.

Mozilla Autopush

Thanks to the alignment with Web Push we can now use Mozilla’s Autopush push server as a backend, both their instance as well as a self-hosted one.

Note though that at least Mozilla’s own instance requires applications to use VAPID, which for example isn’t implemented in Tokodon yet. Additional compatibility considerations are listed here.

Self test

The system settings configuration module for push notifications now has a self-test action, which will send itself a push notification and verify that this was received correctly and sufficiently quickly again.

This isn’t strictly related to the protocol changes, but improved diagnostics help a lot with managing the increased complexity.

Development tooling

Besides the self-test for end user setups we also have a new command line tool for submitting push notifications for testing during development. Previously this could be done easily with sending a HTTP POST with curl, but with message encryption and VAPID signatures this isn’t really feasible anymore.

For convenience the demo push notification client included in the KUnifiedPush repository now also outputs the corresponding command to send it a notification (which is rather lengthy due to passing all the necessary keys).

Outlook

With all this we should be up-to-date with all the relevant specification changes again, and while at it there also has been a bunch of improvements and robustness fixes in general. The next step is adapting applications to make use of all this.