Professional update

I had joined MBRDI in June 2021, after almost 4 years, I decided to part ways with MBRDI this January 2025 and decided to pursue new adventure, more on that when time comes, but for now I am keeping it under wraps. I hope you can respect that! 🙂

However this is not the only professional update I want to talk about, I want to talk about another exciting opportunity,

NGI0 Core grant

I am very happy to announce that I will be working on improving Plasma Mobile (and in general, Linux Mobile) power management through funding support from the NGI0 Core Fund, a fund established by NLnet with financial support from the European Commission’s Next Generation Internet program. You can find very thin details on this page. Though this is not the only project that is being funded through NGI0 Core fund, There are total 56 projects being sponsored as part of October call.

Let’s go for my web review for the week 2025-12.

Please stop externalizing your costs directly into my face

Tags: tech, ai, machine-learning, gpt, copilot, criticism

Those bots are really becoming the scourge of the Internet… Is it really necessary to DDoS every forge out there to build LLMs? And that’s not even counting all the other externalities, the end of the article make it clear: “If blasting CO2 into the air and ruining all of our freshwater and traumatizing cheap laborers and making every sysadmin you know miserable and ripping off code and books and art at scale and ruining our fucking democracy isn’t enough for you to leave this shit alone, what is?”

https://drewdevault.com/2025/03/17/2025-03-17-Stop-externalizing-your-costs-on-me.html

FOSS infrastructure is under attack by AI companies

Tags: tech, ai, machine-learning, gpt, copilot, criticism

More details about the impacts of the LLM companies acting like vandals… This is clearly widespread and generating work for everyone for nothing.

https://thelibre.news/foss-infrastructure-is-under-attack-by-ai-companies/

Careless people – Aral Balkan

Tags: tech, facebook, politics, law, gdpr, surveillance, attention-economy

I guess more reviews of that book will come out. It looks like Meta and some EU politicians are even more rotten to the core than we ever suspected…

https://ar.al/2025/03/21/careless-people/

Everything you say to your Echo will be sent to Amazon starting on March 28 - Ars Technica

Tags: tech, amazon, privacy, surveillance

Now is the time to wake up and get those surveillance devices out of people’s homes…

https://arstechnica.com/gadgets/2025/03/everything-you-say-to-your-echo-will-be-sent-to-amazon-starting-on-march-28/

Man Tests If Tesla Autopilot Will Crash Into Wall Painted to Look Like Road

Tags: tech, tesla, safety

In case it wasn’t clear yet that not relying on Lidar was a stupid move for self-driving cars.

https://futurism.com/tesla-wall-autopilot

Dad demands OpenAI delete ChatGPT’s false claim that he murdered his kids

Tags: tech, ai, machine-learning, gpt, law

Still so reliable… could we confine this to NLP uses please? Should never had been used for anything looking remotely like search.

https://arstechnica.com/tech-policy/2025/03/chatgpt-falsely-claimed-a-dad-murdered-his-own-kids-complaint-says/

It’s all hallucinations

Tags: tech, ai, machine-learning, gpt

Words are important, I’m dismayed at how the marketing speak around generative AI is what people use… that completely muddies the thinking around them.

https://tante.cc/2025/03/16/its-all-hallucinations/

“Vibe Coding” vs Reality

Tags: tech, ai, machine-learning, gpt, copilot, programming

Despite the marketing speak… it’s definitely not there yet. So far all the attempts at using LLM for coding larger pieces end up in this kind of messy results. It helps kickstarting a project indeed but quickly degenerates after that.

https://cendyne.dev/posts/2025-03-19-vibe-coding-vs-reality.html

My Scammer Girlfriend: Baiting A Romance Fraudster | www.bentasker.co.uk

Tags: tech, security, scam

Fascinating exploration of the techniques scammers are using to hook their victims

https://www.bentasker.co.uk/posts/blog/security/seducing-a-romance-scammer.html

Introducing Orpheus Speech - Canopy Labs

Tags: tech, speech, ai, machine-learning

Impressive new models for text to speech.

https://canopylabs.ai/model-releases

HTTP/3 is everywhere but nowhere

Tags: tech, http, quic, community

The picture is a bit to bleak I think, but there’s indeed currently a divide in terms of HTTP/3 adoption. This is fairly aligned with the big players vs long tail creators divide. Hopefully this will get solved at some point.

https://httptoolkit.com/blog/http3-quic-open-source-support-nowhere/

Were multiple return values Go’s biggest mistake?

