Before arriving in Graz I already did some work on the train from Vienna. I published a new version of kio-gopher so KDE Frameworks 6 applications can browse gopher sites and helped finish the review of KDominate, Albert Vaca's latest tactical game.

At the Sprint itself many things were achieved, too many to remember. 

There was some discussion about improving release notes so they go into the appstream files and end up in lots of interesting places (apps.kde.org, Discover, etc).

I also talked a bit with David Edmundson on how to streamline our work in the KDE Security team.

Another important thing was that we introduced a way to help us enable the LeakSanitizer in more repositories (by ignoring leaks that are not our fault and that we can't control) 

Non-planned group photo of Sprint attendees, a few are missing. Apologies!

 

While we were at the Sprint it was announced that we will have Akademy 2026 also in Graz. So start preparing to visit Austria in late September! 

Grazer Linuxtage was very nice, as far as I've heard also very successful in attendance, with the estimate being around 50% more than the previous year (hard to calculate when you don't require registration).

There were not many talks in English but the ones I attended were interesting. If you have time I would recommend giving them a quick skim to see if they interest you.

Transitous - Free and Open Public transport routing  (from KDE's own Volker Krause)

What can we learn from Android for other embedded Linux systems security? (Every app in Android is a different Linux user)

LibreOffice: What we're doing, where we're going, and how you can help (Very fashionable given the latest rifts in the community (sadly))

How we hacked the Bavarian State with an Open Source Open Letter (About how to pressure administrations not to give Microsoft all of our tax money)

I gave a talk about KDE and the 30 years of the Linux desktop, that from the reaction of the attendees I think it was well received, that's always nice :) 

The video from my talk is available at https://media.ccc.de/v/glt26-691-kde-30-years-of-the-linux-desktop 

Thanks everyone involved in the organization and Kevin Krammer in particular for hosting us! 

So useful!

I immediately wanted to apply this to KDE projects. So I took the commands from the post and made some shell aliases and functions for convenience:

# git repo analysis tools
alias what-changes="echo 'What changes a lot?' && git log --format=format: --name-only --since='1 year ago' | rg -v 'po$|json$|desktop$' | sort | uniq -c | sort -nr | head -20"
alias what-breaks="echo 'What breaks a lot?' && git log -i -E --grep='fix|bug|broke|bad|wrong|incorrect|problem' --name-only --format='' | sort | uniq -c | sort -nr | head -20"
alias emergencies="echo 'And what were the emergencies?' && git log --oneline --since='1 year ago' | grep -iE 'revert|hotfix|emergency|urgent|rollback'"
alias momentum="echo \"What's the project's momentum over the past 5 years?\" && git log --format='%ad' --date=format:'%Y-%m' | sort | uniq -c | tail -n 60"
alias maintainers-recently="echo \"Who's been driving this project in the past year?\" && git shortlog -sn --no-merges --since='1 year ago' | rg -v 'l10n daemon script' | head -n 30"
alias maintainers-alltime="echo 'And what about for all time?' && git shortlog -sn --no-merges | rg -v 'l10n daemon script' | head -n 30"
function repo-analysis {
    what-changes
    echo
    what-breaks
    echo
    emergencies
    echo
    momentum
    echo
    maintainers-recently
    echo
    maintainers-alltime
}

Now let’s run it on Plasma. Here’s plasma-workspace, the core of Plasma:

$ git clone ssh://git@invent.kde.org/plasma/plasma-workspace.git
$ cd plasma-workspace
$ repo-analysis
What changes a lot?
  1519  
    38 CMakeLists.txt
    29 shell/shellcorona.cpp
    24 runners/services/servicerunner.cpp
    21 wallpapers/image/imagepackage/contents/ui/config.qml
    19 libnotificationmanager/notifications.cpp
    18 shell/org.kde.plasmashell.desktop.cmake
    18 devicenotifications/devicenotifications.cpp
    17 kcms/lookandfeel/kcm.cpp
    16 wallpapers/image/plugin/model/packagelistmodel.cpp
    16 kcms/cursortheme/xcursor/xcursor.knsrc
    15 wallpapers/image/plugin/model/imagelistmodel.cpp
    15 applets/notifications/global/Globals.qml
    15 applets/devicenotifier/devicecontrol.cpp
    14 wallpapers/image/plugin/imagebackend.cpp
    14 shell/panelview.cpp
    14 .kde-ci.yml
    14 applets/systemtray/systemtray.cpp
    13 runners/services/autotests/servicerunnertest.cpp
    12 krunner/qml/RunCommand.qml

What breaks a lot?
   225 shell/shellcorona.cpp
   183 shell/panelview.cpp
    83 CMakeLists.txt
    74 applets/systemtray/package/contents/ui/main.qml
    71 applets/digital-clock/package/contents/ui/DigitalClock.qml
    63 klipper/klipper.cpp
    62 applets/notifications/package/contents/ui/NotificationItem.qml
    58 wallpapers/image/imagepackage/contents/ui/config.qml
    56 shell/desktopview.cpp
    56 libtaskmanager/tasksmodel.cpp
    54 shell/main.cpp
    54 applets/systemtray/systemtray.cpp
    53 shell/shellcorona.h
    52 krunner/view.cpp
    48 applets/digital-clock/package/contents/ui/CalendarView.qml
    47 runners/services/servicerunner.cpp
    46 wallpapers/image/imagepackage/contents/ui/main.qml
    45 applets/notifications/package/contents/ui/NotificationPopup.qml
    44 applets/systemtray/package/contents/ui/ExpandedRepresentation.qml
    43 startkde/startplasma.cpp

And what were the emergencies?
4f526a7bd1 Revert “applets/systemtray: Prevent popups from overlapping with the panel”
dca5788fee lookandfeel/components: Revert Plasma::setupPlasmaStyle
2c0fd34541 Revert “ContainmentLayoutManager: send recursive mouse release events too”
b6b230f4ff Revert “Read selenium-webdriver-at-spi-run location from CMake”
b8651b56f6 hotfix: Remove doc translations without actual doc
1f43f576e8 Revert “Add forceImageAnimation property to force animated image play”
f0349b6c81 hotfix: remove stray .po file
3ff7ae4269 Revert “CI: enable parallel testing”
83bebc7896 Revert “Limit evaluateScript execution at 2 seconds”
4f45f672be Revert “kcms/componentchooser: Don’t offer NoDisplay services”
3bf0ff8f56 Revert “Disable linux-qt6-next while the regression in Qt gets fixed”
80996f0633 Revert “kcms/wallpaper: set roleNames for WallpaperConfigModel”

What’s the project’s momentum over the past 5 years?
   148 2021-05
    87 2021-06
    62 2021-07
    85 2021-08
   121 2021-09
   106 2021-10
   146 2021-11
   190 2021-12
   191 2022-01
    84 2022-02
   168 2022-03
   130 2022-04
   146 2022-05
   141 2022-06
   136 2022-07
   107 2022-08
   232 2022-09
   234 2022-10
   181 2022-11
   150 2022-12
   154 2023-01
   161 2023-02
   156 2023-03
   156 2023-04
   163 2023-05
   137 2023-06
   186 2023-07
   190 2023-08
   275 2023-09
   226 2023-10
   283 2023-11
   157 2023-12
   131 2024-01
   147 2024-02
   249 2024-03
   180 2024-04
   188 2024-05
   158 2024-06
   128 2024-07
   146 2024-08
   169 2024-09
   156 2024-10
   116 2024-11
    98 2024-12
   145 2025-01
   126 2025-02
   120 2025-03
   116 2025-04
   131 2025-05
   131 2025-06
   132 2025-07
   115 2025-08
   110 2025-09
    97 2025-10
   147 2025-11
   114 2025-12
   140 2026-01
   131 2026-02
   119 2026-03
    44 2026-04

Who’s been driving this project in the past year?
  116  Vlad Zahorodnii
  113  Nicolas Fella
   87  Christoph Wolk
   82  Fushan Wen
   78  Nate Graham
   66  Kai Uwe Broulik
   48  Bohdan Onofriichuk
   37  Harald Sitter
   34  Tobias Fella
   31  Marco Martin
   30  David Edmundson
   25  Akseli Lahtinen
   21  Ismael Asensio
   17  David Redondo
   16  Niccolò Venerandi
   15  Bhushan Shah
   11  Alexander Lohnau
   11  Kristen McWilliam
    9  Oliver Beard
    9  Shubham Arora
    8  Alexey Rochev
    8  Han Young
    8  Philipp Kiemle
    7  Albert Astals Cid
    6  Aleix Pol
    6  Méven Car
    5  Devin Lin
    5  Joshua Goins
    4  Alexander Wilms
    4  Arjen Hiemstra

And what about for all time?
 1543  Fushan Wen
 1497  Marco Martin
 1374  Kai Uwe Broulik
 1030  David Edmundson
  772  Nate Graham
  658  Alexander Lohnau
  551  Aleix Pol
  548  Nicolas Fella
  438  ivan tkachenko
  385  Eike Hein
  264  Sebastian Kügler
  250  Martin Gräßlin
  238  Harald Sitter
  232  Martin Klapetek
  223  Jonathan Riddell
  207  Vlad Zahorodnii
  194  David Redondo
  190  Friedrich W. H. Kossebau
  189  Laurent Montel
  144  Bhushan Shah
  134  Christoph Wolk
  134  Ismael Asensio
  126  Lukáš Tinkl
  121  Niccolò Venerandi
  117  Méven Car
  105  Natalie Clarius
   91  Konrad Materka
   80  Vishesh Handa
   80  Volker Krause
   79  Ivan Čukić

ShellCorona both changing and breaking a lot is no great surprise to me; it’s fiddly and complicated. We need to do something about that. The number of emergencies doesn’t look too bad, and momentum feels fine too. The project also appears to have a nice healthy diversity of contributors. Excellent!

It’s been quite illuminating to run these tools on KDE projects that I’m both more and less familiar with. Give it a try!

France Launches Government Linux Desktop Plan as Windows Exit Begins

Tags: tech, foss, politics, desktop, france, europe

Well, what can I say? This is excellent news and I’m excited to see it happen. Let’s hope more governments do the same. It’ll take a while of course, so we’ll have to be patient.

https://linuxiac.com/france-launches-government-linux-desktop-plan-as-windows-exit-begins/

The Free Market Lie: Why Switzerland Has 25 Gbit Internet and America Doesn’t

Tags: tech, infrastructure, economics

A good explanation and illustration of how natural monopolies work. This is why you want to regulate infrastructure properly.

https://sschueller.github.io/posts/the-free-market-lie/

You can absolutely have an RSS dependent website in 2026

Tags: tech, blog, rss

The stats are clear there. Beside in term of experience, RSS feeds are so superior to newsletters… I wish more bloggers would give up on the newsletter focus. There’s also a good point in this post: as soon as you have a newsletter you will sit on a database of email addresses, it’s definitely a liability.

https://matduggan.com/you-can-absolutely-have-an-rss-dependent-website-in-2026/

The Downfall and Enshittification of Microsoft in 2026

Tags: tech, microsoft, github, apple, linux, business, product-management

Indeed, the giant managed to make itself weak. This means opportunities for other ecosystems to grow faster than before.

https://caio.ca/blog/the-downfall-and-enshittification-of-microsoft.html

Let’s talk about LLMs

Tags: tech, ai, machine-learning, copilot, productivity, craftsmanship

Long but very precise piece about why you can likely ignore LLM for development purpose. Starting from older Fred Brooks work is spot on. Indeed whatever will remain of LLM based tools in the years to come, it’s much smarter to focus on fundamental skills than chase the new tools. At least, I’m trying to do my share in getting myself and others better at the craft.

https://www.b-list.org/weblog/2026/apr/09/llms/

Almost Half of US Data Centers That Were Supposed to Open This Year Slated to Be Canceled or Delayed

Tags: tech, ai, machine-learning, gpt, energy, economics, infrastructure

It’s getting clearer that the industrial LLM complex will have a hard time meeting its targets.

https://futurism.com/science-energy/data-centers-construction-supply

“Cognitive surrender” leads AI users to abandon logical thinking, research finds

Tags: tech, ai, machine-learning, gpt, cognition, bias

It feels like it’s supercharging an old bias… We tend to confuse confidence for competence.

https://arstechnica.com/ai/2026/04/research-finds-ai-users-scarily-willing-to-surrender-their-cognition-to-llms/

The machines are fine. I’m worried about us.

Tags: tech, ai, machine-learning, gpt, copilot, learning, science, research

Excellent piece, it show quite well the problem of skipping the “grunt work”. Without it you can’t really learn your trade (be it astrophysics or anything else). It also shows how the incentives on scientific careers are wrong. It’s not new, but when LLM agents become available, things are definitely changing for the worst.

https://ergosphere.blog/posts/the-machines-are-fine/

Giving LLMs a Formal Reasoning Engine for Code Analysis

Tags: tech, ai, machine-learning, copilot, prolog, logic

Definitely interesting approach. I think neurosymbolic approaches are what we ultimately need so I’m probably biased. At least it means using LLMs for what they’re good at (language skills) and only that. Then rely on proper code symbolic models which do the reasoning heavy lifting. I’d expect it can give nice output with smaller models.

https://yogthos.net/posts/2026-04-08-neurosymbolic-mcp.html

Open source security at Astral

Tags: tech, security, ci, supply-chain

Lots of interesting measures to reduce the risk of supply chain issues. Definitely to be considered on your projects.

https://astral.sh/blog/open-source-security-at-astral

another memory corruption case

Tags: tech, hardware, memory, failure

Failing DRAM chips are real. Here is the case of debugging a single bit flip.

https://trofi.github.io/posts/347-another-memory-corruption-case.html

The Git Commands I Run Before Reading Any Code

Tags: tech, git, version-control, team, audit

Nice little commands to use to discover quickly the state of a code base… Or rather of its team.

https://piechowski.io/post/git-commands-before-reading-code/

Zsh: select generated files with (om[1]) glob qualifiers

Tags: tech, zsh, shell

Oh this is super neat and convenient! I didn’t know about those glob patterns modifiers in zsh.

https://adamj.eu/tech/2026/01/27/zsh-om1-glob-qualifiers/

Two little scripts: addup and sumup

Tags: tech, unix, shell, scripting

A friendly reminder that one can go far mainly with awk.

https://utcc.utoronto.ca/~cks/space/blog/sysadmin/LittleScriptsIX

All of the String types

Tags: tech, memory, unicode, encodings

So many string types! They all have a purpose of course. It’s a good reminder that something mundane like a string type is not that simple.

https://lambdalemon.gay/posts/string-types

Stamp It! All Programs Must Report Their Version

Tags: tech, version-control, debugging

Examples of how i3 and go stamp versions. This is indeed good habits to ease dealing with errors in production.

https://michael.stapelberg.ch/posts/2026-04-05-stamp-it-all-programs-must-report-their-version/

The MVC Mistake

Tags: tech, architecture, complexity

Shows the problem with layer cakes in applications or how you might want to go toward onion architectures.

https://entropicthoughts.com/mvc-mistake

The Mouse That Roared

Tags: tech, leadership, tests, tdd, agile, organisation

Cryptic title to be honest. But this is a good explanation of why any “agile transformation” better start close to the code and in particular with automated tests. If you can crack that nut (and it takes time), the rest will follow naturally.

https://codemanship.wordpress.com/2026/03/30/the-mouse-that-roared/

If you thought the speed of writing code was your problem - you have bigger problems

Tags: tech, productivity, organisation, leadership, ai, machine-learning, copilot

So much this… There are so many organisational problems that churning code faster is likely not what you need. When did we start to obsess with the number of lines of code?

https://andrewmurphy.io/blog/if-you-thought-the-speed-of-writing-code-was-your-problem-you-have-bigger-problems

Are We Idiocracy Yet?

Tags: satire, culture

Getting there, one day at a time.

https://idiocracy.wtf/

Bye for now!

My mission this week has been to scout locations and activities for the Akademy conference later this year. One of the members of our local organizing team let me (temporarily) adopt their stuffed Konqi, so I have been wandering around Graz and the state of Styria with a stuffed dragon taking a bunch of pictures, drinking Aperol Spritz, eating chocolate, and petting animals to make sure that all the places we visit in September will be fun and accessible for everyone who joins.

This year KDE turns 30, so we are planning a big celebration for Akademy. I have been thrilled to discover that Graz is very accessible. The town tourism website has a guide for navigating with a wheelchair or other mobility devices; many restaurants have mocktails or homemade juice/tea options for non-alcoholic drinks; the city is full of plazas you can sit and sip a coffee in for hours when you need a break from walking, and there is an abundance of parks and fountains that children can expel their energy playing in.

I can’t wait to introduce the KDE community to Graz this September!

Akademy 2026 will be a hybrid event held simultaneously in Graz, Austria, and online. The Call for Participation is open! Send us your talk ideas and abstracts.

Why talk at #Akademy2026

Akademy attracts artists, designers, developers, translators, users, writers, companies, public institutions and many other KDE friends and contributors. We celebrate the achievements and help determine the direction for the next year. We all meet together to discuss and plan the future of the Community and the technology we build. You will meet people who are receptive to your ideas and can help you with their skills and experience. You will get an opportunity to present your application, share ideas and best practices, or gain new contributors. These sessions offer the opportunity to gain support and make your plans for your project become a reality.

How to get started

Do not worry about details or slides right now. Just think of an idea and submit some basic details about your talk. You can edit your abstract after the initial submission. All topics relevant to the KDE Community are welcome. Here are a few ideas to get you started on your proposal:

• How KDE can empower building robust communities in changing political climates
• Work towards KDE's goals: Streamlined Application Development Experience, We care about your Input, and KDE Needs You
• Giving people more digital freedom, sovereignty, and autonomy with KDE software
• Advice on how to participate for new users, intermediates and experts
• New developments/plans for KDE Frameworks, Plasma, Applications and other projects
• 30 years of KDE: achievements, highlights, and what’s next
• Anything else that might interest an audience of long-time, new, and potential KDE contributors!

To get an idea of talks that were accepted, check out the program from previous years: 2025 2024, 2023, 2022, 2021, 2020, 2019, 2018, and 2017.

For more details and information, visit Call for Participation.

We're currently working on porting Qt to HarmonyOS. For our CI and developer machines, we need a number of third-party libraries built for HarmonyOS. Cross-compiling open-source C and C++ libraries for this platform has been a manual, error-prone process. Each library has its own build system, whether CMake, Autotools, or Meson. Each needs individual attention to produce correct binaries for the OHOS target. We have been maintaining a hand-written shell script that builds libraries one by one, with per-library workarounds for cross-compilation quirks.

With our vcpkg fork, that script is now a single command.

By adding a corresponding back end to Solid, KDE’s hardware abstraction framework, your phone’s battery status will show up in the “Power & Battery” popup just like a wireless mouse would. The key advantage of reporting a KDE Connect device as storage media is that it can show up in various places just like a USB drive would, including the Places panel in Dolphin and “Disk & Devices” in Plasma’s system tray. Right now, the Places panel entry is actually manually added by kdeconnectd creating a bookmark. This also means that any modifications done to the entry, such as hiding it, will be lost once the device disappears. If instead it is a proper Solid device with a unique identifier, the Places panel will remember that the device was hidden next time it is discovered. Additionally, PowerDevil, Plasma’s power management daemon, already automatically issues a notification when a connected external device runs low on battery.

Now that the fact that you can browse your phone’s storage remotely via KDE Connect is more obvious, I spent some time improving the user experience when doing so. Since KDE Connect is cross-desktop and cross-platform it uses sshfs to provide access to the phone. It doesn’t implement a proper KIO worker like we normally would since that really only works in KDE applications. This unfortunately comes with a couple of downsides: for example, the device is mounted into /run/user/<uid>/<deviceid> which is gibberish that will be shown to the user in the address bar. More importantly, though, it makes the file manager think it’s a local path (which is normally fast to access) and could lead to UI freezes when the connection is slow or unstable.

To improve this, I made use of KIO’s ForwardingWorkerBase. This is a tiny KIO worker that just rewrites a URL and forwards it to a different location. This way, the application sees a “remote” kdeconnect://device/path URL and keeps everything nice and asynchronous but under the hood still uses the sshfs infrastructure we already have. It’s what the magic desktop:/ URL uses that parses the name of .desktop files (so your get nice application names) but other than that merely reads from /home/<user>/Desktop. This also makes the entry in the Places panel match up with the URL being browsed and ultimately makes the device’s name appear on the address bar instead of an ugly UUID.

While at it, I also added a “KDE Connect Devices” link to the “Network” folder, like we already have for Bluetooth, MTP, and Apple devices. Finally, when there is only a single storage location on the device, such as “Internal Shared Storage”, it redirects into it automatically. This saves one click when opening the device and puts you directly where your stuff is. The back end has just been merged and will be released next month as part of KDE Frameworks 6.26. However, since there’s still a bunch of infrastructure work needed around it, the back end is disabled by default. We will likely need to have at least KDE Gear 26.08 and Plasma 6.7 released that will include some necessary changes before we can flip the switch.

If you run latest KDE git builds, please give it a try and let me know what you think! You need to set the SOLID_ENABLE_KDECONNECT=1 environment variable to use it. To enable all debug output to aid debugging, set QT_LOGGING_RULES=kf.solid.backends.kdeconnect*=true or use KDebugSettings.

KDE today announces the release of KDE Frameworks 6.25.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

Another year, another successful Season Of KDE for 20 contributors! This article has been co-written with the input from all contributors.

Lokalize

During Season of KDE 2026, Tanish Kumar worked on cleaning up the UI in Lokalize, KDE’s translation tool. The main task was fixing an annoying bug where the menu bar kept jumping around whenever you switched tabs, which was solved by giving the menus a stable “skeleton” in the KXMLGUI .rc files. Along the way, a bunch of “ghost actions” were discovered - menu entries that existed only in XML - and actually implemented the missing ones like Cut, Copy, Paste, Alternate Translation, Save All, Revert All, and Close All. He also built a Bookmark Manager dialog so translators can see all their bookmarks in one place.

Navya Sai Sadu and Kumud Sagar fixed navigation inconsistencies in the Editor Tab where shortcuts like “Approve and Go Next” failed to respect active filters and custom ordering in the Translation Units view. They ensured consistent behavior across all related shortcuts, including Next Ready, Next Non-Empty, and Next Bookmark. They unified the traversal logic so navigation always follows the filtered and ordered entries and users of Lokalize can now navigate through Translation Units using the keyboard shortcuts or the options in Go menu properly..

Additionally, Kumud identified Lokalize’s on-disk file tracking mechanism and began improving its handling of external file updates.

Jaimukund Bhan fixed foundational issues with the Glossary file, ensuring it could be properly loaded, saved, and autosaved, and cleaned up the codebase by removing an obsolete Restore function that no longer made sense once autosaving was in place. Several UI bugs were resolved, including the editor failing to clear when all terms were deleted and incorrect pre-selection behavior when the app started on the Glossary tab. In the second half, Jaimukund improved the manual term addition workflow by replacing silent blank entry creation with a proper dialog prompt, preventing accidental accumulation of empty entries. He also fixed a broken keyboard shortcut for switching to the previously active tab by replacing an index-based tracking variable with a widget pointer, which remains valid even as tab positions change.

Aditya Sarna made a full Figma redesign for the Glossary tab, which was referenced in several places to implement comprehensive UI and UX improvements. The work involved close collaboration with translators to understand user pain points and iterating on designs based on feedback from the design group. It included replacing button text with icons and adding tooltips to the Add and Delete buttons to clarify their purpose. This was followed by designing a new delete functionality, which introduced a cross button for each entry to make deletion more intuitive. Several additional UI changes were implemented, including shifting elements and improving the overall structure and layout of the Glossary tab. Furthermore, the workflow for adding new terms was refined by moving note text into the dialogue box and enhancing its layout, resulting in a cleaner, more intuitive and user-friendly interface.

Varun Sajith Dass worked on improving the proofing capabilities of Lokalize and implemented a reactive character consistency check that alerts translators in real-time when special characters are mismatched between the source and target strings. This involved debugging Qt UI signals, resolving macOS build issues with KIO workers, and creating a persistent status bar warning system to enhance the overall translation workflow.

Vishesh Srivastava worked on adding Appium-based UI testing to KDE’s Lokalize. Vishesh started with a small bug fix and unit test to familiarize with the codebase and then built a complete Appium test from scratch, including basic tests and a full end-to-end workflow. Another thing done was adding accessibility ids in the UI so Appium could interact with the editor. The tests were integrated into the CMake system, ensured they ran independently of the user, and can run with kde-builder tests with a flag. By the end, Vishesh had developed a functional UI testing framework for Lokalize, along with documentation to help future contributors.

KDE mentorship website

Advaith Sathish Kumar project was transforming mentorship.kde.org into a proper onboarding system for new KDE contributors. On the homepage, the hero section was redesigned, placeholder routing with experience based navigation was replaced, social media links were added, and the news cards to include author, date, and tags were also redesigned. For the /mentees page, I added past mentee details, implemented pagination, and added client-side filtering by year, program, and technology.

Aryan's project was to make mentorship.kde.org better so that new contributors who want to work with the KDE ecosystem have a better onboarding experience. As part of this effort, a new "/programs" page was added. It gives a structured overview of the main KDE mentorship programs and links to help newcomers find their way around the opportunities more easily. He also changed the card template to better organize the repository, making it more structured, easier to maintain. Aryan also filled the /resources page with more useful resources for new contributors.

Documentation website

Mohit Mishra worked on decoupling the bundled dblatex fork from the docs-kde-org repository and fixing PDF generation for Chinese, Japanese and Korean (CJK) languages for KDE documentation. This involved switching the TeX engine to XeTeX from pdfTeX and then re-integrating the KDE styles. The outputs are now nearly identical, with CJK languages rendering correctly as well. There is still work in process to ensure there are no regressions and we can officially switch to this generation.

Scripty

Aviral Singh and Keshav Nanda worked on fixing KDE's translation tools so translators can easily locate where text belongs in the code. Keshav corrected the underlying logic to make sure these paths are always accurate, and Aviral built an automated testing system to validate the fix across KDE projects.

Marknote

Siddharth Chopra worked on Marknote to add source mode for notes. The Source Mode essentially allows users to bypass the rich-text WYSIWYG interface and directly edit the raw markdown. While working on this feature, Siddharth also made a major refactoring of the codebase (on both the QML and C++ sides). Spell checking using Sonnet was also added, among other small fixes and improvements.

KDE Eco

Hrishikesh Gohain worked on setting up KEcoLab's measurement environment with Wayland on Fedora 43 KDE Plasma Desktop. He ported the Okular measurement scripts from the X11-based xdotool to ydotool and kdotool, which work on both X11 and Wayland. His contributions can be found in this merge request. The original project plan had included measuring the KDE Plasma desktop environment itself. However, porting the Okular scripts to Wayland in the new lab setup turned out to be more complex than expected. Moreover, measuring a desktop environment may need some infrastructure changes to the KEcoLab setup. Hrishikesh is currently working towards it and will continue after SoK26 is over.

Automate Promo Data Collection

Chuyen Nguyen wrote automation scripts and created environments for them to perform some of the KDE promotional team's insight data collection tasks. The first script collects KDE's X, Bluesky, Mastodon, and Threads accounts' follower and post counts using a mix of API requests and web scraping methods alongside a local Nitter instance. The second script scrapes the KDE subreddit's Reddit Insights page for weekly metrics on page visits, unique visitors and its total member count and includes a Docker image that allows for headless execution. The final script collects articles related to KDE using Google Alerts emails and performs sentiment analysis on them using a locally run large-language model. The figure below shows output from the follower and post count scraper, Reddit Insights page scraper, and Google Alerts evaluator respectively.

Plasma Setup

Onat Ribar worked on bringing Plasma Setup, KDE's first-run setup wizard, to Plasma Mobile. Plasma Setup was built with desktop screens in mind, and running it on a phone showed overall accessibility issues including but not limited to overlapping components, content clipping on short window sizes, session buttons that remained tappable beneath wizard pages, and a timezone selector built around an interactive map that was nearly unusable on a small touchscreen. Onat worked through these systematically across the wizard's QML UI, resulting in an adaptive experience across screen sizes and input methods without affecting the desktop UX. Two MRs have been reviewed, merged, and are now part of the upstream codebase in repositories plasma-setup and plasma-workspace.

Falkon

Sairam developed a XMPP extension that adds a chat client directly into the KDE Falkon browser's sidebar. Written in Python using Slixmpp, the project lets users message each other and run interactive WebXDC apps right inside their chat window. It supports modern XMPP features like Message Carbons (XEP-0280) for device syncing, Message Corrections (XEP-0308) for edits, Emoji Reactions (XEP-0444), and HTTP File Uploads (XEP-0363). This setup turns Falkon into a communication tool without even leaving the browser.

J Shiva Shankar added XMPP bookmark syncing to the Falkon browser. The basic setup is working, so whenever you add or update a bookmark, it successfully syncs across your devices. Deleting bookmarks still has a few bugs right now, but they have been documented. He plans to keep contributing after SoK to squash these bugs and get the feature completely polished.

Mankala Engine

Sayandeep Dutta helped in redesigning the MankalaNextGen GUI with Kirigami and added designs fixing the Main UI and the Game with game boards and shells. He also added music with Qt to Mankala and made translations in Tamil and Hindi. Made assets for the game variants using Krita in their traditional designs and motifs. Started with the review process of MankalaNextGen with the CI build.

Pavan Kumar enhanced MankalaEngine by adding an opening book and investigated performance of multithreaded alpha-beta search using OpenMP, Pthreads and Taskflow. In addition, he enhanced MankalaNextGen by creating visual assets for game boards and seeds and also created logos for MankalaEngine and MankalaNextGen.

Since I'm on KDE Linux, I use flatpak apps for pretty much everything, such as Kontact suite. I wanted to test out how my Breeze changes would look like in KMail and other apps, but I didn't want to build the whole PIM stack.

Here's how I tested it by building the flatpak-kde-runtime in CI, downloading the built files and using it as a repository for testing any changes to org.kde.Platform locally.

1. First make changes to the flatpak-kde-runtime, such as this here: https://invent.kde.org/packaging/flatpak-kde-runtime/-/commits/work%2Fakselmo%2Ftest-breeze
2. Run the CI
3. Check the pipeline ID for build-runtime-amd64
   • Click the green checkmark, its something like #1210828
4. Download the artifact from here: https://storage.kde.org/ci-artifacts/packaging/flatpak-kde-runtime/p/PIPELINE_ID_HERE/repository-x86_64.tar.gz
5. Extract the tar into some folder after downloading
6. Add it as a repository: flatpak remote-add --no-gpg-verify kde-platform-testing ./repo-x86_64
7. Uninstall the current platform: flatpak uninstall org.kde.Platform --force-remove
   • The force-remove makes sure we do not install any apps, just the platform
8. Run flatpak install org.kde.Platform
9. Select the kde-platform-testing as the repo to install from
10. Done!

Now any app that uses the version of platform (6.10 in my example) will utilize your custom built one.

Akademy 2026 will be a hybrid event held simultaneously in Graz, Austria, 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 2026 conference. The event will take place in Graz and Online from Saturday, 19 September to Thursday, 24 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 2026 website.

Changelog

• Correction bug 515099: Missing secondary currency value in Accounts totals
• Correction bug 514649: Fix initial layout when splash screen is not displayed
• Correction bug 514649: Double click issue on table when there is no selection
• Correction bug 438967: Labels in Skrooge Report axis and Legend tend to illegible
• Correction bug 517475: Alarms triggering even when conditions not met
• Correction bug 515186: Import should remember the directory used last when restarted
• Correction bug 430245: summaries display truncated after searching in Operations grouped by Category
• Correction bug 518461: charts missing in responsive monthly report
• Correction: Better filtering in categories page
• Correction: Fix various error in flatpak mode (import, download sources, ...)

Qt 6.11 brings a set of meaningful improvements to the Qt GRPC library, focusing on stability, safety, performance, and new capabilities that make building gRPC™ based applications in Qt more powerful and productive.

• fixed a crash on Android 12 and older when trying to access any text controls
• fix stylus workarounds for Xiaomi and OnePlus to work properly

Check out the release notes for a full overview of all the new features in Krita 5.3 and 6.0.

Note: this release is only relevant for Android, so only Android APK's and source archives are available. You only need the source archive when building for Android yourself.

[!WARNING] One again, we consider Krita 5.3.1 suitable for productive work; 6.0.1 is, because of the many changes from Qt5 to Qt6 more experimental.

5.3.1.1 Download

Android

Krita on Android is still beta; and is meant to run on chromebooks and tablets only.

• 64 bits Intel CPU APK

• 64 bits Arm CPU APK

• 32 bits Arm CPU APK

Source code

[!NOTE] Note for distributions: if you package both PyQt5 and PyQt6, you will want to patch our source code with this patch: Disallow importing conflicting version of PyQt

• krita-6.0.1.1.tar.gz

• krita-6.0.1.1.tar.xz

md5sum

For all downloads, visit https://download.kde.org/stable/krita/5.3.1/ and click on "Details" to get the hashes.

Key

The the source tarballs are signed. You can retrieve the public key here. The signatures are here (filenames ending in .sig).

At the first start of an application, user can be a bit confused in front of all of these features, buttons and data. In response to that, we often have a short presentation of each element on the screen. This also presents a typical workflow with the application.

First, You need to create a project or document. Then, define the name, the type… Then add content using this or that.

This feature is often called UI walk through, or UI tour.

UI Walker

I made this library to provide an easy way to do a walkthrough in any QML application.

Important Links

• Code source of UiWalker.
• QML Item ready for the Walker
• QML Window including UiWalker

Include Ui Walker to your project

target_link_libraries(MyProject
PRIVATE
    Qt6::Core
    Qt6::Quick
    WalkerComponent # add UIWalker
)

Using cmake it is really easy. You can define the library to be a git submodule and then

Prepare you qml code

The whole concept is based on attached property. To highlight a item, you must define two properties:

• WalkerItem.description: the text that will be displayed when this element is highlighted
• WalkerItem.weight: Numeric value to define the order (ascending order).

ToolButton {
    WalkerItem.description: qsTr("Description of the element")
    WalkerItem.weight: 104
}

Add the UI walker

Currently, you have to add one item. It should have the size of the whole window. This item provides several properties in order to help you manage the output.

Properties:

Here is an example:

 WalkerItem {
    id: walker
    anchors.fill: parent
    visible: false
    dimOpacity: 0.8

    onActiveChanged: {
        //walker.active
    }
        
    Label {
        id: label

        
        text: walker.currentDesc // text from walker
        x: walker.availableRect.x // calculated position
        y: walker.availableRect.y // calculated position
        width: walker.availableRect.width // calculated position
        height: walker.availableRect.height // calculated position
    }
    
    Rectangle {
        x: walker.borderRect.x-2
        y: walker.borderRect.y-2
        width: walker.borderRect.width+4
        height: walker.borderRect.height+4
        border.color: "red"
        color: "transparent"
        radius: 10
        border.width: 4
    }

    ToolButton {
        icon.source: walker.current + 1 === walker.count ? "qrc:/finish.svg" : "qrc:/next.svg"
        
        onClicked:{
            if(walker.current +1 === walker.count)
                walker.skip()
            else
                walker.next()
        }   
    }
}

React on Highlight event

Highlighted items get notified through two signals: enter and exit. Defining signal handlers allow you to react. So you can show the full workflow to add new data.

TextField {
    id: nameField
    // …
    WalkerItem.description: qsTr("Set macro name.")
    WalkerItem.weight: 30
    WalkerItem.onEnter: {
        nameField.text = qsTr("Skill Roll")
    }
}

Start it !

In order, to start the UI tour, you simply have to call the function: start() of the Item. Of course, it is up to you to trigger it automatically when it’s the first start of the application or if the user asked for the tour.

Here you have an example:

Component.onCompleted: {
    if(DiceMainController.uiTour === DiceMainController.UnDone) {
        walker.start()
    }
}

I have a CPP controller with property UiTour which gives the current status of the tour. Here, I call directly the walker function. But it may be safer to call a function to reset the state of the window.

Navigation

The walker provides two important function next() and previous() to navigate. Basically on the walker, you can add buttons in the available Rect to manage the navigation.

Other option, you can define an interval in milliseconds which will call the next() function.

You have to make sure the item is visible while the walker highlight it. It could be tricky to make the path from the end to be beginning. In some case, it is easier to never use the previous function.

Finish it!

Calling the function skip(), close the walker. Then the application is displayed normally. It can be called at any time.

Cheat code

How it works ?

The attached properties

In order to harvest all data from the QML, I had to define attached property.

This is the definition of QObject which will be attached, each time a QML item has defined any Walker property.

class WalkerAttachedType : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString description READ description WRITE setDescription NOTIFY descriptionChanged FINAL)
    Q_PROPERTY(int weight READ weight WRITE setWeight NOTIFY weightChanged FINAL)
    QML_ANONYMOUS
