Planet KDE

Tuesday, 27 October 2026

Meet Clate: the First Design Tool for Real-World Experiences 🔗

Clate Beta is out today, free for everyone. It's a no-code, AI-native UX design tool built for embedded and HMI applications, with QML under the hood, so designers can stay in control of the full user experience.

The story behind the language of AI openness 🔗

Agustín Benito Bethencourt

toscalix 08:00 +00:00

RSS

Explore the AI Openness Timeline by Tagoross, tracing how the language of AI openness evolved from Free Software to open source AI, open weights, transparency and digital sovereignty.

Fixing KIO copy to USB stick and network filesystems 🔗

Méven Car

meven 00:00 +00:00

RSS

I am going to tell the story of fixing a very high priority bug that was 15 years old. Arguably the worst KIO bug.

In September 2011, against KDE 4.7, someone opened bug 281270: "When copying files to a removable disk, speed and progress reflect copying to the local cache not to the disk itself". The report notes the copy notification showed about 50 MB/s to a USB 1.1 device, which cannot go faster than 12 Mbit/s. The reporter had asked a kernel developer, Alan Stern, what was going on, and summed up his answer:

it shows that the copying operation is finished when it has not even been started.

Seventy-seven comments and 17 duplicates later, that is still how a copy to a USB stick behaves in the current release of KIO. My last post about copying was about making KIO copy faster. This one is about the opposite case, a destination that is slower than KIO, and about making the progress bar and copy completion accurate.

The changes are in four KIO merge requests: MR 2506 finds out which devices are removable, MR 2517 and MR 2518 flush the device at the end of a copy or a move, and MR 2283 adds the writeback window. All of it is merged, and will be in KDE Frameworks 6.32, released November 13th 2026.

We will see the cause of the bug, its history, and what it took to fix it.

Why a copy finishes before it has started

The file worker copies a file by handing its data to write(). write() returns as soon as the data is in the page cache, in memory. The kernel writes it to the device later, when it decides to. On a local SSD, later means very soon, and you never notice. On a USB 2.0 stick that writes at 2.3 MB/s, it is another story. Here is a 128 MiB file:

A 128 MiB copy to a USB 2.0 stick before the change: the copy reports complete after 0.06 to 0.13 s, and the data is on the stick after 68 to 91 s, over four runs.

For more than a minute, Dolphin considers the copy finished while the stick is still writing. The progress bar was showing how fast KIO filled memory. Pull the stick out during that minute, and your data is gone.

Network filesystems have a different symptom from the same cause. A large copy to an NFS or SMB share leaves hundreds of MiB in memory to send to the server, and the progress runs far ahead of it. On SMB it is worse than a wrong number: with the default cache=strict, looking at a file waits until its dirty data is written. Listing the folder you are copying into looks at that file. Over a 5 MB/s link, almost every listing during a 1 GiB copy waited 15 to 20 seconds.

Fifteen years in one bug report

The right tool actually showed up very early. Two days after the report, Christoph Feck asked whether there was a way to learn when the data is really on the disk "without causing massive slow downs that any sync type calls would cause". Two weeks later, the reporter passed on Alan Stern's answer, sync_file_range(), and Christoph replied that it looked like "exactly what we need". That was September 2011, and it is the call KIO now uses.

Then not much happened for years, apart from users confirming it and seventeen duplicates. In 2021, Nate Graham raised it to the highest priority, because a move deletes the source files while the copies are still in memory. In 2022, he changed the Disks & Devices applet, so that ejecting a device explains that it is still writing. In 2024, Christoph tested the cachestat() call of Linux 6.5, which reports how much of a file is still dirty in memory, but only for one file at a time.

This bug has been my white whale. I have been contributing to KIO since 2018, and I am still learning how the Linux storage stack behaves underneath it. I tried twice in 2024 and did not get sync_file_range() right. In MR 1718, the sync_file_range() path stayed commented out. In KIO MR 1764 and Dolphin MR 862, the worker waited for the writeback of the chunk it had just written, which had not started, so it never waited at all. Waiting for the window before the one just written is what makes it work. I didn't spot the issue, nor any reviewer unfortunately.

Since then, another contributor proposed turning off the cache for copies, in MR 2162, which was closed.

Why it took so long

Making the copy correct is the easy part: call fsync() after every file, or open the destination with O_DIRECT and skip the cache. Both make copies several times slower, and they would slow down the fast local disks too, where nothing was wrong. Making it correct without making it slow is what took fifteen years, and it needed several things that were not there before.

A way to wait for part of a file. POSIX only offers fsync(), which waits for everything. sync_file_range() is Linux only, and its own manual calls it "extremely dangerous": it does not write the file's metadata, so on its own it guarantees nothing after a crash. It can bound how much is in memory, but the end of the copy still needs a real flush.
Knowing which destinations need it, without asking them. The filesystem type does not show whether a device can be unplugged, and asking a network filesystem anything is a round trip to a server that may be slow. KIO reads the answer from the mount table and from sysfs instead, and two earlier changes to KMountPoint made that cheap enough to do for every copied file:
- MR 2326, in KIO 6.30, caches mounts by the mount id that statx() returns since Linux 6.8, instead of parsing /proc/self/mountinfo on every lookup. A lookup by id became about 700 times faster.
- MR 2487, in KIO 6.32, reads a missing mount with statmount(), which does not walk any path, so a network server that does not answer no longer blocks the lookup. In that case, the lookup went from more than 15 seconds to about 1 ms.
A place to flush at the end of a copy. The file worker copies one file per command, in its own process, and never knows which file is the last one. Only the CopyJob, in the application, knows when the whole copy is over. So the flush needed a new worker command, and a way for the worker to notify the job that a flush is needed. On the way, I found that FileCopyJob dropped the metadata that the worker sent with a copy, so the CopyJob could never have seen it.
A window size that fits every destination. A window too small slows a fast link, and a window too large never fills on a slow one. That is why it now adapts, and why the progress has to stay monotonic when the window shrinks.