Tags: tech, programming, go

With the little Go I wrote, I admit that the multiple return values feature is… odd. Worse though, it has bad ramifications.

https://herecomesthemoon.net/2025/03/multiple-return-values-in-go/

I don’t think error handling is a solved problem in language design

Tags: tech, programming, language, exceptions

Indeed, it’s something where we lack consensus across languages and sometimes within the same ecosystem.

https://utcc.utoronto.ca/~cks/space/blog/programming/ErrorHandlingNotSolvedProblem

The Defer Technical Specification: It Is Time

Tags: tech, c, standard, memory, safety

This could be a big improvement for C. We’ll see how far this goes.

https://thephd.dev/c2y-the-defer-technical-specification-its-time-go-go-go

Speeding up C++ code with template lambdas – Daniel Lemire’s blog

Tags: tech, c++, programming, optimization

Definitely ugly in the end. Still it does the the trick.

https://lemire.me/blog/2025/03/15/speeding-up-c-code-with-template-lambdas/

Our interfaces have lost their senses

Tags: tech, gui, ux

Beautifully crafted post. So much of it is true as well, having several modalities available is better for interactions. We’ve been loosing this overtime, it’s time to reintroduce it… there’s so much to do in the HMI space.

https://wattenberger.com/thoughts/our-interfaces-have-lost-their-senses

Xenographics – Weird but (sometimes) useful charts

Tags: tech, data-visualization

Need new ideas for data visualization? This seems like a good resource.

https://xeno.graphics/

Passive Voice Considered Harmful · Refactoring English

Tags: tech, documentation, writing

Good explanation of why the passive voice should be avoided. Also it gives a few cases where you want to favor the passive voice.

https://refactoringenglish.com/chapters/passive-voice-considered-harmful/

Why I’m No Longer Talking to Architects About Microservices

Tags: tech, architecture, microservices, criticism

Interesting piece… why talking about microservices generally leads nowhere. This is a too loosely defined term and we’re often confusing means and ends.

https://blog.container-solutions.com/why-im-no-longer-talking-to-architects-about-microservices

Who are your teammates?

Tags: tech, leadership, management, team

Interesting way to frame the question for leadership roles.

https://ntietz.com/blog/who-are-your-teammates/

Why “Normal” Engineers Are the Key to Great Teams - IEEE Spectrum

Tags: tech, organization, team, culture, productivity

We should definitely put the 10x engineer myth to rest. Let’s focus on setting up the right organisation and culture instead.

https://spectrum.ieee.org/10x-engineer

Battery breakthrough as 99.99% of lithium extracted from old cells

Tags: tech, battery, ecology

If it can be done at scale this would be very good news.

https://www.independent.co.uk/tech/battery-recycle-lithium-ion-environment-b2713723.html

Why Your Brain Blinds You For 2 Hours Every Days

Tags: science, cognition, neuroscience

Nice video which gives a glimpse on how our brain constantly tries to build a coherent picture of the reality around us. This is quite a feat since our senses are ill equipped to produce such a picture. Of course we don’t even notice all those processes when we go about our days.

https://www.youtube.com/watch?v=wo_e0EvEZn8

Bye for now!

Kaidan 0.12.0 looks and behaves better than ever before! Chats can now quickly be pinned and moved. In addition, the list of group chat participants to mention them is placed above the cursor if enough space is available. With this release, OMEMO can be used right after migrating an account and migrated contacts are correctly verified.

Have a look at the changelog for more details.

Changelog

Features:

• Use square selection to crop avatars (fazevedo)
• Use background with rounded corners for chat list items (melvo)
• Remove colored availability indicator from chat list item (melvo)
• Display group chat participant picker above text cursor in large windows (melvo)
• Do not allow to enter/send messages without visible characters (melvo)
• Remove leading/trailing whitespace from exchanged messages (melvo)
• Ignore received messages without displayable content if they cannot be otherwise processed (melvo)
• Allow to show/hide buttons to pin/move chat list items (melvo)

Bugfixes:

• Fix style for Flatpak (melvo)
• Fix displaying video thumbnails and opening files for Flatpak (melvo)
• Fix message reaction details not opening a second time (melvo)
• Fix opening contact addition view on receiving XMPP URIs (melvo)
• Fix format of text following emojis (melvo)
• Fix eliding last message text for chat list item (melvo)
• Fix unit tests (mlaurent, fazevedo, melvo)
• Fix storing downloaded files with unique names (melvo)
• Fix overlay to change/open avatars shown before hovered in account/contact details (melvo)
• Fix verification of moved contacts (fazevedo)
• Fix setting up end-to-end encryption (OMEMO 2) after account migration (melvo)