public:
    explicit WalkerAttachedType(QObject* parent= nullptr);
    //…
signals:
    void enter();
    void exit();
    //…
};

In the WalkerItem.h, I have to create this static function.

    // …
    Q_OBJECT
    QML_ATTACHED(WalkerAttachedType)
    // …
    static WalkerAttachedType* qmlAttachedProperties(QObject* object)
    {
        QQuickItem* item= qobject_cast<QQuickItem*>(object);
        if(!item)
            qDebug() << "Walker must be attached to an Item";
        s_items.append(item);
        return new WalkerAttachedType(object);
    }

QSceneGraph and Nodes

WalkreItem defines a QML item, written in cpp to be light-weighted. I used QSGNode to draw it on screen. The item code manages the logic of the walkthrough and the update of the geometry.

To make it short, the SceneGraph is the rendering engine of QML. QSGNode defines an API to communicate with it directly.

First, I create the QML item in cpp, using QSGNode to be rendered.

//walkeritem.h
class WalkerItem : public QQuickItem
{
    Q_OBJECT
    QML_ATTACHED(WalkerAttachedType)
    QML_ELEMENT
    Q_PROPERTY(QString currentDesc READ currentDesc NOTIFY currentChanged FINAL)
    Q_PROPERTY(QColor dimColor READ dimColor WRITE setDimColor NOTIFY dimColorChanged FINAL)
    Q_PROPERTY(qreal dimOpacity READ dimOpacity WRITE setDimOpacity NOTIFY dimOpacityChanged FINAL)
    Q_PROPERTY(QRectF availableRect READ availableRect NOTIFY availableRectChanged FINAL)
    Q_PROPERTY(QRectF borderRect READ borderRect NOTIFY borderRectChanged FINAL)
    Q_PROPERTY(int interval READ interval WRITE setInterval NOTIFY intervalChanged FINAL)
    Q_PROPERTY(bool active READ active NOTIFY activeChanged FINAL)
public:
    WalkerItem();
    
