fidzu : KDE

Measuring activity is not about producing more metrics. It is about supporting better decisions and enabling continuous improvement. We restricted our analysis to main/master to observe validated flow and kept visualizations simple to promote adoption across the community.

17 Feb 2026 7:00am GMT

In my last post, I made a solemn vow to not touch Kapsule for a week. Focus on the day job. Be a responsible adult.

Success level: medium.

I did get significantly more day-job work done than the previous week, so partial credit there. But my wife's mother and sister are visiting from Japan, and they're really into horror movies. I am not. So while they were watching people get chased through dark corridors by things with too many teeth, I was in the other room hacking on container pipelines with zero guilt. Sometimes the stars just align.

Here's what came out of that guilt-free hack time.

Konsole integration: it's actually done

The two Konsole merge requests from the last post-!1178 (containers in the New Tab menu) and !1179 (container association with profiles)-are merged. They're in Konsole now. Shipped.

Building on that foundation, I've got two more MRs up:

!1182 adds the KapsuleDetector-the piece that actually wires Kapsule into Konsole's container framework. It uses libkapsule-qt to list containers over D-Bus and OSC 777 escape sequences for in-session detection, following the same pattern as the existing Toolbox and Distrobox detectors. It also handles default containers: even if you haven't created any containers yet, the distro-configured default shows up in the menu so you can get into a dev environment in one click.

!1183 is a small quality-of-life addition: when containers are present, a Host section appears at the top of the container menu showing your machine's hostname. Click it, and you get a plain host terminal. This matters because once you set a container as your default, you need a way to get back to the host without going through settings. Obvious in hindsight.

The OSC 777 side of this lives in Kapsule itself-kapsule enter now emits container;push / container;pop escape sequences so Konsole knows when you've entered or left a container. This is how the tab title and container indicator stay in sync.

Four merge requests across two repos (Konsole and Kapsule) to get from "Konsole doesn't know Kapsule exists" to "your containers are in the New Tab menu and your terminal knows when you're inside one." Not bad for horror movie time.

Configurable host mounts: the trust dial is real

In the last post, I talked about making filesystem mounts configurable-turning the trust model into a dial rather than a switch. That's shipped now.

--no-mount-home does what it says-your home directory stays on the host, the container gets its own. --custom-mounts lets you selectively share specific directories. And --no-host-rootfs goes further, removing the full host filesystem mount entirely and providing only the targeted socket mounts needed for Wayland, audio, and display to work.

The use case I had in mind was sandboxing AI coding agents and other tools you don't fully trust with your home directory. But it's also useful for just keeping things clean-some containers don't need to see your host files at all.

Snap works now

Here's a screenshot of Firefox running in a Kapsule container on KDE Linux, installed via Snap:

I expected this one to be a multi-day ordeal. It wasn't.

Snap apps-like Firefox on Ubuntu-run in their own mount namespace, and snap-update-ns can't follow symlinks that point into /.kapsule/host/. So our Wayland, PipeWire, PulseAudio, and X11 socket symlinks were invisible to anything running under Snap, resulting in helpful errors like "Failed to connect to Wayland display."

The fix was straightforward: replace all those symlinks with bind mounts via nsenter. Bind mounts make the sockets appear as real files in the container's filesystem, so Snap's mount namespace setup handles them correctly. That was basically it.

While I was in there, I batched all the mount operations into a single nsenter call instead of running separate incus exec invocations per socket. That brought the mount setup from "noticeably slow" to "instant"-roughly 10-20x faster on a cold cache. And the mount state is now cached per container, so subsequent kapsule enter calls skip the work entirely.

NVIDIA GPU support (experimental)

This one's interesting both technically and in terms of where it's going.

Kapsule containers are privileged by design-that's what lets us do nesting, host networking, and all the other things that make them feel like real development environments. The problem is that upstream Incus and LXC both reject their NVIDIA runtime integration on privileged containers. The upstream LXC hook expects user-namespace UID/GID remapping, and the default codepath wants to manage cgroups for device isolation. Neither applies to our containers.