Notes:

• Kaidan requires KWindowSystem and KDSingleApplication now (mlaurent)
• Kaidan requires KDE Frameworks 6.11 now
• Kaidan requires KQuickImageEditor 0.5 now
• Kaidan requires QXmpp 1.10.3 now

Download

• Source code (.tar.xz) (sig signed with 04EFAD0F7A4D9724)
• Linux (Flatpak on Flathub)

Or install Kaidan for your distribution:

My home contains multiple FreeBSD machines – laptops, desktops, single-board-computers – which can benefit from sharing storage. In particular, I really only need one copy of the FreeBSD source tree (plus some work-trees for different branches) and one copy of the ports tree and distfiles. This blog post is my notes on setting that up.

These notes are for my home infrastructure, where I trust the machines that are plugged into the wired network, simply because I can see the switch from my desk and know where all the wires go. I’m not taking notes for security.

All of these notes build on the FreeBSD Handbook chapters on ZFS and Network Servers.

Server Side NFS Setup

Configure the server for NFS with sysrc rpcbind_enable=YES nfs_server_enable=YES mountd_enable=YES and then start NFS services service nfsd start . This enables NFS services also after a reboot. To turn them off again, use sysrc and swap NO for YES.

Client Side NFS Setup

Enable NFS client with sysrc nfs_client_enable=YES and then start NFS services with service nfsclient start . This enables NFS services also after a reboot. To turn them off again, use sysrc and swap NO for YES.

Per-Filesystem Setup

For each filesystem that needs to be shared, go through these steps. It is easiest to do this with one filesystem per mountpoint (mountpoint on the client side, so possibly /usr/ports, /usr/src and /usr/obj which want three filesystems on the server side’ however, this does not work well with git work-trees).

Filling the filesystems that need sharing is outside of the scope of these notes, but

• The ports tree lives in git and can be anonymously cloned. There is a nice guide (PDF) as well.
• The source tree contains the whole operating system, lives in git and can be anonymously cloned.

Server Side

• Create a ZFS filesystem, say zdata/export/ports. It doesn’t really matter where it is mounted.
• Turn on NFS sharing on this ZFS filesystem (this step might be redundant), zfs set sharenfs=on zdata/export/ports .
• Set options for NFS sharing with no attention to security at all, zfs set sharenfs="-network=192.168.56.0/24 -maproot=root" zdata/export/ports .
• Don’t bother with /etc/exports, since we’re using ZFS. Turn on sharing for the filesystem with zfs share zdata/export/ports .

Client Side

Just mount the remote filesystem (read-only here) with mount -o ro 192.168.56.1:zdata/export/ports /usr/ports .

When troubleshooting (permission denied), check the IP address of the client is in the network specified by the NFS share on the server.

Mounting a subdirectory of an export isn’t possible. In that case, mount the exported filesystem somewhere temporary (e.g. /mnt/export) and then use mount -t nullfs -o ro /mnt/export/subdir /some/path .

System Updates Over NFS

For me the main reason to set this up is that I can git clone src, build the FreeBSD operating system once, and then share the build results across multiple machines by mounting /usr/src and /usr/obj from the machine that did the build. It saves considerable compile time, even if the resulting installation over the network is a lot slower than from a local md(8) to an NVMe drive.

One minor gotcha is that make installkernel complains a lot about read-only filesystems. But that’s only a complaint, and everything installs normally.

Subsequent mergemaster is normal and make installworld complains in the same way.

Optimization in Akonadi, configurable holiday region in Merkuro and progress on Krita Qt6 port

Welcome to a new issue of "This Week in KDE Apps"! Every week we cover as much as possible of what's happening in the world of KDE apps.

Last week we released the beta for KDE Gear 25.04 and focused on polishing the coming release.

Creative Apps

Krita Digital Painting, Creative Freedom

The developer teams continued to improve the Qt6 port of Krita. Dmitry fixed the HDR support on Windows (Dmitry Kazakov, link). Freya fixed an OpenGL crash on macOS (Freya Lupen, link).

Personal Information Management Apps

Akonadi Background service for KDE PIM apps