    // accessors, signals, slots…

protected:
    QSGNode* updatePaintNode(QSGNode*, UpdatePaintNodeData*) override;// update scenegraph
};



//walkeritem.cpp
WalkerItem::WalkerItem()// in the constructor
{
    setFlag(QQuickItem::ItemHasContents);// must be called
    connect(child, &QQuickItem::widthChanged, this, &WalkerItem::updateComputation);
    connect(child, &QQuickItem::heightChanged, this, &WalkerItem::updateComputation);
}

void WalkerItem::updateComputation()
{
    // compute geometry and list any changes that must be sync with the SceneGraph.
    m_change|= WalkerItem::ChangeType::GeometryChanged;
    update();// call to paint the item
}

QSGNode* WalkerItem::updatePaintNode(QSGNode* node, UpdatePaintNodeData*)
{
    auto wNode= static_cast<WalkerNode*>(node);
    if(!wNode)
    {
        wNode= new WalkerNode();//first time
    }

    if(m_change & WalkerItem::ChangeType::ColorChanged)
        wNode->updateColor(m_dimColor);
    if(m_change & WalkerItem::ChangeType::GeometryChanged)
        wNode->update(boundingRect(), m_targetRect);
    if(m_change & WalkerItem::ChangeType::OpacityChanged)
        wNode->updateOpacity(m_dimOpacity);

    m_change= WalkerItem::ChangeType::NoChanges;
    return wNode;
}

