This is a recipe post. I loathe and despise recipe sites, but this is one I regularly need to look up. In Canadian measures, which is what I still do my baking in even after 30 years in Europe.

Mix well and let stand while collecting the rest:

• 1½ cups rye bran
• 1 c. milk
• ½ tsp. salt

Ready:

• ⅓ c. oil
• 1 egg

Ready:

• ⅔ c. brown sugar
• 1 c. flour
• 2 tsp. baking powder
• ½ c. raisins

Mix the wets. Stir in the drys. Fill muffin pan. Bake 25 minutes at 180℃. Makes 11 muffins because my muffin pan has one broken cup. Uses rye bran because the local windmill has that “left over” as animal feed after milling rye – apparently very few people in the Netherlands use bran anyway, and rye bran even less so. Instead of flour and baking powder use zelfrijzend bakmeel.

Edit: reduce sugar to ½ cup and add 1 tbsp. of molasses to improve flavor and color and reduce sweetness.

One of the biggest behind-the-scenes changes in the upcoming Plasma 6.4 release is the split of kwin_x11 and kwin_wayland codebases. With this blog post, I would like to delve in what led us to making such a decision and what it means for the future of kwin_x11.

Background

KWin started as an X11 window manager almost two and a half decades ago. Over the course of the years, it transformed drastically. It gained support for compositing on X, and it became a Wayland compositor.

Sharing the same codebase was critical in the early days of kwin_wayland. We already had working window management abstractions, which had been tested for many years, so we could reuse them on Wayland instead of writing new from scratch. Also, if kwin_x11 gained a new feature, then kwin_wayland would likely gain it for free too.

As time went by, kwin_wayland outgrew kwin_x11. They still shared code but they became quite distinct projects with different mental models how things operate, e.g. how pixels get on the screen or how input works. It also didn’t help that many Plasma developers jumped the X11 ship and turned to the Wayland side as part of the “eating your own dog food” practice, which eventually led to the feature freeze in KWin/X11 back in 2018 due to the lack of sufficient testing and various breakages.

Some time around 2020, we started taking a more bold and aggressive approach to Wayland session development because we saw that Plasma Wayland was trailing behind other desktop environments and something had to be changed in order to catch up. Such a policy produced great results, and Plasma is now one of the leading Wayland desktop environments. Unfortunately, it also greatly contributed to the number of regressions in the X11 session.

Another issue was that there were some features that we couldn’t make work as expected on Wayland so we had to drop them for everyone, which understandably made X11 users unhappy.

Goals

A few years ago, we started contemplating the idea of splitting the X11 and Wayland codebases because of the growing list of regressions affecting the X11 session, and architecture restrictions imposed on KWin/Wayland by the way KWin/X11 works.

That would allows us to keep KWin/X11 working as is without it breaking too often and freely change KWin/Wayland in ways that we think are best suited to make the Plasma Wayland session even better. Of course, it is not a silver bullet solution: we replace one problem with another problem (mainly related to maintenance and ensuring interface compatibility between two projects).

Details

After various discussions online and at Akademy and also seeing (impressive) Plasma Wayland usage statistics, we decided that it’s the right time to do such a split. The main kwin repository is going to host KWin/Wayland, while the kwin-x11 repository is going to host KWin/X11.

KWin/X11 and KWin/Wayland are co-installable so users can freely switch between the X11 and Wayland sessions back and forth and also make sure that updating to 6.4 is not a big hassle for distributions. You’ll be able to have only KWin/X11 or only KWin/Wayland on your computer, or both.

The codebase split doesn’t affect Xwayland support in KWin/Wayland. In other words, X11 applications will continue running on Plasma Wayland.

Extensions

Like any other Plasma component, KWin’s functionality can be extended using plugins. There’s good and bad news. The good news is that extensions written in JavaScript and QML (for example, fancy effects that are available at the KDE Store) will continue working both with kwin_x11 and kwin_wayland as expected, so extension developers don’t need to do anything about it. The bad news is that C++ extensions should be specifically targeted for kwin_x11 and kwin_wayland because neither provides API and ABI compatibility guarantees for its C++ API.

As Wayland progress moves forward, it is likely that the scripting API of KWin/Wayland will be further extended.

