Release 20 of the Qt Creator IDE adds support for working with AI coding agents, a Zen Mode that puts your code editor into the focus, support for the GN (Generate Ninja) build system, and many more improvements.

This is supposed to be a blog post about Libre Graphics Meeting (LGM) this year, but since I haven't written about the previous ones I went to, I decided to write about those as well. So this post will have bits of 2024 and 2025 in them as well, as far as I remember them, along with the experiences from the 2026 edition. And also some small bits about what's planned for the upcoming ones!

I'm not much of a taker of photos, so I don't have much to show in that regard, but I got stories and links. Some of the conference talk links go to YouTube in absence of alternatives. At the time of writing, the talk recordings are still being moved from a Peertube instance that's going away to the Chaos Computer Club's excellent media hosting service. Presumably in the future, you will be able to find all the LGM talks categorized by year under the conferences/lgm category or under events/lgm or somewhere else on media.ccc.de.

I've also never had a personal blog, so I guess a brief introduction: I'm Carsten, I develop software. I'm involved in Krita, my main focus there being on Android. I'm also the maintainer of Drawpile. The two programs have plenty in common and so there's a good amount of cross-contamination.

With that out of the way, I'll start not at the beginning, but at the now.

Next Year: LGM 2027

Next year's Libre Graphics Meeting will be from May 5th to 8th 2027 in the city of Linz, Austria at the Kunstuniversität (art university). That's Austria the country in Europe, not Australia. The talks will probably be streamed again for online viewing. There is also some mulling about LGM 2028 going on already, with the idea of it being hosted in Montreal, Canada being floated about.

Since it's still very early in the organization, you probably won't be able to find those dates listed anywhere yet, but you can probably find them in the Matrix channel backscroll. That is also a good place to go if you want to listen in on the meetings and participate.

Otherwise, if you want to keep up to date with the event, you can also follow the Fediverse account. Otherwise, the website also has information, but at the time of writing, it is still in its 2026 state.

Two Years Ago: LGM 2024

This was my first Libre Graphics Meeting. It was also the first one in quite a while, it took quite the hit from COVID and the usual yearly cadence it had kept up for over 15 years had lapsed. 2020 and 2021 were online, 2022 and 2023 didn't have any LGMs at all. 2024 was the first year it came back. I don't remember it that way, but looking at the group photos from then, the crowd is definitely smaller than in the subsequent years. The venue for it were the ActivDesign offices, which is probably a comparatively tighter space, making it seem like it was more folks around.

I'd taken over the maintenance of Drawpile, having some more time for that kind of thing after quitting my day job. That also involved porting the program to Android, which is how I ended up on the Android side of Krita, and to the web browser using WebAssembly. The latter felt like something that few people had done before and I had stories to tell about it, which is why I gave a talk on the topic.

While this is probably my first publicly recorded talk, I've given enough of them before that this wasn't a new experience. However, it was the first one that had a good chunk of less technical people in the crowd, so I tried to have some lighter parts, at least as far as possible in such a techy topic. I'm pretty happy with how it turned out and people seemed quite interested in it, given the amount of questions and "hallway" conversations I had.

There was also a talk about Krita's new text tool by Wolthera, the primary author thereof. She couldn't be there in person, so that talk was given remotely. She's also got a blog post series on the matter. Today of course, Krita has this new text tool she was working on!

I don't remember every talk and so I don't want to go over each of them, but many of them I still remember fondly and it was nice seeing the people that held them at subsequent LGMs again. The folks from ActivDesign of course, like Elisa, Animtim or Cédric, who were involved in organizing the event. Tom Lechner's talks are always interesting and almost given in a conversational manner. This year's being one of hiking, foggy mountains in the Pacific North-West and default cubes in their natural habitat. It was also the first time I've really seen "live computer art stuff" through Jules Fouchy's Coollab. Well, what that stuff is really called is "generative art", but of course if you search for that nowadays, you just get slop instead. This is not that anyway, it is more about creating living installations created in real time and transforming them, like creating live visuals given an audio feed, manipulatable by a gyroscope from a performer's phone. There was also a bit of a conference talk with AMRO, the Art meets Radical Openness festival in Linz, Austria. Which is where next year's LGM connection comes from and some of the people involved with AMRO are also doing the organization of LGM 2027! You can find all the recorded talks in this playlist, unfortunately the lightning talks are not part of it.

Outside of the conference itself, there's also plenty of memories. Rennes was a nice city, my first experience with it being at the train station and desperately trying to find a ticket machine for the bus. After what must have been an hour of walking from the top of the station to the underground metro, I gave up and just got on the bus without a ticket - only to find that you just touch your bank card to a contactless pay terminal. Since the fees are a single, flat price no matter where you're going, that's all you need.

There was also much Brittany-typical stoat iconography in the city. After a picnic on the first day, we went out to eat on the second one. We had galettes, which are basically savory buckwheat crêpes. If I recall correctly, GIMP sponsored those for everyone that was there. I also had a bit of a talk with Lasse Fister, the lead organizer from the subsequent LGMs, about his attempts of having software recognized as being "for the public good" in Germany. Which informed that direction with Drawpile to instead focus on the artistic side of things, rather than trying to explain free software to the tax office, which seems like it was the right path because it lead to it having its public goodness recognized without a hitch. I unfortuantely had to leave on the third day, so I missed out on the rest of the meeting, a mistake I didn't repeat again.

And while I don't have photos, I still have my shirt, badge and official coffee cup! It's even signed, although that has faded a bit. Nonetheless a precious item.

Last Year: LGM 2025