Carl Schwan reduced the memory usage of various Akonadi resources by around 75% each. The optimized resources, which take advantage of this new API, are the following: Birthday, VCard files and directories, Ical, Mbox, Open-Xchange, cardDAV and calDAV. There is already significant progress done in that direction also for the IMAP and POP3 resources. The technical background behind this is that these resources running as independent processes are now using non-visual QCoreApplication instead of the more powerful QApplication, which is more appropriate resource wise for background services. This is part of the Don't depend on QtWidgets in lower parts of the stack milestones. (Carl Schwan, 25.08.0. Link 1, link 2, link 3, link 4, link 5, link 6, link 7, link 8, link 9, link 10, link 11, ...)

Daniel made a change to ensure that operations in Akonadi that operate on a large number of items are processed as multiple smaller batches which the SQL engine can then handle (Daniel Vratil, 25.08.0. Link).

Merkuro Calendar Manage your tasks and events with speed and ease

Tobias ported Merkuro Calendar to the new QML declaration which slightly improves the performance but more importantly enables us to take advantage of the QML tooling (Tobias Fella, 25.04.0. Link).

Carl made the region used to display holidays configurable. You can also select more than one region now (Carl Schwan, 25.04.0. Link)

Kleopatra Certificate manager and cryptography app

Tobias moved the notepad feature to a separate window, which means it's now possible to have multiple notepads open at the same time (Tobias Fella, 25.08.0. Link).

Tobias also ensured the GPG password prompt (pinentry) in Kleopatra is properly parented to the correct parent window on Wayland (Tobias Fella, 25.04.0. Link). Other apps using GPG were also fixed.

KOrganizer KOrganizer is a calendar and scheduling application

Allen made a series of small improvements and bugfixes to Korganizer. He improved the configure view menu action description (link), added more information to the delete folder dialog (link), and added a search option to consider the current view filters. (Link).

Social Apps

NeoChat Chat on Matrix

James improved the thread support. Now it is possible to open a context menu for the individual thread messages (James Graham, 25.08.0. Link).

Kaidan Modern chat app for every device

Melvin fixed downloading files (Melvin Keskin, link 1 and link 2).

Graphics and Multimedia Apps

Amarok Rediscover your music

Tuomas fixed some database and encoding issues. (Tuomas Nurmi, link)

digiKam Photo Management Program

The digiKam team released version 8.6.0. of the powerful photo classifying and editing tool. Among many other things, digiKam now comes with a smarter face management tool, an improved auto-tagging system that identifies elements in your images, fully automatic red-eye removal, and a new image quality feature that classifies images according to their aesthetic quality. The digiKam developers also fixed 140 bugs.

You can read more about this release on digiKam's website.

System Apps

Kate Advanced text editor

Javier Guerra added text search to the build output. (Javier Guerra, 25.08.0. Link)

Leo Ruggeri made the reset history menu button only visible when relevant. (Leo Ruggeri, 25.08.0. Link)

Educational Apps

GCompris Educational game for children

Bruno Anselme added a 6th level to the Guess 24 game. (Bruno Anselme, Link)

Utilities

KTrip Public transport navigator

Volker improved the history of past searches in KTrip by reusing some code from Itinerary. The biggest improvements are that the list is now de-duplicated, and the model supports more features not yet exposed to the UI. (Volker Kruase, 25.08.0. Link)

Other

Luigi removed Qt5 support in Minuet and Step.

…And Everything Else

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

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

Get Involved

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

You can help KDE by becoming an active community member and getting involved. Each contributor makes a huge difference in KDE — you are not a number or a cog in a machine! You don’t have to be a programmer either. There are many things you can do: you can help hunt and confirm bugs, even maybe solve them; contribute designs for wallpapers, web pages, icons and app interfaces; translate messages and menu items into your own language; promote KDE in your local community; and a ton more things.

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

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

Welcome to the February 2025 development and community update.

Development Report

Text Tool Rework Update

Wolthera has written a new post about recent Text Tool updates which will be coming in Krita 5.3.

A Glyph Palette has been added to Text Tool Options, which allows selecting glyph alternates as well as showing a font character map (MR!2080). The Text Properties Docker now shows CSS Font Variants glyph properties (MR!2325) and OpenType features property (MR!2343).

Qt6 Port Progress

Krita now has Qt6 CI builds for Linux, Windows (MR!2328), and macOS (MR!2334). Android has yet to be built, as the platform has more complications and fewer developers working on it.

Most of Krita's custom Qt patches have now been ported by Dmitry, and ANGLE and HDR support are revived on Windows (deps commit).

Community Report

February 2025 Monthly Art Challenge Results