Future of KWin/X11

KWin/X11 will be still maintained for the foreseeable future. But that maintenance work will boil down to fixing build errors, adapting to new KDE Frameworks and Plasma APIs, and backporting window-related fixes from KWin/Wayland. There are no plans to drop KWin/X11 in the Plasma 6 lifecycle, although it’s highly possible that it will happen in Plasma 7.

KWin/X11 won’t receive new features anymore; until recently, it received new features that had been developed against KWin/Wayland passively (because both lived in the same repository). However, it might be actually a good thing because the X11 session doesn’t receive that much testing nowadays.

Qt Contributor’s Summit 2025 is taking place in Munich in May. Unfortunately, I won’t be able to make it this year, so let’s talk about some of my recent contributions to our favorite cross-platform UI toolkit.

A couple of years ago I added a context menu to the line number bar in KWrite and Kate. Rather than having to go to the menu to toggle automatic line breaks or bookmarks, those options were now accessible from the context menu. I’ve always wanted to do the same to the scrollbar and have a mini-map option there. However, it wasn’t possible to extend the default context menu and I didn’t want to re-implement all of its Up/Down/Pg Up/Pg Down/etc logic. I therefore added a QScrollBar::createStandardContextMenu method similar to what QLineEdit has. As the name implies, it builds the regular context menu and hands it to you, so you can add your own actions to it.

Speaking of menus, I uplifted SH_Menu_SelectionWrap that decides whether menu selection wraps around when using the arrow keys from QStyle to QStyleHints. This allows Qt Quick Controls Menu to behave the same as QMenu. This behavior is off by default on macOS, for instance, and our own Qt Quick Controls 2 Desktop Style currently handles keyboard input itself to implement wrapping.

I’ve talked about it before that I sometimes just fire up a profiler and look at application startup performance. That’s while working on KWrite I noticed that it was spending a good amount of time parsing the shared-mime-info database. It’s basically a huge XML file containing information about all file types there are and how to detect them, either by file extension or by magic bytes within. Now, why would it even load that database when opening a blank new document?

There’s several places where KWrite and the underlying KTextEditor Framework need to know the type of a viewed file: to load the correct syntax highlighter, display the correct file icon in the tab bar and recent documents list, and so on. When the file type isn’t already known it tries to guess from its contents. Qt caches the database of course but the first one to create a QMimeDatabase triggers a load. However, none of this really matters for an empty document so it now assumes an empty document be of type text/plain. The correct type is actually application/x-zerosize but that’s really not what you want here.

My trusty ThinkPad has a “keyboard key” (Fn+F11) which under Windows supposedly opens some keyboard settings page. For the longest time, I thought it just wasn’t supported under Linux because I couldn’t create a global shortcut with it. Recently I noticed in KWin’s Debug Console that it did in fact recognize the key. Turns out Qt just didn’t have a corresponding Qt::Key. Starting from Qt 6.10 there will be a new Qt::Key_Keyboard value.

Qt Wayland Client

Since last time I talked about Qt Wayland, I have done a few more optimizations to its SHM (Shared Memory) backing store. It’s the canvas that Qt provides to software-rendered applications for drawing their user interface.

I finally merged support for scrolling the backing store. This lets an application, such as a text editor or terminal emulator, optimize scrolling through a view by merely moving the pixels and filling in only the small gap that’s now left. Unfortunately, this optimization cannot be provided when using fractional scaling because there’s no integer number of pixels we can just move up or down.

Furthermore, Qt Wayland no longer uses a backing store with alpha channel if the window didn’t request one. Most toplevel application windows are opaque after all. It doesn’t really matter from the compositor’s POV since a wl_surface can carry an “opaque region” that indicates what part of the window is actually opaque and Qt sets it accordingly. ARGB32 and RGB32 are the same in-memory size, too. Nevertheless, not using an alpha channel lets Qt skip certain operations, such as clearing the paint area before starting to draw.

While investigating a performance problem in animations under Wayland, I noticed that StackView’s new pushItem methods didn’t use any animation by default. As part of the effort to give QML tooling, such as qmlcachegen and qmllint, more context, many generic methods were supplemented by proper overloads. For example, StackView.push(var) takes either an Item, a Component, or a URL but you could call it with anything and that’s why it has to be invoked dynamically. StackView.pushItem on the other hand is declared three times with an explicit type which allows to generate more efficient code.