The next LGM was in Nuremberg, Germany, which is quite a lot easier for me to get to. This time it was a larger space at the Karl-Bröger-Zentrum, which had more room available. Lasse put everything together despite plenty of hurdles and the support structures from one and a half decades of LGMs not being there anymore. During the event Simon Harhues also took on a good amount of organizational tasks, spontaneously if I recall correctly. The tech was done by folks from Chaos-West TV, who did a tremendous job despite the venues at times questionable tech. At times it felt like the recordings of the talks were already cut and online before the speaker stepped off the stage. And as the most important person of the event, Lasse's mother prepared the coffee.

Several people that were there at the last LGM were around once more, who were nice to see again. And there were several others that would come back the next year again. Krita also had a physical presence this time with tiar being there, myself not being a member of the core development team yet, although I'd already made some contributions to it. GIMP and Inkscape also had a presence again.

I gave a talk again this time around, with the lurid title of 3000% Faster File Saving With Time Travel. It's about a new file format for Drawpile, which turned out to have some very cool properties that I thought could be applicable to other programs as well. By now, a good chunk of the second part of the talk that goes on about future stuff has become a reality. A similar kind of format may be coming for Krita as well, although it will take some experimenting with what's doable in that regard.

This year also brings the continuing format of the State of Libre Graphics talk by MABarbe. It features a short overview of what's going on with various projects in the libre graphics world, even if they are not at LGM. If you know any free software projects that aren't represented in this but you think should be, it may be worth letting the project maintainer and/or the LGM groups know about it.

Once again, I don't want to retell every single talk since I don't remember all of them, but I'll give a brief survey again. Tom Lechner's talk this time was about waterfalls in Godot, which was another memorable one. Live computer art stuff had more of a presence this time, with Coollab once more, but also OPENRNDR and Processing being around. The talks about PDF were also interesting, one being a lightning talk on CapyPDF and the other on various kinds of flavors of PDF. And, most interestingly for my work, there was a talk on Inkscape's UI, on usability and UX evaluation and a workshop on the latter by Simon Harhues. During that, we went through Krita with someone unfamiliar with the software try to accomplish a task and document the issues. It was pretty eye-opening to see the things that a user tried first and having their thoughts spoken, since even if they did manage to accomplish the task eventually, they took some wrong turns or came to incorrect conclusions. A few of the experiences from this lead to features, such as hitting Escape to deselect in Drawpile. All recorded talks can be found in this playlist.

Since the schedule was pretty packed this time and my hostel bed was a small train ride away, I didn't end up going to too many evening events, although there were some concerted lunches. The last day had a big get-together with everyone who still had time, which was a nice end to the event. Looking back at it and comparing it with the LGMs before and after, it really does seem like the meeting is picking up steam again, becoming more organized and eventful.

No limited-edition plastic coffee cup this time, but I do have a shirt, a badge and stickers.

This Year: LGM 2026

Finally, the event this year. It was in Nuremberg again with the same organizer and tech team, but the venue was Zollhof. The internet was a lot better and the place was better equipped for this kind of conference matter. Coffee was provided without parental guidance this time. There was also a nice community room in the basement, although it didn't end up getting that much use since it was very far away from the conference hall on the very top floor, which is where most of the hallway conversations ended up being.

Krita-wise, tiar, Animtim and I were there. GIMP was also around to a degree, although Inkscape had less of a presence this time around. I also didn't have a talk this year, mostly because I didn't really have a single concrete thing to talk about among everything I'd been doing and the new work on the file format I'd already talked about in the last year.

The memories here are the freshest, so I'll go into some more detail here on talks where I have something to say. I won't go into every talk, since stuff like fonts, printing or live coding I simply don't have much to say about and I don't want this to just be a summary with no additional insights over just watching the talks. Which you can do via this playlist.

Once again, there was a State of Libre Graphics talk by MABarbe. Drawpile isn't featured this time around, which MABarbe and I blame wholly on Matrix failing to do its job of delivering messages.

Jules Fouchy, the primary developer of Coollab, held a talk about something we've chatted about at LGM 2024 already: UI frameworks. My own research and experience was that the choices that could be taken seriously - i.e. runs on Linux, Windows, macOS, Android, iOS/iPadOS and in the browser with possibility of hardware acceleration - were basically Qt, web view (Electron and friends) or an immediate GUI on top of OpenGL (Dear ImGui and friends.) While Coollab has different requirements, he kind of comes to the same conclusion. It is worth the watch.

Also on the first day there was a kind of crazy talk by Øyvind Kolås about ctx, a rasterizer, and its vector desktop, which is a whole desktop environment around it. The whole thing is pulling itself up on its own bootstraps, which is kind of wild to see, it is worth watching the talk.

After having held a talk on PCB design the last year, Simon Budig held a soldering workshop. Since I have some experience in that regard I ended up joining it to help out a bit, everyone there put together a small board with a few components: resistors, a battery compartment, a switch and blinkenlights on a printed circuit board with the LGM logo on the front. This gets slotted into a 3D-printed case with a magnet inserted into a very tightly fitted recess via a lot of force applied. Turning it on lights up the logo in different colors that shift over time, see the photo below.

In the lightning talks on the second day, Krita contributor Animtim held a talk about GCompris, a tool for children with different activities, of which several of the creative ones are quite interesting to play with for adults as well. There was also a talk on palettes appropriate for different color visions by Øyvind. I also talked very briefly about animation in the ORA format to see if there was anyone except Krita folks interested in it, but we didn't have anyone present at the time.

