Let’s go for my web review for the week 2026-21.

Make your website or blog fediverse-ready

Tags: tech, fediverse, blog

It’s not complicated, and a good thing to do.

https://stefanbohacek.com/blog/make-your-website-or-blog-fediverse-ready/

Dumb Ways for an Open Source Project to Die

Tags: tech, foss, community

Not sure it warranted the “dumb” mention in the title. Still it’s likely a good idea to have a list of the ways projects can die.

https://nesbitt.io/2026/05/19/dumb-ways-for-an-open-source-project-to-die.html

On Google declaring war on the Web

Tags: tech, google, ai, machine-learning, gpt, attention-economy, knowledge

Ultimately, they just want people to stay on the pages they fully control and not have them visit anything out of their mall.

https://tante.cc/2026/05/20/on-google-declaring-war-on-the-web/

I don’t think AI will make your processes go faster

Tags: tech, ai, machine-learning, copilot, engineering, processes, productivity

Good overview of why we don’t see a speed up in development processes when AI tools are introduced. The bottlenecks don’t magically get destroyed.

https://frederickvanbrabant.com/blog/2026-05-15-i-dont-think-ai-will-make-your-processes-go-faster/

Twelve Ways to Be Wrong About AI-Assisted Coding

Tags: tech, ai, machine-learning, copilot, productivity, research, science

Or why most of the studies we see out there can’t be trusted. They’re full of holes and flaws. We’d really know people who know what they do in humanities to conduct such studies to get a chance at a proper picture.

https://third-bit.com/2026/05/20/twelve-ways-to-be-wrong/

Misconceptions about the UNIX Philosophy

Tags: tech, unix, history, microservices

I agree with this short history tour. It’s the composability which matters.

https://posixcafe.org/blogs/2024/01/05/0/

Shell Tool Testing

Tags: tech, tests, shell

A proof that you don’t need much to write a test suite.

https://zork.net/~st/jottings/shell-tool-testing.html

Spork: A posix_spawn you can use as a fork

Tags: tech, unix, linux, processes, research

fork() doesn’t want to die. But help is coming it seems. Maybe the day it disappears from kernels is “near”.

https://dl.acm.org/doi/epdf/10.1145/3713082.3730396

C++26: More function wrappers

Tags: tech, c++

Time to retire std::function in new code.

https://www.sandordargo.com/blog/2026/05/20/cpp26-copyable-function

Scaling Rust codebases: Lessons learned organizing large projects and managing errors

Tags: tech, rust, architecture, complexity, pattern

Nice suggestions on how to structure larger Rust code bases. The proposed error handling is particularly neat and tidy. This is doable in other languages but tends to be more verbose.

https://kerkour.com/rust-organize-large-projects-code-error-handling

SIMD-accelerated integer-to-string conversion

Tags: tech, simd, performance

Really smart SIMD trick which packs a punch.

https://lemire.me/blog/2026/05/18/simd-accelerated-integer-to-string-conversion/

Dependency cooldowns are unfair; we should use phased rollouts instead

Tags: tech, security, supply-chain

This is a good point. I feel unease at the current trend pushing toward cooldowns. The proposed rollout scheme is much better and fairer.

https://illegalcode.net/rfcs/phased_rollouts.html

Stop Using Pull Requests

Tags: tech, codereview, pairing, mob-programming, trust, productivity

The title is a bit too much of a blanket statement. Still there’s indeed a lovely no between pair programming and merge requests. If possible you should favour the former. Yet it rarely happens in practice, there are reasons for that.

https://a4al6a.substack.com/p/stop-using-pull-requests

organizational knowledge

Tags: tech, organisation, knowledge

Knowledge management is hard. It’s almost never a tool problem despite what people claim.

https://jarche.com/2026/05/organizational-knowledge/

Three Tips for Succeeding as an Accidental Leader

Tags: tech, leadership, management, learning

The responsibilities drop on people before they’re ready for it (I see it first hand regularly at customers). Such tips are thus welcome and helpful during the transition.

https://www.jrothman.com/newsletter/2026/05/three-tips-for-succeeding-as-an-accidental-leader/

Two facilitation methods starting with a single line: Actions|Results & +|Δ

Tags: facilitation, decision-making

Nice little facilitation formats. I’ll try those for sure.

https://improvesomething.today/single-line-facilitation/

Three ways people respond to a problem (other than solving it)

Tags: problem-solving

Very good points. Solving problems is not necessarily what happens when they are identified.

https://improvesomething.today/responses-to-problems/

Bye for now!

We're excited to announce the release of version 1.14.0 of the Qt Extension for Visual Studio Code! This release introduces QML Live Preview with hot-reload capability, bringing real-time feedback directly into your editor.