So I wrote a custom LXC mount hook that runs nvidia-container-cli directly with --no-cgroups (privileged containers have unrestricted device access anyway) and --no-devbind (Incus's GPU device type already passes the device nodes through). This leaves nvidia-container-cli with exactly one job: bind-mount the host's NVIDIA userspace libraries into the container rootfs so CUDA, OpenGL, and Vulkan work without the container image shipping its own driver stack.

There's a catch, though. On Arch Linux, the injected NVIDIA libraries conflict with mesa packages. The container's package manager thinks mesa owns those files, and now there are mystery bind-mounts shadowing them. It works, but it's ugly and will cause problems during package updates. I hit this on Arch first, but I'd be surprised if other distros don't have the same issue-any distro where mesa owns those library paths is going to complain.

So NVIDIA support is disabled by default for now. The plan: build Kapsule-specific container images that ship stub packages for the conflicting files, and have images opt-in to NVIDIA driver injection via metadata. Two independent flags control the behavior: --no-gpu disables device passthrough entirely (still on by default), and --nvidia-drivers enables the driver injection.

Architecture: pipelines all the way down

The biggest behind-the-scenes change in v0.2.1 is the complete restructuring of container creation. The old container_service.py was a 1,265-line monolith that did everything sequentially in one massive function. It's gone now.

In its place is a decorator-based pipeline system. Container creation is a series of composable steps, each a standalone async function that handles one concern:

Pre-creation: validate → parse image → build config → store options → build devices
Incus API call: create instance
Post-creation: host network fixups → file capabilities → session mode
User setup: mount home → create account → configure sudo → custom mounts → host dirs → enable linger → mark mapped

Each step is registered with an explicit order number and gaps of 100 between steps, so inserting new functionality doesn't require renumbering everything. The decorator handles sorting by priority with stable tie-breaking, so import order doesn't matter.

This pattern worked well enough that I plan to extend it to other large operations-delete, start, stop-as they accumulate their own pre/post logic.

On the same theme of "define it once, use it everywhere": container creation options are now defined in a single Python schema that serves as the source of truth for the daemon's validation, the D-Bus interface (which now uses a{sv} variant dicts, so adding an option never changes the method signature), and the C++ CLI's flag generation. Add a new option in Python, recompile the CLI, and you've got a --flag with help text and type validation. Zero manual C++ work.

The long-term plan is to use this same schema to dynamically generate the graphical UI in a future KCM. Define the option once, get the CLI flag, the D-Bus parameter, the daemon validation, and the Settings page widget-all from the same schema.

First external contributor

Marie Ramlow (@meowrie) submitted a fix for PATH handling on NixOS-the first external contribution to Kapsule. I don't have a NixOS setup to test it on, so this one's on trust. That's open source for you: someone shows up, fixes a problem you can't even reproduce, and you merge it with gratitude and a prayer.

Testing

The integration test suite grew substantially. New tests cover host mount modes, custom mount options, OSC 777 escape sequence emission, and socket passthrough. The test runner now does two full passes-once with the default full-rootfs mount and once with --no-host-rootfs-to verify both configurations work.

Bugs caught during testing that would have been embarrassing in production: a race condition in the Incus client where sequential device additions could clobber each other (the client wasn't waiting for PUT operations to complete), and Alpine containers failing because they don't ship /etc/sudoers.d by default.

CI/CD: of all the things to break

I finally built out the CI/CD pipelines. They use the same kde-linux-builder image that builds KDE Linux itself-mainly because it's one of the few CI images with sudo access enabled, which we need for Incus operations.

The good news: the pipeline successfully builds the entire project, packages it into a sysext, deploys it to a VM, and runs the integration tests. That whole chain works. I was pretty pleased with myself for about ten minutes.

The bad news: when the first test tries to actually create a container, the entire CI job dies. Not "the test fails." Not "the runner reports an error." The whole thing just... stops. No exit code, no error message, no logs after that point. Nothing.

I'm fairly sure it's causing a kernel panic in the CI runner's VM. Which is, you know, not great.

Debugging this has been miserable. I can't get any logs after the panic because there are no logs-the kernel is gone. I tried adding debug prints before each step in the container creation pipeline to isolate exactly where it dies. The prints don't come through either, probably because of output buffering, or maybe the runner agent doesn't get a chance to stream the output to GitLab before the entire VM goes down.

The weird part: it's not a nested virtualization issue. Regular Incus works fine on the same runner-you can create containers interactively, no problem. And it doesn't reproduce on KDE Linux at all. Something about the specific combination of the CI environment and Kapsule's container creation path is triggering it, and I have no way to see what.

I've shelved this for now. The pipeline is there, the build and deploy stages work, and the tests would work if the runner didn't kernel panic when Kapsule tries to create a container. If anyone reading this has ideas, I'm all ears.

What's next: custom container images

The biggest item on my plate is custom container images. Right now, Kapsule uses stock distribution images from the Incus image server. They work, but they're not optimized for our use case-things like the NVIDIA stub packages I mentioned above need to live somewhere, and "just install them at container creation time" adds latency and fragility.

Incus uses distrobuilder for image creation, so the plan is straightforward: image definitions live in a directory in the Kapsule repo, a CI pipeline invokes distrobuilder to build them, and the images get published to a server.

The "published to a server" part is where it gets political. I talked to Ben Cooksley about hosting Kapsule images on KDE infrastructure, and he's-understandably-not yet convinced that Kapsule needs its own image server. It's a fair pushback. This is all still experimental, and spinning up image hosting infrastructure for a project that might change direction is a reasonable thing to be cautious about.

So for now, I'll host the images on my own server. They probably won't be the default, since the server is in the US and download speeds won't be great for everyone. But they'll be available for testing and for anyone who wants the NVIDIA integration or other Kapsule-specific tweaks. I'll bug Ben again when the image story is more fleshed out and there's a clearer case for why KDE infrastructure should host them.

Beyond that: get the Konsole MRs (!1182 and !1183) reviewed and merged, and figure out why CI kills the kernel. The usual.

17 Feb 2026 4:15am GMT

New Features

Those who like tailoring the look and feel of their environment can now turn their current setup into a new global theme! This custom global theme can be used for the day and night theme switching feature.

A more subtle way of modifying the look of your apps is by changing the color intensity of every frame:

Choose emoji (Meta+.) skin tones more easily with a new skin tone selector:

A major focus of Plasma 6.6 has been speeding up common workflows. So if the system has a camera, you can quickly connect to a new Wi-Fi network simply by scanning its QR code:

Hover the pointer over any app's icon playing sound in the task manager, and scroll to adjust its volume:

And save yourself a click by enabling Open on hover in your Windows List widget. You can also filter out windows not on the current desktop or activity:

Hold down the Alt key and double-click on a file or folder on the desktop to bring up its properties:

In Memory of Björn Balazs

In September, we lost our good friend Björn Balazs to cancer.

An active and passionate contributor, Björn was still holding meetings for his Privact project from bed even while seriously ill during Akademy 2025.

Björn's drive to help people achieve the privacy and control over technology that he believed they deserved is the stuff FLOSS legends are made of.

Björn, you are sorely missed and this release is dedicated to you.

17 Feb 2026 12:00am GMT

Here is an overview on the new features added to the Quick3D.Particles module for Qt 6.10 and 6.11. The goal was to support effects that look like they are interacting with the scene and to do this without expensive simulations/calculations. Specifically we'll be using rain effect as an example when going trough the new features.

16 Feb 2026 6:48am GMT

Tellico 4.2 is available, with some improvements and bug fixes. This release now requires Qt6 (> 6.5) as well as KDE Frameworks 6. One notable behavior change is that when images are removed from the collection, the image files themselves are also removed from the collection data folder.

Users have provided substantial feedback in a number of areas to the mailing list recently, which is tremendously appreciated. I'm always glad to hear how Tellico is useful and how it can be better. Back up those data files!

Improvements:

• Added new data sources for DOI Foundation, Metron, and ISFDB.
• Updated data sources for Dark Horse Comics, Springer Nature, MusicBrainz, Kino.de, and BoardGameGeek (Bug 511824).
• Added option to change the file preview size and increased default to 256×256 px.
• Updated file saving to remove images no longer in collection from the data folder (Bug 509244).
• Added capability to import OnMyShelf JSON files.

Bug Fixes:

• Fixed bug with XML generation for user-locale (Bug 512581).

15 Feb 2026 9:57pm GMT

A new version (3.4) of Bouncy Ball has just been released on the KDE Store. You can update through Discover, or by heading over to the store: https://store.kde.org/p/2344070 Previous posts:Bouncy Ball will always bounce backThis week in Bouncy Ball - new features land I'm happy to share that this version now includes support for custom...... Continue Reading →

15 Feb 2026 8:24am GMT

Game AI engines, particularly those using tree search algorithms like alpha-beta pruning and MTD(f), are computationally intensive. As modern devices from desktops to mobile phones feature multi-core processors, parallelizing these algorithms has become essential for creating stronger AI opponents without sacrificing response time.

This blog explores various parallelization libraries and threading models suitable for game AI that I'm exploring to integrate with KDE's Mancala Engine, with a focus on cross platform compatibility and mobile architecture considerations.

The Challenge: Parallelizing Tree Search

Tree search algorithms like alpha-beta pruning are inherently sequential due to their dependency on pruning decisions. However, several parallelization strategies exist:

• Root parallelization: Search different root moves in parallel
• Tree parallelization: Split the search tree across threads
• Leaf parallelization: Parallelize evaluation functions

Each approach has trade-offs between speedup efficiency, implementation complexity, and scalability.

Library Options for C++ Parallelization

1. C++ Standard Library Threading (std::thread, std::async)

Overview: Native C++11+ threading support with no external dependencies.

Pros:

• Zero external dependencies
• Cross-platform (works on Linux, Windows, macOS, Android, iOS)
• Fine-grained control over thread management
• Excellent for root parallelization
• Lightweight and well-understood

Cons:

• Manual thread pool management required
• No built-in work-stealing or load balancing
• More boilerplate code for complex patterns

Mobile Considerations:

• Works well on ARM architectures
• Need to be mindful of battery consumption
• Should respect system thread limits (typically 4-8 cores on mobile)

Best For: Simple parallelization patterns, root parallelization, projects wanting minimal dependencies

2. OpenMP

Overview: Compiler-based parallelization using pragmas. Supported by GCC, Clang, MSVC, and ICC.

Pros:

• Extremely simple to add parallelism (#pragma omp parallel for)
• Automatic load balancing and work distribution
• Minimal code changes required
• Good for data-parallel operations
• Built-in thread pool management

Cons:

• Less control over thread behavior
• Can be tricky with complex data structures
• Overhead for fine-grained parallelism
• Limited support on some mobile toolchains

Mobile Considerations:

• Android NDK supports OpenMP (with libomp)
• iOS/Xcode has limited/deprecated OpenMP support (requires third-party builds)
• Performance varies significantly across ARM implementations
• May not be ideal for battery-constrained scenarios

Best For: Quick parallelization wins, data-parallel loops, prototyping

3. Intel Threading Building Blocks (oneTBB)

Overview: High-level C++ template library for parallel programming, now open-source as oneTBB.

Pros:

• Sophisticated work-stealing scheduler
• Excellent scalability across core counts
• High-level abstractions (parallel_for, parallel_reduce, task groups)
• Automatic load balancing
• Well-tested and production-ready
• Good documentation and community

Cons:

• External dependency (though header-only options exist)
• Learning curve for advanced features
• Slightly heavier than std::thread

Mobile Considerations:

• Good ARM support
• Used in production mobile apps
• Efficient on heterogeneous architectures
• Respects system constraints well

Best For: Complex parallelization patterns, production code, scalable performance

4. C++17 Parallel Algorithms (std::execution)

Overview: Standard library parallel algorithm execution policies.

Pros:

• Part of C++17 standard
• Clean, declarative syntax
• Works with existing STL algorithms
• Compiler/library handles parallelization

Cons:

• Limited compiler support (especially on mobile)
• Less control over threading behavior
• Not all STL implementations support it fully
• May use different backends (TBB, OpenMP, etc.)

Mobile Considerations:

• Limited support on Android NDK
• iOS support depends on libc++ version
• May not be available on older mobile platforms

Best For: Modern codebases, simple parallel transformations

5. Qt Concurrent

Overview: Qt framework's high-level threading API.

Pros:

• Excellent if already using Qt
• Very simple API
• Cross-platform including mobile
• Integrates with Qt's event loop
• Good for KDE projects

Cons:

• Requires Qt dependency
• Heavier than standalone threading libraries
• Overkill if not using Qt elsewhere

Mobile Considerations:

• Excellent mobile support (Qt is mobile-first)
• Used in many production mobile apps
• Good power management integration

Best For: KDE/Qt projects, applications already using Qt

6. Taskflow

Overview: Modern C++ parallel task programming library with a focus on task graphs.

Pros:

• Header-only option
• Modern C++17 design
• Task graph visualization
• Excellent for complex dependencies
• Very active development

Cons:

• Relatively newer (less battle-tested)
• Smaller community than TBB
• May be overkill for simple parallelization

Mobile Considerations:

• Good ARM support
• Lightweight enough for mobile
• Efficient task scheduling

Best For: Complex task dependencies, modern C++ projects

7. std::jthread and C++20 Features

Overview: Improved threading primitives in C++20.

Pros:

• Automatic thread joining
• Cooperative cancellation with stop tokens
• Cleaner than std::thread
• No external dependencies

Cons:

• Requires C++20 compiler support
• Still requires manual thread pool implementation
• Limited mobile compiler support currently

Mobile Considerations:

• Growing support in Android NDK
• iOS support depends on Xcode version
• Future-proof choice

Best For: New projects targeting C++20+

Conclusion

The combination of modern C++ threading primitives and careful mobile optimization will create a significantly stronger AI opponent while maintaining good battery life and thermal characteristics.

References & Further Reading

• oneTBB Documentation: https://oneapi-src.github.io/oneTBB/
• C++ Concurrency in Action - Anthony Williams
• ARM big.LITTLE Technology: https://www.arm.com/technologies/big-little
• "Parallel Alpha-Beta Search" - Feldmann (1993)
• "Lazy SMP" - Hyatt & Newborn (1997)
• "Parallel Search of Strongly Ordered Game Trees" - Marsland & Campbell (1982)

15 Feb 2026 12:00am GMT

So, while working with caching and scrapping, I understood the difference between immutable and mutable objects/datatypes very clearly. I had a scenario, where I am webscraping an API, the code looks like this.

from aiocache import cached

@cached(ttl=7200)
async def get_forecast(station_id: str) -> list[dict]:
 data: dict = await scrape_weather(station_id)
 # doing some operation
 return forecasts

and then using this utility tool in the endpoint.

async def get_forecast_by_city(
 param: Annotated[StationIDQuery, Query()],
) -> list[UpcomingForecast]:
 forecasts_dict: list[dict] = await get_forecast(param.station_id)
 forecasts_dict.reversed()

 forecasts: deque[UpcomingForecast] = deque([])
 for forecast in forecasts_dict:
 date_delta: int = (
 date.fromisoformat(forecast["forecast_date"]) - date.today()
 ).days
 if date_delta <= 0:
 break
 forecasts.appendleft(UpcomingForecast.model_validate(forecast))

 return list(forecasts)

But, here is the gotcha, something I was doing inherently wrong. Lists in python are mutable objects. So, reversing the list modifies the list in place, without creating a new reference of the list. My initial approach was to do this

14 Feb 2026 6:08pm GMT

Welcome to a new issue of This Week in Plasma!

This week we put the finishing touches on Plasma 6.6! It's due to be released in just a few days and it's a great release with tons of impactful features, UI improvements, and bug fixes. I hope everyone loves it!

Meanwhile, check out what folks were up to this week:

Notable UI Improvements

Plasma 6.7.0

Moved System Settings' "Remote Desktop" page to the "Security & Privacy" group in System Settings. (Nate Graham, krdp MR #139)

After

Before

Improved the way loop devices are handled in the Disks & Devices widget. (Bogdan Onofriichuk, plasma-workspace MR #6260)

Reduced visual jagginess in the split image effect of wallpaper previews that show both a light and dark version. (Fushan Wen, plasma-workspace MR #6283)

The Kicker Application Menu widget now supports using a non-square icon for its panel button, just like Kickoff does. (Christoph Wolk, plasma-desktop MR #3522)

Added a dedicated global action for un-tiling a quick-tiled window. It doesn't have a keyboard shortcut by default, but you can assign one yourself. (Kevin Azzam, KDE Bugzilla #500636)

Videos in SDDM login screen themes can now be previewed in System Settings. (Blue Terracotta, sddm-kcm MR #99)

Improved the appearance of various dialogs created by KWin. Read more here! (Kai Uwe Broulik, kwin MR #8702)

You can now configure how long it takes the window switcher to appear after you start holding down Alt+Tab. (Guilherme Soares, KDE Bugzilla #486389)

Frameworks 6.24

In Kirigami-based apps, hovering the pointer over buttons that can be triggered with keyboard shortcuts now shows the shortcuts. (Joshua Goins, kirigami MR #2040)

After

Before

Gear 26.04.0

Setting up a Samba share for one of your folders so people can connect to it over the network now turns on the Samba service (on systemd-based distros) if needed. This completes the project to make Samba sharing relatively painless! (Thomas Duckworth, KDE Bugzilla #466787)

Notable Bug Fixes

Plasma 6.5.6

Monitor names shown in the Brightness & Color widget now update as expected if you connect or disconnect them while the system is asleep. (Xaver Hugl, KDE Bugzilla #495223)

Fixed multiple issues that caused custom-tiled windows on screens that you disconnect to move to the wrong places on any of the remaining screens. (Xaver Hugl, kwin MR #7999)

Plasma 6.6.0

Hardened KWin a bit against crashing when the graphics driver resets unexpectedly. (Vlad Zahorodnii, kwin MR #8769)

Fixed a case where Plasma could crash when used with the i3 tiling window manager. (Tobias Fella, KDE Bugzilla #511428)

Fixed a potential "division by 0" issue in system monitoring widgets and apps that messed up the display percentage of Swap sensors on systems with no swap space. (Kartikeya Tyagi, libksysguard MR #462)

Worked around a Wayland bug (yes, an actual Wayland bug - as in, a bug in one of its protocol definitions!) related to input method key repeat. Why work around the bug instead of fixing it? Because it's already fixed in a newer version of the protocol, but KWin needs to handle apps that use the old version, too. (Xuetian Weng, kwin MR #8700)

Unified the appearance of HDR content in full-screen windows and windowed windows. (Xaver Hugl, KDE Bugzilla #513895)

Fixed a layout glitch in the System Tray caused by widgets that include line breaks (i.e. \n characters) in their names. (Christoph Wolk, KDE Bugzilla #515699)

The Web Browser widget no longer incorrectly claims that every page you visit tried to open a pop-up window. (Christoph Wolk, kdeplasma-addons MR #1003)

Fixed a layout glitch in the Quick Launch widget's popup. (Christoph Wolk, kdeplasma-addons MR #1004)

You can now launch an app in your launcher widget's favorites list right after overriding its .desktop file; no restart of plasmashell is required anymore. (Alexey Rochev, KDE Bugzilla #512332)

Fixed an issue that made inactive windows dragged from their titlebars get raised even when explicitly configured not to raise in this case. (Vlad Zahorodnii, KDE Bugzilla #508151)

Plasma 6.6.1

When a battery-powered device is at a critically low power level, putting it to sleep and charging it to a normal level no longer makes it incorrectly run the "oh no, I'm critically low" action immediately after it wakes up. (Michael Spears, powerdevil MR #607)

The overall app ratings shown in Discover now match a simple average of the individual ratings. (Akseli Lahtinen, KDE Bugzilla #513139)

Searching for Activities using KRunner and KRunner-powered searches now works again. (Simone Checchia, KDE Bugzilla #513761

Frameworks 6.24

Worked around a Qt bug that caused extremely strange cache-related issues throughout Plasma and Kirigami-based apps that would randomly break certain components. (Tobias Fella, kirigami MR #2039)

Notable in Performance & Technical

Plasma 6.6.0

Added support for setting custom modes for virtual screens. (Xaver Hugl, kwin MR #8766)

Added GPU temperature monitoring support for additional GPUs. (Barry Strong, ksystemstats MR #123)

Plasma 6.7.0

Scrolling in scrollable views spawned by KWin (not Plasma, just KWin itself) no longer goes 8 times slower than it ought to. Thankfully there are very few such views, so almost nobody noticed the issue. However fixing it facilitates adding a "scroll to switch virtual desktops" feature to the Overview effect for Plasma 6.7! (Kai Uwe Broulik, kwin MR #8800)

Frameworks

Moving a file to the trash is now up to 50 times faster and more efficient. (Kai Uwe Broulik, kio MR #2147)

How You Can Help

KDE has become important in the world, and your time and contributions have helped us get there. As we grow, we need your support to keep KDE sustainable.

Would you like to help put together this weekly report? Introduce yourself in the Matrix room and join the team!

Beyond that, you can help KDE by directly getting involved in any other projects. Donating time is actually more impactful than donating money. Each contributor makes a huge difference in KDE - you are not a number or a cog in a machine! You don't have to be a programmer, either; many other opportunities exist.

You can also help out by making a donation! This helps cover operational costs, salaries, travel expenses for contributors, and in general just keep KDE bringing Free Software to the world.

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

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

14 Feb 2026 12:03am GMT

I recently had the opportunity to sit down with my mentor, Schimon Jehudah, for an intensive technical session.

14 Feb 2026 12:00am GMT

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

The Media Can't Stop Propping Up Elon Musk's Phony Supergenius Engineer Mythology

Tags: tech, politics, journalism, business

There's really a problem with journalism at this point. How come when covering the tech moguls they keep leaving out important context and taking their fables at face value?

https://karlbode.com/the-press-is-still-propping-up-elon-musks-supergenius-engineer-mythology/

But they did read it

Tags: tech, literature, scifi, business, politics

Indeed, don't assume they misunderstood the sci-fi and fantasy they read and you know. Clearly they just got different opinions about it because their incentives and world views are different from your.

https://tante.cc/2026/02/12/but-they-did-read-it/

Microsoft's AI-Powered Copyright Bots Fucked Up And Got An Innocent Game Delisted From Steam

Tags: tech, game, dmca, copyright, law

Automated DMCA take downs have been a problem for decades now… They still bring real damage, here is an example.

https://www.techdirt.com/2026/02/12/microsofts-ai-powered-copyright-bots-fucked-up-and-got-an-innocent-game-delisted-from-steam/

Launching Interop 2026

Tags: tech, web, browser, interoperability

This is a very important initiative. For a healthy web platform we need good interoperability between the engines. I'm glad they're doing it again.

https://hacks.mozilla.org/2026/02/launching-interop-2026/

How I built Fluxer, a Discord-like chat app

Tags: tech, foss, messaging

Clearly early days… Could that become a good place to land for people fleeing off Discord?

https://blog.fluxer.app/how-i-built-fluxer-a-discord-like-chat-app/

New And Upcoming IRCv3 Features

Tags: tech, messaging, irc

It's nice to still see some activity around IRC.

https://libera.chat/news/new-and-upcoming-features-3

Uses an ESP8266 module and an Arduino sketch to display the local time on a inexpensive analog quartz clock

Tags: tech, hardware, embedded, ntp, time

This is definitely a cool hack. Now I feel like doing something like this to every clock I encounter.

https://github.com/jim11662418/ESP8266_WiFi_Analog_Clock

LLVM: Concerns about low-quality PRs beeing merged into main

Tags: tech, ai, machine-learning, copilot, foss, codereview

Clearly Free Software projects will have to find a way to deal with LLM generated contributions. A very large percentage of them is leading to subtle quality issues. This also very taxing on the reviewers, and you don't want to burn them out.

https://discourse.llvm.org/t/concerns-about-low-quality-prs-beeing-merged-into-main/89748

An AI Agent Published a Hit Piece on Me

Tags: tech, ai, machine-learning, copilot, foss, commons

I guess when you unleash agents unsupervised their ethos tend to converge on the self-entitled asshole contributors? This raise real questions, this piece explains the situation quite well.

https://theshamblog.com/an-ai-agent-published-a-hit-piece-on-me/

Spying Chrome Extensions: 287 Extensions spying on 37M users

Tags: tech, browser, security, attention-economy, spy

Oh this is bad! The amount of data exfiltrated by those malicious extensions. Data brokers will do anything they can to have something to resell. This is also a security and corporate espionage hazard.

https://qcontinuum.substack.com/p/spying-chrome-extensions-287-extensions-495

ReMemory - Split a recovery key among friends

Tags: tech, tools, security

Accidents can happen in life. This might come in handy if you loose memory for some reason. It requires planning ahead though.

https://eljojo.github.io/rememory/

Penrose

Tags: tech, tools, data-visualization

Looks like a nice option for visualisations.

https://penrose.cs.cmu.edu/

Boilerplate Tax - Ranking popular programming languages by density

Tags: tech, programming, language, statistics, type-systems

Interesting experiment even though some of the results baffle me (I'd have expected C# higher in the ranking for example). Still this gives some food for thought.

https://boyter.org/posts/boilerplate-tax-ranking-popular-languages-by-density/

The cost of a function call

Tags: tech, c++, optimisation

If you needed a reminder that inlining functions isn't necessarily an optimisation, here is a fun little experiment.

https://lemire.me/blog/2026/02/08/the-cost-of-a-function-call/

It's all a blur

Tags: tech, graphics, blur, mathematics

Wondering if blurs can really be reverted? There's some noise introduced but otherwise you can pretty much reconstruct the original.

https://lcamtuf.substack.com/p/its-all-a-blur

Simplifying Vulkan One Subsystem at a Time

Tags: tech, graphics, vulkan, api, complexity

There are lessons and inspirations to find in how the Vulkan API is managed. The extension system can be unwieldy, but with the right approach it can help consolidate as well.

https://www.khronos.org/blog/simplifying-vulkan-one-subsystem-at-a-time

What Functional Programmers Get Wrong About Systems

Tags: tech, data, architecture, system, type-systems, functional, complexity

Interesting essay looking at how systems evolve their schemas over time. We're generally ill-equipped to deal with it and this presents options and ideas to that effect. Of course, the more precise you want to be the more complexity you'll have to deal with.

https://www.iankduncan.com/engineering/2026-02-09-what-functional-programmers-get-wrong-about-systems/

Modular Monolith and Microservices: Modularity is what truly matters

Tags: tech, architecture, modules, microservices, services, complexity

No, modularity doesn't imply micro services… You don't need a process and network barrier between your modules. This long post does a good job going through the various architecture options we have.

https://binaryigor.com/modular-monolith-and-microservices-modularity-is-what-truly-matters.html

Using an engineering notebook

Tags: tech, engineering, note-taking, memory, cognition

I used to do that, fell into the "taking notes on the computer". And clearly it's not the same, I'm thinking going back to paper notebooks soon.

https://ntietz.com/blog/using-an-engineering-notebook/

On screwing up

Tags: tech, engineering, organisation, team, communication, failure

Everyone makes mistakes, what matters is how you handle them.

https://www.seangoedecke.com/screwing-up/

Why is the sky blue?

Tags: physics, colors

Excellent piece which explains the physics behind the atmospheric colours. Very fascinating stuff.

https://explainers.blog/posts/why-is-the-sky-blue/

Bye for now!

13 Feb 2026 11:44am GMT

This release brings improvements to generators, better build system integration and several bugfixes.

As always, big thanks to everyone who reported issues and contributed to QCoro. Your help is much appreciated!

Directly Awaiting Qt Types in AsyncGenerator Coroutines

The biggest improvement in this release is that QCoro::AsyncGenerator coroutines now support directly co_awaiting Qt types without the qCoro() wrapper, just like QCoro::Task coroutines already do (#292).

Previously, if you wanted to await a QNetworkReply inside an AsyncGenerator, you had to wrap it with qCoro():

QCoro::AsyncGenerator<QByteArray> fetchPages(QNetworkAccessManager &nam, QStringList urls) {
 for (const auto &url : urls) {
 auto *reply = co_await qCoro(nam.get(QNetworkRequest{QUrl{url}}));
 co_yield reply->readAll();
 }
}

Starting with QCoro 0.13.0, you can co_await directly, just like in QCoro::Task:

QCoro::AsyncGenerator<QByteArray> fetchPages(QNetworkAccessManager &nam, QStringList urls) {
 for (const auto &url : urls) {
 auto *reply = co_await nam.get(QNetworkRequest{QUrl{url}});
 co_yield reply->readAll();
 }
}

Other Features and Changes

• Generator's .end() method is now const (and constexpr), so it can be called on const generator objects (#294).
• GeneratorIterator can now be constructed in an invalid state, allowing lazy initialization of iterators (#318).
• qcoro.h now only includes QtNetwork and QtDBus headers when those features are actually enabled, resulting in cleaner builds when optional modules are disabled (#280).

Bugfixes

• Fixed memory leak in QFuture coro wrapper when a task is destroyed while awaiting on a QFuture (#312, Daniel Vr√°til)
• Fixed include paths when using QCoro with CMake's FetchContent (#282, Daniel Vr√°til; #310, Nicolas Fella)
• Fixed QCoroNetworkReply test on Qt 6.10 (#305, Daniel Vr√°til)

Full changelog

See changelog on Github

Support

If you enjoy using QCoro, consider supporting its development on GitHub Sponsors or buy me a coffee on Ko-fi (after all, more coffee means more code, right?).

13 Feb 2026 12:00am GMT

Friday, 13 February 2026

KDE today announces the release of KDE Frameworks 6.23.0.

This release is part of a series of planned monthly releases making improvements available to developers in a quick and predictable manner.

New in this version

13 Feb 2026 12:00am GMT

The world of free and open-source software (FOSS) is full of big-hearted, altruistic people who love serving society by giving away their labor for free. It's incredible. These folks are supporting so many people by providing the world with high quality free software, including in KDE, my FOSS community of choice.

But while they do it, who's supporting them? We don't talk about this as much.

A recent Reddit post by a volunteer developer burning out reminded me of the topic, and it's not the first one. Denis Pushkarev of core-js wrote something similar in 2023, and we're probably all familiar with this XKCD comic:

The topic is also not limited to the FOSS world; it's broadly applicable to all volunteer activities. Can't feed the homeless in a soup kitchen if you're sick and sneezing into the soup! Can't drive to the library to teach adult reading classes if your car's broken down.

In order to support others, you need support yourself! Who can provide that support? Here are a bunch of cases that work:

• Yourself in the present (with a job - related or unrelated to your FOSS work)
• Yourself in the past (retired)
• Your partner in the present (married to a primary or sole income-earner)
• Your partner in the past (partner left you lots of money after death or divorce)
• Your parents in the present (you're their dependent)
• Your parents in the past (born rich or received a big inheritance later)
• The state (disabled, a student, or on a similar program)

All these cases work. They provide enough money to live, and you still get to work on FOSS!

There are lots of other good options, but here are some of the bad ones that don't work:

• Other people via donations: you never get enough donations, and if you put the effort into fundraising required to make it work, that becomes your job.
• Yourself in the future: if you're living off loans, you're screwing over future you!
• Nobody: if you're eating up your savings, you'll eventually run out of money and be destitute. If you're fortunate enough to live in a place where "The state" is an option, it will be at a diminished standard of living.

We must always answer for ourselves the question of how we're going to be supported while we continue to contribute to the digital commons. If you don't do it for a living, it's a critically important question. Never let anyone guilt-trip you into doing volunteer work you don't have the time or money for! It's a sure road to burnout or worse.

Airplane safety briefings tell people to "put on your mask before helping others." Why? Same reason as what we're talking about here: you can't support others if you're not first supported yourself. If you try, you'll fail, either immediately, or eventually. You must be properly supported yourself before you can be of use to others.

12 Feb 2026 10:58pm GMT

We are happy to announce the release of Qt Creator 19 Beta2.

12 Feb 2026 12:36pm GMT

As explained in one of my previous blog posts where I revamped the unresponsive window dialog, KWin isn't really designed to show regular desktop windows of its own. It instead relies on helper programs to display messages. In case of the "no border" hint, it just launched kdialog, a small utility for displaying various message boxes from shell scripts. This however came with a couple of caveats that have all been addressed now:

First of all, the dialog wasn't attached to the window that provoked it. When the window was closed, minimized, or its border manually restored, it remained until manually dismissed. Secondly, it said "KDialog" and used a generic window icon (that would have been an easy fix of course). Further, the user might not even have kdialog installed which actually was the case on KDE Linux until very recently. Ultimately and most importantly, it told you that you were screwed if you didn't have a keyboard but didn't offer and help if you really went without one. I therefore added an option to restore the border right from the dialog. Should you have a dedicated global shortcut configured for this action, it will also be mentioned in the dialog.

The dialog when manually setting a window full-screen has similarly been overhauled, including an undo option. While at it, I removed the last remaining code calling kdialog, too: the "Alt+tab switcher is broken" message. It is now a proper KNotification. Something you should never see, of course.

Another dialog that I gave some attention was the prompt when copying a file would overwrite its destination. If you have Kompare installed and copy a plain text file (that includes scripts, source code, and so on), the dialog displays a "Compare Files" button. It already guesstimated whether the files are similar but now you can actually see it for yourself.

KIO's PreviewJob that asynchronously generates a file preview now provides the result of its internal stat call, too. This means that once you receive the preview, you also get the file's properties, such as size, modified time, and file type basically for free. The rename dialog then displays this information in case it wasn't provided by the application already. Dolphin now also makes use of this information while browsing a folder which should improve responsiveness when browsing NFS and similarly mounted network shares. At least when previews are enabled, it no longer determines file types synchronously in most scenarios.

Since the rename dialog is able to fetch file information on demand, Ark, KDE's archiver tool, rewrites the source URL it displays in the dialog to a zip:/ URL (or tar:/ or whatever supported archive type). This way the dialog can display a preview transparently through the Archive KIO worker which also gained the ability to determine a file's type from its contents. In case you didn't know, you can configure Dolphin to open archives like regular folders.

Finally, most labels in KIO that show the mtime/ctime/atime no longer include the time zone unless it is different from the system time zone. Showing "Central European Standard Time" in full after every date was a bit silly. Unfortunately, QLocale isn't very flexible and only knows "short" (19:00) or "long" (19:00:00 Central European Standard Time) formats. You can't explicitly tell it to generate a time string with seconds, or with 12/24 hour clock, or a date with weekday but no year, and unfortunately the "long" time format includes the full time zone name.

12 Feb 2026 8:00am GMT