Jehan held a talk about GIMP's community, which is worth a watch if you're involved in a free software project. It could probably have been twice as long to go more into depth on the topic, but it gives a good history and some insights on how to handle such a long-running project. In particular, their experience with Google Summer of Code students is very different to Krita's: theirs usually turned into long-time contributors, while ours usually disappeared after they were done. While Krita is sitting out on this year's GSoC for various reasons, it'd probably be worth looking deeper into it next year.

I didn't quite wrap my head around it during Jean-Michael Celerier's talk on ossia score, but there was a workshop later where I understood it a bit better. It is a program that lets you orchestrate various kinds of input sources, processing steps and output sinks together with nodes and a timeline. For example, you can read sensor data from a phone, denoise it and then output it into a shader program to make visuals during a live performance. Or you can connect a sound source with a light installation. While I would probably have to use it more to wrap my head around the connection between the timeline and nodes, it is an interesting combination of the two.

Speaking of timelines and nodes, MABarbe held a talk about representing a timeline as nodes, which is another way to look at the matter, although this one is a UX design experiment, not something available to try and feel out. Still, it's worth watching the talk in combination with the ossia score one above.

Lila Pagoda's talk about putting design students in front of free software is also a good watch. It reminds me quite a lot of the UX experiments we did in 2025 and I would really like to read the students' reviews that were mentioned, but haven't found them publicly released. It is also an insight on technical awareness to a degree, where students never even look at alternatives that may even be better than proprietary solutions. But that's probably a marketing matter more than anything, which I don't understand much of.

Tom Lechner held a talk again this year, this time about imposition, which is how you cut, fold and arrange papers to produce their eventual "bound" form. It's not something I've ever thought about, so actually seeing it in action is fascinating. Right afterwards, Alexander Lehmann's talk about their Frag den Staat game is in a similar direction, being taken along with the experience of making that game.

And as the final talk, flabbet from PixiEditor held a talk about their node-driven editor. Particularly interesting is the use of a node graph for their brush editor, since it makes the flow of information more apparent than the "fixed-function pipeline" in other brush engines. Whereas those tend to accumulate a lot of special knobs and switches, having a node editor allows for easier stacking of primitives. A particularly interesting part thereof being the ability to have user input nodes, which means that an artist that just wants to tweak the brush a bit doesn't need to dive into the node graph, but can instead just adjust some sliders and curves on the frontend.

The conference ended with a get-together outside this time, which was a bit less comfortable due to the lack of seating opportunities in the hills of the old city. Still, we talked about nodes, crash reports and optimization, some of which has conjured ideas on implementing them into Drawpile and/or Krita. Although they haven't yet manifested due to being busy on other matters in that regard.

So for the spoils this year. I got a shirt again, badge, stickers and the aforementioned soldering project.

And since I already looked at next year's LGM above, that concludes this post! If it's reachable for you, consider coming as well, the attendance is free. Otherwise, save the date to watch the streams and participate from online!

This is a weekly update from my Google Summer of Code 2026 project with KDE, improving effect widgets in Kdenlive, a free and open source video editor.

This week was driven entirely by reviewer feedback on MR !887; the draft MR for the Curves Widget.

Point snapping instead of rejection

When two curve control points are placed too close on the x-axis, avfilter/MLT crashes with Key point coordinates are too close or not strictly increasing.

The original guard in AssetParameterModel::internalSetParameter silently rejected the update, the user moved a point but nothing happened visibly. Reviewer Bernd Jordan flagged this as confusing UX.

The fix: instead of rejecting, snap the offending point so it maintains the minimum safe x-distance (~0.00266) from its neighbor. The curve is always valid, always sent to MLT, and the user sees immediate feedback.

Removing the 5 point limit for avfilter.curves

The curve editor had a maximum of 5 control points, inherited from frei0r.curves. JB pointed out there is no reason to keep this limit for avfilter.curves, it is a frei0r-specific constraint.

The fix: setMaxPoints is now only called for frei0r.curves. The avfilter.curves widget has no upper limit on control points.

Both fixes are in MR !887.

JB also noted the null placeholder approach in m_widgets for secondary av_curve params is not ideal long term, waiting on his direction before touching that.

This week, I worked on two things: a bug fix that was created during the ActionCollection port and starting the import/export feature.

Bug fix: Lock/Unlock action text:

A bug was created after !29 was merged. When a wallet was locked, the placeholder message displayed a "Lock" button instead of "Unlock". The issue came from ActionData using static text, while the lock action needs to reflect the wallet's current state. The fix was easy — switch between the lock and unlock ActionData dynamically based on the locked property.

AC.ActionCollection.action: locked ? "unlock" : "lock"

This was submitted as !31 and merged.

Configure Shortcuts menu item:

I added a "Configure Shortcuts…" menu item to the globalDrawer(!32), using AC.StandardActionData.KeyBindings to attach to the action automatically created by ActionCollectionManager.

Import/Export feature: I started implementing the import/export feature. The format is KWalletManager-compatible XML, so users can migrate between KWalletManager and KeepSecret. The implementation adds: -ImportExportManager C++ class with exportToFile() and importFromFile() methods. -Export… and Import… menu items in the globalDrawer. -File picker dialogs using QtQuick.Dialogs.

The merge request !33 is open and under review.

Even well-designed applications can become difficult to understand when their main workflows involve multiple controls, pages, or unfamiliar interaction patterns. Expecting users to discover these features on their own may lead to frustration, abandoned tasks, and additional support requests. Kirigami-Addons' onboarding module addresses this problem by presenting contextual guidance directly in the user interface, highlighting relevant elements and explaining them when they matter. When implemented through reusable and non-intrusive components, it can improve the user experience without requiring substantial changes to the existing application code.