We have here an item with a geometry like any other item (x,y,width, height), we also have a dimColor and dimOpacity. Any time one of these properties change. I have to sync with the QSceneGraph to update either the geometry, the dimColor or the dimOpacity. Each time, one property changes, I stored the type of change in the m_change member and I call update().

The render engine will call my item with the QSGNode reprenting it on the SceneGraph side. Then I can call function on my SGNode. When sync is finished I reset the change to NoChange and return the node.

The updatePaintNode can be called with a null node. In this case, you have to create it. It will be the case, the first time. And it could happen later in some cases for optimalization reason.

Now, let see the code of the QSGNode. You have to see the QSGNode as the root item of a tree. Where each node is in charge of representing one aspect of the item: its geometry, its color and its opacity.

// header
class WalkerNode : public QSGNode
{
public:
    WalkerNode();
    virtual ~WalkerNode();
    void update(const QRectF& outRect, const QRectF& inRect);
    void updateColor(const QColor& dim);
    void updateOpacity(qreal opacity);

private:
    QSGOpacityNode m_opacity;
    QSGFlatColorMaterial m_dimMat;
    QSGGeometryNode m_dim;
};

In the constructor, I create each node, and then I define the hierarchy.

WalkerNode::WalkerNode()
{
    auto dimGeo= new QSGGeometry(QSGGeometry::defaultAttributes_Point2D(), 0);
    dimGeo->setDrawingMode(QSGGeometry::DrawTriangles);
    dimGeo->allocate(triangleCount * 3);

    m_dim.setGeometry(dimGeo);
    m_dim.setMaterial(&m_dimMat);
    m_dimMat.setColor(Qt::black);

    m_opacity.setOpacity(0.6);

    m_opacity.appendChildNode(&m_dim);
    appendChildNode(&m_opacity);

    markDirty(QSGNode::DirtyMaterial | QSGNode::DirtyGeometry | QSGNode::DirtyOpacity);
}