It didn’t make much sense that they would behave differently, of course. Indeed online documentation clearly said “If no operation is provided, PushTransition will be used.” We concluded it was a copy-paste mistake and I changed this for Qt 6.8.3, even though it’s technically a behavior change.

I’ll be jealous of your Weißwurstfrühstück in Munich and am looking forward to attending Qt Contributor’s Summit again in 2026!

Ever wondered how todays apps can scale up so smoothly, bounce back from crashes like its no big deal, and keep running even when everythings going wrong? Well, the secret sauce is probably Kubernetesyep, the magic behind the scenes! Often called as K8s, Kubernetes is this awesome open-source platform thats basically taken over the tech world. But whats actually happening under the hood? How does it pull off all this magic? Lets dig in, take away the mystery, and see what makes Kubernetes so great!

The Rise of the Container Kingdom

Alright, lets begin with a brief overview before delving into Kubernetes. Picture yourself shipping products worldwide. You could simply throw everything onto a ship without any plan, but good luck dealing with that chaosit would be a complete disaster! Thats where containers enter the scene: neat, uniform boxes that enhance shipping efficiency and reliability. In the realm of software, Docker had a similar concept and thought, Lets apply this to applications! Now, developers can enclose their programs into these tidy little containers, including all necessitiessuch as libraries and configurations. Heres the catch: operating a single container? No issue, its extremely straightforward. However, attempting to oversee hundreds or even thousands of them across multiple machines, ensuring theyre all functioning, distributing the load, and remaining updatedthats when it becomes complicated very quickly. Thats where Kubernetes steps in, serving as the ultimate overseer, ensuring this entire container operation runs seamlessly and appears effortless

The Anatomy of Kubernetes

Kubernetes is fundamentally a framework that assists in the administration of containerized applications across various machines. It functions on a cluster architecture, which consists of two main components: the control plane, acting as the operational brain, and the worker nodes, which supply the essential computing resources. Lets explore this further.

The Control Plane: The Central Intelligence

The control plane is the starting point of everything. It encompasses multiple components that supervise the cluster, make crucial decisions, and ensure your applications operate correctly. Heres what it comprises:

• 

  API Server: The gateway to Kubernetes. Every interactionwhether you are deploying an application using kubectl or a component is assessing the clusters healthoccurs through the API server. It serves as the primary communication hub.

• etcd: The memory bank of Kubernetes. This distributed key-value store retains the configuration data and state of the cluster. Consider it the definitive source of truth that ensures consistency across the system.

• Controller Manager: The regulator. It monitors the state of the cluster and guides it towards your specified configurations (for instance, I require 3 replicas of this application). If a pod fails, the controller manager promptly intervenes.

• Scheduler: The allocator. It decides which worker node will hold your new container by analyzing resource availability, constraints, and policies. It is similar to a game of Tetris, but centered on CPU and memory resources.

The Worker Nodes: The Essential Contributors

The worker nodes serve as the operational environment for your applications. Each node consists of a machine, which may be either physical or virtual, that is equipped with the necessary resources.

• Kubelet: The local agent. It talks to the control plane and ensures the containers on its node are running as expected. If the scheduler says, Run this pod, the kubelet makes it happen.

• Container Runtime: The Container Runtime is the software that retrieves images and initiates the containers, like Docker or containerd. It serves as the underlying engine for these operations.

• Kube-Proxy: Kube-Proxy acts as the networking intermediary. It enables communication between pods and the external world by overseeing network configurations on each node.

To consistently align the desired statewhat you wish to achievewith the actual statewhat is occurringthe control plane and worker nodes collaborate to create a cohesive cluster.

The Magic Trick: Self-Healing and Scaling

Now that weve introduced the characters, lets witness the magic unfold. Two of Kubernetes most impressive abilities are its self-healing and auto-scaling features.

Self-Healing:

Picture this: youve launched a web application with 5 replicas. Suddenly, one pod fails because of a bug. In a conventional setup, you would be hurriedly trying to restart it. With Kubernetes, the controller manager detects the issuedesired state: 5 pods; actual state: 4 podsand directs a node to generate a replacement. Its as if the system has an intrinsic capacity to regenerate, rising from the ashes effortlessly.