Fixing Color Visuals, Exporting and Importing

We received multiple reports of problems when importing the Penpot library file. Users would see a Penpot instance crash upon loading our library.

One of our contributors noticed that there was a problematic graphic in the library that, when removed, did not make the Penpot instance crash.

I noticed that the graphic in question is a SVG export from Figma and contained calls that were not supported by Penpot. This color collection had a detail of all our Ocean colors and their gradients. I made the change to a png image instead so that the svg graphics from Figma in Penpot were no longer a problem.

Penpot Additions

The Penpot library also contains a few new section headers so that it’s easier for users to understand what they are looking at. Please note that any sets that say “BASE *” means that they are parent components and are not needed for building components.

Base components are denoted by their name, it starts with a “_*”. This means, this is a parent component. Their purpose is to make it faster for designers to edit many components at once.

For example, a button has two versions “_Buttonbase” and “Button”. In this case, “_Button Base” is the parent componen and if you change the corner radius, all “Button” components will update accordingly.

There are always shared components than base components. Hence the need to accelerate component editing.

When you download our library, you can easily identify these components and make the changes that fit your design.

Updated Folder Icons for Legibility

In a previous iteration, I created folder clones from one size and mathematically shrunk them for another size. While this works, it’s not optimized. A few of the folder icons were like this and looked blurry, not sharp.

After remembering the need for work there, I adapted those folders and they are now published in the git page for Ocean. Places at 32px should now look more polished.

Progress with App Icons

DISCLAIMER: ICONS ARE NOT FINAL! THIS IS A PREVIEW!

App icons are moving along well. I recently picked them back up to continue the work after receiving some initial feedback. I have settled on a style based off subtle and soft gradients.

At the same time, previous versions of these icons seemed dull and lifeless, color-wise. I decided to look for better, more vibrant colors and this is where I landed. I also worked on better rounded shapes. Note that we are following 3 different ideas around these icons, icons with a round background, icons with a squared background, unbounded icons (Icons not anchored to a background shape). In this way, we have more ways to express the best icon idea we want to share.

I also realized that Qt does not support layer blend modes. I was using some of that in the icons to have an easier time adapting colors in borders and edges. I had to undo those and re-adapt the colors to not use blend modes. Maybe in the future Qt will have support for them.

Ocean + Union

Union is about to make its first appearance to the public as an engine. Plasma 6.7 will bring this to light. I have communicated with the Union team and we expect to work together after this first launch to begin creating Ocean components in code.

I tried working through building a Storybook using the Penpot MCP server but it seemed pretty convoluted and is not a documented process. I will keep trying and maybe just create the Storybook site manually.

Akademy Presentation

Akademy is once again on the horizon. I submitted a progress update talk about Ocean. I am hoping by then, we have actual Ocean UI components to show. We will work toward that.

See you all in September in Graz to celebrate our 30th year!

Relevant Links

YouTube Channel: https://www.youtube.com/anditosan

Invent Repo: https://invent.kde.org/abetts/ocean-design

Documentation: https://invent.kde.org/teams/vdg/issues/-/wikis/Ocean-Design—Overview-and-Details

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

When comparing Qt for MCUs vs LVGL, an independent study by Spyrosoft (updated with new data in May 2026) shows that Qt for MCUs reduces development time by approximately 30% compared to LVGL, requires roughly half the handwritten application code, and achieves better or equivalent FPS performance at a fraction of the CPU usage. The efficiency improvement comes mainly from Qt's integrated toolchain, which facilitates better collaboration among designers, developers, and QA engineers. Additionally, Qt for MCUs offers comprehensive safety certification, professional services, and support, positioning it as a superior LVGL alternative for complex projects where functional safety and compliance are essential. A second benchmark released by Silicon Signals confirms the performance advantage in both CPU and RAM consumption.

Commit: https://invent.kde.org/qt/qt/qt5/-/commit/aa749695075684f0c8585ede19e361f9accb4287

Commercial release announcement: https://www.qt.io/blog/commercial-lts-qt-5.15.19-released 

OpenSource release announcement: https://lists.qt-project.org/pipermail/announce/2026-May/000626.html

This was the last Qt5 release.

The KDE Qt5 Patchset Collection remains open in case something very very very very very 
very very very very very very very very very very very very very very very 
very critical is needed.

We just had a release of a new library, and future framework: kirigami-app-componets, which is a new repository where a certain kind of Kirigami extensions will go.

This repository will contain modules that are intended to be building blocks for applications to integrate within the KDE Frameworks ecosystem.