A writeback window

Waiting for the device after every write would be correct but very slow. Waiting only at the end leaves the progress wrong for the whole copy. KIO now does something in between, with sync_file_range(), which lets a program start the writeback of part of a file and wait for it.

The data is written in windows. When a window is full, the worker hands it to a helper thread, which writes it back and waits for it, while the copy fills the next window. The copy only waits when the window before the one it hands over is not written yet. So at most two windows of the copy are ever in memory and not on the device, and the progress bar is never more than one window ahead of what is really written.

The helper thread was needed to accommodate CIFS, the kernel client for Samba and Windows shares. On CIFS, the call that starts the writeback of a window does more than start it: it sends the data to the server, and waits for the server to grant the credits to do so, blocking the calling thread for about 157 ms per 128 MiB window. So the copy could not fill the next window while the previous one was sent. With the helper thread making that call, sending a window and filling the next one overlap.

A window holds about 200 ms of writeback, at the speed measured on the window before. It starts at 1 MiB, can at most double from one window to the next, and stays below 16 MiB, or 128 MiB on CIFS. On a fast link the windows grow, so the copy keeps its speed. On a slow link they stay at about 1 MiB, and anything that has to wait for the file waits a fraction of a second, not for the whole file.

Complete means on the device

A window bounds how much is left in memory, but there is still something left at the end. For a removable device, KIO now also makes the end of the copy wait for it.

A file larger than the largest window, 16 MiB, is flushed with fsync(), and then its folder, before the copy reports it done. By then the window has already written all but the last two windows, so the flush is short.

Small files are the hard part. The obvious fix, an fsync() for every file, made 3000 files of 16 KiB take 10 seconds instead of 0.04 seconds on a local disk. So the worker flushes no small file by itself. After a copy to a removable device, it notifies the job, and the CopyJob sends it one more command before reporting success: write back the whole filesystem of the destination, with one syncfs(). While that runs, the copy notification shows "Writing the copied data to the device...". If the flush fails, the copy fails, because the data may not be on the device.

A move needed more than that. Before, KIO deleted each source file right after its copy, while the copy could still be only in memory, which is why the bug got its highest priority. Now a move to a removable device keeps its sources until the flush has succeeded, and deletes them after it. If the flush fails, or the stick is unplugged during it, every source stays. A source that changed while it waited for the flush stays too, with a warning. A copy or a move that stops on an error, or that you cancel, still flushes the device, and a move then deletes only the sources of the files that are on it.

Here is the same USB stick again, with the small files added:

Copies to a USB 2.0 stick, before and after the change. 128 MiB file: the copy reports complete after 0.06 to 0.13 s before, over four runs, and 28.1 s after; the data is on the stick after 68 to 91 s before and 28.1 s after. 3000 files of 16 KiB: complete after 1.2 s before and 183.9 s after; on the stick after 185.2 s before and 183.9 s after. Progress ahead of the stick: 128 MiB before, 3 MiB after.

Yes, the copies now take longer by the clock, but only because the clock now includes the time the stick spends writing. The time until the data is really on the stick did not get worse. The speed of this stick varies a lot from run to run, so the 28 seconds against 68 to 91 seconds for the large file is not a speedup I would count on. The small files never fill a window, so they only depend on the flush at the end.

Which destinations get a window

A local fixed disk does not need any of this, and keeps the current behaviour exactly. With the removable policy forced onto a local disk for testing, the 3000 small files took 1.55 s against 1.54 s before the change.

Deciding what is removable is less obvious than it sounds. The filesystem type does not expose it: exFAT can be a memory card, and FAT is also the EFI partition of your laptop. Most USB disks do not even report removable media. MR 2506 adds a private function to KIO that asks sysfs: the disk's own removable flag, then the USB port or PCIe slot it hangs off, which the kernel marks removable when it can be reached from outside the machine, and SD cards. It follows encrypted and LVM volumes down to the disk under them.

Network filesystems are easier: every mount that KIO already considers slow gets a window. That is NFS and CIFS, but also Ceph, GlusterFS, 9p, sshfs, and FUSE filesystems such as rclone. The worker finds the mount from the mount id of the destination folder, without a round trip to the server.

Numbers on network shares

To measure this, I used KIO's own copy job, comparing KIO master just before the change with KIO master after it, while another thread listed the destination folder every 50 ms. The SMB server ran on the same machine, with 2 ms of delay added to its traffic, and for the slow link a limit of 40 Mbit/s, about 5 MB/s.

On the slow link, the listing is the difference you would feel:

The copy runs about 3% slower with the window. On a fast link, the copy keeps up:

One of the five copies before the change failed with a write error from the share, so these numbers come from four rounds. The times vary between runs: in an earlier run, the copy with the window was 4% slower.

