fidzu : KDE

Very technical post, feel free to ignore if you're not working on KDE stuff.

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.

09 Apr 2026 8:53pm GMT

Akademy 2026: Registration

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, 12 September to Thursday, 19 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.

09 Apr 2026 8:12am GMT

The Skrooge Team announces the release 26.4.0 version of its popular Personal Finances Manager based on KDE Frameworks.

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, ...)

09 Apr 2026 12:00am GMT

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.

08 Apr 2026 12:44pm GMT

Krita 5.3.1.1 is an Android-only fix for 5.3.1. It is exactly the same as Krita 5.3.1, but with two fixes:

• 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).

08 Apr 2026 12:00am GMT

Evaluating and starting to develop professional, production-grade GUIs on embedded Linux should be frictionless. Based on this statement, we are always working with our partners to improve the Qt developer experience. Together with Toradex we recently made major improvements to the Torizon Qt VS Code template, making it easier for you as a developer to use Qt Device Creation Enterprise workflows inside the same template that you might already have been using with the Device Creation Community Edition. On top of that, there is a brand-new Qt demo in the Torizon Demo Gallery which you can try right away.

Torizon is a production-ready, container-based embedded Linux platform that simplifies how Qt applications are deployed and maintained. Qt developers may already be familiar with Boot2Qt, which is a useful tool to get a Qt prototype running quickly. However, scaling that prototype into a secure, maintainable, and updatable product usually requires building and managing your own Yocto stack. Torizon removes this burden, providing a pre-integrated OS, hardware-optimized Qt runtime, OTA automated updates, CVE tracking and a consistent containerized workflow, letting you focus entirely on your Qt application instead of maintaining the underlying Linux distribution.Below you'll find what's new, why it helps Qt developers, and exactly how to try it.

07 Apr 2026 10:07am GMT

Explore how SWHID is applied in real-world scenarios to improve SBOMs, support Cyber Resilience Act compliance, and enable software traceability. Discover practical use cases across telecom and automotive industries, based on insights from recent industry talks.

07 Apr 2026 6:00am GMT

The problem

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.

07 Apr 2026 12:13am GMT

Tuesday, 7 April 2026. Today KDE releases a bugfix update to KDE Plasma 6, versioned 6.6.4.

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:

View full changelog

07 Apr 2026 12:00am GMT

The last post regarding work on fixing Oxygen was a month and a half ago. With all that's happened in between, it feels like so much more time has actually passed. With this post, I'd like to do a sort of mid-term update summing up all of the improvements done so far. These improvements are...... Continue Reading →

05 Apr 2026 7:00am GMT

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.

05 Apr 2026 12:00am GMT

1.

05 Apr 2026 12:00am GMT

The Kdenlive 26.04 Release Candidate is ready for testing. Many bug fixes and workflow adjustments should make your editing sessions nicer. It is also worth noting that we had quite a few new contributors helping our small team on this, so thanks to all those who helped us!

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.

04 Apr 2026 9:00am GMT

Last week I attended this year's FOSSGIS-Konferenz in Göttingen, Germany, focusing on public transport and indoor navigation topics.

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.

04 Apr 2026 5:45am GMT

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.

04 Apr 2026 12:00am GMT

Let's go for my web review for the week 2026-14.

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!

03 Apr 2026 12:33pm GMT