Language Selection

English French German Italian Portuguese Spanish

Kde Planet

Syndicate content Planet KDE
Planet KDE | English
Updated: 1 day 23 hours ago

Kdenlive 23.08.1 released

Monday 18th of September 2023 05:38:23 PM
The first maintenance release of the 23.08 series is out:


  • Fix audio channel setting breaking opening of existing project file. Commit.
  • Fix possible crash in audiolevel widget. Commit.
  • Fix default audio channels for project not correctly saved. Commit.
  • Fix guide/marker categories all black on some non english locales. Commit.
  • Ensure Media browser saves zoom level when using mouse wheel to zoom. Commit.
  • Extract audio: export only active streams, merge all if requested. Commit.
  • Fix crash on subclip transcoding. Commit.
  • Fix audio extract for multi stream clips. Commit.
  • When restoring audio or video component in timeline, first try target track, then mirror track. Commit.
  • Fix multi guide export enabled by default. Commit.
  • Fix guides categories all black when opening a project from a different locale. Commit.
  • Fix archiving crash on Windows caused by filesystem case sensitivity. Commit.
  • Project Bin: don’t draw icon frame if icon size is null. Commit.
  • Fix zone rendering not remembered when reopening a project. Commit.
  • Fix detection/fixing when several clips in the project use the same file. Commit.
  • Correctly update guides list when switching timeline tab. Commit.

The post Kdenlive 23.08.1 released appeared first on Kdenlive.

So let’s talk about this Wayland thing

Sunday 17th of September 2023 11:23:33 PM

Wayland. It comes up a lot: “Bug X fixed in the Plasma Wayland session.” “The Plasma Wayland session has now gained support for feature Y.” And it’s in the news quite a bit lately with the announcement that Fedora KDE is proposing to drop the Plasma X11 session for version 40 and only ship the Plasma Wayland session. I’ve read a lot of nervousness and fear about it lately.

So today, let’s talk about it!

What is Wayland?

Wayland is a set of protocols that govern how a compositor draws stuff on the screen, and how apps interact with the compositor’s drawing-stuff-on-the-screen infrastructure. It’s similar to the HTTP and SMTP protocols that govern how web browsers and email clients send and receive web pages and data.

Wayland also includes an implementation of those protocols in a set of extremely lightweight libraries called libwayland-client and libwayland-server that offer stable and versioned APIs. Apps and compositors such as KDE’s KWin and GNOME’s Mutter use those APIs to do stuff.

Why does Wayland exist?

In a nutshell, because X11–the thing it’s replacing–is dead.

X11 has been in maintenance mode for years, and recently has gotten no real development at all other than changes to the XWayland compatibility system that allows X11 apps to use a Wayland compositor. Having something as central as the window server being unmaintained is a major issue, as it means no bug fixes, no security patches, and no new features to let it keep up with a changing world.

Why did X die?

The fundamental X11 development model was to have a heavyweight window server–called Xorg–which would handle everything, and everyone would use it. Well, in theory there could be others, and at various points in time there were, but in practice writing a new one that isn’t a fork of an old one is nearly impossible. Everyone strongly preferred to standardize on a single X server and migrated in unison from one to another when a better fork became available, because it was convenient. And it was convenient because because it centralized limited development resources, and when a feature was added to the X server, everyone gained access to it automatically.

But there was a drawback: because everyone was using Xorg, any feature added to support any use case could break everything else that everyone else used, and this happened frequently. Bug fixes frequently regressed obscure functionality that others were using.

In essence, Xorg became too large, too complicated, and too fragile to touch without risking breaking the entire Linux ecosystem. It’s stable today because it’s been essentially frozen for years. But that stability has come hand-in-hand with stagnation. As we all know in the tech world, projects that can’t adapt die. Projects that depend on them then die as well.

How is Wayland any better?

Wayland was conceived of by X developers who wanted to avoid repeating their own mistakes. In addition to a lot of technical differences, by being a minimal set of protocols and two extremely thin client and server libraries, all the heavy lifting was delegated to individual compositors, which became the window servers of their environments. A new feature added to one would not destabilize any other compositors. Compositors were also free to implement new features via private protocols outside of the standard ones that apps only targeting that compositor could use.

Wait, that sounds like it sucks

Wayland has not been without its problems, it’s true. Because it was invented by shell-shocked X developers, in my opinion it went too far in the other direction. Wayland’s minimal core protocols are lacking most of the features that non-trivial apps and desktops actually need to work–such as screen locking, screen sharing, cross-app window activation, non-integer scaling, and so on. Compositors all needed to come up with ways to do these things themselves. And that need for each compositor to implement everything itself fragments development efforts and disadvantages small teams without the expertise of heavy-hitting graphics developers. These are real problems and we shouldn’t sweep them under the rug.

Yes, but there are solutions

Over time the minimal core protocols have been extended to cover what’s needed for a Linux desktop and sophisticated apps to work. Much of this work is very recent, driven by KDE, and funded by Blue Systems and Valve Software. So most complaints you read about Wayland missing this or that (such as fractional scaling, or screen sharing, or global shortcuts) from over a year or two ago are likely to be wrong today.

In addition, the problem of fragmentation of effort is being solved by wlroots, a library of Wayland implementations that you can use to build a Wayland compositor. We don’t use it in KDE’s KWin compositor because we already did most of that work ourselves before wlroots existed, but it’s a big benefit to anyone writing a new compositor from scratch today. And there’s a chance we might port KWin to use wlroots in the future.

Why is the adoption taking so long?

The fact that Wayland’s minimal core protocol made it unable to fully replace the thing it aimed to replace was a bad architectural design decision on the part of its authors that crippled the prospect of its rapid adoption when it was released in 2008. We didn’t see the same problem with other newer projects like Systemd and PipeWire which were adopted much faster.

