For many years Plasma comes with its own system online accounts system, known as KAccounts. The idea is simple: In Systemsettings you log into a given online service once, and then several applications can use that login, instead of loggin in inside each application separately.

The number of services available and applications making use of them changed a bit over recent years. As of right now the following services are supported:

• Nextcloud: This is used by Dolphin to add a shortcut for file access via webdav to the Network section, as well as the Purpose framework to allow uploading files to Nextcloud.
• Owncloud: Used for the same things as Nextcloud.
• Google: Used by Purpose for uploading to YouTube. In theory also used by kio-gdrive for browsing Google Drive, but access to this is currently blocked by Google.
• OpenDesktop: Used for reviewing store.kde.org content in Discover

This isn’t all that much. Notably absent here is KDE PIM, which could greatly benefit from integrating with the Nextcloud and Google accounts. This is something many users have asked for over time. Plus, there’s more services that are used across applications and could benefit from a systemwide online accounts system, like Mastodon or Matrix.

Overall the situation with online accounts support in KDE is unsatisfactory, and it’s not for a lack of trying. Over the last few years there have been several smaller improvements to the system. However there have been no changes to the overall architecture. At this point I am convinced that the architecture is what’s holding us back, and we need to do something about that.

The current system is based on the Accounts SSO framework. It consists of several libraries and processes, split across about a dozen different repositories. This makes for a rather complex system for what is effectively reading and writing to a sqlite database and some OAuth handling. It also receives very little development activity, to the point where it was hard to get the required patches for Qt6 support in. Using an external accounts system as based for KAccounts only makes it harder to iterate on our system, while providing no meaningful interoperability with other parties.

The system also isn’t designed for a sandboxed world. Apps have direct access to the accounts database and keychain, so there is no ability to restrict which apps can use which accounts. While per-application access control wasn’t really feasible for traditional Linux packaging, with sandboxed formats like Flatpak we can and want to restrict apps to only be able to access select accounts.

Having pondered the problem for a while I came to the conclusion that we need a fresh start for our online accounts story, a new system that fullfils the following goals:

• It’s actually used by relevant KDE and third-party software
• Easy to hack on and extend
• Easy to be integrated into consumer software, with minimal dependencies
• Can be extended with third-party providers
• Account data is stored reasonably securely, with per-application access control (for sandboxed applications at least)

Based on these goals I have developed a prototype for how such a system could look like.

At its core there is a daemon process that manages the accounts, and exposes them via a DBus interface. Applications uses this DBus interface to list availble accounts as well as their parameters and credentials. Only accounts the app has been granted access to are visible that way. Application authentication works in a way that’s inspired by how xdg-desktop-portal works.

An application can trigger a request for accessing a new account. The dameon will then handle the whole login flow and, if successful, will return a handle to the new account. Alternatively the user can log into a given service in the systemsettings module and give access to relevant apps though that.

Currently the following services/apps are supported:

• Nextcloud: Used by Purpose and KDE PIM
• Mastodon: Used by Tokodon
• Google: Used by KDE PIM and Purpose

You can find the code at https://invent.kde.org/nicolasfella/konlineaccounts.

It is still very much a prototype, which is by no means ready for production, but it shows the basic concept. If you have input on this please get in touch, for example by filing an issue.

Last weekend I once again attended the bi-annual OSM Hack Weekend in Karlsruhe hosted by Geofabrik. I’ve also been at the OSM Hack Weekend in Berlin hosted at Wikimedia Deutschland a couple of weeks ago and haven’t written about that yet, so this is the combined report for both events.

Transitous

Transitous, our community-run public transport routing service, has been the topic of several discussions:

• Ways to deal with GTFS static feed rotation happening out of sync with corresponding realtime feeds. This results in time periods where available realtime information cannot be matched to base schedule data and thus gets needlessly discarded.
• How to best configure GBFS provider groups as supported by MOTIS v2.7.
• Integrating GBFS data from Citybikes, which would substantially increase the amount of available rental vehicle data.
• Assessing what it would take to add Transitous as an additional routing option to the OpenStreetMap website.
• Investigating how far along the OSM Road Closures GSoC project is, as that kind of data is obviously very interesting to integrate eventually.
• Exploring whether FOSSGIS e.V. would be a suitable organisational home for Transitous.

KPublicTransport

KPublicTransport, KDE’s client library for accessing different journey planning services used by Itinerary and KTrip, got a few improvements to catch up with Transitous and MOTIS v2.6 and v2.7 changes:

• Access to agency/operator URLs.
• Querying available station-bound and free-floating rental vehicles from MOTIS.
• Support for direct booking URLs for station-based rental vehicles.

Station-bound rental vehicles other than bikes are now also displayed with the correct vehicle icon on the map.

Indoor mapping

Indoor mapping was of course also on the agenda:

• I got to try Tobias’s JOSM patches improving level filtering. Especially the option to filter on elements without a level tag is helpful for fixing level tagging in existing buildings for me.
• We talked about ongoing tagging discussions from TU Munich’s BIM import, in preparation for the next quarterly OSM Indoor Meetup.
• We discussed whether we should have another in-person Indoor tagging workshop following the one from 2022, in order to have some time to work on finalizing tagging proposals and updating the current indoor tagging documentation.

Emergency and weather alerts

At the CAP Implementation Workshop two weeks ago a WFS/OGC feature layer for CAP alerts was mentioned, and presented as something so far only offered by a commercial entity.

With my almost non-existent GIS knowledge this looked like something that shouldn’t be too hard to provide by our CAP alert aggregation service as well. And thanks to the input from the right people I got a basic prototype set up in less than an hour. All the magic is provided by pg_featureserv, which can expose a PostGIS database (which we already have) in a way it can be consumed by e.g. QGIS.

One important difference here is that unlike its proprietary counter-part this doesn’t expose many CAP fields yet, as we hold only the bare minimum as dedicated database columns right now. However, should anyone actually need this, adding more columns isn’t a big deal.

Event planning

We also looked at upcoming events in 2026 and how we could have Transitous specifically and the Open Transport community more generally represented there:

• 39C3, 27-30 Dec in Hamburg Germany. We’ll try to have some kind of Transitous meetup there.
• FOSDEM, 31 Jan-1 Feb in Brussels, Belgium. The CfP for the Railways & Open Transport track is still open and we have poked a few people to submit talks.
• FOSSGIS-Konferenz, 25-28 Mar in Göttingen, Germany. The CfP is already closed, a few proposals have been submitted.

Still further out is next year’s State of the Map which will be end of August in Paris, France. That’s obviously something where Transitous should be present as well, and where we might have the option of a travel-optimized adjacent Transitous sprint along the way.

Ideas for a 2026 edition of the Open Transport Community Conference are also floating around already, volunteers to drive this still very much needed though.

You can help!

Hack weekends how this is called in the OSM community or sprints as this is known in the KDE community are immensely valuable and productive. There’s a great deal of knowledge transfer happening, and they are a big motivational boost.

However, physical meetings incur costs, and that’s where your donations help! KDE e.V. and local OSM chapters like the FOSSGIS e.V. support these activities.

Welcome to a new issue of This Week in Plasma!

This week Spectacle gained OCR (optical character recognition) functionality, allowing you to turn words in images into selectable text!

(and yes, this is Spectacle recording itself performing OCR)

Right now the functionality is limited to Spectacle, but the code is in the process of being moved to a library so more apps can benefit, too. Thanks a lot to Jhair Paris, who implemented this feature that will appear in Plasma 6.6!

In addition, many UI improvements landed, as well as some high-priority bug fixes and performance improvements. A good week, I’d say! Have a look:

Notable UI Improvements

Plasma 6.5.3

You can now drag a tab out of a Chromium/Chrome window and immediately tile it to a screen edge or corner. (David Redondo, link)

Implemented some improvements to the Breeze theming for GTK 4 apps, including making the rounded corners consistent and fixing invisible expander arrows for expandable group boxes. (Kevin Duan, link 1 and link 2)

Made the favorites column in the Kicker Application Menu widget compatible with more kinds of icons in non-default icon themes. (Christoph Wolk, link)

Plasma 6.6.0

Overhauled a bunch of the portal-based permission dialogs to just look way nicer in general. (Harald Sitter, link 1, link 2, link 3, link 4, link 5, link 6, link 7, link 8, link 9, link 10, link 11, link 12)

Renaming a file or folder on the desktop now lets it keep its existing position. (Błażej Szczygieł, link)

Plasma’s Timer widget now has a nicer and more straightforward configuration page, with two old pages merged into one new one. (Tobias Fella, link)

For similar reasons, the system Tray’s only two main configuration pages have also been merged into a single new one. (Nate Graham, link 1 and link 2)

When an app asks to register keyboard shortcuts on launch and you don’t let it, this preference is now remembered, instead of the annoying app just asking again the next time it launches. (David Redondo, link)