Why start a new repository when kirigami-addons already exists?

We now had a standalone release of kirigami-app-components with a single module inside for testing purposes, but the target here is to move it to frameworks releases, with all the stability promises and quality constraints of Frameworks.

Kirigami-addons is a bit more experimental of nature and have modules which, while they are a good first approach at solving a particular problem, would definitely need some work and refactoring for us to be comfortable having them in Frameworks, while other kirigami-addons modules will be a more straightforward import into kirigami-app-components.

An example of a module that was very useful but needed some work in its architecture is the StatefulApplication module (import org.kde.kirigamiaddons.statefulapp). It provides a Kirigami ApplicationWindow subclass and a way to map QActions to Kirigami actions.

The central idea is having a series of actions that can have their keyboard shortcuts configured by the user (while also providing a component for such configuration UI).

A problematic aspect of StatefulApp is that it’s based too much on C++: in order to add actions, it is necessary for the app to create a subclass and add them as QActions, then the QML part has to connect the QActions and Kirigami.Action using the proper API.

This is OK for the parts of the app where the logic is completely on the C++ side, but when it is necessary to add a very simple action (closing a page, opening a search dialog, and so on), this brings far too much boilerplate.

org.kde.kirigami.actioncollection

ActionCollection is the module that we introduce with kirigami-app-components. It’s all about collections of actions that are defined declaratively via QML (with the option of creating collections on the C++ side as well) and that have shortcuts configurable by the user via the standard interface.

In order to define a new collection, we would write the following QML:

import org.kde.kirigami.actioncollection as AC
AC.ActionCollectionManager {
    id: manager
    pageRow: pageStack

    AC.ActionCollection {
        name: "org.kde.myapp.mainactions"
        text: i18n("Main Actions")
        AC.ActionData {
            name: "hello"
            text: i18n("Hello")
            icon.name: "document-send"
            defaultShortcut: "Ctrl+H"
        }
        AC.StandardActionData {
            standardAction: AC.StandardActionData.Copy
        }
        ...
    }
    AC.ActionCollection {
        name: "org.kde.myapp.photoactions
        text: i18n("Photo Actions")
        AC.ActionData {
            ...
        }
        ...
    }
}

The ActionCollectionManager will be a single instance for the whole application, and it is what takes care of instantiating the common actions (such as About Application, About KDE, Configure Shortcuts, and so on) and doing the plumbing with the configuration dialogs and so on.

ActionCollection is a set of actions semantically grouped together in the same category (if an application would have, for instance, actions that operate on photos and actions that operate on videos, those could be two different collections).

ActionData is the semantic representation of an action (internally it is a QAction, so it has all its properties) and will be defined only once for the whole application. Instances of Kirigami.Action will be attached to it (even more than one), and those will define the actual buttons and menu entries in the application.

A Kirigami.Action is attached to an ActionData via an attached property:

Kirigami.Action {
    // Here shows how important is that each ActionCollection has
    //  an app-global unique name and each action has a collecion-global
    // unique name as well
    AC.ActionCollection.name: "org.kde.myapp.mainactions"
    AC.ActionCollection.action: "hello"
    onTriggered: {
        // Logic here
    }
}

The Kirigami.Action instance will not have text, shortcut, or icon defined, because everything comes from the attached ActionData. Only the onTriggered logic will be defined there (as well as the logic for when the action is enabled or visible).

When an ActionCollectionManager is created, a collection named org.kde.globalactions will be automatically created as well, which also contains an action called "KeyBindings“. When triggered, this dialog will open:

This is the configuration UI where it is possible to configure all the application shortcuts.

Another action called “FindAction" is also available: when triggered, this other dialog will open instead:

This is the classical Ctrl+Alt+I dialog also present in QWidget applications, where it is possible to search and trigger all the application’s actions.

In this article, I am going to talk about having a PGO (Profile-Guided Optimization) build of Clang.

Every C# UI framework comes with a familiar pattern: Windows-first, Linux absent, roadmap uncertain. WPF stalled, MAUI skipped Linux, WinUI 3 stays Windows-native. At the same time, demand for embedded Linux grows and C# teams feel the lack of good UI alternatives for C# on Linux. Qt Bridges, a bridging technology in public beta for C#, provides access to a UI framework that allows preserving your existing C# codebase while utilizing Qt Quick’s feature-rich UI libraries and APIs, hardware acceleration, and cross-platform capability.

Qt Bridges is a project we have been developing since 2025 to bring Qt’s UI framework capabilities to other programming languages, without going through the full set of bindings. The focus is on the interaction with backend data objects, seamlessly integrated as QML components in a Qt Quick interface.