And unfortunately, shepherding new protocols through the approval process to fix this problem is a grueling political exercise. It demands empathy and compromise with people from other projects who approach the problem you’re trying to solve from a fundamentally different perspective. Someone may disagree that the problem is even worth solving. Bikeshedding derails the discussion and everyone gets demoralized and stops working on it. For a long time, the urgency of pushing through it was low because X wasn’t dead yet.

So it took over a 15 years and resulted in Wayland’s dirty laundry being aired in public for that whole time. And that sucks. But… we’re there now. Standard protocols now exist for just about everything anyone needs. The few remaining obvious omissions (like screen color calibration) are being actively worked on as a matter of priority.

“Are we there yet?”

Plasma and KDE apps work great on Wayland, especially in the upcoming Plasma 6 release. Like I said, there are still a few omissions, but those holes are being plugged very quickly these days.

Most 3rd-party apps that aren’t Wayland-native also work fine via the XWayland compatibility layer. But there are some that don’t, because they integrate very deeply into some part of the system in a way that requires X11 support. These need to be ported to use new Wayland APIs.

A lot of app developers became accustomed to tuning out Wayland news while it was still a toy, and didn’t do the porting work. Well, it’s not a toy anymore, and now many are now feeling blindsided by the sudden urgency to port their apps to use Wayland. That’s understandable. But this time it’s for real, and the time to port is now. For any protocols that still aren’t good enough and need revision, app developers’ input is needed to revise them or even propose new ones. This process takes a long time, so better to start sooner rather than later. But it’s not just gonna go away.

Which brings us to Fedora KDE

Fedora has always been a “leading edge” distro that pushes forward the technical state of the art on Linux by adopting new technology once it’s mostly ready, thus causing it rapidly improve in a way that it otherwise would not have. Fedora was the first distro to adopt Systemd, PulseAudio, and PipeWire. It was the first to use the Plasma Wayland session by default. And now Fedora KDE wants to be the first to drop the Plasma X11 session entirely and make everyone use the Plasma Wayland session.

It should be clear that Fedora’s target audience consists of people who are excited about change. If this is you, all of these projects should seem exciting and cool! If not… then Fedora isn’t for you. And that’s fine. The Linux world has approximately five hundred bajillion distros. What’s that you say? Only about 20 of them are any good? Well, fair enough, but even if that pulled-out-of-someone’s-butt number is accurate, there are still 19 distros that aren’t Fedora! Reinstalling your OS is unpleasant, but it’s important to choose the right one that suits your needs and preferences. Choice comes with the responsibility of choosing wisely.

Maybe you’re afraid that Fedora is a “canary in the coalmine” that shows the way everything is going to go. And you wouldn’t be wrong about that, but transitions still take time. Distros that intentionally ship old software like Ubuntu LTS or Debian Stable will let you keep using X11 for years and years. Arch will probably keep shipping X11 for a while too. You have options. By the time Ubuntu LTS removes X11 too, everything will be fully ready.

Putting it all together

Wayland is a replacement for X11, which is dead. Despite a rocky development process, it’s ready enough for Plasma and KDE apps that Fedora KDE is pushing it pretty hard. Many 3rd-party apps are already Wayland-native, but many are not, and they need to put in the work to port to Wayland. If anything they need is still missing, they need to step up to be part of the process of adding it. This process is happening, and isn’t going to stop happening. We need to work together to make it happen faster and more smoothly.

Kraft Version 1.1

Saturday 16th of September 2023 08:48:43 PM

Kraft (Github) is a desktop utility making it easy to create offers and invoices quickly and beautifully in small companies.

Today we are releasing Kraft Version 1.1 with significant improvements for users and the Krafts integration with latest software such as cmake and KDE.

It received updated dutch translations in UI and also for the manual. The application icon was fixed, and some cmake related fixes were done that make Kraft working with different versions of Akonadi that are available on different distributions.


For users, two significant improvements are included: The header- and footer texts of the documents now may contain macros that support automatic computing of values such as dates that depend on the document date. With that, it is for example easy to have for example a payment date printed out on the document, that is ten days later than the document date.

There are even more interesting macros, stay tuned for a separate post about this feature.

Insert Templates Button

The second new feature is a new button that allows to insert templates for the header- or footer text at the cursor position. Before it was only possible to replace the entire text with a template. This will give users way more flexibility how to structure template texts.

In parallel to these improvements, work is also going on in a branch for Kraft 2.0 which will enable more collaborative functions for Kraft.

Weather Benefits

Saturday 16th of September 2023 07:48:50 AM

The upside of a wet summer followed by a late heatwave is here.

This week in KDE: more Plasma 6 dev

Saturday 16th of September 2023 04:54:30 AM

This week it was pretty much all Plasma 6 all the time. With the release date four and a half months away, work is kicking into high gear to make sure that we hit our deadline!

Plasma 6

General infoOpen issues: 87

Made even more cursor responsiveness improvements for the Plasma Wayland session! The cursor is really very responsive now

Web Review, Week 2023-37

Friday 15th of September 2023 03:38:22 PM

Let’s go for my web review for the week 2023-37.

Willingham Sends Fables Into the Public Domain

Tags: culture, law, public-domain

This is unclear on the technicalities (is it even possible to just claim it like this? is CC0 required? etc.). Still this is a bold move, hats off to this renowned author.

Google gets its way, bakes a user-tracking ad platform directly into Chrome | Ars Technica

Tags: tech, google, surveillance, attention-economy

If you’re still using Chrome, maybe you shouldn’t… They’re clearly making it easier to overcome ad blocker and the tracking won’t be a third party thing anymore, this browser will directly report on your behavior.

Meet the Guy Preserving the New History of PC Games, One Linux Port at a Time

Tags: tech, gaming, maintenance, culture

Interesting conservation work. Video games being part of our culture, especially indie ones, it’s important for such work to happen and be funded.