Here the final tree:

Define or Update the geometry

void WalkerNode::update(const QRectF& out, const QRectF& in)
{
    // out is the geometry of the window
    // in is the geometry of the highlighted item
    const auto a= out.topLeft();
    const auto b= in.topLeft();
    const auto c= in.topRight();
    const auto d= out.topRight();
    const auto e= in.bottomRight();
    const auto f= out.bottomRight();
    const auto g= in.bottomLeft();
    const auto h= out.bottomLeft();

    {
        auto gem= m_dim.geometry();
        auto vertices= gem->vertexDataAsPoint2D();
        QList<std::array<QPointF, 3>> triangles{{a, b, d}, {b, d, c}, {d, c, f}, {c, f, e},
                                                {f, e, h}, {e, g, h}, {h, g, a}, {g, a, b}};
        int i= 0;
        for(auto t : triangles)
        {
            vertices[i + 0].set(t[0].x(), t[0].y());
            vertices[i + 1].set(t[1].x(), t[1].y());
            vertices[i + 2].set(t[2].x(), t[2].y());
            i+= 3;
        }

        m_dim.markDirty(QSGNode::DirtyGeometry | QSGNode::DirtyMaterial);
    }

    markDirty(QSGNode::DirtyGeometry | QSGNode::DirtyMaterial);
}