Getting there took me four tries. My first version was 10 to 20% slower on the fast link, because of the CIFS behaviour described above. Then, with the windows aimed at 500 ms, listings on the slow link went up to 4.2 seconds, because each request of a listing waits behind the window being sent. Aiming the windows at 200 ms brought the listings down to 1.7 seconds.

NFS, on the same machine with 2 ms of delay:

The copy times are close: 11% slower in the first round, and slightly faster in the two others.

Part of a frozen Dolphin

Bug 423187 collects many ways in which a slow mount can freeze Dolphin. In one of its comments, Frank Gehann copied a 100 MB file to an SMB share while browsing it, and found two causes: Dolphin's main thread waiting for answers from the share, and folder listings waiting behind the queued upload.

The window helps with the second cause: each request of a listing now waits behind at most two windows, about 400 ms of writeback, and a whole listing took 1.7 seconds on the 5 MB/s link instead of 5 to 11. The statmount() change helps with part of the first one. KFileItem::isSlow(), which Dolphin calls on its main thread before it reads a file to find its type, no longer waits for any server, on Linux 6.8 or later. Work is underway to fix the rest of the first cause in Frank's open MR 2484 and MR 2485.

The stick that pauses

One measurement sent me down a rabbit hole. During a large copy to the USB stick, listing a folder on the stick sometimes took about 15 seconds, before the change as much as after it. It looked like the writeback window was making something wait.

It was the stick. Roughly every 8 seconds, a single 120 KiB write to it took 4 to 7 seconds to complete, and the listing waited for a page that was stuck behind such a write. KIO cannot fix a device that stops for seconds at a time, but at least we now know the copy is not to blame. In the runs for this post, the slowest listing took 3.6 ms during the copy of the large file, but 7 seconds during the copy of the small files, against 15 seconds before the change.

Copying between two filesystems

One more thing landed along the way, and this one is a plain speedup. In 2021, in Frameworks 5.88, I replaced sendfile() with copy_file_range() in the file worker, in MR 602. At the time, Linux copied with copy_file_range() across filesystems too. Linux 5.19 changed that back: between two filesystems, the call fails again with EXDEV. Since then, a copy from one filesystem to another went through read() and write() in the worker, one buffer at a time.

MR 2520 now falls back to sendfile() in that case, which copies from one file to another inside the kernel:

Copy of 1 GiB between two filesystems, medians of 5 rounds. tmpfs to ext4: 443 ms before, 272 ms after. ext4 to tmpfs: 531 ms before, 278 ms after.

A copy to the USB stick takes as long as before, because its write speed is the limit. This one is merged too, and will also be in KDE Frameworks 6.32.

Closing

With all this, a copy to a USB stick now finishes when the data is actually on the stick. On network filesystems, the progress now follows what the server has received, and the share stays usable during the copy.

sync_file_range() is mainly used by databases and storage engines. No other file manager that I know of uses it. Now KIO, and so Dolphin, uses it too.

Happy unplugging.

My KDE workflow with jujutsu 🔗

Thiago Masato Costa Sueto

@herzenschein:kde.org 00:00 +00:00

Atom

Intro🔗

I’ve been learning Jujutsu (jj), a a version control system that serves as a frontend for git, but changes the workflow itself instead of just being a GUI or a set of aliases.

It has facilitated my git workflow immensely, but it also scared me when it comes to some design decisions. After all, I’m familiar with git and know how to avoid screwing things up with it; I was unfamiliar with jujutsu and didn’t know how to not screw up there.

When I tried to apply it to my KDE workflow, I learned about what it does that I don’t want. Here’s my notes about it, in case anyone is interested in trying it.

For the record, I've done all the following workflows before:

keep all changes in semantically split commits regardless of file
keep each file into its own commit <-- this is what I do most nowadays because I docs is easier this way
squash everything into one commit
make a single large commit, then split it into multiple

Maybe I'll write about this in the future, we'll see.

Configuration🔗

This section explains what I feel are required changes to the default Jujutsu settings so it matches my usage.

I don't want jj to track main/master unless I do so explicitly🔗

Jujutsu has a concept of “tracked bookmarks” (where a bookmark is essentially a git branch for our purposes). When you do track a bookmark, every time you push to a remote, all tracked bookmarks get pushed at the same time.