Touch Pianist - Tap in Rhythm and Perform Your Favourite Music

Tags: tech, music, funny

Really cool and fun experiment. Surprisingly relaxing I find.

If a hammer was like AI…

Tags: tech, ai, gpt, ethics, ecology, bias

Lays out the ethical problems with the current trend of AI system very well. They’re definitely not neutral tools and currently suffer from major issues.

Against LLM maximalism · Explosion

Tags: tech, ai, gpt, language

Now this is a very good article highlighting the pros and cons of large language models for natural language processing tasks. It can help on some things but definitely shouldn’t be relied on for longer term systems.

Computer Science from the Bottom Up

Tags: tech, system, unix, cpu, memory, filesystem

I didn’t read it since it’s basically a whole book. Still from the outline it looks like a very good resource for beginners or to dig deeper on some lower level topics.

A systematic approach to debugging | nicole@web

Tags: tech, debugging

Good process for fixing bug. Definitely similar to how I approach it as well.

A user program doing intense IO can manifest as high system CPU time

Tags: tech, io, storage, cpu, kernel, performance

A good reminder that depending what happens in the kernel, the I/O time you were expecting might turn out to be purely CPU time.

Linear code is more readable

Tags: tech, programming, craftsmanship

A bit of a rambling, there’s something interesting in it though. Splitting small functions early will do more harm than good if they’re not reused. Don’t assume they automatically make things easier to read.

Async Rust Is A Bad Language

Tags: tech, rust, asynchronous, criticism

More details are surfacing regarding async and Rust… definitely not a match in heaven it seems.