Kirigami-Addons' onboarding module provides a complete set of features for defining and running contextual walkthroughs in Kirigami applications:

• Declarative steps: attach guidance text directly to existing QML elements without restructuring the interface.
• Source areas: define the UI region covered by a walkthrough and containing its onboarding steps.
• Automatic sequencing: visit steps according to their declaration order.
• Walkthrough groups: create multiple onboarding flows, such as basic and advanced tutorials, over the same interface.
• Conditional steps: disable individual steps dynamically; disabled or destroyed elements are skipped automatically.
• Visual highlighting: outline the current element while dimming and blurring the surrounding interface.
• Configurable appearance: adjust the highlight padding and the intensity and quality of the background blur.
• Adaptive tooltips: position guidance above, below, or within the available space around the highlighted element.
• Navigation controls: move forward or backward, or cancel the walkthrough, using buttons, keyboard shortcuts, or QML methods.
• Lifecycle hooks: prepare or restore the interface before a walkthrough or individual step is displayed.
• Dynamic interface support: navigate between pages, tabs, views, dialogs, or other containers before highlighting their elements.
• Custom content: add application-specific metadata and present images, animations, videos, or other QML content inside the onboarding tooltip.
• Responsive geometry tracking: keep the highlight synchronized when elements move, resize, or change parents’ positions.
• State monitoring: observe the active walkthrough, source, current step, guidance text, geometry, and navigation availability.
• Accessible navigation: provide accessible button labels, keyboard operation, right-to-left layout support, and platform-consistent styling.

Adding Onboarding to Your Kirigami Application

This section explains how you can add onboarding features to your Kirigami appplication.

Basic onboarding declaration

After importing the onboarding module, mark a common ancestor of the UI elements with Onboarding.isSource. This source defines the area where the module creates its overlay, applies the background effect, and searches for onboarding steps. Steps are declared directly on descendant elements using attached properties. Here, Onboarding.texts associates guidance with the Create project button, while Onboarding.start() begins the walkthrough. Steps are presented in declaration order, allowing onboarding to be added with minimal changes to the existing QML structure. You can use Onboarding attached properties to highlight/explain individual controls, layouts/groups, and even sub-controls.

Defining multiple onboarding workflows

The Onboarding.sourceGroups property declares the workflows available from a source area. The empty string represents the default workflow started by Onboarding.start(), while named groups, such as advanced, are started by passing their name to Onboarding.start().

Each step uses Onboarding.groups to select the workflows in which it participates. The entries in Onboarding.texts correspond by position to those groups, allowing the same UI element to provide different guidance in each workflow. In this example, Create project belongs to both workflows, while Enable version control appears only in the advanced one.

Extending onboarding tooltips with additional data

The Onboarding.additionalData property associates application-specific metadata with a step. In this example, the metadata provides an animated WebP and its caption. A custom component reads the current step through Onboarding.currentItem.additionalData and displays this content using AnimatedImage and Label. Finally, binding the component to Onboarding.additionalDataComponent inserts it into the default tooltip between the guidance text and navigation controls, allowing applications to enrich onboarding steps without replacing the complete tooltip implementation.

Examples

This is the example tutorial included in the Kirigami Addons repository. It demonstrates how the onboarding module can highlight individual controls, groups of controls such as layouts, and even sub-controls. It also shows how to attach additional data to onboarding steps, such as a video and its caption, and how to define multiple onboarding workflows within the same application.

And this is the onboarding module in Minuet: a short guided walkthrough that highlights the most important parts of the exercise screen, explains what each control does, and helps new users understand the flow without leaving the application.

The onboarding module provides a declarative and non-intrusive way to introduce users to important controls and workflows in Kirigami applications. With support for multiple workflows, dynamic interfaces, custom tooltip content, lifecycle hooks, and configurable visual effects, it can address both simple guidance and more advanced onboarding scenarios.

A possible direction for future work is allowing each onboarding step to wait for a specific user interaction before continuing. Instead of relying only on the Next button, a step could advance after the user clicks a highlighted control, changes a value, or completes an expected action. This would extend the module beyond explanatory walkthroughs and enable fully guided, interactive tutorials in which users learn application workflows by performing the actual operations.

Give the module a try in your application and share your experience, suggestions, and use cases. Feedback is especially welcome while these APIs are still being refined for an upcoming Kirigami Addons release.

For almost two decades, the PackageKit package management abstraction layer has shipped with pkcon as its command-line client. pkcon does its job, but it was always kind of a “testing” front-end for the PackageKit daemon rather than a tool designed for everyday use. The focus has instead been on the GUI tools, automatic system updates, GUI application managers and other front-ends. Its command names mirror the D-Bus API almost one-to-one (get-details, get-updates, get-depends), output is very plain, and there is no machine-readable mode for scripting. Most importantly though, there has been no development on it at all for almost a decade, so pkcon was stuck in its rudimentary state from that era.

Since a lot of changes will be coming to PackageKit, and testing the daemon and working with it from the command-line was not very pleasant anymore in 2025/2026, I decided to modernize the tool as part of my work as fellow for the Sovereign Tech Agency last year. pkgcli is the new command-line client for PackageKit. It is built from the ground up to be pleasant to use interactively and easy to drive from scripts.

Why a new tool?

Of course, instead of introducing a new tool, I could have just expanded pkcon instead. The problem with that approach is that the pkcon utility has been around for so long and its command-line API had ossified so much, that rather than changing it and potentially breaking a lot of scripts relying on its quirks, I decided to introduce a new tool instead. pkcon can still be optionally compiled for people who need it in their scripts and workflows.

The goals for pkgcli, and the features it now has are:

• Human-friendly command names. Verbs that read the way you’d describe the task, instead of mirroring the D-Bus API 1:1: show, search, list-updates, what-provides, instead of get-details and friends.
• Readable, colored output by default (still respecting NO_COLOR and degrading gracefully).
• A real scripting mode. A global --json flag emits JSONL instead of fully human-readable output when possible, to make it easier to use the tool for scripting purposes.
• Sensible defaults. A few defaults have been changed, such as the metadata cache-age, or automatic cleanup of unused dependencies being enabled by default. This is more in line with current defaults by other tools and frontends. We also print package information in a slightly different, more readable way.
• Better handling of internationalized text. Text should now align properly in the terminal window, and we should no longer have completely chaotic text output on non-English locales (especially Chinese/Japanese).

Why not pkgctl?

Originally, this tool was called pkgctl, to match other common cross-distro tool names. However, that name was already taken by an Arch-specific distro development tool. When this issue was raised, we decided to just rename our tool to pkgcli with the next release, to avoid the name clash on Arch Linux.

Examples!

Here are some examples on how to use the new tool (some of which include the abridged output pkgcli prints).

Search for anything containing the string “editor” in name or description, then look at the details of one result:

$ pkgcli search editor
Querying                  [████████████████████████████████████████] 100%
▣ ace-of-penguins 1.5~rc2-7.amd64 [debian-testing-main]
▣ acorn-fdisk 3.0.6-14.amd64 [debian-testing-main]
▣ ardour 1:9.2.0+ds-1.amd64 [debian-testing-main]
✔ audacity 3.7.7+dfsg-1.amd64 [manual:debian-testing-main]
✔ audacity-data 3.7.7+dfsg-1.all [auto:debian-testing-main]
▣ augeas-tools 1.14.1-1.1.amd64 [debian-testing-main]
▣ emacs 1:30.2+1-3.all [debian-testing-main]
▣ gedit 48.1-9+b1.amd64 [debian-testing-main]
▣ gedit-common 48.1-9.all [debian-testing-main]
▣ gedit-dev 48.1-9+b1.amd64 [debian-testing-main]
[...]

$ pkgcli show nano
Package: nano
Version: 9.0-1
Summary: small, friendly text editor inspired by Pico
Description: GNU nano is an easy-to-use text editor originally designed as
 a replacement for Pico, the ncurses-based editor from the non-free mailer
 package Pine.
[...]
URL: https://www.nano-editor.org/
Group: publishing
Installed Size: 2.9 MB
Download Size: 646.0 KB

Search only within package names rather than descriptions:

$ pkgcli search name python3

Check for updates. refresh updates the metadata, then list-updates reports what’s available:

$ pkgcli refresh && pkgcli list-updates
Loading cache            [████████████████████████████████████████] 100%
▲ cme 1.048-1.all [debian-testing-main]
▲ gir1.2-gdm-1.0 50.1-2.amd64 [debian-testing-main]
▲ imagemagick 8:7.1.2.24+dfsg1-1.amd64 [debian-testing-main]
▲ imagemagick-7-common 8:7.1.2.24+dfsg1-1.all [debian-testing-main]
▲ imagemagick-7.q16 8:7.1.2.24+dfsg1-1.amd64 [debian-testing-main]
▲ libdlrestrictions1 0.22.0.amd64 [debian-testing-main]
▲ libfftw3-bin 3.3.11-1.amd64 [debian-testing-main]
▲ libfftw3-dev 3.3.11-1.amd64 [debian-testing-main]

Explore relationships between packages:

$ pkgcli list-depends inkscape  # list what inkscape depends on
$ pkgcli list-requiring libappstream5  # list what requires libappstream5

Find the package that provides a capability, here the AV1 GStreamer decoder:

$ pkgcli what-provides "gstreamer1(decoder-video/x-av1)"
✔ gstreamer1.0-plugins-bad 1.28.3-1.amd64 [auto:debian-testing-main]

You can also have JSON output for most commands! Attach --json to any query and pipe the result straight into jq. Each line is a self-contained JSON object:

$ pkgcli --json list-updates | jq -r '.name'
cme
gir1.2-gdm-1.0
imagemagick
imagemagick-7-common
imagemagick-7.q16
libdlrestrictions1
libfftw3-bin
libfftw3-dev
libfftw3-double3

Try it

pkgcli is built by default alongside the rest of PackageKit since PackageKit 1.3.4. If your distribution ships a recent enough PackageKit, it should already be on your PATH. You can read its man page man pkgcli for more information. Feedback, bug reports, and patches are very welcome.

Quite a few things have happened around the Android platform support for KDE applications in recent months, so high time for another update on that.

Qt 6.11

As already mentioned previously, we have updated the Qt version to 6.11. That has the unfortunate consequence of losing support for Android 8 and older. Due to that we also removed the ARM32 builds, as devices running Android 9 or higher are very likely capable of using ARM64 builds anyway, cutting down the CI cost by a third.

The previously often annoying interactions between input focus and the virtual keyboard seems to have improved somewhat with Qt 6.11. Changes in how the back key/gesture is handled however also caused a few regressions, like a double page pop in more deeply nested applications (Kirigami MR 2100).

SafeArea support

While the previous focus of dealing with “safe” screen areas (ie. parts of the application window not being covered by screen cutouts or system controls like the Android status and navigation bars) had been on not breaking horribly due to Android’s changed default behavior we have meanwhile been working on polishing this to actually look decent.