While this is handy for most people (like those who have their own small projects and don't need branches), well, in KDE we usually don’t ever commit to master unless the change is tiny and uncontroversial; instead we put our work in work/<username>/branch-name (a work branch) and make a merge request. And jujutsu defaults to tracking master/main.

If a contributor has the ability to commit to master, this may be a hazard. I can easily see someone making a commit in their local master branch for testing or whatever reason (bisecting? triggering tool behavior? I don't remember what for, but I've done this before), forgetting about it after some time, and then being surprised they pushed to master.

This may be an irrational fear, but I’d rather the tool cater to my own stupidity instead. Hence, I disable tracking the master branch.

[git]
track-default-bookmark-on-clone = false

I don't want jj to automatically track bookmarks at all🔗

I once tried this setting after being confused at the official documentation, whose listed use cases seemed beneficial to me; in reality I don’t want it at all, and I spent quite some time trying to figure out why Jujutsu was not giving me the behavior I wanted.

As mentioned above, every tracked bookmark gets pushed by default when you do a generic jj git push without specifying a bookmark. Like in I don't want jj to track main/master unless I do so explicitly, there can be an accident where you accidentally push a change made to some branch you didn’t intend to push. This is probably more likely to happen here, in fact.

So the jujutsu defaults for this are fine, actually, and I just make a deliberate note here to avoid setting this up, and if I ever do, it will only happen with work branches.

# [remotes-origin]
# auto-track-bookmarks = "work/username/*"

I want jj to advance the bookmark as soon as I commit🔗

Jujutsu doesn’t have a concept of “current branch”. Instead, you work on “detached commits”, in git lingo, and just make a bookmark point to the tip of the last detached commit.

This is of course incredibly annoying to do every time you want to push your branch, so the jujutsu folks implemented a feature to do this: advance branches.

Every time you use jj commit, your branch is automatically advanced; in other words, the new commit becomes the tip of the branch.

For this I want two settings.

I want jj to only advance the bookmark in my work branches (I sometimes work on other people’s branches, I don’t want to push them to the remote accidentally):

[experimental-advance-branches]
enabled-branches = ["glob:work/username/*"]

I don't want jj to ever move the bookmark on main/master unless I do so explicitly (again, for my (irrational) fear of accidentally committing something to master):

[experimental-advance-branches]
disabled-branches = ["main", "glob:push-*"]

When I do want to have these settings to be different, I can just jj config edit --repo to apply that config to my specific repo. I do this for this blog's repository, for example.

I want more descriptive autogenerated bookmarks🔗

Jujutsu does a neat thing where if you never specify a bookmark/branch name, it will simply autogenerate one for you in the push-randomletters format.

I can see why people would want that (in principle you don't need to care about branch names if you always do PRs/MRs immediately), but I don’t want it. It’s ugly and non-descriptive. While not exactly often, KDE contributors sometimes make branches that don’t get an MR until later in life; if I were to browse a list of non-descriptive branch names, it would be more annoying than helpful.

If it ever happens, I want it to be at least somewhat descriptive. So...

In the case I ever intentionally or accidentally push an autogenerated bookmark, I want jj to at least have a more readable default autogenerated branch name based on the commit name without spaces and without single quotes in lowercase:

templates.git_push_bookmark = "\"work/username/\" ++ description.first_line().replace(\" \", \"-\").replace(\"'\", \"\").lower()"

There’s a bit of quote witchcraft going on because TOML, but this means the generated bookmark for a commit named Add setup page would be named work/username/add-setup-page.

This does have the limitation of being based on the last commit (I think?), but come on, I'm not that good with jj yet.

Resulting configuration🔗

The result, including username, email and ssh signing set up, resides in ~/.config/jj/config.toml:

[user]
name = "Your User"
email = "your-email@example.com"

[git]
# Don't want to track main/master
track-default-bookmark-on-clone = false

# [remotes.origin]
# Generic `jj git push` sends it to all tracked bookmarks
# auto-track-bookmarks = "work/username/*"

[templates]
# Any autogenerated bookmarks become work/username/add-setup-page
git_push_bookmark = "\"work/username/\" ++ description.first_line().replace(\" \", \"-\").replace(\"'\", \"\").lower()"

[experimental-advance-branches]
## Automatically runs jj bookmark advance on commit
enabled-branches = ["glob:work/username/*"]
disabled-branches = ["main", "glob:push-*"]

[signing]
behavior = "own"
backend = "ssh"
key = "~/.ssh/mysshkey.pub"

Instead of manually specifying the path to the file, you can just run jj config edit --user.

If you want a programmatic way to set these settings, there's jj config set --user <name> <value>. For example: jj config set --user git.track-default-bookmark-on-clone false.

Workflow🔗

I’m not going to explain how jujutsu works in this blog post.

I am going to link you to the official documentation and to Steve Klabnik’s Jujutsu tutorial instead.

Here in this blog post I’m simply going to show you the jujutsu commands I use for my workflow, based on actions, so you know what you need to do in these situations.

I want to turn an existing cloned git repo into something I can use jj on🔗

jj git init

I want to clone a repo and have it ready for use with jj🔗

jj git clone <repo-link>

I want to create a new branch, push it, and start working on it🔗

jj bookmark create work/username/i18n
jj git push --bookmark work/username/i18n
jj bookmark track work/username/i18n@origin

It’s necessary to track the bookmark so it gets pushed with jj git push later on. Otherwise you may simply jj git push --bookmark <bookmarkname> every time.

I want to create a new empty working copy🔗

jj new

I want to “checkout” (switch?) to a commit, change or branch, no matter if detached or not🔗

jj edit <change-or-bookmark>

This is great. You don’t need to do the whole git dance to edit a previous commit at all:

git log
git rebase --interactive
mark as edit/e
make a change
git rebase --continue

You just jj edit, edit what you want, then you jj edit back to the tip/branch. All subsequent commits are automatically rebased for you, and jujutsu will warn you of any conflicts.

I want to turn a change into an actual commit and have it be the latest tip of my branch (I’m already working on a branch as set up earlier)🔗

jj new
# Make a change
jj describe
jj bookmark advance

Or, with experimental-advance-branches:

jj new
# Make a change
jj commit

I recommend using jj commit, but it’s good to know that it’s equivalent to jj describe + jj bookmark advance.

I want to move added changes in a working copy ("currently checked out commit") into a parent change🔗

jj squash
# That's the same as
jj squash --from @ --into @-

This is great because I feel the most common use case for a squash is from child to parent. You’d normally do git rebase --interactive and mark a commit as squash/s for this. Here you don’t even need to check the log or rely on tab completion.

Convenient if you’re the type to squash all changes into a single commit, but you really want to jj diff your working copy first to make sure your changes are how you want them.

Instead of switching to a change and editing it, I want to move added changes in a working copy to a specific change, interactively🔗

jj squash --interactive --into <change-id>
# This will modify that change's change-id btw!
# Don't reuse the same id from shell history.

If you know the change ID or commit you want to squash into, you can actually use it with interactive mode, which provides you a nice TUI to select the exact things you want to transfer.

I made a new commit (which automatically creates an empty working copy) and want to merge the previous commit into its parent🔗

# If I don't want to leave the current working copy:
jj squash --from @- --into @--
# Or if I do leave the current working copy:
jj edit @-
jj squash

Here @ is the current working copy (like git’s HEAD) and @- is the working copy’s parent (like HEAD~ or HEAD~1). There’s stuff like @-- which is the parent of the parent too (like HEAD~2).

I have a working copy with too many changes and I want to split it into multiple🔗

jj split --interactive

It doesn't matter if your working copy is an existing named commit or if it's an anonymous working copy.

Let's say your case is the former: after splitting the changes, the ones that were marked will be the only things in the current named commit; the ones that you did not mark will be in a separate commit.

Let's say your case is the latter: after splitting the changes, the ones that were marked will be part of the current working copy, which will get a new name like if you did jj describe; the ones you did not mark will be in a separate commit.

Split does not create a new empty working copy (because you might want to split the commit further).

I want to get back to the parent change🔗

jj edit @-

I want to stash changes in my unnamed working copy and edit something else🔗

jj edit <commit>

Yeah, you don't really do anything. You can just leave that commit and go back to it later, it's autostashed for you. See the next section.

I want to get back to the child change (that's not an empty working copy)🔗

jj edit @-
# Finished, I want to go back!
jj edit @+

Of course, if the child change was an empty working copy, then this command fails with Error: Revset '@+' didn't resolve to any revisions, and you'll need jj new.

However, if there was work in an unnamed working copy before you moved to a parent commit, then trying to edit the child change actually will restore the working copy you had (with a different change id). You can think of this as jj essentially stashing your working copy changes, and restoring them immediately upon editing it again.

Let's think of a similar hypothetical scenario where, after doing jj edit @-, instead of doing jj edit @+ you were to do jj new. What happens then? Rather than abandon the changes, you branch it. The parent @- will actually have two unnamed children (that you can edit with their change ids), and jj log will show this.

This distinction is only briefly mentioned in the official docs despite being awesome, so I wanted to elaborate it here.

I am in an edited working copy but I want to drop changes while keeping the bookmark pointer if there is any🔗

jj abandon --retain-bookmarks

You probably always want to use --retain-bookmarks. Might as well keep that in your shell history instead of jj abandon.

Using jj abandon with experimental-advance-branches means the tip loses the bookmark, and you’ll need to mark it again. With jj abandon --retain bookmarks the bookmark is sent to the previous commit. I wish that was the default when I have experimental-advance-branches enabled.

I made an error that might have been destructive in my repo or history and I need to correct it🔗

# Acts as a literal ctrl + z
jj undo

This reverts the last operation in jj operation log.

Particularly good when you’re resolving a conflict and you accidentally confirm the changes instead of quitting!

I wish I had that in git when I was starting... I've had so much trouble even trying to read the damn git reflog.

I want to change the order of my commits🔗

jj arrange

This is usually done with git rebase --interactive. It’s fine. I like that it semantically makes sense, though it takes a bit of effort to lose the muscle memory.

I want to rebase my changes onto up-to-date master🔗

jj git fetch
jj rebase --onto master@origin

No need to git pull --rebase origin master or update your local master branch to in turn rebase your branch locally, jj uses the remote reference directly. It just needs to know what has changed in the remote beforehand (hence the git fetch).

By the way, in KDE we rarely ever do merge commits, or that rebase process involving "merge master into commit" or something. In fact, I'm so used to our workflow that I actually don't know how to rebase that other way!

I want to resolve conflicts that originate from a rebase🔗

# Upon attempting to rebase, an error message will pop up
# Saying to do exactly the following
jj new <first-commit-with-conflicts>
jj resolve
jj diff
# If it's resolved
jj squash
# Continue resolving until everything is done
jj edit <bookmark>
jj git push --bookmark <branch you were working on>

Probably the most elaborate process here.

It helps that jj resolve gives you a nice TUI with individual changed lines with context, like a git frontend TUI would.

I want to view only the log for my current bookmark🔗

jj log --revision 'trunk()..@'

This is similar to:

git log master..HEAD

In both jj and git it can be annoying to see the whole log, especially if the last commit on master/main was your own.

Sunday, 25 October 2026

Options are expensive. Not having them has a cost too. 🔗

Nuno Pinheiro

pinheiro 18:19 +00:00

RSS

So... I'm working on something new for Oxygen.

The idea is fairly simple: giving users the option to choose between symbolic and colourful icons for actions, the little things you see in toolbars and menus. One option for people who prefer the clean, monochrome look, another for those who like a bit more colour in their interfaces. You choose, and hopefully everyone is happy.

Sounds easy enough, right?

Heee... well, there's a small problem with that.

Oxygen is a theme, and themes are brutal things to maintain. Especially when you care about the details, and especially when you want to offer choices without making one of them feel like an afterthought.

Just to give you an idea of the scale of this particular problem, Oxygen has 719 colourful action icons in the 32×32 size alone. Breeze has roughly 1,200 icons, excluding copies and symbolic links. And I'm not simply scaling the existing artwork down and calling it a day. I'm drawing new versions from scratch for 16×16, 22×22, and 32×32, with 24×24 and 48×48 derived directly from the 22×22 versions.

That's a lot of little pictures.

A LOT. Over 9.000!!!!

So far, I've made approximately 130 new icons in each of those three sizes. You can follow the work in the symbolicActions directory on KDE Invent. with simlinks and sizes around 1150 new files in the past 4 days...

And each one has to work at its intended size, with its own limitations, proportions, and details. What looks perfectly fine at 32 pixels can turn into a muddy mess at 16. A detail that makes an icon recognisable at one size can become noise at another. Sometimes you have to redraw the thing almost entirely to make it work.

Multiply that by hundreds of icons, and you start to understand why maintaining a theme is such a monumental amount of work. And this is just one part of it.

But there's some good news too! Over in Oxygen Labs, we now have a working prototype of a patch for the KDE settings module (KCM) that lets you choose between symbolic and colourful action icons.

Which is rather the point of all this.

The user gets Options in the settings. Pick the style you prefer in the size you prefer, hit save, and carry on using your computer. They don't need to know about the hundreds of files, the different sizes, or the months spent adjusting individual shapes. Ideally, it just works.

So why bother?

Because We think user options matter. Even when they seem trivial, even when most people will never touch the setting that is very hiden :D, even when the work required to support them seems completely disproportionate to the little checkbox or dropdown that exposes them.

We all use our computers differently. We have different tastes, different habits, different ideas about what makes an interface comfortable to use. Some people love symbolic icons because they keep the interface quiet and consistent. Others prefer colourful icons because they make actions easier to recognise, or simply because they enjoy having a bit more colour around. And I cant make up my mind as i think it depends :D. Neither is wrong. And if we can offer both without compromising the quality of either, why shouldn't we?

Of course, every option has a cost. Someone has to design it, implement it, test it, and keep it working. In a theme like Oxygen, that cost can be enormous, because an apparently small choice can multiply the amount of artwork that needs to exist and be maintained.

But there is a cost to having no choice as well. It means deciding that everyone should use the same thing, whether it suits them or not. Sometimes that's a perfectly reasonable decision. We can't offer a setting for absolutely everything. But I don't think we should dismiss options just because the work behind them is invisible.

Because apparently, giving people a choice between two kinds of tiny pictures is how I choose to spend my free time. Anyway, there's still plenty to do, but I'm slowly making my way through this rather ridiculous pile of icons. One at a time. on the bright side my daily commits now rival Laurent :D,.... J.K. im only human

On some other news, due to popular demand (all 3 of you) ;(, we are going to make a new video on the qml theming thing, I'm thinking on doing the switch element with a twist ( a literal one ). Wil keep you posted

Saturday, 24 October 2026

This Week in Plasma: Fixing All the Bugs, PiP, and Performance 🔗

Farid Abdelnour

@frdbr:kde.org 00:00 +00:00

RSS

Welcome to a new issue of This Week in Plasma. And it’s going to be a big one, folks!

This week, a familiar pattern played out: people upgraded to Plasma 6.8 and found all the bugs that nobody reported during the beta period, and the Plasma team worked incredibly hard to fix them! You’ll see the result below: tons of bug fixes.

It’s clear that not enough people are testing Plasma’s beta releases to uncover and report all regressions. We’re open for ideas on how to improve this.

In addition to the bug fixes, this week also saw a number of nice new features, UI improvements, and performance enhancements. Consequential stuff! Check it out below:

Notable new features

Plasma 6.9

After extended testing, KWin’s support for the Wayland picture-in-picture (PiP) protocol has been deemed stable enough, and turned on by default! (Vlad Zahorodnii, kwin MR #10175)

Screenshot of a KDE Plasma system showing a frame from the KDE documentary in a picture-in-picture window floating over this very post viewed in the LibreWolf web browser

Window sizes and positions are now remembered on a per-screen-arrangement basis!

This means if you arrange your open windows across two screens, then disconnect one, then rearrange the windows to suit the now-single-screen arrangement… then when you reconnect the second screen, open windows will jump to the sizes and positions they last had on the two-screen arrangement. And when you disconnect a screen again, open windows will jump to the sizes and positions they had on the single-screen setup.

Note that this only takes effect within a running session for open windows; it does not affect the positioning of windows that are closed and then reopened. That’s still being worked on. (Jakob Petsovits, kwin MR #10198)

You can now permanently deny XWayland-using apps from asking to control the pointer and keyboard, and also see which apps have been denied and revoke their denials. (David Redondo, KDE Bugzilla #521576)

“Legacy X11 App Support” page in System Settings, showing the new “See Denied Applications” button

In-progress downloads in Firefox that produce a nice native Plasma notification via Plasma Browser Integration can now be paused and resumed from that notification. (Simon Hürlimann, plasma-browser-integration MR #207)

Plasma Browser Integration now supports the Brave browser. (Geevarghese ST, plasma-browser-integration MR #179)

Notable UI improvements

Plasma 6.8.2

The Activity Switcher sidebar no longer stretches wallpaper images for screens without a 16:9 aspect ratio; now the wallpaper is shown faithfully, but cropped if needed. (Niccolò Venerandi, KDE Bugzilla #478784)

When you use a plain color as your wallpaper in conjunction with the “accent color from wallpaper” feature, the accent color is now set to the exact color of your wallpaper, not a generated shade of it. (Niccolò Venerandi, KDE Bugzilla #513851)

A Plasma system with a plain lavender wallpaper color, and the automatically-chosen accent color is the same

Holding down a key that plays or pauses media now plays or pauses it once, rather than repeatedly. (Niccolò Venerandi, KDE Bugzilla #521448)

When using the zoom feature with “Push” pointer tracking, zooming in or out some more will now center the zoom on the pointer’s current location. (Maxim Stomphorst, KDE Bugzilla #508098)

Plasma 6.9

If you hold down the Shift or Ctrl keys to select multiple items on System Monitor’s Applications or Processes pages, the items in the list views temporarily stop rearranging themselves so you can actually select items properly! (Vladimir Pahomchik, plasma-systemmonitor MR #479)

System Settings’ Wi-Fi & Networking page now uses the more familiar “forget” terminology for removing networks. (Taras Oleksyn, KDE Bugzilla #525844)

On System Settings’ Task Switcher page, the feature to preview a new Alt+Tab window switcher style now simply triggers it to appear rather than using a simulation, which ensures that it always looks right. This also fixes a bug that made certain visualizations un-preview-able. (Kai Uwe Broulik, kwin MR #10154 and KDE Bugzilla #508088)

Frameworks 6.32

When your operating system hasn’t set up PAM and KWallet properly, the wizard that prompts you to create a new wallet now steers you in the direction of a Blowfish wallet, and instructs you in how to use GPG if you choose that option but no GPG keys are found. (Thomas Duckworth, KDE Bugzilla #353960)

Notable bug fixes

Plasma 6.8.1

Fixed a case where Plasma could crash while screens were being connected, disconnected, or rearranged. (Marco Martin, plasma-workspace MR #7249)

Fixed an edge case that broke the lock screen for people doing an in-place upgrade from Plasma 6.7’s X11 session to Plasma 6.8’s Wayland session. In-place upgrades are not recommended because they can and will unearth similarly unpleasant issues, but this one is fixed now. (David Edmundson, kscreenlocker MR #383)

Fixed a case where Spectacle could save an image to the wrong location after it had previously been saved to a different location. (Mohanraj Velayutham, KDE Bugzilla #526111)

Fixed an issue in the color scheme editor window that would make its preview area show the wrong colors much of the time when it was opened while using a dark system color scheme. (Akseli Lahtinen, KDE Bugzilla #527382)

Fixed a visual glitch in System Monitor’s column configuration window. (Akseli Lahtinen, KDE Bugzilla #527190)

The Meta+V clipboard popup now gets focused as expected when the system is using a higher than normal focus stealing prevention mode. (Christoph Wolk, KDE Bugzilla #527326)

Remote desktop clients connecting to Plasma’s built-in remote desktop (RDP) server now see pointers with the correct colors when the server uses a colorful pointer. (Zhongli Wu, KDE Bugzilla #524148)

Fixed an issue in Plasma’s built-in remote desktop (RDP) server that would make it only accept the first connection made by the Mac remote desktop app currently named “Windows App for Mac” (formerly named “Microsoft Remote Desktop”), and fail for subsequent attempts until the server was restarted. (Oliver Beard, KDE Bugzilla #527202)

Plasma 6.8.2

Hardened KWin against crashing when given invalid global keyboard shortcut keys. (Vlad Zahorodnii, plasma-desktop MR #4097)

Fixed a regression that could sometimes make files and folders on the desktop become temporarily invisible on the primary screen of a multi-screen setup. (Brodi Elwood, KDE Bugzilla #527226)

Fixed two regressions with pinned tasks on the Task Manager widget: one that made them fail to open in the correct positions when using certain settings, and another that made them briefly disappear when their window was moved to another screen while using the feature to only show tasks on the current screen. (Marco Martin and Samuel Collins, KDE Bugzilla #527189 and KDE Bugzilla #527507)

Fixed a regression that broke notifications using the sliding effect for people who had old non-default animation duration values in their config files. (Vlad Zahorodnii, KDE Bugzilla #527478)

Fixed a regression that sometimes reset the wallpaper on certain screens in multi-screen setups. (Marco Martin, KDE Bugzilla #527150)

Fixed a regression that made the lock screen stop blurring the wallpaper on the primary screen of a multi-screen arrangement while the interactive controls were shown. I think we managed to miss this one because Plasma 6.8’s default wallpaper is already kind of blurry! (Marco Martin, KDE Bugzilla #527569)

Fixed a regression that made the Activity Switcher sidebar slightly overflow off the bottom of the screen when there are any horizontal panels. (Marco Martin, KDE Bugzilla #527158)

Fixed a regression that made the Fcitx5 CJK input method’s “candidates panel” force a floating panel to un-float. (Devin Lin, KDE Bugzilla #527067)

Fixed a regression that made the Activity Pager widget show two underlines for the active Activity, rather than just one. (Christoph Wolk, KDE Bugzilla #527235)

Fixed an issue in Plasma’s built-in remote desktop (RDP) server that showed a blank screen for client apps lacking support for hardware-accelerated H.264 video. (Matteo Beretta, KDE Bugzilla #526931)

Fixed a long-standing issue that could make desktop widgets change their size on login when using a multi-screen setup. (Marco Martin, KDE Bugzilla #490687)

Fixed an issue in the Sticky Keys feature that made it sometimes not work quite right. (Vlad Zahorodnii, KDE Bugzilla #509714)

Fixed multiple issues relating to the names and orders of virtual desktops getting out of sync between the Overview effect and the Pager widget. (Niccolò Venerandi, KDE Bugzilla #501660, KDE Bugzilla #501808, KDE Bugzilla #506247, and KDE Bugzilla #522322)

Fixed an issue with Plasma’s on-screen keyboard that could make it unexpectedly appear and get stuck there in Fedora KDE’s installer. (Aleix Pol Gonzalez, KDE Bugzilla #524506)

Fixed an issue with the wrong window in a group getting highlighted when hovering over its Task Manager tooltip thumbnail. (Christoph Wolk, KDE Bugzilla #527229)

Panel Spacer widgets now work correctly on vertical panels. (Niccolò Venerandi, KDE Bugzilla #518799)

The Media Player widget now correctly displays the name of media that includes non-ASCII characters. (Niccolò Venerandi, KDE Bugzilla #503405)

Scrolling on the Kickoff Application Launcher’s “All Applications” page now works properly with a touchpad when the page is configured to show apps in a grid, rather than in a list. (Christoph Wolk, KDE Bugzilla #526911)

Discover no longer appears five times in the “Choose Application” window. (Taras Oleksyn, KDE Bugzilla #511886)

Plasma’s built-in remote desktop (RDP) server now tracks the pointer more accurately for scaled virtual screens, and resizes accurately when virtual screens are changed in size. (Zhongli Wu, krdp MR #273, krdp MR #277, and krdp MR #298)

Plasma 6.9

Disabling a critical notification no longer makes it appear anyway while Do Not Disturb mode is active. (Ramil Nurmanov, KDE Bugzilla #519592)

Frameworks 6.32

Did you know that you can scroll horizontally with a traditional scroll wheel mouse by holding down Alt while scrolling? Or at least you could before Qt 6.12, but we’ve adapted to a change made in that Qt release that broke this functionality in the custom scroll handler used by Plasma and KDE’s QtQuick apps, and now it works again. (Marco Martin, KDE Bugzilla #526317)

KRunner no longer incorrectly tries to pluralize the word “Hertz”. (Tobias Fella, KDE Bugzilla #527386)

Qt 6.12.1

Fixed a Qt bug that made Plasma hang on logout while any System Monitor widgets were present. (David Edmundson, KDE Bugzilla #527240)

Notable in performance & technical

Plasma 6.8.1

When Plasma’s built-in remote desktop (RDP) server automatically generates a TLS certificate, it lasts for ten years, not one day. (Zhongli Wu, krdp MR #265)

Plasma 6.8.2

Plasma’s system monitoring widgets no longer let you configure line charts to show so much history that their data collection would make Plasma lag and freeze. (Niccolò Venerandi, KDE Bugzilla #527627)

Buttons to copy text to the clipboard on websites displayed in the Web Browser widget now work as expected. (Niccolò Venerandi, KDE Bugzilla #523381)

The volume feedback sound now unconditionally uses the relevant sound from the active sound theme, fixing a few edge cases where it would sometimes use the system’s fallback sound theme instead. (Niccolò Venerandi, KDE Bugzilla #525954)

Plasma 6.9

If you let the Plasma Login Manager sit there without logging anyone in, it will now eventually let the monitors enter power saving mode. (Raphael Erard, KDE Bugzilla #484015)

Frameworks 6.32

Improved the performance of the common SVG-reading code used throughout Plasma and many apps. (Mátyás Nyilas, ksvg MR #120)

All KDE software should no longer hang when a network share that was manually mounted and added to the Places panel becomes unavailable! (Méven Car, KDE Bugzilla #272361)

How you can help

This week there are a number of new ways to help KDE!

Ask the KDE Goals champions

“Ask the champions” banner for the KDE Goals process

The champions of the new KDE Goals for the 2026-2028 cycle will be answering your questions live on YouTube and PeerTube on October 29 at at 17:00 UTC. Leave them your questions at the KDE Forum post! As a reminder, the new goals are:

KDE for Enterprise and Deployments: Ask David Edmundson, Kevin Ottens, Neal Gompa, and Kai Uwe Broulik about how they plan to make KDE the best choice for businesses and public institutions.
Better documentation: Check in with Nate Graham, Thiago Masato Costa Sueto, and Joseph P. De Veaugh-Geiss about improving KDE’s documentation.
Next Generation Styling for KDE: Find out how Arjen Hiemstra, Akseli Lahtinen, and Andy Betts are working to implement a unified styling system.

Donate to the fundraiser

KDE’s annual end-of-year fundraiser has started, and making a donation is a hugely impactful way to keep KDE financially solvent. Due to… world events… costs for travel, computer hardware, and server infrastructure are higher than ever. KDE needs your help to keep the lights on, so donate today if you can!

Take the desktop icons survey

Help us figure out how desktop icons should behave in various tricky situations by taking a survey on the topic.

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

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

This Week in Plasma: Fixing All the Bugs, PiP, and Performance 🔗

Nate Graham

ngraham 00:00 +00:00