Auto-Scaling:

Traffic spiking? Kubernetes has your back. The Horizontal Pod Autoscaler (HPA) watches metrics like CPU usage or custom app metrics. If your apps getting hammered, HPA tells the cluster to deploy more pods. When the storm passes, it scales back down. Its elastic computing at its finestno overprovisioning, no waste

Pods: The Smallest Spell in the Book

Pods are the wizard's tiniest spells, if Kubernetes is the wizard. The fundamental building piece is a pod, which is a wrapper around one or more containers that share network and storage resources. Consider it a comfortable home for the containers in your app. Kubernetes determines where pods reside in the cluster; you manage pods rather than containers directly.

Pods are meant to be transient. The scheduler and controller manager allow them to die and reappear in another part of the cluster. The flexibility of Kubernetes is largely due to this abstraction; pods enable it to rearrange workloads like a pro chess player.

Networking: The Invisible Threads

Containers need to talkto each other, to databases, to the internet. Kubernetes weaves a network thats both simple and powerful:

• Every pod gets its own IP address, even across nodes, flattening the network and avoiding port conflicts.

• Services provide stable endpoints for pods, load-balancing traffic across them. If a pod dies and respawns, the service keeps the connection alive.

• Ingress controllers handle external traffic, routing HTTP requests with finesse.

Its like an enchanted web, ensuring communication flows seamlessly no matter where your pods land.

Why It Feels Like Magic

Kubernetes feels magical because it abstracts away the chaos of distributed systems. You declare what you wantvia YAML files or Helm chartsand Kubernetes makes it happen. Crash recovery? Load balancing? Rolling updates? Its all baked in. Under the hood, its a symphony of components working in concert, but to you, its a single spell: kubectl apply.

The Trade-Off: Complexity vs. Power

Of course, no magic comes without a cost. Kubernetes has a steep learning curveterms like persistent volume claims, CRDs, and RBAC can feel like arcane runes at first. And running it in production demands care: monitoring, logging, and security dont set themselves up. But for those who master it, Kubernetes unlocks unparalleled power to build resilient, scalable systems.

Conclusion: The Wizard Unveiled

Kubernetes isnt just a tool; its a paradigm shift. Under the hood, its a marvel of engineeringdistributed components, clever abstractions, and relentless automation. Whether youre running a small app or a global platform, K8s brings order to the chaos of modern computing. So next time you deploy a pod or scale an app with a single command, tip your hat to the magic happening beneath the surface. The wizardry of Kubernetes is realand its here to stay.

Last week I decided to clean up a bit of digital cruft. That is, I moved a few of my websites onto a single VPS, saving quite a bit of monthly server hosting costs.

What I did was that I moved VPSes from Linode (Akamai) to DigitalOcean, but also migrated a full web hotel from One to DigitalOcean (converting email accounts to email forwards).

As this is something that I do very rarely, I decided to document the process here so that I don’t have to look everything up again next time around.

The grunt work was about migrating a number of L*MP services to a LEMP server. There are a couple of tasks involved here, mainly migration of databases and getting WordPress running in a subdirectory using Nginx. The rest of the exercise had to do with the moving of nameservers and waiting for DNS propagation to get certbot to provide certificates for the new location.

Migration of MySQL databases

The migration of a database between machines can be broken down into three stages:

1. Dumping the old database
2. Creating a new database and user
3. Sourcing the database contents into the new database

I choose to do it in these three stages, as I’d like to keep the old database dump as an additional backup. The other option would be to transfer the database contents in a single step, merging steps 1 and 3 into one

Nevertheless, I use mysqldump to dump the database contents, and then bzip2 to reduce the size of the dump. This is efficient since and SQL dump is quite verbose.

mysqldump -u username -p --databases databasename | grep -vE \"^(USE|CREATE DATABASE)\" | bzip2 -c - > dumpname.sql.bz2

This is derived from the answer by Anuboiz over at stack overflow. The resulting file is then transferred to the new server using scp together with the actual website.

The next step is to create a new database and a new database user. Here, I assume MariaDB (using the mysql commands), as my main target is WordPress. For other database engines, e.g. Postgresql, please check the docs for exact grammar, but the SQL commands should be very similar.