For the "Fabulous Flora" theme, 27 forum members submitted 34 original artworks. And the winner is… Hollyhocks by @Elixiah

The March Art Challenge is Open Now

For the March Art Challenge, @Elixiah has chosen "Virtual Plein Air Painting" using MapCrunch or Google Maps street view, as the theme. The optional challenge is doing paired entries; one urban, one rural. See the full brief for more details, and see the sights without stepping outside your door.

Featured Artwork

Best of Krita-Artists - January/February 2025

Nine images were submitted to the Best of Krita-Artists Nominations thread, which was open from January 14th to February 11th. When the poll closed on February 14th, these five wonderful works made their way onto the Krita-Artists featured artwork banner:

Luca - To the Sea by @deerblue

Long Head Guy by @Celes

Bird by @SkyJack

Recent illustration I did for a card game by @JoaoGGarin

Study of a Fox by @Hagetisse

Ways to Help Krita

Krita is Free and Open Source Software developed by an international team of sponsored developers and volunteer contributors.

Visit Krita's funding page to see how user donations keep development going, and explore a one-time or monthly contribution. Or check out more ways to Get Involved, from testing, coding, translating, and documentation writing, to just sharing your artwork made with Krita.

Other Notable Changes

Other notable changes in Krita's development builds from Feb. 12 - Mar. 17, 2025, that were not covered by the Development Report.

Stable branch (5.2.10-prealpha):

• Resources: Correctly load UTF-8 .pat pattern names. (bug report) (Change, by Nicholas LaPointe)

Unstable branch (5.3.0-prealpha):

Bug fixes:

• Animation: Fix crash on closing secondary animated document during playback. (bug report) (Change, by Emmet O'Neill)
• General: Fix menubar disappearing after toggling system global menubar feature. (Change, by Carl Schwan)

Features:

• Freehand Brush Tool: Add Brush Smoothing options to adjust the smoothing based on brushstroke speed. (Change, by killy |0veufOrever)
• Preferences: Add a global pen tilt direction offset in Tablet settings. This can be used to make tilt brushes work similarly for left- and right-handed users, or behave better without tilt support. (Change, by Maciej Jesionowski)
• Scripting: Add Canvas.setPreferredCenter() and Canvas.pan() for panning the canvas. (Change, by Dov Grobgeld)
• Python Plugins: Add Mutator plugin. This consists of an action to randomly modify brush preset settings such as color and size, and a docker to customize these mutations. (Change, by Emmet O'Neill)
• G'MIC: Update to 3.5.3. (Change, by Ivan Yossi)

Nightly Builds

Pre-release versions of Krita are built every day for testing new changes.

Get the latest bugfixes in Stable "Krita Plus" (5.2.10-prealpha): Linux - Windows - macOS (unsigned) - Android arm64-v8a - Android arm32-v7a - Android x86_64

Or test out the latest Experimental features in "Krita Next" (5.3.0-prealpha). Feedback and bug reports are appreciated!: Linux - Windows - macOS (unsigned) - Android arm64-v8a - Android arm32-v7a - Android x86_64

I just got myself a brand new car: an ID.Buzz with seven seats so that I can fit the whole family at once. I’m very happy with the car this far, but since it has connectivity, I want to see if I can integrate it into HomeAssistant.

To do this, I wanted to use the CarConnectivity project by Till Steinbach. It is a Python package that comes in a few parts. The main project, a Volkswagen connector, an MQTT bridge and a HomeAssistant MQTT discovery helper.

Having played with the software for a bit (and reported a bug that Till fixed asap – I’m impressed!) I decided to setup the whole thing on my little RaspberryPi that runs a few little services I use around the house.

Preparing this, I setup a new user and installed the software in a Python virtual environment:

sudo adduser carconnectivity
sudo su carconnectivity
cd
mkdir carconnectivity
cd carconnectivity/
python -m venv venv
source venv/bin/activate
pip install carconnectivity-connector-volkswagen==0.5a1 carconnectivity-plugin-mqtt carconnectivity-plugin-mqtt_homeassistant
vim carconnectivity.json

Using the vim command, I created the CarConnectivity configuration file. Update usernames, passwords and IPs to your needs. I will experiment with the interval parameter, as I don’t want to discharge the 12v battery by querying the car too much.

{
        "carConnectivity": {
                "log_level": "error",
                "connectors": [
                        {
                                "type": "volkswagen",
                                "config": {
                                        "interval": 1800,
                                        "username": "hello@example.com",
                                        "password": "secret"
                                }
                        }
                ],
                "plugins": [
                        {
                                "type": "mqtt",
                                "config": {
                                        "broker": "my-mqtt.local",
                                        "username": "user",
                                        "password": "secret"
                                }
                        },
                        {
                                "type": "mqtt_homeassistant",
                                "config": {}
                        }
                ]
        }
}

Having configured the service (and having run it manually to fix my mistakes) I created the carconnectivity.service systemd service shown below (in /etc/systemd/system):

[Unit]
Description=Car Connectivity to MQTT
After=network-online.target

[Service]
Type=simple
User=carconnectivity
Group=carconnectivity
WorkingDirectory=/home/carconnectivity/carconnectivity/
Environment="LC_ALL=sv_SE"
ExecStart=/home/carconnectivity/carconnectivity/venv/bin/carconnectivity-mqtt /home/carconnectivity/carconnectivity/carconnectivity.json

[Install]
WantedBy=multi-user.target

And then I started and enabled the service.

sudo systemctl start carconnectivity
sudo systemctl enable carconnectivity

Finally, I had a look at the status and made sure that everything looks ok.

sudo systemctl status carconnectivity

And, viola, the car shows up as a device in Home Assistant. Magic!

Friendly country, Friendly people, Reunions, New Experience, a bit of hustle and that’s LIFE!

So, this was my 4th conference and 3rd international trip! A lot of new experiences and new friends, but let’s talk about FOSSASIA Summit 2025 first.

FOSSASIA Summit 2025

This is the first conference where I was having a lot of different tasks, lightning talk, representing Ubuntu booth and KDE booth. So, a lot of different perspectives will be here. Sometimes I’ll be writing from KDE’s pov, sometimes Ubuntu’s and sometimes my own.

Introduction

One of the biggest obstacles for users switching to Linux is choosing the right distribution. With the end of support for Windows 10 on October 14, 2025, many users are looking for alternatives to continue using their devices.
This project aims to help users migrate from Windows 10 to GNU/Linux by analyzing their system specifications, asking relevant questions, and recommending a ranked list of distributions with KDE Plasma based on their preferences.

This post will break down how we approached this problem in SoK25, focusing on two core challenges:

1. Designing a recommendation logic that ranks distributions based on user preferences.
2. Detecting hardware specifications and integrating them into the ranking logic.

Original Idea

Step 1: Initial Design for the Questionnaire

When we started the project, we considered including a range of distributions and desktop environments. Over the course of SoK, however, we decided to limit the recommendations to distributions offering KDE Plasma. I will first present the original idea.

To keep things simple, we decided to limit the number of questions we would ask Windows users. Instead of overwhelming users with technical details, we settled on a set of key questions. These cover parameters like:

• Ease of installation
• Support for older hardware
• Quality of documentation
• Community support
• Frequency of updates (Rolling or Point)
• Preferred UI style (Windows-like or Mac-like)

Each response contributes to a “parameter” of user preference vector, which helps in matching the needs of user with the best-fitting distributions.

Step 2: Selecting Initial Distributions

We initially started with a limited set of well-known beginner-friendly distributions:

• Fedora KDE
• Kubuntu
• Lubuntu
• Linux Mint XFCE
• Linux Mint Cinnamon

Revised Idea

Over the course of SoK25 we decided to narrow the scope of the chooser app and rename it Win10-2-KDE-Chooser. After receiving some feedback from the community, we decided it made sense to focus on KDE-only solutions for a Season of KDE project, while others can adapt the idea at a later date.
With this new scope, we think the app can be promoted by the KDE community in the context of the ‘End Of 10’ campaign. The new scope includes:

• The app will target devices running Windows 10.
• The app will recommend distros with KDE Plasma.
• The recommended distros for first-time users include Fedora KDE, Kubuntu, and Debian KDE (specifically the live installer, which uses Calamares).

In the rest of this SoK25 post, I will describe the implementation of the original idea in more detail, and this can later be adapted before release. This has been the focus of my work for the first half of SoK25.

Step 3: The Recommendation Logic

The core logic behind ranking distributions is vector-based similarity measurement. Each distribution is represented as a vector, with dimensions corresponding to the parameters defined in our questionnaire.

The approach works as follows:

1. User Preference Vector: The answers provided by the user form a vector with numerical values assigned to each preference.
2. Predefined Distribution Vectors: Each distribution has a corresponding vector based on predefined scores.
3. Similarity Calculation: The similarity between the user vector and each distribution vector is computed using a mathematical function.

TL;DR : We are using dot product and a penalty criteria (multiplying by 0.5) for ranking the distros

Choosing the Right Similarity Function

Initially, we considered cosine similarity, but we found that dot product gave better results.

• Cosine Similarity measures how closely two vectors align in terms of direction, but it ignores magnitude.
• Dot Product considers both direction and magnitude, making it a better fit since we care about absolute scores.

Example:

{width=456 height=164}

According to dot product: A>B>C Dot Product recommends Distro A as the best choice, which makes sense.

But according to cosine similarity: C>B>A

Distro C appears as the best match because it follows the same ratio (even though its scores are much lower). Since we care about absolute quality in preferred criteria rather than just proportional similarity, dot product is the better approach.

Here’s how we implemented the ranking in Python:

    def recommend(self):
        if not self.user_vector or not self.distro_vectors:
            return "No sufficient data to generate recommendations."

        scores = {}
        user_vector_np = np.array(self.user_vector)

        for distro, vector in self.distro_vectors.items():
            distro_vector_np = np.array(vector)
            score = np.dot(user_vector_np, distro_vector_np)

            scores[distro] = score

        sorted_indices = np.argsort(list(scores.values()))[::-1]
        ranked_recommendations = [(list(scores.keys())[i], list(scores.values())[i]) for i in sorted_indices]
        return ranked_recommendations

Step 4: Handling Categorical Questions

While numerical parameters like “Ease of Installation” are easy to quantify, categorical preferences (e.g., “Do you prefer a Windows-like UI?”) are more like binary or ternary preferences and are difficult to score.

To handle this, we introduced a penalty mechanism:

• If a distribution does not match the user’s categorical preference, a penalty factor (e.g., 0.5) is applied to its score.
• This ensures that distributions aligning with strong user preferences are ranked higher.

Here’s the modified code which ranks distros with penalties:

  def recommend(self, penalty_factor=0.5):
        if not self.user_vector or not self.distro_vectors:
            return []  # Return an empty list instead of a string

        scores = {}
        user_vector_np = np.array(self.user_vector)
        binary_params = {"updates", "UI_Look"}

        for distro, data in self.distro_vectors.items():
            distro_vector_np = np.array(data["scores"])
            final_score = np.dot(user_vector_np, distro_vector_np)

            for param in binary_params:
                if param in self.user_binary_preferences and param in data["raw_scores"]:
                    if self.user_binary_preferences[param] != data["raw_scores"][param]:
                        final_score *= penalty_factor

            scores[distro] = final_score

        return sorted(scores.items(), key=lambda x: x[1], reverse=True)

Conclusion

This ranking system forms the backbone of the chooser app, helping users find the most suitable distribution based on their needs. While our initial model looks good, we are still refining the parameters (questionnaire), expanding the dataset, and revising the app to fit the new scope

Next steps include:

• Enhancing hardware detection to factor in compatibility scores. Given the limited time left in SoK25, I will only focus on Nvidia driver detection.
• Improving penalty logic for better handling of categorical preferences.

This project has been an exciting challenge and I’m looking forward to refining it further. Stay tuned for more updates!

Acknowledgement

Thank you to the Season of KDE 2025 admin and mentorship team, in particular flyingcakes an Aakarsh MJ and Joseph, the KDE e.V., and the incredible KDE community for supporting this project.

Please feel free to contact me here: @drowsywings:matrix.org

The FreeBSD Foundation exists to support the FreeBSD community and the FreeBSD project. Some of its projects are aimed at improving the experience of FreeBSD on specific hardware. There is an ongoing, and expanding, laptop experience project. To expand that project further, the foundation has provided Framework laptops to a bunch of developers working on the FreeBSD laptop and desktop experience. I’m one of those developers, and here are some initial notes on the process. The notes assume experience with FreeBSD.

Some disclaimers up front: the FreeBSD foundation is a lot like KDE e.V., which supports the KDE community and project. I wear a board hat for KDE e.V., but on the FreeBSD side I’m “just a ports developer”. Of course, the ports I try to work on are the KDE ones, so there’s a happy synergy here.

An anonymous donor sponsored these machines. While I am part of the FreeBSD donations@ team, I was not involved in the overall decision-making around this donation.

The machine I got is a Framework 13 with an AMD 7000 series CPU. That’s not the very-very latest one, which has a Ryzen 300 series in it, but it is at least 3 CPU generations newer than any other machine I have. For me in particular of interest is that it has the same GPU series, AMD Polaris 12, as my FreeBSD 14-STABLE desktop machine, so I can share experimentation with graphics drivers between them.

I picked the 2.8K display with rounded corners, because that’s potentially an interesting edge-case for the KDE Plasma 6 desktop; if there’s any funny-stuff needed for those corners, then we need to know about it.

Let’s Get Physical

Although it’s completely irrelevant for the long-term use of the laptop, I’ve got to hand it to the Framework folks: the packaging is really nice. Recyclable cardboard, well-laid-out, understandable boxes. I don’t often get a “huh, that’s clever” reaction when unpacking consumer electronics.

There’s a screwdriver included, cunningly hidden beneath the do-it-yourself-installation memory modules. That’s clever.

When it comes to putting the machine together, the installation guide with videos is both comprehensive and easy-to-follow. “Put DDR5 SO-DIMM modules in corresponding sockets” and “insert NVMe into socket” is straightforward, I do that all the time when (re)building desktop machines.

The bezel, on the other hand …

The bezel around the screen is just a thin bit of plastic. I got a red one, because FreeBSD (there is no KDE Blue option). It is essential to place it correctly, with all the screen-cables nicely aligned. I did not, and just clicked the bezel in place, pushed down on it and then closed the laptop, “per the instructions”. Except the bezel stuck out about 2mm, and on re-opening the laptop, it just about tore the bezel in half.

After 20 tricky minutes I could get the laptop open again and removed the bezel, repaired it, and tried again. I don’t really have a suggestion to improve the bezel installation except “try very carefully to close the laptop a bit, re-open, close a bit further, re-open, …” until it’s clear that the lid closes properly. Take some time to (re)route the cables to the screen so that they are as flat as possible.

Accessories

The little modules for the Framework laptop are pretty nifty. I’m already thinking I should have gotten an additional USB-C one. I selected one unusual module, RJ-45 wired ethernet, because my experience with FreeBSD and WiFi is not a good one. However, that’s what this whole laptop project is for. The FreeBSD Foundation has already funded work on laptop WiFi, so it’s probably over-cautiousness on my part.

With all the physical bits in place, the big question…

Will it run Doom?

Of course. Don’t be silly.

Will it run FreeBSD?

Yes, but that takes a little bit of effort. Download a FreeBSD 14.2 image and write it to a USB stick on some other machine. Leave it on your desk for now.

Boot the Framework laptop for the first time and let it do memory training and whatnot. Do not connect any devices and let it complain that there’s nothing to boot.

Reboot, still with nothing attached, and spam F2 during boot. You have to do this to get to the EFI shell / system configuration before it tries to boot anything. Disable secure boot. Linuxes have a signed GRUB shim nowadays, or other bits and pieces so they work with secure boot. FreeBSD 14.2 does not, yet.

Now insert the USB stick, reboot, and go through the installer process. It’s a text installer (still, as I still haven’t built FreeBSD support in Calamares) and gets you to a working system in about 5 minutes. Having the wired ethernet helps avoid any trouble here.

Reboot after installation and you can get a text console. All that technology for a late-80s user experience.

Will it run X11?

Yes, but the 14.2-RELEASE Errata point out that DRM kernel modules do not work if you grab the pre-built ones. This was true on March 12th 2025, so:

• Run pkg to install the package manager (initially it is a stub)
• Run pkg install git to install git (this pulls in a surprising amount of other stuff)
• Get the system sources (with git)
• Rebuild the world and install it
• Get the ports tree (with git)
• Build graphics/drm-61-kmod from ports (just make ; make install, and the port itself is a real quick build)
• Build graphics/gpu-firmware-amd-kmod from ports, remember FLAVOR=polaris12 for the GPU in this laptop (otherwise the default flavor is built)

After that, enable the amdgpu module in rc.conf, or load it by hand. Any old X11 stuff will do, but I suggest installing x11/kde and x11/sddm.

Will it run KDE Plasma 6 Wayland?

Hahaha. No. But yes.

KDE Plasma 6 on Wayland in general works. But on this specific machine, with this specific grapics card, Plasma starts, all the processes of a KDE Plasma desktop are running, and the screen displays a single white text-cursor in the upper-left corner.

It’s not this-specific-machine, either, since I have a desktop with Intel CPU and an AMD RX550 video card that behaves the same.

Last time I dug into KWin internals in an attempt to figure this out I ended up with “some part of the OpenGL stack is lying” and then gave up. Now with a fresh laptop that just cries out for a modern desktop, I’m going to try again.