The GTK theme chooser now lets you preview the dark version of the theme, too. (Luan Oliveira, link)

Frameworks 6.21

File transfer notifications now fall back to file-based progress display in situations when size-based progress display isn’t available. (Pan Zhang, link)

The Breeze icon theme now includes icons for Nim code files. (Sophie Ahumada, link)

Notable Bug Fixes

Plasma 6.4.6

Fixed a seemingly random Plasma crash. (David Redondo, link)

Plasma 6.5.3

Fixed a regression that made KRunner crash when searching on operating systems that use Musl as their C standard library instead of Glibc. (John Zimmermann, link)

Fixed a case where Discover could crash while updating software if Flatpak itself throws a malformed error. (Aleix Pol Gonzalez, link)

Fixed a regression that broke Spectacle’s “exclude shadows” option. (Vlad Zahorodnii, link)

Fixed a regression that made desktop icons not get visually hovered when approaching them from the left side at certain speeds and locations. (Błażej Szczygieł, link)

Fixed an issue that made the context menu for apps or processes being monitored in System Monitor open in the wrong place when using certain multi-screen setups. (Oliver Schramm, link)

Worked around a Qt regression that broke hiding columns in System Monitor’s table views using the column header context menu. (Alexey Rochev, link)

Worked around a kernel bug that that made some systems fail to go to sleep the first time it was initiated. (Bhushan Shah, link)

Worked around some driver bugs that caused mangled cursor styling with certain GPUs. (Xaver Hugl, link 1 and link 2)

Other bug information of note:

• 4 very high priority Plasma bugs (same as last week). Current list of bugs
• 31 15-minute Plasma bugs (down from 35 last week). Current list of bugs

Notable in Performance & Technical

Plasma 6.5.3

Fixed a case where KWin could get blocked due to heavy disk I/O operations. (Vlad Zahorodnii, link)

The clipboard portal now supports being used in remote desktop sessions and with middle-click primary selection. (David Redondo, link 1 and link 2)

Increased the level of visual fidelity when using a fractional scale factor. (Xaver Hugl, link)

Plasma 6.6.0

Increased the level of visual fidelity when using a fractional scale factor even more, this time when using software rendering. (Vlad Zahorodnii, link)

A process that’s crashing in a loop can no longer make the system run out of memory and freeze as a result of the crash tracer trying to debug all the crashes. (Harald Sitter, link)

How You Can Help

Donate to KDE’s 2025 fundraiser! It really makes a big difference. Believe it or not, we’ve already hit out our €75k stretch goal! I’ve been informed that a second stretch goal is available now, too! I’m just in awe of the generosity of the KDE community and userbase. Thank you all for helping KDE to grow and prosper.

If money is tight, you can help KDE by directly getting involved. 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.

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.

Let’s go for my web review for the week 2025-46.

Valve is about to win the console generation

Tags: tech, valve, kde, hardware, gaming, desktop

Early days, we’ll need to see the pricing and reviews. I’m obviously excited to see KDE going in even more consumer devices by default. Let’s hope it sells even better than the Steam Deck.

https://xeiaso.net/blog/2025/valve-is-about-to-win-the-console-generation/

Meta’s Chief AI Scientist Yann LeCun To Depart And Launch AI Start-Up Focused On ‘World Models’

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

I was actually wondering when this would happen. Was just a matter of time, would have expected this move a couple of months ago.

https://www.nasdaq.com/articles/metas-chief-ai-scientist-yann-lecun-depart-and-launch-ai-start-focused-world-models

Less is More: Recursive Reasoning with Tiny Networks

Tags: tech, ai, machine-learning, reasoning, research

Clearly needs further exploration. I’d like to see it submitted in a peer reviewed journal but maybe that will come. Still it’s nice to see people for new approaches. It’s a breath of fresh air. I like it when there are actual research rather than hype. Hopefully the days of the “scale it up and magic will happen” are counted.

https://arxiv.org/abs/2510.04871

Introduction to IncusOS

Tags: tech, virtualization, containers, infrastructure, linux, incus

I didn’t know about this project. This sounds interesting, smart use of mkosi to make an Incus tailored system.

https://linuxcontainers.org/incus-os/

Linux process priorities demystified

Tags: tech, linux, kernel, processes, multithreading

Does a nice job explaining how the scheduling can be investigated from outside the kernel. It is a good introduction on the topic.

https://www.sigma-star.at/blog/2022/02/linux-proc-prios/