sudo mysql
mysql> CREATE DATABASE databasename;
mysql> USE databasename;
mysql> CREATE USER 'username'@'localhost' identified by 'password';
mysql> GRANT CREATE, ALTER, DROP, INSERT, UPDATE, DELETE, SELECT, REFERENCES, RELOAD on databasename.* TO 'username'@'localhost' WITH GRANT OPTION;
mysql> EXIT

Check out this digital ocean tutorial for details on the above commands.

The next step is to read the database contents into the new database. For this, we need to unzip the sql dump, e.g. bunzip2 dumpname.sql.bz2, which will result in a file called dumpname.sql. Please notice that bunzip2 unzips the file and removes the original, zipped, file. If you want to keep the original, use the -k option.

Once you have the dumpname.sql file available, you can read it into the database with the newly created user using the source command as shown below.

mysql -u username -p
enter the password here
mysql> USE databasename;
mysql> SOURCE dumpname.sql;
mysql> EXIT

Now you should have a new database with the old database contents on the new server, with an associated database user. For WordPress sites, make sure that you reflect any changes in the associated wp-config.php file.

WordPress in a subdirectory using Nginx

The other piece of the puzzle that was new to me was to run WordPress from a subdirectory, e.g. example.com/blog/, rather than from the root level, e.g. example.com/.

Removing most of the nginx server configuration, the following parts does the magic:

server {
        root /var/www/thelins.se;
        index index.php index.html;

        server_name thelins.se www.thelins.se;

        ...

        # For root
        location / {
                try_files $uri $uri/ /index.php?$args;
        }

        # For subdirectory
        location /johan/blog/ {
                try_files $uri $uri/ /johan/blog/index.php?$args;
        }

        location ~ \.php$ {
                fastcgi_split_path_info ^(.+\.php)(/.+)$;
                fastcgi_pass unix:/run/php/php7.4-fpm.sock;
                fastcgi_index index.php;
                include fastcgi.conf;
        }

        ...
}

The trick was to ensure that the subdirectory try_files statement refer to the correct index.php. Notice that this has to be done for each WordPress instance, if you happen to have multiple WordPress installations in various subdirectories on the same domain.

Conclusions

Its a bit of hassle to migrate a lot of web sites at once, but the monetary saving from moving the low traffic sites onto a single VPS, and the simplification of the management and monitoring by moving all VPSes to a single provider makes it worth it.

The last maintenance release of the 24.12 cycle is out.

For the full changelog continue reading on kdenlive.org.

Model/View Drag and Drop in Qt - Part 2

Moving a row between treeviews, step 1

Moving a row between treeviews, step 2

Moving a row between treeviews, step 3

class CountryModel : public QAbstractTableModel
{
    ~~~
    Qt::ItemFlags flags(const QModelIndex &index) const override
    {
        if (!index.isValid())
            return {}; // depending on whether you want drops as well (next section)
        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
    }

    // the default is "return supportedDropActions()", let's be explicit
    Qt::DropActions supportedDragActions() const override { return Qt::MoveAction; }

    QMimeData *mimeData(const QModelIndexList &indexes) const override; // see below

    bool removeRows(int position, int rows, const QModelIndex &parent) override; // see below
};

QMimeData *CountryModel::mimeData(const QModelIndexList &indexes) const
{
    QByteArray encodedData;
    QDataStream stream(&encodedData, QIODevice::WriteOnly);
    for (const QModelIndex &index : indexes) {
        // This calls operator<<(QDataStream &stream, const CountryData &countryData), which you must implement
        stream << m_data.at(index.row());
    }

    QMimeData *mimeData = new QMimeData;
    mimeData->setData(s_mimeType, encodedData);
    return mimeData;
}

bool CountryModel::removeRows(int position, int rows, const QModelIndex &parent)
{
    beginRemoveRows(parent, position, position + rows - 1);
    for (int row = 0; row < rows; ++row)
        m_data.removeAt(position);
    endRemoveRows();
    return true;
}