We split the surface we have to cover in triangles.

Todo

1. Animations: Smooth animation while transiting from one item to another.
2. Test on bigger apps
3. Find a logic to allow previous
4. Use shader effect to make it better.
5. Other…

Conclusion:

UiWalker is already in production. It works like a charm. I hope to use it elsewhere. Then, I will add some new features. Contributions and comments are welcomed.

Hope you find this article interesting.

Plasma 6.6 was released in February 2026 with many feature refinements and new modules to complete the desktop experience.

This release adds three weeks’ worth of new translations and fixes from KDE’s contributors. The bugfixes are typically small but important and include:

For the next digiKam releases, the digiKam team needs photographs for digiKam and Showfoto splash-screens. Proposing photo samples as splash-screens is a simple way for users to contribute to digiKam project. The pictures must be correctly exposed/composed, and the subject must be chosen from a real photographer’s inspiration. Note that we will add a horizontal frame to the bottom of the image as in the current splashes.

Please remember that this is an RC version, not yet final, to be used only for testing and reporting issues.

Features highlights:

• Added animated previews for transitions
• Added a feature to mirror the monitor to an external monitor, allowing you to see the image in the usual interface, while duplicating the output to a secondary monitor
• Added an entry in the timeline context menu to directly import a clip to the project and add it at click position
• Added an option to always zoom on the mouse position instead of the timeline playhead
• Generate audio thumbnails for sequences
• Dropping a transition to timeline will automatically adjust its duration to the above/below clips
• Allow changing speed of multiple clips

Feedback Needed

Now is your chance to test it and let us know if you encounter any bugs or have suggestions to help us polish the final release. Share your feedback in the comments below

Available Binaries

The AppImage and Windows versions can be downloaded through the links below. Update: the MacOS binaries are now also available

Download the binaries from below and give it a spin!

Pre-release binaries can be downloaded here.

OSM indoor mapping

As it is tradition by now, Tobias and I hosted the Indoor OSM BoF.

The (translated) session notes are in the wiki. There’s some recurring themes, such as increasing the level of detail in the third dimension, as well as how to properly map inclined areas and two-dimensional walls. None of that has a good solution yet, so we are trying to get the right people together for a multi-day in-person workshop to finally progress those topics.

I’m also increasingly wondering whether we need to replace the term “indoor” in this context, as that means different things to different people:

• Mapping physically within a building. That separation is all but clear-cut though, in particular in and around train stations.
• Mapping using areas rather than ways. That’s also not unique for being “indoor”.
• Using the level tagging from SIT. While referring to “floor levels”, this is the best way we have to place features vertically, and that’s also something that isn’t limited to buildings.

Kate getting syntax highlighting for ISO 10303-21 STEP files, a file format used in building information modeling (BIM) (ie. the best possible data source for importing building geometry into OSM) is of course purely coincidental.

Indoor routing

Triggered by talks on indoor navigation in previous years which weren’t as forthcoming with actually publishing their code or papers as one might expect for a conference with “FOSS” in the name already, I presented the work we did in KDE for OSM-based indoor routing for Itinerary and Kongress.

The implementation is part of the KOSMIndoorMaps library and uses Recast Navigation under the hood. This works solely on areas, without needing an explicit routing graph. And it allows for routing to/from any arbitrary point, which is a requirement for localization/navigation use-cases. There’s drawbacks as well, directional cost on inclined ways are hard to consider with this for example.

Richard from TU Dresden presented an alternative approach for indoor routing, semi-automatically generating routing graphs inside areas. This provides visually nicer results in narrow corridors, but becomes more challenging in open areas. By pure chance both our talks used the same building for demonstration, quite useful for discussing the strength and weaknesses of both ways.

Another topic of discussions was how to scale this up from working on a single building to something a planet-scale router such as MOTIS could integrate. Neither approach is well suited for that out of the box.

Transitous

Transitous was featured in Felix’ and Robin’s talk about new developments in MOTIS. Many of the new features presented there can already be seen in use on Transitous.

The conference provided the opportunity to talk to data providers about what we would need or would like to have for Transitous, as well as to data consumers, such as CoMaps, who are exploring integrating public transport routing.

And with several Transitous contributors around we also discussed a bunch of topics being currently looked into:

• How to integrate the Danish Siri-over-AMQP feeds.
• Parsing issues with the Swiss aerial lift NeTEx feed.
• Sorting out the API key handling for the Baden-Württemberg Amarillo ride sharing feed.
• Implementing spport for temporary POIs such as events.
• Getting “DIID” elevator identifiers into OSM, for matching SIRI-FM realtime status feeds to OSM data for routing.
• How to integrate empirical delay data into the MOTIS API.

KDE Itinerary

I also met a few Itinerary users and got feedback on current issues. An area that needs work is the fallback handling in the KPublicTransport library. We aren’t very good (yet) at switching to different sources when the primary one fails to deliver useful results. With the DB API becoming increasingly unreliable due to randomly blocking access (not just our apps, also affects their website), this becomes increasingly visible.

FOSSGIS e.V.

FOSSGIS e.V. is the German local chapter for OSM, and the organizer of the FOSSGIS-Konferenz. Given the significant overlap in topics (and some overlap in people) FOSSGIS e.V. has been one of the obvious organizational umbrellas for both the Open Transport Community Conference and Transitous.

This has been moving forward recently, and will solve a few practical problems:

• Allow us to hold assets like domains independent of individual contributors, removing single points of failure.
• Allows us to receive and spend money in a clean way.

This is rather important for the long-term sustainability of both initiatives. Being able to handle money is especially pressing for the Open Transport conference, as given the rather expensive location this year we’d like to offer some form of travel support for people who aren’t attending this as part of their job.

Dynamic traffic data

Following a joined HeiGIT/BKG talk on routing quality there were a lot of hallway discussions on dynamic traffic data, as well as a session during the unconference part, all focusing on a proper free and open solution for this.

Dynamic traffic data includes:

• (Aggregated) realtime traffic flow data (ie. current traffic jams).
• Raw traffic flow sensor data, ie. sensors counting vehicles or floating vehicle position/speed vector data.
• Statistical traffic flow data (ie. high traffic expected during specific times).
• Dynamic traffic sign data, such as adaptive speed limits.
• Temporary closures due to construction work, accidents, etc.
• Realtime availability data for bike or car parking spaces.

This is crucial information for road routing, traffic planning and research. However currently this data is collected and owned by a few proprietary vendors. Google is a particularly big player here, using the position data submitted by Android phones.

In order to build a free and open replacement the only chance we have is to do that jointly, between all parties with any interest in this, otherwise this wont gather the necessary critical mass. Doing this under the OSM umbrella seems to be the obvious choice, especially since this needs to be mapped on to the static OSM road network data anyway.

It would certainly be an ambitious project, but there’s a bunch of building blocks to work with already:

• Sensor data from some public authorities, with various levels of processing applied.
• A few cases of realtime data for dynamic traffic signs from their operators.
• (Planned) construction site data in Datex II format by public authorities,
• Floating vehicle information from GTFS-RT vehicle position feeds for busses (which we consume for Transitous already).
• A community maintained road closure/construction database from SOSM.
• Realtime parking data, partially even in standardized ParkAPI or Datex II formats.
• Crowd sourcing in end user apps like CoMaps is likely also a viable option, similar to the work on crowd sourcing delay information for Transitous.

While this is mostly affecting roads (and thus cars and busses), construction work can also affect pedestrian and bike routing, either entirely or by changing e.g. relevant accessibility properties for wheelchair routing. There was agreement that any free and open effort should equally consider those modes of transportation.

The open source routing engines either already have support for integrating dynamic traffic data, or have adding support on their roadmap, Transitous would certainly integrate that as well. Public agencies were equally interested in open traffic data, but not all of them did show quite the same enthusiasm for also contributing to that yet.

All this gave me a slight déjà vu to the state of public transport routing prior to FOSSDEM 2024, there seems to be a critical amount of interest and willingness to join such an effort, somebody™ just needs to kick-start it.

Welcome to a new issue of This Week in Plasma!

This was a somewhat quiet week mostly full of UI and stability improvements, perhaps because many KDE contributors are gearing up for next week’s mega-sprint in Graz! For the same reason, expect next week’s post to be short or non-existent.

Notable UI improvements

Plasma 6.7