Announcing Magika 1.0: now faster, smarter, and rebuilt in Rust

Tags: tech, filesystem, foss

Looks more and more like an interesting solution for file type detection.

https://opensource.googleblog.com/2025/11/announcing-magika-10-now-faster-smarter.html?m=1

The (lazy) Git UI You Didn’t Know You Need

Tags: tech, git, version-control, tools

Nice tour of LazyGit. I keep hearing good things about it, I should really try it.

https://www.bwplotka.dev/2025/lazygit/

Imperative to relational

Tags: tech, databases, sql, learning

Long but nice post about all the things you need to figure out about working with databases when the only thing you know is imperative languages.

https://madhadron.com/imperative_to_relational.html

Automated Equality Checks in C++ with Reflection (C++26)

Tags: tech, c++, metaprogramming

Another nice use of the upcoming C++ reflection feature.

https://lemire.me/blog/2025/11/09/automated-equality-checks-in-c-with-reflection-c26/

Hardening the C++ Standard Library at massive scale

Tags: tech, c++, safety, security, standard

Interesting work from Apple and Google to have better hardening in libc++. It’s nice to see it ripples through the upcoming C++26 standard as well.

https://queue.acm.org/detail.cfm?id=3773097

channels-console: Real-time monitoring, metrics and logs for Rust channels

Tags: tech, rust, debugging, distributed, multithreading

Early days but this looks like interesting tooling to inspect and debug programs using Rust channels.

https://github.com/pawurb/channels-console

The state of the Rust dependency ecosystem

Tags: tech, rust, ecosystem, supply-chain

Interesting analysis of the crates ecosystem. It shows quite well some of the challenges and weaknesses. Nothing to worry about yet about the ecosystem health overall. Still, you should probably be careful when picking dependencies.

https://00f.net/2025/10/17/state-of-the-rust-ecosystem/

GPU Glossary

Tags: tech, gpu, hardware, learning

Looks heavy on the NVidia specifics but it looks like a very comprehensive view of the important concepts in a GPU.

https://modal.com/gpu-glossary

The “Dependency Cutout” Workflow Pattern

Tags: tech, foss, economics, supply-chain, community

This is indeed the best way to handle your open source dependencies. I got concerns about the ability to sell that to management though because of the extra steps. It’s also probably why you want to have an OSPO in your company, it’s a good way to lower the barrier for developers to contribute this way.

https://blog.glyph.im/2025/11/dependency-cutout-workflow-pattern.html

100% coverage is not that trivial

Tags: tech, tests, tdd, coverage

In a large codebase it’s not a given indeed. That’s why you want integration tests to get there.

https://blog.ploeh.dk/2025/11/10/100-coverage-is-not-that-trivial/

Composable Tests

Tags: tech, tests, tdd

This is maybe the property of tests which is the most easily misunderstood. It’s not always easy to respect it as well.

https://tidyfirst.substack.com/p/composable-tests

Forget Chatbots. You Need a Notebook.

Tags: tech, note-taking, science, research, productivity

I had a few moment like this in my life. I definitely recommend it. I’ve never been more productive than isolated in a mountain with only books, notebooks and pens.

https://calnewport.com/forget-chatbots-you-need-a-notebook/

Bye for now!

Friday, 14 November 2025

KDE today announces the release of KDE Frameworks 6.20.0.

This release is part of a series of planned monthly releases making improvements available to developers in a quick and predictable manner.

New in this version

Stretching your Qt UI to devices powered by microcontrollers (MCU) is now even easier! The Qt Quick Ultralite Converter of the Qt AI Assistant translates a QML to Ultralite-compliant code. It brings core Qt graphical features to resource-constrained embedded systems, streamlining application development and deployment.

Akademy 2026 will be a special edition, marking the 30th anniversary of KDE! This milestone event will take place at the Graz University of Technology in Graz, Austria.

This birthday edition of Akademy will continue to bring together contributors, users, partners, and friends of KDE to reflect on three decades of collaboration, innovation, community growth, and commitment to Free Software. Just like previous years, Akademy 2026 will be a hybrid event, offering both on-site and online participation.

We will be announcing the exact dates soon. Until then, follow us on Mastodon and Lemmy for the latest Akademy updates!

About Graz