class DropModel : public QAbstractTableModel
{
    ~~~
    Qt::ItemFlags flags(const QModelIndex &index) const override
    {
        if (!index.isValid())
            return Qt::ItemIsDropEnabled;
        return Qt::ItemIsEnabled | Qt::ItemIsSelectable; // and optionally Qt::ItemIsDragEnabled (previous section)
    }

    // the default is "copy only", change it
    Qt::DropActions supportedDropActions() const override { return Qt::MoveAction; }

    QStringList mimeTypes() const override { return {QString::fromLatin1(s_mimeType)}; }

    bool dropMimeData(const QMimeData *mimeData, Qt::DropAction action, 
                      int row, int column, const QModelIndex &parent) override; // see below
};

bool DropModel::dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int column, const QModelIndex &parent)
{
    ~~~  // safety checks, see full example code

    if (row == -1) // drop into empty area = append
        row = rowCount(parent);

    // decode data
    const QByteArray encodedData = mimeData->data(s_mimeType);
    QDataStream stream(encodedData);
    QVector<CountryData> newCountries;
    while (!stream.atEnd()) {
        CountryData countryData;
        stream >> countryData;
        newCountries.append(countryData);
    }

    // insert new countries
    beginInsertRows(parent, row, row + newCountries.count() - 1);
    for (const CountryData &countryData : newCountries)
        m_data.insert(row++, countryData);
    endInsertRows();

    return true; // let the view handle deletion on the source side by calling removeRows there
}

The post Model/View Drag and Drop in Qt - Part 2 appeared first on KDAB.

Back this month with another update on the progress for our new design system in Plasma.

This update includes:

– Icon selection and request to submit bugs

– Icon review and changes

– Plasma Sprint updates

If you would like to participate in an open design project like ours, learn more about it here: https://community.kde.org/Get_Involve… Learn more about our organization:

• Facebook: KDE Community

• Twitter: @kdecommunity

• Mastodon: @kde@floss.social

• LinkedIn: KDE • Reddit: r/kde

• Lemmy: KDE Community

• Instagram: @kdecommunity

• YouTube: KDE Community

• PeerTube: KDE Channel

#FigmaIcons #IconDesign #FigmaTutorial #LearnFigma #FigmaTips #UIUXDesign #GraphicDesign #VectorArt #FigmaDesign #IconCreation #FigmaForBeginners #FigmaWorkflow #DigitalDesign #FigmaCommunity #FigmaIconDesign #DesignWithFigma #UXDesignTips #FigmaTipsAndTricks #IllustrationDesign #IconDesignTutorial #penpot #opensource #opendesign

LSP Support in KDevelop, systemDGenie rewrite and big UI changes in Dolphin

Welcome to a new issue of "This Week in KDE Apps"! Every week we cover as much as possible of what's happening in the world of KDE apps. This time we will cover the past two weeks as I was traveling last weekend.

Last week we released KDE Gear 24.12.3, which concludes the 24.12 series of KDE Gear. 25.04.0 is right around the corner, with only a few days left before the beta and feature freeze. Aside from the numerous bug fixes and polishing going on, we also had some pretty big changes in Krita regarding advanced text editing options, KDevelop with support for the LSP protocol, some big UI changes in Dolphin, and a complete rewrite of systemDGenie.

General Changes

Balló György added improvements to many Kirigami projects for when they run with the software rendering backend. Projects that have been improved include Kirigami and Kirigami Addons, but also many apps like Tokodon, Kaidan, Angelfish and more.

Volker wrote a small report about the recent improvements to KDE Apps on Android. You can find it on his blog.

We fixed an issue in KIO SFTP support where symlinks would be truncated (Kishore Gopalakrishnan, 25.04.0. Link), and another in KIO SMB support where shared resources from other computers on multiple LANs and virtual LANs were not displayed when using WSDD (Harald Sitter, 24.12.3. Link).

Another thing that got fixed was an issue where the report bug button would not open the report URL (Carl Schwan, KF 1.12.0. Link).

Graphics and Multimedia Apps

Elisa Play local music and listen to online radio

Balló György fixed restoring the hidden Elisa instance on file opening (Balló György, 25.04.0. Link), and Jack Hill fixed the spacebar play/pause action, as it was not being triggered when specific buttons had the focus (Jack Hill, 25.04.0. Link).

Gwenview Image Viewer