Good performance is not just big O - Julio Merino (

Tags: tech, performance, programming

Good list of things to keep in mind when thinking about performances. Of course, always measure using a profiler when you want to be really sure.

Response Time Is the System Talking

Tags: tech, queuing, networking, system, performance

Interesting way to approximate how loaded a system is.

FIFO queues are all you need for cache eviction

Tags: tech, caching

Interesting caching strategy. Looks somewhat simple to put in place as well.

Death by a thousand microservices

Tags: tech, microservices, criticism, complexity

Looks like the morbid fascination for microservices is fading. This is very welcome. This piece is a good criticism of this particular fad and gives an interesting theory of why it came to be.

Making visually stable UIs | Horizon EDA Blog

Tags: tech, gui, fonts

Think of the typography and fonts if you don’t want to have text jumping around in your GUI.

Bricolage | Some notes on Local-First Development

Tags: tech, web, frontend, crdt

Interesting, “state of the union” regarding local-first we frontend. Lots of pointers towards other resources too.

Multi-page web apps

Tags: tech, web, frontend, complexity

Good reasoning, multi-page applications should be the default choice for web frontends architecture. The single page applications come at a cost.

The Tyranny of the Marginal User - by Ivan Vendrov

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

OK, this is a very bleak view… maybe a bit over the top I’m unsure. There seems to be some truth to it though.

On Waiting - Tim Kellogg

Tags: management, organization, patience

This is a sound advice. In other words, don’t commit too early, only when you got enough information. Of course monitor to make sure you don’t miss said information.

Bye for now!

Countering string bloat (addendum)

Friday 15th of September 2023 02:00:00 PM

As last weeks post on countering string bloat has triggered some interest (and a few misunderstandings) here are a few more details on that topic. Nevertheless this isn’t going to be a comprehensive discussion of string handling in Qt (and was never meant to be), there’s plenty of posts and talks on that subject already out there if you want to dig deeper.

When to use QLatin1String

The KWeatherCore example in the last post was mainly discussing the use of QLatin1String in combination with Qt’s JSON API, as that has corresponding overloads. And that is a very important point, preferring QLatin1String over QStringLiteral for constant strings is only generally advisable if such overloads exist.

Things will work either way of course (as long as we are only dealing with 7bit ASCII strings), but at a cost. QLatin1String is implicitly convertible to a QString, which involves a runtime memory allocation of twice its size and a text codec conversion to UTF-16. QStringLiteral exists to avoid precisely that, and saving that runtime cost is generally preferable over a few bytes in storage.

So this is always a case-by-case decision. QLatin1String overloads only exist in places where they can actually be implemented more efficiently, and it only makes sense to add them in those cases.

Note that “overload” is to be understood a bit more loosely than in the strict C++ sense here. Examples:

  • String comparison and searching.
  • JSON keys.
  • QLatin1String::arg as an alternative for QString::arg.
  • String concatenations, in particular in combination with QStringBuilder.

Yes, exceptions might exist where the reduced binary size trumps the additional runtime cost, e.g. for sparsely used large data tables. But there might be even better solutions for that, and that’s probably worth a post on its own.


With the right choice being a case-by-case decision, there’s also understandably demand for better tooling to support this, search/replace isn’t going to cut it. While I am not aware of a tool that reliably identifies places where QLatin1String overloads should be used instead, there are tools that can at least support that work.

Clazy has the qstring-allocations static check to identify QString uses that can potentially be optimized to avoid memory allocations. This is actually the reverse of what is discussed here, so it’s a good way to catch overzealous QLatin1String uses. It has the second to lowest reliability rating regarding false positives though, so this is also not something to apply without careful review.

Clazy’s qlatin1string-non-ascii check is another useful safety net, finding QLatin1String literals that cannot actually be represented in the Latin-1 encoding.

Enabling QT_NO_CAST_FROM_ASCII also helps a bit as it forces you to think about the right type and encoding when interfacing with QString API.

The other aspect of tooling is looking at binary size impact of code changes. A simple but effective tool is bloaty, which is what produced the size difference table in the previous post. Make sure to strip binaries beforehand, otherwise the debug information will drown everything else.

For a more detailed look, there is also the size tree map in ELF Dissector.

ELF Dissector's size tree map showing KPublicTransport, the big block in the center being QRC data. Expected savings

How much savings to expect varies greatly depending on a number of circumstances. It’s also worth looking at absolute and relative savings separately. In the previously mentioned KWeatherCore example this were 16kB or 7% respectively.

This is due:

  • Few if any QLatin1String overloads were used, so a lot of room for optimization.
  • The library is very small and a significant part of it is JSON handling.
  • Other significantly more impactful optimizations to its static data tables had been applied previously (see e.g. this MR).

Let’s look at another example to put this into perspective, this change in KPublicTransport. Just like the KWeatherCore change this also changes QStringLiteral to QLatin1String in places where corresponding overloads exist, primarily in JSON API.

FILE SIZE VM SIZE -------------- -------------- -0.1% -16 -0.1% -16 .eh_frame_hdr -0.1% -144 -0.1% -144 .eh_frame -0.1% -430 -0.1% -430 .text -0.9% -3.97Ki -0.9% -3.97Ki .rodata -0.3% -4.00Ki -0.3% -4.54Ki TOTAL

The savings here are lower though, just 4kB or 0.3%. This is due:

  • The majority of this code already uses QLatin1String overloads, the change only fixes a few cases that slipped through.
  • Unlike with KWeatherCore the QString overloads remain in use for generic code not using literal keys. We therefore see no reduction due to fewer used external symbols (.plt remains unchanged).
  • The library is much larger in total.
  • The data size is dominated by compiled in resources, primarily polygons in GeoJSON format (the big red box in the center of the above screenshot).

The latter would be the much more relevant optimization target here, as GeoJSON isn’t the most efficient way neither regarding space nor regarding runtime cost.

In general, the absolute amount of size reduction should be somewhat proportional to the amount of QStringLiteral changed to QLatin1String. If the relative change is surprisingly low, it’s worth checking what else is taking the space.

An even more extreme example that came up in discussions on this is Tokodon, where the relative reduction was just a fraction of a percent. A view in ELF Dissector reveals the reason for that, its giant compiled-in Emoji tables overshadowing everything else

Size tree map for Tokodon, the large top left and center blocks are all related to static Emoji data.

Besides the data size (which wont be entirely avoidable here) this also involves a significant amount of static construction code, which is the even more interesting optimization target as it also impacts application startup and application runtime memory use.


As always with optimizations there is no silver bullet. Occasionally looking into the output of various profiling and analysis tools for your application or library usually turns up a few unexpected details that are worth improving.

Nevertheless I stand by my recommendation from last time to keep the seemingly minor details like the use of the right string API in mind. It’s an essentially free optimization that adds up given how widely applicable it is.

Krita 5.2 Release Candidate is out!

Friday 15th of September 2023 11:24:25 AM

The release candidate is here for Krita 5.2, this means that we are confident that all the major bugs brought on by the changes in Krita 5.2 have now been fixed, and would like you to give it another round of testing.

Please pay extra attention to the following features of Krita, since they got updated or reworked since Beta2:

  • assignment of profiles to displays in multi-monitor setup (Krita should use EDID info to map the displays to profiles everywhere, except on macOS)
  • dockers layout should now be properly restored after Krita restart, even after the usage of canvas-only mode
  • autokeyframing feature of animated layers got a lot of fixes since Beta2

Here is the full list of bugs (and other minor changes) have been fixed since the second beta:

  • Fix crash when activating Halftone filter in Filter Brush (Bug 473242)
  • Fix a crash when activating Color Index filter in the filter brush (Bug 473242)
  • text: Write xml:space as XML attribute in SVG output
  • text: Normalize linebreaks into LF when loading from SVG
  • Build patched libraqm with Krita instead of in 3rdparty deps
  • [qtbase] Correctly parse non BMP char refs in the sax parser
  • Actually load the fonts in the QML theme (Bug 473478)
  • Fix Channels docker to generate thumbnails asynchronously (Bug 473130)
  • Fix wobbly lines when using line tool (Bug 473459)
  • text: Make sure white-space overrides xml:space
  • text: Reject negative line-height in SVG
  • Simplified fix for tag selector and checkboxes problem (CCBug 473510)
  • Fix creation of a new image from clipboard (Bug 473559)
  • Make sure that the horizontal mode of the preset chooser is properly initialized
  • Hide preset chooser mode button when the chooser is in horizontal mode (Bug 473558)
  • Only repaint KisShapeLayerCanvas on setImage when really needed
  • text: Do not synthesize bold in several cases like fonts that are already bold or variable fonts.
  • AnimAudio: Fixed crash when loading animation file with audio attached, due to incompletely constructed canvas.
  • Fix a model warning in KisTimeBasedItemModel (Bug 473485)
  • Don’t recreate the frames when not necessary (Bug 472414)
  • Fix cross-colorspace bitBlt with channel flags (Bug 473479)
  • text: Also consider HHEA metrics for default line height (Bug 472502)
  • Fix BDF font-size matching (Bug 472791)
  • Make sure that the node emits nodeChanged() signal on opacity change (Bug 473724)
  • Fix ‘enabled’ state of the actions in the Default Tool (Bug 473719)
  • Respect statusbar visibility after Welcome page (Bug 472800)
  • Fix a warning in outline generation code in shape tools (Bug 473715)
  • Possibly fix a crash when switching animated documents (Bug 473760)
  • OpenGL: Request DeprecatedFunctions on Windows to fix Intel driver (Bug 473782)
  • Allow welcome page banner to shrink
  • text: Use line-height when flowing text in shape (Bug 473527)
  • text: Make first word of text-in-shape flush against the shape
  • Fix color values under transparent pixels be lost in Separate Image (Bug 473948)
  • flake: Fix transformation of text path and shape-inside (Bug 472571)
  • Make sure that Krita correctly specifies video codec for libopenh264 (Bug 473207)
  • Don’t allow New/Open File buttons to grow taller (Bug 473509)
  • raqm: Fix Unicode codepoint conversion from UTF-16
  • Android: Bump targetSdkVersion to 33
  • Fix multiple issues with auto-keyframing code
  • Edit Shapes tool: make moving points move points by a delta instead of snapping them to the cursor
  • Initialize tool configGroup before optionWidget (Bug 473515)
  • Fix updates on autokeyframing with onion skins enabled (Bug 474138)
  • JPEG-XL: fix crash on importing XYB grayscale that needs transform
  • JPEG-XL: also apply patches workaround on lossy export
  • Fix artifacts when using assistants in images with high DPI (Bug 436422)
  • Don’t allow closing hidden document views without confirmation (Bug 474396)
  • logdocker: Fix infinite tail recursion with multiple windows (Bug 474431)
Download Windows

If you’re using the portable zip files, just open the zip file in Explorer and drag the folder somewhere convenient, then double-click on the Krita icon in the folder. This will not impact an installed version of Krita, though it will share your settings and custom resources with your regular installed version of Krita. For reporting crashes, also get the debug symbols folder.

Note that we are not making 32 bits Windows builds anymore.


The separate gmic-qt AppImage is no longer needed.

(If, for some reason, Firefox thinks it needs to load this as text: to download, right-click on the link.)


Note: if you use macOS Sierra or High Sierra, please check this video to learn how to enable starting developer-signed binaries, instead of just Apple Store binaries.


We consider Krita on ChromeOS as ready for production. Krita on Android is still beta. Krita is not available for Android phones, only for tablets, because the user interface requires a large screen. RC1 packages for Android are signed as usual.

Source code md5sum

For all downloads, visit and click on Details to get the hashes.


The Linux AppImage and the source .tar.gz and .tar.xz tarballs are signed. This particular release is signed with a non-standard key, you can retrieve is here or download from the public server:

gpg --recv-keys E9FB29E74ADEACC5E3035B8AB69EB4CF7468332F

The signatures are here (filenames ending in .sig).



The post Krita 5.2 Release Candidate is out! appeared first on Krita.

Too Many Sites

Friday 15th of September 2023 06:56:32 AM

I’m trying to come up with a plan to harmonize all my sites. There are way too many installs on too many machines spread out over vendors and sites. A general clean-up is really needed.

Right now I have a couple of sites that are self-hosted (they run on a old machine in my office), a VPS at Linode and a couple of VPSes at DigitalOcean. I also have a couple of sites run via github pages.

Right now, a majority of the sites are based around WordPress which is great due to the ease of use – but static sites are easier (and cheaper) to host. In addition to this, I also have a couple of Django apps running on VPSes. Nice, but requires quite a bit of RAM in my experience.

So, the general plan is to clean up my domains, and to harmonize the environments. Perhaps a single WordPress machine, that also hosts the static sites, and the dedicated machines for the more complex Django apps. There will also be a bunch of URL rewrites to make the structure better, i.e. this blog will probably live under, but be available via the old URL too (

When reviewing my domains, I found the following ones that I most likely will give up. If there are any takers, please tell me what you want it for, and I’d be happy to hand it over to you (contact me at e8johan-at-gmail):

  • (open source in Swedish)
  • (I’ve already got, and I won’t write another book until Qt 8)
  • (see

Also, I plan to pull all the machines over to DigitalOcean, as they offer a really nice interface (and APIs!) for managing VPSs, DNS and more (and I’ve gotten used to them while building Eperoto’s infrastructure).

Finally, I intend to collect all domain name registrations at a single registrar (most likely Loopia, but let’s see.

KDE: KDE neon user edition updates! Debian updates, Snaps on hold.

Thursday 14th of September 2023 05:06:28 PM

I had to make the hard decision to put snaps on hold. I am working odd jobs to “stay alive” and to pay for my beautiful scenery. My “Project” should move forward, as I have done everything asked of me including finding a super awesome management team to take us all the way through. But until it is signed sealed and delivered, I have to survive. In my free time I am helping out Jonathan and working on KDE Neon, he has done so much for me over the years, it is the least I can do!

So without further ado! Carlos and I have been working diligently on new Frameworks 5.110, Plasma 5.27.8, and Applications 23.08.1! They are complete and ready in /user! With that, a great many fixes to qml dependencies and packaging updates. Current users can update freely and the docker images and ISO are building now. We are working on Unstable… as it is a bit unstable right now, but improving

Discover GCompris

Thursday 14th of September 2023 12:09:27 PM

GCompris includes well over a hundred fun educational activities. In this video you will learn how they are divided into categories and see a number of examples of what you can find in the GComrpis treasure trove.

KDE Gear 23.08.1

Thursday 14th of September 2023 12:00:00 AM

Over 120 individual programs plus dozens of programmer libraries and feature plugins are released simultaneously as part of KDE Gear.

Today they all get new bugfix source releases with updated translations, including:

  • gwenview: Fix navigation with side mouse buttons (Commit)
  • kio-extras: Thumbnail: Fix heap-use-after-free in AudioCreator::create (Commit, fixes bug #469458)
  • akonadi-calendar: Use correct identity when sending iTIP counter-proposal (Commit, fixes bug #458524)

Distro and app store packagers should update their application packages.

On the Road to Plasma 6, Vol. Ⅲ

Wednesday 13th of September 2023 05:31:07 PM

Another month, another Plasma 6 update. I’ve been pretty busy during the past weeks, mostly further improving the Wayland session, fractional scaling, and dealing with Qt bugs. Working under the hood like this is tremendously important albeit somewhat ungrateful when there aren’t any pretty pictures to show.

Still looks the same now, doesn’t it? By the way, there is a Wallpaper Contest going on!

A key reason for being able to work so efficiently on kwin_wayland nowadays is that our apps can survive a restart of the Wayland compositor. I can just recompile KWin and restart it like I could on X11. Check out David’s blog post to learn more, including some spectacular video demos, and things we could do with that capability in the future!

I’m a huge fan of screen edges, so I have my bottom left, bottom center, and bottom right edge configured to trigger the window overview, KRunner, and peek at desktop, respectively. I noticed that under Wayland while selecting loads of text and bumping into the bottom of the screen, expecting the view to scroll, the screen edge triggered instead, interrupting the selection operation. This was fixed by simply checking whether the mouse is currently pressed when triggering the edge. Of course, windows can still be moved past the sides to switch desktops. Unfortunately, this also means that an edge cannot be triggered by dragging a file. This never really worked on X either, and the overview effect isn’t prepared to handle drag events anyway, but in the future I’d really like to be able to start dragging a file, drag it into the overview effect, and drop it on another window.

Speaking of drag and drop, I also fixed the mouse cursor being stuck after dropping a file. Qt has an “override cursor” that is set to a hand (or the like) while dragging but the code for resetting it wasn’t called from the Wayland drag handler. Additionally, I made child surface positioning in KWin more spec-compliant. Using an XDG Positioner, a client can specify the relative position of a popup window and define rules for how it should be placed when there isn’t enough room (for instance, flip it to the other side or just move it around slightly) and whether those rules should be applied once or continuously. As a result, GTK fly-outs dodge screen edges while moving around, whereas context menus in Qt apps just stick to their parent window stoically.

Regarding mouse cursors, there’s now a cursor-shape protocol which lets applications set a cursor by name, e.g. crosshair, wait, col_resize, as opposed to painting their own cursor surface. I never understood the original design decision behind requiring clients to know how to parse Xcursor images, pick the right cursor theme, size, etc. There are sure use cases for custom cursor pixmaps but your run-of-the-mill desktop app probably just wants a pointer and an IBeam. With cursor-shape, theme handling is delegated to the compositor which can then load the correct theme once and re-use it for all supporting clients.

I fixed a bug in the QtWayland implementation where switching from shape cursors to bitmap cursors didn’t work as could be observed with Kolourpaint’s tool cursors. Moreover, Qt no longer allocates a cursor surface at all if the app never used a bitmap cursor. While we switched the default modifier key for moving windows from Alt to Meta to free Alt for applications like Blender, two decades of muscle memory aren’t easily retrained, so I kept it as it was before. Unfortunately, this meant that during Alt+Tab it would move the window grid around instead of interacting with it since “I am pressing Alt”. As a remedy, KWin now checks whether a window is movable before stealing mouse events for initiating an unrestricted move operation.

I have always been an opponent to fractional scaling – there are no “half pixels”. Nevertheless, I have now switched my 14″ laptop to use 175% scaling and naturally began fixing all the bugs. Wayland core protocol only supports integer scaling, a client can specify whether a buffer is at 1x or 2x (or 3x, or…) scale, and the compositor matches that up with its output scale. Recently, using the Viewporter and Fractional scale protocol, a compositor can instead announce that a client is supposed to render natively with a scale of – in my case – 210/120. Yet, since fractional scale is a property of an individual window, it doesn’t map well to QScreen or QGuiApplication APIs which look at the output that is still technically at 2x scale.

This manifests itself in blurry or pixelated icons when using QIcon::pixmap without specifying a device pixel ratio, or using qApp->devicePixelRatio(). I fixed both Breeze style and Dolphin to rasterize icons at the scale of the window. Sadly, sometimes an app starts rendering before the fractional scale is set and you end up with a single frame at 2x which is then replaced by another frame at the correct scale. I fixed both KWin and QtWayland to not assume a (potentially incorrect) scale factor before the actual scale factor has been determined but the underlying issue of rendering prematurely still needs to be investigated.

Dolphin rendering icons at 175% scale, before and after

On the Qt front I finally figured out why Plasma 6 kept crashing when receiving KDE Connect notifications. Technically, it wasn’t KDE Connect’s fault but it is one of the more prominent users of “resident” notifications. Normally, a notification is removed once it times out because that’s how the notification spec works and if we didn’t, we’d potentially cause memory leaks in apps. However, in order to provide a more interactive notification history, an app can explicitly set the “resident” property and control a notification even after it timed out. When it does, the relevant flag is set on the notification which causes the popup model to filter it out and thus remove the popup. Qt then tried to signal that the property has changed on the popup which was deleted in the meantime, leading to a crash. The fix was basically a one-liner but investigating it was quite a challenge: have you ever tried to print the contents of a QV4::String (to figure out the name of the property it accessed when it crashed) during a post-mortem coredump analysis?

Qt 6.6 Beta 3, I believe, also broke invoking certain methods on attached properties, which Plasma makes heavy use of. This lead to, among other things, System Tray icons not reacting to mouse clicks anymore. Luckily, a bunch of fellow Plasma hackers were on an even more bleeding-edge Qt build than I was, and as a result the issue could be spotted and resolved quickly. Qt 6 also treats trailing null bytes in QByteArray differently from Qt 5, which broke the XDG portal file picker, since it might have tried to start in a folder named “Downloads\0” instead of “Downloads”. Furthermore, Qt 6.6 gained API for reading file time stamps in UTC, saving timezone conversions. This is now used by KConfig and KService and saves like a couple of tens of milliseconds on startup of all our apps. A penny saved is a penny got.

Finally, we have decided on a release timeline for Plasma 6! An Alpha release will be made in November, accompanied by a soft feature freeze. Beta releases will follow throughout December and January, and the final release is slated for February 2024. This makes it even more important that you give Plasma 6 a spin and report – or fix – all the bugs! Check out our Community Wiki for a comprehensive list of open issues and instructions on how to run it. Needless to say you can also Donate to KDE to fund development and the necessary infrastructure.

Discuss this post on KDE Discuss.

Games, consoles and the Meta mystery

Tuesday 12th of September 2023 10:00:00 PM

For the past few days I was at the seaside.

As my better half had some work that she needed to take with her, I also took my new laptop and when she was doing her thing, I tweaked a few small things here and there. Nothing major though, as we were still on vacation.


Not that I game much these days, especially on PC1, but if I already have a Vega 8 graphic card, it would be wasteful not to at least try it.

By default I am booting into Zen kernel, as it is said to provide a smoother experience on laptops/desktops as well as with gaming.

Lutris (and Steam)

Initially installing either Lutris or Steam failed me with a SegFault, but after asking on the forums and digging through Lutris documentation, I managed to get both installed.

Then I added my Steam, GOG and libraries to Lutris. Installing (and launching) games through Lutris is super convenient.

A problem I am still running in with though is a bit weird. Lutris offers a really nifty option to change the keyboard to US when launching a game. That is quite handy for me since my default layout in Neo2.

But the problem is that even after the game ends, (some?) GTK applications – at least Firefox, GIMP – retain US layout even after the game (or even Lutris) ends. So far I could not figure out how to fix this or work around it, apart from simply not using that option.

The few games I tried seem to run fine (e.g. Return to Monkey Island runs perfectly), but I am sure there is some performance tweaking to be made … some other day.

Mouse go whoops!

This was a bit awkward …

I have a Roccat Kone Pure mouse2, which I find to be a great programmable mouse with 12 buttons. It is marketed as a “gaming mouse”, but honestly I use it to bind some keyboard shortcuts to mouse buttons.

As is often the case with these things, to update and modify the firmware on the device itself there is a (no longer maintained, but stable) (semi-)official niche one-man Linux tool – Roccat Tools. The tool still works fine, even though it has not seen an update since 2019.

If you want to write firmware to the (mouse) device, you need write premissions to it, which is obviously and sanely, not the case the default. The packages do provide the correct UDev rules, but you still need to add yourself to the roccat group.

And here is where it got ugly.

I forgot to use --append in the usermod command … yeah, not great. Do not forget to use it.

To fix my stupid mistake, I had to log in as root (luckly I could!) and add myself to the right groups from memory. I hope I got it right

Checkpoint Restore For Graphical Applications using QtWayland compositor handoffs

Tuesday 12th of September 2023 08:22:49 AM

Checkpoint restore allows you to safe the state of an application to disk at any given pooint during its execution, and then recover it at that exact point.

Using compositor handoff to switch between desktops

Tuesday 12th of September 2023 08:19:45 AM

In the video we can see applications seamlessly move between Plasma, Gnome, Weston, Hyprland and Sway as part of the wayland robustness project.

QtWayland Robustness through compositor handoffs

Tuesday 12th of September 2023 08:18:00 AM

This is a video demonstration of a new feature in Qt 6.6 to handle clients surviving a compositor restart.

Why did I become a Software Heritage Ambassador

Tuesday 12th of September 2023 07:00:00 AM
Recently, I decided to join the Software Heritage (SwH) Ambassador program. This is an effort to build a group of volunteers that supports both the SwH organization and its community in different areas like awareness, communication, community growth, ecosystem development, technical excellence, etc. The SwH Ambassadors Program is currently formed by around 30 people with … Continue reading Why did I become a Software Heritage Ambassador

KDE Plasma 5.27.8, Bugfix Release for September

Tuesday 12th of September 2023 12:00:00 AM

Tuesday, 12 September 2023. Today KDE releases a bugfix update to KDE Plasma 5, versioned 5.27.8.

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

This release adds five months' worth of new translations and fixes from KDE's contributors. The bugfixes are typically small but important and include:

  • KRunner: make debut on X11 faster. Commit.
  • Powerdevil: don't automatically suspend by default if running in a virtual machine. Commit.
  • System Settings: Remove soft hyphens in keywords used for searching. Commit.
View full changelog

QtWayland 6.6 Brings Robustness Through Compositor Handoffs

Monday 11th of September 2023 12:00:45 PM

Every release has a killer feature. Qt 6.6 features the opposite - staying alive. This blog post describes work to make Qt clients more robust and seemlessly migrate between compositors, providing resistance against compositor crashes and more.


Right now if you restart pulseaudio your sound might cut out, restart NetworkManager and you lose your wifi, restart an X11 window manager and your decorations disappear.

But within a second it's all back to normal exactly where you left off with everything recovering fine.

This isn't true for display servers. If X11 restarts you're back at the login prompt. All drafts lost, games unsaved, work wasted.


For X11 this was unfixable; clients relied on memory stored by the Xserver, they made synchronous calls that were expected to return values, and multiple clients talked to multple clients.

This was a real problem in my early days of Linux, X11 would lock up frequently enough that most distributions had a shortcut key to restart the server and send you back to the login prompt.

It's less of an issue now as X11 has been in a lengthy period of feature freeze.


Wayland makes it possible to fix all this. Memory allocations are client side, all operations are async, all protocols are designed that the compositor always has complete control.

Yet the current user-facing state is considerably worse:

  • Compositors and displays servers are now the same process, doubling the space for errors

  • Compositors are typically extensible with 3rd party plugins and scripts

  • The wayland security model means the compositor absorbs even more functions from global shortcuts to screencasting and input-method handling

  • The wayland ecosystem is not in a period of feature freeze with wayland protocols constantly evolving to cover missing features and new ideas.

    Even if there was a perfect compositor:

  • 40% of kwin's crash bug reports are either upstream or downstream causes

  • The current compositor developer experience is limited with developers having to relogin and restart their apps and development setup just to test their latest changes.


The solution for this? Instead of exiting when the compositor closes, simply...don't!

If we could connect to a new compositor we just need to send the right amount of information to bring it in sync and notify the application code of any changes to bring this in sync.

For Qt applications all this information is handled in the backend, in the Wayland Qt Platform Abstraction (QPA).

Qt already has to handle screens and input devices being removed, clipboards being revoked and drag and drops cancelled. Supporting a whole reset isn't introducing any new work, we just have to trigger all of these actions at once, then reconnect to the newly restored compositor and restore our contents.

Applications already have to support all of these events too as well as handle callbacks to redraw buffers. There's no changes needed at an application code level, it's all done as transparently as possible.

Handling OpenGL is a challenge, right now we don't have a way to keep that alive. Fortunately we put in lots of effort previously in supporting GPU resets throughout the Qt stack. The QtWayland backend fakes to the applications that a GPU reset has occured through the Qt abstractions.

For the majority of applications including all QtQuick users this happens automatically and flawlessly, building on the work that we put in previously.

Whilst the overall concepts might sound invasive, the final merge-request to support all of this for all Qt applications was fewer lines than supporting middle-click paste.

Almost no work needs doing on the compositor side. For a compositor there's no difference between a new client, and a client that was running previously reconnecting. The only big change we made within Kwin is having a helper process so the whole process can be seemless and race-free.


Path Forward

This post is about Qt, but the world is bigger than that. Not only does this technique work here, but we have pending patches for GTK, SDL and even XWayland, with key parts of SDL merged but disabled already.

The challenge for the other toolkits is we can't use the same OpenGL trick as Qt. They either lack GPU reset handling either at a toolkit level or within the applications.

Supporting OpenGL requires new infrastructure. We've tried from the start to get some infrastructure in place to allow this.It was clear that proposing library changes for client reconnection support was an uphill battle whilst being unproven in the wild.

After Qt6 is rolled out to a wider audience and shown to work reliably, we'll refocus efforts on pushing upstream changes to the other platforms.

Potential Perks

This isn't just about crashes. If support becomes mainstream there will be additional opportunities:

  • We can easily upgrade to new features without having to log out and back. This is one of the reasons why kwin development is happening at such a rapid pace in recent months. We're not having to test in fake nested sessions or waste time logging in and setting up between changes.

  • We can support multihead, running different compositors per group of outputs and move seemlessly between them.

  • It's feasible to switch between compositors at runtime. With the application handling the reconnect logic, they can easily handle the case where compositor feature sets vary.

  • Checkpoint restore in userspace, being able to suspend your application to disk and then pick up where you left off like nothing happened. It could never work for X applications, but with wayland reconnect support we can make it work.


More information about the long term goal this can be found at the kwin wiki, or each out to me directly if you want to add support.

Discuss this at

More in Tux Machines

digiKam 7.7.0 is released

After three months of active maintenance and another bug triage, the digiKam team is proud to present version 7.7.0 of its open source digital photo manager. See below the list of most important features coming with this release. Read more

Dilution and Misuse of the "Linux" Brand

Samsung, Red Hat to Work on Linux Drivers for Future Tech

The metaverse is expected to uproot system design as we know it, and Samsung is one of many hardware vendors re-imagining data center infrastructure in preparation for a parallel 3D world. Samsung is working on new memory technologies that provide faster bandwidth inside hardware for data to travel between CPUs, storage and other computing resources. The company also announced it was partnering with Red Hat to ensure these technologies have Linux compatibility. Read more

today's howtos

  • How to install go1.19beta on Ubuntu 22.04 – NextGenTips

    In this tutorial, we are going to explore how to install go on Ubuntu 22.04 Golang is an open-source programming language that is easy to learn and use. It is built-in concurrency and has a robust standard library. It is reliable, builds fast, and efficient software that scales fast. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel-type systems enable flexible and modular program constructions. Go compiles quickly to machine code and has the convenience of garbage collection and the power of run-time reflection. In this guide, we are going to learn how to install golang 1.19beta on Ubuntu 22.04. Go 1.19beta1 is not yet released. There is so much work in progress with all the documentation.

  • molecule test: failed to connect to bus in systemd container - openQA bites

    Ansible Molecule is a project to help you test your ansible roles. I’m using molecule for automatically testing the ansible roles of geekoops.

  • How To Install MongoDB on AlmaLinux 9 - idroot

    In this tutorial, we will show you how to install MongoDB on AlmaLinux 9. For those of you who didn’t know, MongoDB is a high-performance, highly scalable document-oriented NoSQL database. Unlike in SQL databases where data is stored in rows and columns inside tables, in MongoDB, data is structured in JSON-like format inside records which are referred to as documents. The open-source attribute of MongoDB as a database software makes it an ideal candidate for almost any database-related project. This article assumes you have at least basic knowledge of Linux, know how to use the shell, and most importantly, you host your site on your own VPS. The installation is quite simple and assumes you are running in the root account, if not you may need to add ‘sudo‘ to the commands to get root privileges. I will show you the step-by-step installation of the MongoDB NoSQL database on AlmaLinux 9. You can follow the same instructions for CentOS and Rocky Linux.

  • An introduction (and how-to) to Plugin Loader for the Steam Deck. - Invidious
  • Self-host a Ghost Blog With Traefik

    Ghost is a very popular open-source content management system. Started as an alternative to WordPress and it went on to become an alternative to Substack by focusing on membership and newsletter. The creators of Ghost offer managed Pro hosting but it may not fit everyone's budget. Alternatively, you can self-host it on your own cloud servers. On Linux handbook, we already have a guide on deploying Ghost with Docker in a reverse proxy setup. Instead of Ngnix reverse proxy, you can also use another software called Traefik with Docker. It is a popular open-source cloud-native application proxy, API Gateway, Edge-router, and more. I use Traefik to secure my websites using an SSL certificate obtained from Let's Encrypt. Once deployed, Traefik can automatically manage your certificates and their renewals. In this tutorial, I'll share the necessary steps for deploying a Ghost blog with Docker and Traefik.