Graz is the second-largest city in Austria and the capital of the federal state of Styria. Known for its well-preserved old town, which is a UNESCO World Heritage Site, Graz offers a blend of historic charm and modern vibrancy. The city is home to numerous cultural attractions, including the iconic Schlossberg with its clock tower, the Kunsthaus Graz, and the Murinsel, a unique architectural feature on the River Mur. Graz is also renowned for its educational institutions, particularly the University of Graz and the Graz University of Technology, making it a hub for innovation and research. The city's lively atmosphere, beautiful parks, and rich culinary scene make it an ideal destination for both leisure and professional visits.

About Akademy

For most of the year, KDE, one of the largest free and open software communities in the world, works online communicating over email, instant messaging, video-conferencing, forums and mailing lists. Akademy provides all KDE contributors with the opportunity to meet in person to foster social bonds, work on concrete technology issues, discuss new ideas, and reinforce the innovative, dynamic culture of KDE. Akademy brings together artists, designers, developers, translators, users, writers, sponsors and many other types of KDE contributors to celebrate the achievements of the past year and help determine the direction for the next year. Hands-on sessions offer the opportunity for intense work, bringing those plans to reality. The KDE community also welcomes companies building on KDE technology to Akademy, as well as those who are looking for opportunities.

Aurorae is a decoration engine that allows you easily using third party decoration themes from KDE Store.

It’s been around for quite a while and it has a plenty long history. However, in the recent years, it has been somewhat neglected. The UI trends changed, e.g. rounded corners are all the rage now, but there has been no changes in Aurorae to allow theme creators to follow those trends more easily. There are also performance issues. In comparison to the default Breeze decoration theme, it performs quite poorly, unfortunately.

What is Aurorae anyway?

In Plasma, we have a C++ library that’s used to implement window decorations called KDecoration. Both Breeze and Aurorae use KDecoration, but the main difference between the two is that the former directly implements a window decoration that follows Breeze style, while the latter is just a very themeable window decoration.

Aurorae supports both QML and SVG themes. With a QML theme, you need to write some QML code to define how the window decoration should look and behave. With an SVG theme, you need to provide a bunch of SVG files that specify how the window frame and various buttons look. Under the hood, SVG themes are effectively built as QML themes.

QML is pretty cool because with a few lines of code, you can get something that works and looks very decent. But for our usecase, it’s also a heavy tool, and due to the way how QtQuick works, it’s very challenging to have proper fractional scaling support. To be fair, normal applications that use QtQuick are mostly fine, it’s just that we have a pretty unique usecase where we need full control where every individual pixel gets painted.

Aurorae V2

Recently, I started a rewrite of Aurorae with a few goals in mind. The first goal is to improve performance so KWin doesn’t struggle when you resize a window (just to be clear, no, this doesn’t mean that there are performance issues in QtQuick. The way QML decorations are rendered is inefficient. We render a QtQuick scene in an offscreen texture, then download its contents, and then upload its contents in another texture. These roundtrips kill performance, and they are necessary because of KDecoration API constraints). The second goal is to open up the road for fractional scaling support improvements, like fixing misaligned window border edges or gaps between the decoration and the window contents. The third goal is to prepare the foundation for future improvements and to provide more tools so artists can create themes that reflect “modern” stylistic tendencies.

In this rewrite, raw KDecoration and KSvg APIs are used. This makes aurorae decorations quite lightweight and it significantly improves performance. Some fractional scaling issues have already been fixed, while others still need more work. Window decorations are rendered on the CPU side. While, yes, it will be nice to have everything done on the GPU side, doing things on the CPU side is also not that of a big bottleneck right now. In the future, we may follow up on doing more things on the GPU, but for now, it is not high priority.

The main focus has been on improving performance issues and preserving compatibility with the previous implementation of SVG decoration themes so decorations look more or less the same way. There may be some (unintentional) differences, but they should be very minimal.

What about QML decoration themes then? The main idea behind them is brilliant, but after so many years, there are not that many window decoration themes that use QML. In either case, the original (V1) and rewritten (V2) aurorae engines live side-by-side, but the future of V1 is unclear. QML and SVG decoration themes will use V1 and V2, respectively.

Future plans

At the moment, the goal is to continue polishing and optimizing V2. There are certain limits how far we can push things due to the theme format. Some parts of the theme force us to do some things, which ideally we shouldn’t do.

It’s highly likely (not saying this for sure though!) that there will be a V3, which is going to address some theme limitations and add support for new features, for example rounding bottom window corners or outlines.

If you’re a decoration theme creator and would like to see some particular feature in Aurorae, feel free to reach out to me (@zzag) on Matrix (e.g. in #kwin) or file a feature request at https://bugs.kde.org (product: kwin; component: aurorae).