• Fixed misplaced drawer handles (Kirigami MR 2102).
• Fixed NeoChat’s chat bar being placed behind the bottom navigation bar (NeoChat MR 2893).
• Fixed a double bottom margin in NeoChat (Kirigami MR 2107).
• Fixed floating buttons in Itinerary getting misplaced (Kirigami MR 2105).
• Fixed Alligator global drawer expanding into the status bar (Alligator MR 172).
• Fixed runtime warnings in Tokodon when computing safe margins (Kirigami MR 2110).

If you spot places where this still doesn’t work correctly, let us know in the #kde-android Matrix channel!

Notifications

There’s also a number of improvements and extensions for notification handling:

• Fixed interactions with notification actions or the notification itself having no effect (MR 200).
• Implemented confirming inline replies (MR 202). This fixes the notification showing a spinner animation indefinitely after submitting an inline reply.
• Improved icon handling. We can now properly distinguish between what Android calls the “small” and “big” notification icons, a symbolic application icon and an image of e.g. a chat avatar. This will require small changes to applications to get the best result, in most cases providing a symbolic application icon should be enough already (MR 201).
• A new API for cross-platform notification configuration is in review (MR 203). This will also benefit Flatpak applications.

Safe JNI usage

Interaction between our C++ code and Android’s Java platform APIs happens via the so-called Java Native Interface (JNI). That’s a rather low-level C interface with little to no type safety and the need for error-prone handwritten arcane signature strings. Already back in the Qt 5 era I had therefore written a few helpers for a more type-safe use of this in KAndroidExtras.

Much of this functionality is meanwhile available in Qt 6 in a very similar fashion, with the JNI array support being the latest addition in Qt 6.9. Compared to raw JNI use this is already a massive improvement, see e.g. MR 204 making use of this in KNotifications. It avoids practically all hand-written JNI signatures as well as much of the manual type conversion.

One part is still missing though, type-safe wrappers so that function arguments and property types are checked at compile-time. That has been extracted and rebased on top of Qt’s JNI code in KJniExtras now. It’s only 10% of the code, with most of the complex template magic gone.

As a small downside we are unfortunately losing the ability to test JNI code on Linux with this, as the old approach provided a mock implementation when not building for Android.

Calendar access

With the type-safe JNI wrappers small enough now to be copied as a single header file, this finally unblocked the move of the Android platform calendar backend from Itinerary upstream to KCalendarCore (MR 242).

Together with the calendar runtime permission API already in Qt, this should make e.g. an “add to calendar” feature for Kongress or KTrip easy to add now.

File dialogs and remote files

An often reported issue against several of our applications is that they seemingly don’t do anything when opening a file via the platform file dialog. This happens for files on a cloud share, which the Qt Quick file dialog silently discards due to not being local files, making this look like as if the user has canceled the dialog to the application. Therefore just nothing happens and no error message is shown either.

Interestingly enough, that problem also happens on KDE Plasma, where the native file dialog also can select remote files, it’s just much less common there. But since we can tell the Plasma file dialog to only allow selecting local files, this one is easy to fix (CR 742273, available in Qt 6.12).

On Android we don’t have that option, nor would that be really satisfying anyway, opening files from a cloud share is a very valid usecase. Therefore there’s now also a proposed change to the Qt Quick file dialog to optionally allow selecting arbitrary URLs, similar to what its Qt Widgets counter-part already offers (CR 743681). This wont automatically fix the problem, but it would at least give applications a chance to do something about this.

Locale-aware sorting

Something fairly basic that Qt on Android so far didn’t do properly (at least when not bundling it with multi-10MB worth of ICU libraries) was locale-aware sorting. When using English you might not notice that, but in many other languages this results in weird and confusing lists. In German for example the letter “Ä” gets basically treated like “A” for sorting, while so far it ended up after “Z” on Android.

There’s now a proposed Qt patch (CR 741548) implementing a QCollator backend for Android using platform infrastructure. This uses Android’s native ICU flavor when available and otherwise falls back to the less efficient and less featureful Java API.

Crash reporting

While we have automatic crash reporting on Linux since some time (see e.g. Harald’s LAS talk for more details), crashes on Android were not handled at all by our applications so far.

Based on discussions at the Graz Sprint in April this has now changed, KCrash can now detect a previous crash when starting an application, and offers to submit an automatic crash report to KDE’s Sentry instance.

Those reports have been very helpful on Linux already, providing very important information about issues and allowing to prioritize those with the most impact, but it’s nevertheless crucial we don’t submit anything without user consent.

The bulk of the implementation is in KCrash MR 101, a few changes are necessary for integrating this into applications as well though.

In your build.gradle, add sentry-android-core as a dependency:

dependencies {
  ...
  implementation 'io.sentry:sentry-android-core:8.43.0'
}

In your AndroidManifest.xml, add a meta-data entry configuring the Sentry DSN for your application:

<application ...>
  <meta-data android:name="io.sentry.dsn" android:value="https://<token>@crash-reports.kde.org/<app-id>"/>
</application>

And finally, remove the build system and preprocessor conditions excluding KCrash use on Android. Note that verifying this part is crucial, without KCrash you’ll get the aggressive default behavior of Sentry, uploading without user consent.

Inhibition

Earlier this year KGuiAddons got a new API for inhibiting system actions such as locking the screen. The obvious usecase for this is a video player, but e.g. Itinerary uses this as well for ensuring your screen stays on while showing a barcode to be scanned at a ticket check.

Android platform support for this has also been added (MR 203), allowing the removal of corresponding code in applications.

Outlook

While all of that is good progress, things are likely about to change. Later this year Google is planning to roll out measures making it significantly harder to provide and install applications on Android.

For more information check out Keep Android Open, a campaign supported by the KDE e.V. among many other organizations.