Pedro Hernández added an option to display hidden files (Pedro Hernandez, 25.04.0. Link), and we changed how image size integers were displayed to make them clearer in all languages. Previously, we displayed 1,024x1,024. Now it is 1024x1024.

Kasts Podcast application

Bart De Vries properly implemented single instance behavior (Bart De Vries, 25.04.0. Link).

Okular View and annotate documents

Okular now supports, in addition to S/MIME based signatures, PGP/GPG based signatures. PGP signatures have the advantages that it is a lot easier to get a PGP key than a S/MIME key. Note that this feature is not yet enabled by default and for the moment only works between Okular users (Sune Vuorela, 25.04.0. Link).

Creative Apps

Kdenlive Video editor

Darby Johnston added support for OpenTimelineIO export and import using the C++ library. This allows importing and exporting projects files to/from other video-editing applications that implement this open standard (Darby Johnston supported by KDenlive fundraiser, 25.04.0. Link).

Krita Digital Painting, Creative Freedom

Wolthera van Hövell implemented basic support for the font-feature-settings CSS property in Krita. This allows tweaking the rendering of text based on OpenType font features (Wolthera van Hövell, Link). Wolthera wrote an excellent blog post on this topic, as well as covering the support of font variants mentioned two weeks ago. You can find the post on her blog.

Maciej Jesionowski added a global pen tilt direction offset, which can be helpful to make the brushes feel the same for right- and left-handed users (Maciej Jesionowski, Link).

The process of porting Krita to Qt6 is making good progress: the macOS version now compiles (Freya Lupen. Link), and the implementation of the tablet switching API for Windows is now using Qt APIs instead of a custom implementation (Dmitry Kazakov, Link).

In other news, Carl Schwan fixed the menubar visibility state being saved as non visible if the global menu option is turned on. This become an issue when turning off the global menu, as Krita's menubar wouldn't appear again (Carl Schwan, Link).

Personal Information Management Apps

KOrganizer KOrganizer is a calendar and scheduling application

Allen Winter improved the agent selection dialog. Now the Ok button is only enabled when an item is selected and the search text field has a placeholder (Allen Winter, 25.04.0. Link).

Merkuro Calendar Manage your tasks and events with speed and ease

Shubham Shinde added support for displaying holidays in the week view and the month view. Note that it is possible to disable this feature (Shubham Shinde, 25.04.0. Link 1, link 2 and link 3).

Kleopatra Certificate manager and cryptography app

Tobias Fella fixed decrypting files with very long paths on Windows (Tobias Fella, 25.04.0. Link).

Akonadi Background service for KDE PIM apps

Milian Wolff optimized some code in Qt related to timezones to improve the performance of some serialization in Akonadi. (Milian Wolff, Qt 6.8. Link)

KDE Itinerary Digital travel assistant

Volker Krause unified the formatting of temperature ranges and dynamic depending on the home country. Similarly, imperial speed units are shown for countries that use them (Volker Krause, 25.04.0. Link 1 and link 2).

Again Itinerary has increased the number of ticket types it supports and now handles multi-page 12go PDF tickets and Ghotel reservation emails.

Social Apps

NeoChat Chat on Matrix

Joshua Goins moved the "Explore rooms" button from the hamburger to the space drawer (Joshua Goins, 25.04.0. Link), added a dialog explaining what to do next when tapping "Verify this device" (Joshua Goins, 25.04.0. Link), and made joining remote rooms more reliable (Joshua Goins, 25.04.0. Link). Joshua also fixed a bug where emoji autocompletion would destroy the current message draft (Joshua Goins, 25.04.0. Link).

Meanwhile, James Graham improved the handling of switching link previews on and off (James Graham, 25.04.0. Link).

Developer Apps

Kate Advanced text editor

Niels Thykier added built-in support for the debputy language server. This is used when writing Debian package (Niels Thykier, 25.04.0. Link).

Meanwhile, Joshua Goins improved the titles of terminal tabs and assigning an icon to them (Joshua Goins, 25.04.0. Link). Joshua also improved the UI of the compiler explorer integration. This includes polishing some strings, adding tooltips and fixing some padding issues (Joshua Goins, 25.04.0. Link).

KDevelop Featureful, plugin-extensible IDE for C/C++ and other programming languages