Breeze-themed menu items throughout KDE’s software ecosystem now visually change when clicked. (Akseli Lahtinen, breeze MR #605)

A variety of tooltips throughout Plasma now follow the styling of the active Plasma theme as expected. (Nicolas Fella, libplasma MR #1435)

Improved the Mouse Mark effect’s support for touchscreens: now you can draw multiple lines at a time if you have a multi-touch-capable screen. (Tin Dao, kwin MR #8951)

Synchronizing settings to the Plasma Login Manager now includes the current set of keyboard layouts. (Oliver Beard, KDE Bugzilla #516778)

Simplified the UI for the Clipboard widget’s QR code page: now the copy button is in the header, rather than all alone on its own row. (Tobias Fella, plasma-workspace MR #6451)

After

Before

Removed the feature to force the Task Manager and System Tray widgets to use a large spacing and icon size while in touch/tablet mode; it just didn’t work out, and caused un-resolvable sizing bugs. (Nate Graham, KDE Bugzilla #511439)

Improved the accuracy of widget positioning on the desktop: dragging a widget somewhere it won’t fit will now show its preview rectangle in the nearest place where it will fit, which is where it will end up. (Tobias Fella, plasma-workspace MR #6452)

Discover now uses consistent terminology when it asks you to restart. (Nate Graham, KDE Bugzilla #517630)

Frameworks 6.25

Trying to paste when your clipboard is empty now fails silently rather than showing a notification about it. (Tobias Fella, kio MR #2168)

Notable bug fixes

Plasma 6.6.4

Hardened Plasma against crashing while trying to load a broken widget. (Harald Sitter, libplasma MR #1456)

Fixed a case where the KDED background daemon could die with a Wayland protocol error when changing the screen resolution. (Xaver Hugl, KDE Bugzilla #516217)

Fixed a bizarre issue that mangled certain text formatted with Markdown styling while Plasma’s on-screen keyboard was enabled but not visible. (Devin Lin, KDE Bugzilla #516511)

Fixed a case where System Settings’ Plasma Style page could crash on certain distros shipping Qt 6.11 with asserts turned on. (Ismael Asensio, plasma-workspace MR #6458)

Fixed usage graphs for certain NVIDIA GPUs being broken in the System Monitor app and widgets. (Bernhard Friedreich, libksysguard MR #465)

Popups for editing widgets while in Plasmas’s edit mode now work with a touchscreen. (Marco Martin, KDE Bugzilla #509880)

Hardened KWin against XWayland apps being sized incorrectly on systems with config files containing inappropriate scale values. (Xaver Hugl, kwin MR #9049)

Rolled out a more complete fix for context menus of System Tray icons sometimes having ugly square black corners. (Nate Graham, KDE Bugzilla #513307)

Plasma 6.7

Made two technical fixes to the process of configuring OpenConnect VPNs (Aviral Singh and Alexander Becker, KDE Bugzilla #385395 and KDE Bugzilla #518289)

Notable in performance & technical

Plasma 6.7

Implemented support for the xx-fractional-scale-v2 Wayland protocol, which improves visual fidelity by reducing gaps between adjacent items. (Vlad Zahorodnii, kwin MR #9023)

Continued with the work to add Vulkan support. (Diego Gomez, kwin MR #9027)

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.

The Last Quiet Thing

Tags: tech, ux, design, business, attention-economy

A good piece, well designed too. Shows how demanding our current devices are. So much attention requested and so much complexity the user has to deal with. We clearly lost the plot as an industry.

https://www.terrygodier.com/the-last-quiet-thing

What we think is a decline in literacy is a design problem

Tags: tech, philosophy, learning, reading, design

Indeed it’s not simply books vs screens. It’s about design and how our attention gets fractured (on purpose). We need to recognise there are many ways to learn and to produce ideas, then design for it. We’d be better off as a civilisation rather than staying with the current attention economy.

https://aeon.co/essays/what-we-think-is-a-decline-in-literacy-is-a-design-problem

Here’s why I’ve installed a Dead Man’s Switch on my home server

Tags: tech, self-hosting, life, death

You’re self-hosting? Better keep in check what happens to the people who depend even indirectly on your services when you’re gone.

https://www.androidauthority.com/home-server-dead-man-switch-3648903/

LinkedIn Is Illegally Searching Your Computer

Tags: tech, linkedin, surveillance

Are we surprised? Of course depends on the browser and they’re looking mostly for extensions. Clearly they try hard to map what people use, it’s corporate espionage.

https://browsergate.eu/

DRAM pricing is killing the hobbyist SBC market

Tags: tech, embedded, memory, economics, ai, machine-learning, gpt

The price hike on RAM due to the LLM as a service bubble is really killing interesting fields. Can’t we have nice things? Will the arm race end soon?

https://www.jeffgeerling.com/blog/2026/dram-pricing-is-killing-the-hobbyist-sbc-market/

Nations priced out of Big AI are building with frugal models

Tags: tech, ai, machine-learning, gpt, research, innovation, economics

Real innovations come from constraints. The frugal AI movement is clearly where we will see interesting things emerging. Interestingly, those approaches are closer to what AI is about as a research field than the industrial complex which got unleashed with all its extractive power.

https://restofworld.org/2026/frugal-ai-big-tech/

The Comforting Lie Of SHA Pinning

Tags: tech, supply-chain, security, git

We’re not helped much by our tools here… Clearly provenance needs to be double checked.

https://www.vaines.org/posts/2026-03-24-the-comforting-lie-of-sha-pinning/

handymkv: A tool to simplify use of MakeMKV and the HandBrakeCLI tool

Tags: tech, bluray, video, codec, tools

You got bluray discs to encode for use on your NAS? This looks like a nice option.

https://github.com/dmars8047/handymkv

Running out of Disk Space in Production

Tags: tech, architecture, storage, failure

Are you sure your understand how your reverse proxy works and the impacts it can have in production?

https://alt-romes.github.io/posts/2026-04-01-running-out-of-disk-space-on-launch.html

your hex editor should color-code bytes

Tags: tech, hex, data-visualization, debugging

Interesting color coding for hex editor. It indeed brings interesting properties.

https://simonomi.dev/blog/color-code-your-bytes/

Git Bayesect

Tags: tech, git, tools, tests

Git bisect won’t help much for flaky tests… but maybe this bayesian approach can.

https://hauntsaninja.github.io/git_bayesect.html

slowql: SQL static analyzer for performance, security, compliance and cost

Tags: tech, databases, sql, tools, performance, security, ci

Looks like an interesting tool to check your SQL queries on the CI.

https://github.com/makroumi/slowql

Joins are NOT Expensive!

Tags: tech, databases, performance

Interesting article which goes deep in comparing joins vs denormalised big tables. The conclusion is in the title, bit it’s worth a read for the other insights.

https://www.database-doctor.com/posts/joins-are-not-expensive

C++26 is done!

Tags: tech, c++, standard, reflection

The new standard is upon us and it’ll be massive. It indeed looks like another C++11. If used it’ll feel like a very different language.

https://herbsutter.com/2026/03/29/c26-is-done-trip-report-march-2026-iso-c-standards-meeting-london-croydon-uk/

What happens when a destructor throws

Tags: tech, c++, exceptions

A good reminder of why destructors shouldn’t throw. It really has to be a last resort measure and only carefully considered. There’s a reason why they are nothrow by default since C++11.

https://www.sandordargo.com/blog/2026/04/01/when-a-destructor-throws

Why Don’t You Use String Views (as std::wstring_view) Instead of Passing std::wstring by const&?

Tags: tech, c++, c, memory

Indeed be careful at how you use strings when interacting with C APIs. String views are likely not what you want in that context. There is a reason why they don’t have c_str().

https://giodicanio.com/2024/05/14/why-dont-you-use-string-views-like-std-wstring_view-instead-of-passing-std-wstring-by-const-reference/

Watch out for missed warnings on vendor C++ toolchains

Tags: tech, c, c++, compiler, embedded

Vendor toolchains should see only a limited trust. Like in this case they’re often partial or old.

https://blog.poly.nomial.co.uk/2026-03-31-watch-out-for-missed-warnings-on-vendor-cpp-toolchains.html

Why Fakes Beat Mocks and Testcontainers

Tags: tech, tests, fake, failure

I vehemently agree with this piece. Fakes are unfortunately underrated. They’re the most powerful test double, I wish more projects would invest in them (can be quite an investment, which the article doesn’t quite show unfortunately).

https://pierrezemb.fr/posts/why-fakes-beat-mocks-and-testcontainers/

Working software runs locally

Tags: tech, developer-experience, tests

This is indeed very important to ensure the tooling around your project supports running the whole thing locally. Too often projects sacrifice the ability to do this, it’s clearly a hindrance to testability and a short feedback loop.

https://nickmonad.blog/2026/working-software-runs-locally/

Scaling a Monolith to 1M LOC: 113 Pragmatic Lessons from Tech Lead to CTO

Tags: tech, architecture, debugging, observability, orm, backend, frontend, organisation, leadership

Lots of good insights in here. Of course YMMV and some definitely depends on your context. That’s a lot of dimensions to keep in mind though.

https://www.semicolonandsons.com/articles/scaling-a-monolith-to-1m-loc-113-pragmatic-lessons-from-tech-lead-to-cto

Why the verb “to be” is so irregular

Tags: linguistics, history, english

Fascinating origins of “to be”. As usual to understand this kind of phenomenon, or at least start to build a theory, you have to go back quite far in history.

https://www.deadlanguagesociety.com/p/why-the-verb-to-be-is-so-irregular

Bye for now!