Regardless of how this will eventually materialize, the direction is clear, Android isn’t going to be a viable long-term platform for FOSS software, not even in its Google-free form. I have mostly considered it a stop-gap solution until Linux on the phone is ready anyway, so this is another reason to increase the effort into that direction.

Welcome to a new issue of This Week in Plasma!

This week the Plasma team put the finishing touches on Plasma 6.7 with another big push on bug fixing. It’s looking really good for release next Tuesday!

As a result, some feature work and UI polishing started to trickle in for Plasma 6.8.

Check it out:

Notable new features

Plasma 6.8

Plasma Browser Integration now supports the Flatpak version of Microsoft Edge. (Conley Dawson, KDE Bugzilla #521109)

Notable UI improvements

Plasma 6.6.6

Window actions that involve the mouse wheel no longer respect your “natural scrolling” preference; we reasoned that in this situation, up should always mean up and down should always mean down. (Vlad Zahorodnii and David Edmundson, KDE Bugzilla #442789)

Plasma 6.7

If you authorize an app to be able to remote-control the system without asking for permission first (for example, a remote desktop app), when it does so, now Plasma shows a notification that it’s happening. (David Redondo, xdg-desktop-portal-kde MR #571)

When navigating by using the number pad keys to move the pointer, pressing multiple keys now moves the pointer in a direction halfway between them. (Vlad Zahorodnii, KDE Bugzilla #486520)

KRunner-powered searches now suppress results from the “Global Shortcuts” provider when there are better results from other ones, which makes the search results more relevant for common searches. (Oliver Beard, KDE Bugzilla #3710)

Changed the automatic day/night theme switcher to switch halfway between the start and end of dawn or dusk, rather than at the end. (Vlad Zahorodnii, Bugzilla #511973)

Added kde-shader-wallpaper to the list of allowed wallpaper plugins in Plasma Login Manager. (y4m y4m, plasma-login-manager MR #141)

Plasma 6.8

Improved Plasma’s ability to detect dark GTK 2 themes and apply a matching icon theme, which should substantially reduce cases of illegible icons in old GTK 2 apps when using a dark color theme. (Luan Oliveira, kde-gtk-config MR #144)

The top edges of non-maximized Breeze-themed windows now have as much extra draggable area as the bottom and side edges already do. (Sergey Katunin, KDE Bugzilla #504225)

Made the portal-based permission dialogs more consistent in their presentation and wording. (Nate Graham, xdg-desktop-portal-kde MR #575)

Frameworks 6.28

You can now use the Meta key on its own to trigger KWin’s Overview screen. (Vlad Zahorodnii, KDE Bugzilla #518302)

Improved the alignment of thumbnail previews in open/save dialogs. (John Doe, frameworks-kio MR #2249)

Notable bug fixes

Plasma 6.6.6

Fixed an issue that made KWin accidentally leak the CAP_SYS_NICE capability to child processes it launched, which would break the Bubblewrap sandboxing system when applied to those processes. (Vlad Zahorodnii, KDE Bugzilla #521013)

Fixed a bug that could make Plasma crash when changing the monitor layout during the login process. (Marco Martin, KDE Bugzilla #510477)

Fixed an issue that could make the “Today” button on the Digital Clock widget’s calendar popup highlight the wrong day when in a time zone later than UTC and the local time was before midnight in UTC time. (Fushan Wen, KDE Bugzilla #521114)

The feature that lets apps screencast without asking permission no longer requires the screen setup to be identical to what it was when the permission was granted. (David Redondo, KDE Bugzilla #519122)

SVG-based wallpapers are now able to fully participate in the dark/light wallpaper switching feature. (David W., KDE Bugzilla #519168)

Fixed a bug that prevented explanatory text showing up as expected in the generic “[app] wants to do [thing]” portal dialog. (David Redondo, xdg-desktop-portal-kde MR #584)

Plasma 6.7

Fixed a very odd issue that would break the Icons-Only Task Manager widget if you created a file named metadata.desktop right inside your home folder. (Christoph Wolk, KDE Bugzilla #521247)

If you somehow manage to delete a multi-activity setup’s active activity, Plasma now switches you to the next one instead of crashing and leaving you with a broken desktop. (Angel Parra, KDE Bugzilla #521124)

Fixed a case where Discover could crash while processing changes to distro packages. (Aleix Pol Gonzalez, discover MR #1335)

Fixed a case where Plasma could crash when waking from sleep after monitors were added or removed during sleep. (David Edmundson, KDE Bugzilla #https://bugs.kde.org/show_bug.cgi?id=521078)

Fixed a case where System Monitor would crash when quit while the column configuration dialog was open. (Nicolas Fella, KDE Bugzilla #491000)

Worked around an issue in GTK 4 that could make selected text in some GTK 4 apps become irritatingly de-selected. (Vlad Zahorodnii, KDE Bugzilla #517573)

Fixed a weird regression that could make the pointer inappropriately display the “app is launching” animation when minimizing windows using the Plastik window decoration style. (Vlad Zahorodnii, KDE Bugzilla #516264)

Fixed a regression that made non-random wallpaper slideshows start over from the first one at every login, instead of remembering the last-seen wallpaper. (Fushan Wen, KDE Bugzilla #512559)

Fixed a regression that made System Monitor’s Process Table view display unformatted data. (Arjen Hiemstra, libksysguard MR #476)

Fixed a very weird issue that could make KWin get confused and stop running animations and animated effects properly after opening an app that creates an invisible window. (Vlad Zahorodnii, KDE Bugzilla #519789)

Fixed an issue that could sometimes make the Weather Report widget endlessly reload after waking the system from sleep. (Ce Sun, KDE Bugzilla #517280)

Made System Monitor graphs’ axis labels show fractional values when needed. (Tobias Fella, KDE Bugzilla #521041)

Made it possible to un-favorite apps that are marked as favorites in Kickoff/Kicker/etc. even if they contain some weird character combinations. (Christoph Wolk, KDE Bugzilla #520894)

Fixed an issue that could make the notification icon in the System Tray get stuck in a half-rotated state if the animation got interrupted for any reason. (Kai Uwe Broulik, KDE Bugzilla #458156)

Fixed an issue that made a translated label turn into an English label after changing and saving settings on System Settings’ Screen Locking page. (Sergey Katunin, KDE Bugzilla #521293)

Made the Color Picker widget not visually overflow when placed inside a Grouping widget. (Tobias Fella, KDE Bugzilla #517052)

Frameworks 6.28

Fixed a weird issue that could make Plasma freeze if you created a .desktop file, set its icon to be a local AVIF image, and put it on the desktop. (Akseli Lahtinen, KDE Bugzilla #521200)

Qt 6.11.2

Fixed an apparently fairly common way that Plasma could crash when fetching album art for remote media (for example, on YouTube) shown in Media Player widgets. (Mårten Nordheim, KDE Bugzilla #505490)

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.

Would you like to help put together this weekly report? Introduce yourself in the Matrix room and join the team!

Beyond that, you can help KDE by directly getting involved in any other projects. Donating time is actually more impactful than donating money. 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 out by making a donation! This helps cover operational costs, salaries, travel expenses for contributors, and in general just keeps KDE bringing Free Software to the world.

To get a new Plasma feature or a bug fix mentioned here

Push a commit to the relevant merge request on invent.kde.org.

Let’s go for my web review for the week 2026-24.

Total Reciprocity Public License

Tags: tech, foss, licensing, copyright

More an experiment than something I’d recommend for real. Still it shows there’s a gap we need to close in the licenses available. Let’s hope the OSI and the FSF will do strong moves toward closing this gap.

https://trplfoundation.org/

Forms of Open Source Government

Tags: tech, foss, governance, satire

In part useful, in part satire I think. Still it gives a good idea of various governance models in FOSS communities.

https://nesbitt.io/2026/06/09/forms-of-open-source-government.html

Retro-Tech Parenting

Tags: tech, culture, learning, parenting

There’s a path to get people (children included) to get into technology with enough of the veneer of convenience to make sure it is a learning experience… While keeping it pleasurable.

https://havenweb.org/2026/05/28/retro-tech.html

Pokémon Go Scans Quietly Trained The Navigation Tech Now Headed Into Military Drones

Tags: tech, game, surveillance, attention-economy, defense

How do you like our particular brand of dystopia? That’s what you get for using proprietary data farming game I guess.

https://dronexl.co/2026/06/09/pokemon-go-scans-niantic-vantor-military-drone-navigation/

The Blight Reaches Microsoft: 73 Repos Disabled in 105 Seconds

Tags: tech, microsoft, github, security, supply-chain, ai, machine-learning, gpt, copilot

There’s really something nasty at play. Those coding agents are clearly not insulated from the system enough and too easy to manipulate in order to exfiltrate sensitive information.

https://opensourcemalware.com/blog/miasma-reaches-azure

our workplace LLM mass delusion

Tags: tech, ai, machine-learning, gpt, management, trust

This piece asks a very profound question in fact. If you’re in a workplace where senior management allows and pushes everyone to get deluded about the real capabilities of those tools, how do you later move forward and rebuild trust?

https://blog.avas.space/llm-circus/

To my students

Tags: tech, learning, culture, ethics, politics, quality

Very nice piece, timely and needed. Indeed, let’s hope people stick to those principles.

http://ozark.hendrix.edu/~yorgey/forest/00FD/index.xml

How LLMs Actually Work

Tags: tech, ai, machine-learning, gpt, architecture, neural-networks

A good primer on the main architecture traits of transformer models.

https://www.0xkato.xyz/how-llms-actually-work/

Local-First Software Is Easier to Scale

Tags: tech, performance, architecture

It’s definitely easier not having to scale at all. Which is what you get when you design for local first / client side.

https://elijahpotter.dev/articles/local-first-software-is-easier-to-scale

Linux latency measurements and compositor tuning

Tags: tech, graphics, linux, desktop, performance, debugging

Interesting read, this is really tricky to measure such latency. It looks like we might have room for improvements on latency still. Curious to see if the proposed fixes will make it in kwin.

https://farnoy.dev/posts/linux-latency

Test-case Reducers Are Underappreciated Debugging Tools

Tags: tech, tests, debugging

Interesting family of testing and debugging tools indeed. I should definitely reach out to those more.

https://tratt.net/laurie/blog/2026/test_case_reducers_are_underappreciated_debugging_tools.html

Why Queues Don’t Fix Overload (And What To Do Instead)

Tags: tech, queuing, architecture, distributed

Queues are not magic. If they’re unbounded you’re in for a world of pain as load increases.

https://pmbanugo.me/blog/why-queues-dont-fix-overload-and-what-to-do-instead

The User Doesn’t Care - But you should

Tags: tech, programming, quality

Indeed, when people say “users don’t care about quality” (tests or otherwise), this is mostly folklore. As soon as something goes wrong they’ll care.

https://lewiscampbell.tech/blog/260607.html

The un-hateable engineering managers

Tags: tech, engineering, management

Sometimes, you got to deliver the bad news… It’s healthy if you feel uneasy about it though.

https://newsletter.manager.dev/p/the-un-hateable-engineering-managers

Bye for now!