KDevelop now support the Language Server Protocol (LSP) in addition to the native support for C++, PHP and Python. This reuses Kate's plugin, so, at the moment, it is only available when Kate is also installed (Igor Kushnir and Sven Brauch, 25.04.0. Link).

Konsole Use the command line interface

Jonathan Marten fixed a crash when double clicking on a terminal scroll bar (Jonathan Marten, 25.04.0. Link).

System Apps

Ark Archiving Tool

Natsumi Higa fixed the extraction of timestamps from 7-Zip archives, which now includes nanoseconds (Natsumi Higa, 25.04.0. Link).

Dolphin Manage your files

Dolphin is having its looks tweaked and has a new icon with an actual picture of a dolphin inside it! (Darshan Phaldesai, 25.04.0. Link).

In the same vein, Akseli Lahtinen added a background to the navigation bar of Dolphin and Gwenview (Akseli Lahtinen, KF 6.12.0. Link).

And Nate Graham added a nicer split icon to the toolbar (Nate Graham, 25.04.0. Link).

In other Dolphin news, Akseli Lahtinen fixed a crash when opening a new tab with search (Akseli Lahtinen, 24.12.3. Link).

systemdGenie System service manager

systemDGenie was completely rewritten using QML. The new version also relies a lot less on blocking DBus calls (Carl Schwan, 1.0.0. Link).

KWalletManager Store and manage your passwords

Xuetian Weng sorted a security issue and passwords copied from the KWallet Manager are no longer visible in the clipboard history of Plasma (Xuetian Weng, 25.04.0. Link).

Education Apps

Kiten Japanese Reference and Study Tool

Balló György fixed the font size of the result view. The font size was stored as point size, but passed as pixel size, causing that the actual font size is smaller than it should be (Balló György, 25.04.0. Link). Balló also fixed the background color of some views when switching to a dark theme (Balló György, 25.04.0. Link).

KHangMan Hangman Game

Max Brazhnikov Added support for non-latin alphabets (Max Brazhnikov, 25.04.0. Link).

KStars Desktop Planetarium

Hy Murveit added an altitude graph to the scheduler table (Hy Murveit, Link)

Utilities

Alligator RSS feed reader

Mark Penner made the text elide in the RSS entry list so that the buttons are always visible (Mark Penner, 25.04.0. Link), and Balló György set the default format to import and export feeds as OPML (Balló György, 25.04.0. Link).

KDE Connect Seamless connection of your devices

José Rebelo added the possibility of filtering out notifications from the Android work profile (José Rebelo, Link).

KDiskFree View Disk Usage

Kai Uwe Broulik added an option to explore in Filelight (Kai Uwe Broulik, 25.12.0. Link), and icons to the context menu entries (Kai Uwe Broulik, 25.12.0. Link).

KGet Download manager

Balló György fixed the windows activation when the current window is in the system tray (Balló György, 25.04.0. Link).

KRDC Connect with RDP or VNC to another computer

Fabio Bas added a setting for desktop scale and device scale (Fabio Bas, 25.04.0. Link), while Fabian Lesniakd disabled Kerberos support completely, since it turned out that having a broken support for it was worse than no support at all (Fabian Lesniak, 25.04.0. Link).

OptiImage Image optimizer to reduce the size of images

Balló György fixed the name of the generated optimized images, and now the suffix is appended before the file extension (Balló György, Link).

…And Everything Else

This blog only covers the tip of the iceberg! If you’re hungry for more, check out Nate's blog about Plasma and be sure not to miss his This Week in Plasma series, where every Saturday he covers all the work being put into KDE's Plasma desktop environment.

For a complete overview of what's going on, visit KDE's Planet, where you can find all KDE news unfiltered directly from our contributors.

Get Involved

The KDE organization has become important in the world, and your time and contributions have helped us get there. As we grow, we're going to need your support for KDE to become sustainable.

You can help KDE by becoming an active community member and getting involved. 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. There are many things you can do: you can help hunt and confirm bugs, even maybe solve them; contribute designs for wallpapers, web pages, icons and app interfaces; translate messages and menu items into your own language; promote KDE in your local community; and a ton more things.

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

To get your application mentioned here, please ping us in invent or in Matrix.