Skip to content

Wednesday, 21 February 2024

KdeEcoTest is an emulation tool aimed at emulating user activity when measuring the energy consumption of an application. You can read more about work on KdeEcoTest at this SoK23 and this SoK24 blog post. Check out the KDE Eco handbook for more details about measuring software's energy consumption.

KDE Eco logo.
Figure : KDE Eco logo.

One of the main goals of the KDE Eco project for Season of KDE 2024 is to extend KdeEcoTest so it can run on both Windows and GNU/Linux (X11 & Wayland). This enables energy consumption measurements of a single application across different platforms, such as Okular in X11 vs. Wayland vs. Windows.

This also makes it possible to compare Okular with a proprietary application like Adobe Acrobat. Comparisons with proprietary software are possible because KdeEcoTest can create usage scenario scripts without requiring access to the source code of the software being tested!

I have taken the task of extending support for Windows.

Getting Started: Platform Abstraction Layer

The primary function of KdeEcoTest is to emulate user behavior. Why do we need an abstraction layer for this?

  1. Think about simulating keyboard shortcuts. We'll need to change many parts of the code. But if we have an abstraction layer, we can add new features easily. Just add a function to the right module.
  2. Currently, we have 3 modules for 3 different platforms, namely, Wayland, X11, and Windows. If a fourth platform needs to be added, one can simply extend the base handler class and implement the abstract functions.
  3. This abstraction layer ensures that the same script can be used for testing across several different platforms.

During the first two weeks of SoK'24, Athul Raj K and I worked on understanding the code base and creating the abstraction layer. The layer provides two interfaces to access the underlying methods for taking window or input actions, a WindowHandler and an InputHandler (which have platform specific implementations).

Running a Standard Usage Scenario script on the Windows Platform for <a href="">GCompris</a> prepared with KdeEcoTest.
Figure : Running a Standard Usage Scenario script on the Windows Platform for GCompris prepared with KdeEcoTest.

Initial Task: pywin32 For Windows Management

pywin32 is a python module that provides access to many of the Windows APIs. This is used to perform window management actions for the Windows platform. Special thanks to Emmanuel for pointing out this wonderful module which has made it very convenient to extend KdeEcoTest support to Windows.

Win32 is an application programming interface (API) developed by Microsoft. It is dedicated to 32-bit Windows operating systems. Using this API, developers benefit from a set of functions for creating Windows applications using programming languages such as C, C++, and Visual Basic. They are able to control and manipulate various aspects of the Windows operating system. ctypes is a Python library for calling functions from shared libraries (DLLs) with a syntax similar to C. Pywin32 uses ctypes to use win32 functions.

During the first week, I explored the module to find the required functions and tested them out on a Windows machine. In the third week of Sok'24, I integrated the functions in the KdeEcoTest codebase. Now, the same test scripts that were used to test on X11 also run on Windows! The WindowActionHandler of win32 module under core/Handlers/ handles the window management functions for Windows platforms.

class WindowActionHandler(BaseWindowActionHandler):
 def GetHandler(cls):
 return cls()

 def GetActiveWindow():
 # returns the handle of the currently active window
 win_id = win32gui.GetForegroundWindow()
 return win_id

 def GetwindowLocation(win_id):
 # returns active window loaction -> {"x": start_x, "y":start_y}
 start_x, start_y, end_x, end_y = win32gui.GetWindowRect(win_id)
 location = namedtuple("location", ["x", "y"])
 return location(start_x, start_y)

 def GetWindowGeometry(win_id):
 # returns active window geometry -> {"width": width, "height": height}
 start_x, start_y, end_x, end_y = win32gui.GetWindowRect(win_id)
 width = end_x - start_x
 height = end_y - start_y
 geometry = namedtuple("geometry", ["width", "height"])
 # return {"width": width, "height": height}
 return geometry(width, height)

 def SelectWindow():
 # returns the window handle of the window selected by user
 x, y = win32gui.GetCursorPos()
 win_id = win32gui.WindowFromPoint((x, y))
 return win_id

 def WindowMove(win_id,win_posx:int, win_posy:int):
 # relocates active window to specified loaction
 current_size = WindowActionHandler.GetWindowGeometry(win_id)
 win32gui.SetWindowPos(win_id, win32con.HWND_TOP, win_posx, win_posy, current_size.width, current_size.height, win32con.SWP_SHOWWINDOW)

 def ResizeWindow(win_id,n_height:int,n_width:int):
 # resizes active window to specified dimensions
 current_position = WindowActionHandler.GetwindowLocation(win_id)
 win32gui.SetWindowPos(win_id, win32con.HWND_TOP, current_position.x, current_position.y, n_width, n_height, win32con.SWP_SHOWWINDOW)

 def WindowFocus(win_id):
 # brings the window to top(focus)

A Minor Setback: Adding Support For Input Actions

pywin32 also provides support for simulating mouse actions such as left clicks as well as keyboard key presses. However, I am not yet able to create a proper listener for input actions of the user. The module does not provide a default listener, although it does provide a function win32api.GetAsyncKeyState() which can be used as a listener inside an infinite loop. Running an infinite while-loop results in unnecessary resource utilization of processor and main memory, which slows down the tool and affects the results of the test cases.

For these reasons, pynput has been chosen instead, which works across all the targeted platforms.

The class InputActionHandler bundles all the pynput handlers required for emulating the user input activities

class InputActionHandler(BaseInputActionHandler):
 def GetHandler(cls):
 return cls()

 def __init__(self) -> None:
 self.mouse = mouse.Controller()
 self.mouse_listener = mouse.Listener
 self.mouse_buttons = mouse.Button

 self.keyboard = keyboard.Controller()
 self.keyboard_listener = keyboard.Listener
 self.keyboard_keys = keyboard.Key

Looking Forward

Currently, I am working on testing the accuracy of mouse pointers using the 9 point calibration testing. This can also be used to check window size inaccuracy caused by window decorations such as the title bar on Windows.

I also plan to replace pynput with pywin32 if I can find or develop a proper listener for user actions.

I would like to thank the project mentors Emmanuel Charrau and Joseph P. De Veaugh-Geiss for their amazing support and guidance. Also, I am thankful to Athul Raj K, my fellow contributor in SoK'24, for his support and collaboration during this Season of KDE.

Tuesday, 20 February 2024

gcompris 4.0

Today we are releasing GCompris version 4.0.

This version adds translations for 3 more languages: Bulgarian, Galician and Swahili.

It contains 190 activities, including 8 new ones:

  • "Grammar classes" is an activity to learn to identify words grammatical classes, one class at a time.
  • "Grammar analysis" is similar to the previous one, but with several classes requested for each sentence.
  • "Calcudoku" is an arithmetic game where the goal is to fill a grid with numbers according to specific rules.
  • With "Guess 24", using the 4 given numbers and the operators, find the number 24!
  • In "Frieze", reproduce and complete the different friezes.
  • "Read a graduated line" is an activity where you need to find a value represented on a graduated line.
  • In "Use a graduated line", place the given value on the graduated line.
  • In "Adjacent numbers", learn which numbers come before or after the given sequence.

It contains bug fixes and graphics improvements on multiple activities.

One major milestone has been reached with this version: after almost 9 years of work, the task of reworking all the graphics to fit the guidelines has been completed!

It is fully translated in the following languages:

  • Arabic
  • Bulgarian
  • Breton
  • Catalan
  • Catalan (Valencian)
  • Greek
  • Spanish
  • Basque
  • French
  • Galician
  • Croatian
  • Hungarian
  • Italian
  • Lithuanian
  • Malayalam
  • Dutch
  • Polish
  • Brazilian Portuguese
  • Romanian
  • Slovenian
  • Turkish
  • Ukrainian

It is also partially translated in the following languages:

  • Azerbaijani (97%)
  • Belarusian (86%)
  • Czech (94%)
  • German (95%)
  • UK English (95%)
  • Esperanto (99%)
  • Estonian (95%)
  • Finnish (94%)
  • Hebrew (95%)
  • Indonesian (95%)
  • Macedonian (90%)
  • Norwegian Nynorsk (95%)
  • Portuguese (95%)
  • Russian (95%)
  • Slovak (83%)
  • Albanian (99%)
  • Swedish (95%)
  • Swahili (99%)
  • Chinese Traditional (95%)

You can find packages of this new version for GNU/Linux, Windows, Android, Raspberry Pi and macOS on the download page. This update will also be available soon in the Android Play store, the F-Droid repository and the Windows store.

Thank you all,
Timothée & Johnny

Announcing the Kubuntu Graphic Design Contest:

Shape the Future of Kubuntu

We’re thrilled to unveil an extraordinary opportunity for creatives and enthusiasts within and beyond the Kubuntu community

The Kubuntu Graphic Design Contest.

This competition invites talented designers to play a pivotal role in shaping the next generation of the Kubuntu brand. It’s your chance to leave a lasting mark on one of the most beloved Linux distributions in the world.

What We’re Looking For:

The contest centers on reimagining and modernizing the Kubuntu brand, including the logo, colour palette, fonts, and the default desktop environment for the upcoming Kubuntu 24.04 release. We’re seeking innovative designs that reflect the essence of Kubuntu while resonating with both current users and newcomers.


Inspiration: Contestants are encouraged to review the current brand and styles of,, and to understand the foundational elements of our visual identity.

Creativity and Modernity: Your submission should propose a fresh, modern look and feel for the Kubuntu brand and its supporting marketing materials. Think outside the box to create something truly unique.

Cohesion: While innovation is key, entries should maintain a cohesive relationship with the broader KDE and Ubuntu ecosystems, ensuring a seamless user experience across platforms.

How to Participate:

The contest is open now! We welcome designers from all backgrounds to contribute their vision for Kubuntu’s future.

Multiple entries are allowed, giving you ample opportunity to showcase your creativity.

Submission Deadline: All entries must be submitted by 23:59 on Sunday, 31st March.


Winner will have the honour of seeing their design become the face of Kubuntu 24.04, receiving recognition across our platforms and within the global open-source community.

First Prize:

  • Global recognition of your design as the new face of Kubuntu.
  • A trophy and certificate.
  • A Kubuntu LTS optimized and validated computer: the Kubuntu Focus Ir14 Laptop or the Kubuntu Focus NX MiniPC with 32 GB of RAM – over a $1,000 value.
  • Kubuntu Focus branded merchandise up to $50 USD shipped.

Second Prize:

  • Your runner up entry featured on
  • A trophy and certificate.
  • Kubuntu Focus branded merchandise up to $50 USD shipped.

Third Prize:

Join the Contest:

This is more than a competition; it’s a chance to contribute to a project that powers the computers of millions around the world. Whether you’re a seasoned designer or a passionate amateur, we invite you to bring your vision to life and help define the future of Kubuntu.

For more details on how to submit your designs and contest rules, visit our contest page.

Let’s create something extraordinary together. Your design could be the next symbol of Kubuntu’s innovation and community spirit.

Apply now: Contest Page


KdeEcoTest is an automation and testing tool which allows one to record and simulate user interactions with a Graphical User Interface. It is being developed as part of the FOSS Energy Efficiency Project to create usage scenario scripts for measuring the energy consumption of software in the KDE Eco initiative. Emmanuel Charruau is the original developer and lead maintainer of the project. In Season of KDE 2023 the tool was further improved by Mohamed Ibrahim under the tutelage of Karanjot Singh and Emmanuel Charruau.

One of the main goals in Season of KDE 2024 is to make the KdeEcoTest cross-platform so it can run on Windows and Linux systems (both Wayland and X11). Another necessary change in KdeEcoTest is to completely remove the use of libX11 and xdotool from the code base, which had issues with pixel coordinates while testing.

A benefit of a tool such as KdeEcoTest is that it is possible to create usage scenario scripts without having access to the source code of the software being tested. This is in contrast to a tool such as Selenium-AT-SPI, which requires access to the application's sources (QML file).

See how Selenium-AT-SPI helps with the KDE Eco project (Selenium-AT-SPI KDE Eco).

Getting Started: Platform Abstraction Layer

For the tool to be cross platform, it requires a platform abstraction layer, which is what Amartya Chakraborty and I, the SoK24 team, set out to write first. Any action, either simulated or read by the KdeEcoTest tool, can be separated into Window-based and Input device-based. The design goal is therefore to provide platform-independent interfaces for performing these actions.

We finished work on the abstraction layer and integrated it into the current code base with some minor changes. The layer provides two interfaces, a WindowHandler and an InputHandler (which have a platform-specific implementation), in order to access the underlying methods for taking window or input actions.

The team's next task was to implement these platform-specific classes. For the SoK24 project, Windows-specific classes were tasked to Amartya Chakraborty, while I set out to implement support for Wayland.

Adding Wayland Support: KDE's kdotool

From initial conversations between me, Emmanuel, and other members of the KdeEcoTest channel, we decided on using ydotool, a program written in C that simulates input devices with uinput. This enables the simulation of input devices on Wayland as well.

But ydotool was not enough as it did not support manipulating windows like xdotool did and we still required listening to input devices. For Window-based actions it requires communication with the underlying display server or compositor (in Wayland world), and Wayland currently did not have such a protocol. So we went back to the drawing board and tried different methods, even running the application as an X Client on Xwayland, which indeed worked but could hardly be called a solution to supporting Wayland.

Running as X client on Wayland using Xwayland. (Image from Wayland docs published under an <a href="">MIT</a> license.)
Figure : Running as X client on Wayland using Xwayland. (Image from Wayland docs published under an MIT license.)

We thought that currently there did not exist any solution for Wayland, but we were wrong. It turns out that KWin, the KDE Plasma compositor for Wayland and X11, already had one! One fine day Emmanuel posted a message on the KDE Dev channel, and voilà we got our solution from a KDE developer in the form of a Rust tool, kdotool. The tool uses KWin’s dbus interface to upload a JavaScript file and access methods and properties provided by the KWin scripting API. Just love you, KDE!

Emmanuel brought kdotool’s author ‘genericity’ on board and we set sail. With some minor tweaks and upgrades we integrated kdotool into KdeEcoTest and we now have all window-related functionalities set up and working on X11 and Wayland. (Oh … and by the way that’s when I found out you can’t have gitsubmodules on The use of the KWin specific APIs means that KdeEcoTest will currently only work on KDE Plasma.

Special mention to ‘genericity’ for developing this great tool.

Adding Input Actions

With all window-related actions in, it was time to add support for input actions. I was testing this out with ydotool, but later dropped it and decided to directly access uinput. Reading through Linux kernel documentation, I found it's rather better to use the evdev interface, which also allows one to create and simulate devices and also to read inputs from existing ones.

evdev is the generic input event interface. It passes the events generated in the kernel straight to the program, with timestamps. The event codes are the same on all architectures and are hardware independent. The layout of the input event -

struct input_event {
 struct timeval time;
 unsigned short type;
 unsigned short code;
 unsigned int value;

time is the timestamp, it returns the time at which the event happened. Type is for example EV_REL for relative movement, EV_KEY for a keypress or release. code is event code, for example REL_X or KEY_BACKSPACE. value is the value the event carries. Either a relative change for EV_REL, absolute new value for EV_ABS (joysticks ...), or 0 for EV_KEY for release, 1 for keypress and 2 for autorepeat.

You can find more details about the input event codes here,

libevdev sits below the process that handles input events, in between the kernel and that process. The stack would look like this:

  • Kernel → libevdev → libinput → Wayland compositor → Wayland client

And for X11 using libinput:

  • Kernel → libevdev → libinput → xf86-input-libinput → X server → X client

With the python-evdev binding for libevdev one could directly access evdev devices, but there is a catch: the script needs to be run as root, or the user needs permissions to read and write from /dev/input and /dev/uinput (and also /dev/console to run dumpkeys to get the keyboard drivers translation table). Considering the challenges, this was something we could live with.

My first plan was to directly use evdev to simulate and listen to input devices, but digging into it some more I found out that pynput had a uinput backend that, it turns out, was not fully implemented (it was partially implemented for keyboard). pynput is a cross-platform Python library that allows one to control and monitor input devices. Since pynput was already being used in KdeEcoTest and it supported all other systems (except Wayland), implementing a backend that uses libevdev would allow for using pynput and its already implemented methods and classes directly.

I finished writing a backend for pynput which allowed me to simulate and listen for mouse and keyboard events on Wayland. But there is one more problem with directly using libevdev. Input events generated from libevdev are passed to libinput before reaching the compositor.

libinput (Image from Wayland docs published under an <a href="">MIT</a> license.)
Figure : libinput (Image from Wayland docs published under an MIT license.)

libinput processes these inputs and provides easy-to-use APIs to handle them. It also provides configurable interfaces, which means that inputs we simulate using uinput may not be interpreted the same way by the compositor. For, e.g. the delta values in EV_REL type events (Event type for relative movement) generated by evdev devices such as a mouse are converted into relative movement on screen using a function called pointer accelaration in libinput. This function depends on the pointer acceleration profiles configured by the user depending on the compositor. There are namely two: "adaptive and flat". We skip further low level details about this here, and just add that switching to "flat" profile provides 1:1 movement between the device and the pointer on-screen. This also means that the mouse acceleration profile needs to be set to flat when running KdeEcoTest.

Now all that was required was to alias InputHandler class's attributes to pynput classes. This may be improved in the future when individual level implementation is required.

With both now implemented and integrated, KdeEcoTest supports running on Wayland, and also with the contribution from Amartya Chakraborty it runs on Windows as well.

Finished Platform Abstraction layer

The platform abstraction layer in current form sets the required backend for pynput, imports the necessary backend and exposes the required interfaces WindowHandler and InputHandler. When running on KDE Plasma, since we require kdotool, it additionally adds kdotool to the path.

import platform as _platform
import os
from pathlib import Path
import importlib

def set_handlers(package):
 module = None
 if _platform.system() == 'Windows':
 module = '.win32'
 elif _platform.system() == 'Linux':
 if os.environ.get('XDG_SESSION_DESKTOP',None) == 'KDE':
 module = '.kwin'
 #add kdotool to path
 KDOTOOL_PATH = os.path.join(Path(os.path.dirname(__file__)).parent,'bin/kdotool/release')
 os.environ['PATH'] = KDOTOOL_PATH + ':' + os.environ['PATH']
 elif os.environ.get('XDG_SESSION_TYPE',None) == 'X11':
 print('Platform Not Supported')

 return importlib.import_module(module,package)
 except ImportError:
 raise ImportError('Platform not supported')

backend = set_handlers(__name__)

WindowHandler = backend.WindowActionHandler
InputHandler = backend.InputActionHandler

del backend

__all__ = [

Looking Forward

The listener for mouse events in pynput's uinput backend currently does not listen for touchpad events, because the event codes generated made it confusing to implement one. I think a better approach would be to use libinput for listening for events, as this would provide abstraction and also make it easier to write code for handling events, but libinput currently lacks a python binding.


Of course it is far from complete. KdeEcoTest is still very much a work in progress and we're happy to have more developers looking to contribute. Hop on to the KdeEco and KdeEcoTest matrix channels to join the developers and follow the tool's development.

See for the FEEP repository, which hosts the KdeEcoTest tool among others.

Thank you to Emmanuel, 'genericity', Amartya, Joseph, as well as the whole KDE community and Wayland developers for helping out with the project.

Monday, 19 February 2024

Kdenlive 23.08.5 has been released, featuring a multitude of bug fixes, including many issues related to nested sequences and same-track transitions. This release temporarily removes Movit effects until they are stable for production. However, the primary focus of this release was to continue the ongoing efforts in transitioning to Qt6 and KF6.

It’s important to note that, due to this transition, we regret to inform our Mac users that a package for this release won’t be available. We kindly request them to wait for the 24.02 release, expected by the end of the month.

Full changelog

  • Fix undocked widgets don’t have a title bar to allow moving / re-docking. Commit.
  • Multi guides export: replace slash and backslash in section names to fix rendering. Commit. Fixes bug #480845.
  • Fix sequence corruption on project load. Commit. Fixes bug #480776.
  • Fix multiple archiving issues. Commit. Fixes bug #456346.
  • Fix possible sequence corruption. Commit. Fixes bug #480398.
  • Fix sequences folder id not correctly restored on project opening. Commit.
  • Fix Luma issue. Commit. See bug #480343.
  • Fix subtitles not covering transparent zones. Commit. Fixes bug #480350.
  • Group resize: don’t allow resizing a clip to length < 1. Commit. Fixes bug #480348.
  • Fix crash cutting grouped overlapping subtitles. Don’t allow the cut anymore, add test. Commit. Fixes bug #480316.
  • Fix clip monitor not updating when clicking in a bin column like date or description. Commit. Fixes bug #480148.
  • Fix start playing at end of timeline. Commit. Fixes bug #479994.
  • Fix save clip zone from timeline adding an extra frame. Commit. Fixes bug #480005.
  • Fix clips with mix cannot be cut, add test. Commit. See bug #479875.
  • Fix project monitor loop clip. Commit.
  • Fix monitor offset when zooming back to 1:1. Commit.
  • Fix sequence effects lost. Commit. Fixes bug #479788.
  • Improved fix for center crop issue. Commit.
  • Fix center crop adjust not covering full image. Commit. Fixes bug #464974.
  • Disable Movit until it’s stable (should have done that a long time ago). Commit.
  • Fix cannot save list of project files. Commit. Fixes bug #479370.
  • Fix editing title clip with a mix can mess up the track. Commit. Fixes bug #478686.
  • Fix audio mixer cannot enter precise values with keyboard. Commit.
  • Prevent, detect and possibly fix corrupted project files, fix feedback not displayed in project notes. Commit. See bug #472849.
  • Test project’s active timeline is not always the first sequence. Commit.
  • Ensure secondary timelines are added to the project before being loaded. Commit.
  • Ensure autosave is not triggered when project is still loading. Commit.
  • Fix variable name shadowing. Commit.
  • When switching timeline tab without timeline selection, don’t clear effect stack if it was showing a bin clip. Commit.
  • Fix crash pressing del in empty effect stack. Commit.
  • Ensure check for HW accel is also performed if some non essential MLT module is missing. Commit.
  • Fix tests. Commit.
  • Fix closed sequences losing properties, add more tests. Commit.
  • Don’t attempt to load timeline sequences more than once. Commit.
  • Fix timeline groups lost after recent commit on project save. Commit.
  • Ensure we always use the correct timeline uuid on some clip operations. Commit.
  • Add animation: remember last used folder. Commit. See bug #478688.
  • Refresh effects list after downloading an effect. Commit.
  • Fix audio or video only drag of subclips. Commit. Fixes bug #478660.
  • Fix editing title clip duration breaks title (recent regression). Commit.
  • Glaxnimate animations: use rawr format instead of Lottie by default. Commit. Fixes bug #478685.
  • Fix timeline focus lost when dropping an effect on a clip. Commit.
  • Fix dropping lots of clips in Bin can cause freeze on abort. Commit.
  • Right click on a mix now shows a mix menu (allowing deletion). Commit. Fixes bug #442088.
  • Don’t add mixes to disabled tracks. Commit. See bug #442088.
  • Allow adding a mix without selection. Commit. See bug #442088.
  • Remove line missing from merge commit. Commit.
  • Fix proxied playlist clips (like stabilized clips) rendered as interlaced. Commit. Fixes bug #476716.
  • Always keep all timeline models opened. Commit. See bug #478745.

The post Kdenlive 23.08.5 released appeared first on Kdenlive.

Saturday, 17 February 2024

Some time ago, Marco started a series of articles on SObjectizer. It is starting to become the source for all things SObjectizer – it is currently at post number 19 – quite an endeavour.

For those who haven’t met SObjectizer before, it is a framework for writing concurrent applications which supports the actor model, publish-subscribe…

EDIT: The series are available on Marco’s blog as well as on

This week the focus was on annoying longstanding issues, and a whole bunch of them are now history! If you’ve used KDE software for any significant amount of time, I bet you noticed and were annoyed by at least one of the issues mentioned below, and can now rejoice at their annihilation! This effort has dropped the number of 15-minute Plasma bugs to its lowest level ever–just 30. The Mega-Release will be shipped in under two weeks, and we want it to be as fabulous as possible!


…But first, some bugfixes backported to Plasma 5.27!

Fixed a way that KWin could crash in the Plasma Wayland session (Xaver Hugl, Plasma 5.27.11. Link)

Files copied to the clipboard are now made available to sandboxed apps using the portal system, so you can paste them into those apps (Karol Kosek, Plasma 5.27.11. Link)

After opening your laptop’s lid, the brightness of its backlit keyboard is now correctly restored to the same value it had before the lid was closed (Werner Sembach, Plasma 5.27.11. Link)

KDE 6 Mega-Release

(Includes all software to be released on the February 28th mega-release: Plasma 6, Frameworks 6, and apps from Gear 24.02)

UI improvements

When a panel popup is open, clicking on an empty area of the panel will now close it (David Edmundson, link)

When you try out a Global Menu and all your apps’ in-window menubars get hidden, if you later change your mind and remove the Global Menu, all of those apps’ in-window menubars now re-appear automatically instead of remaining hidden until manually shown again (David Edmundson, link)

When any of your physically connected screens are marked as disabled, opening System Settings’ Display & Monitor page now always shows an enabled screen when it opens, rather than sometime showing one of the disabled screens (David Edmundson, link)

Added Breeze icons for OpenVPN and Cisco VPN configuration files (Kai Uwe Broulik, link):

Bug fixes

Important note: I don’t mention fixes for bugs that were never released to users; it’s just too much for me (it would probably be too much for you to read as well), and most people never encountered them in the first place. Because we’re in the middle of a big Plasma dev cycle, there are a lot of these bugs! So big thanks to everyone who’s made it a priority to fix them!

Fixed several common random-seeming crashes in Plasma’s Activities backend code (Harald Sitter, link)

Fixed a significant annoyance that would, in most distros, cause several types of files to be opened in the wrong apps by default (e.g. images opened in Okular rather than Gwenview) until the first time the user changed any of the file associations (Harald Sitter, link)

Fixed a visual glitch in Gwenview that could cause image thumbnails to overlap when using a fractional scale factor (David Edmundson, link)

in Spectacle, drawing annotations with a touchscreen or a stylus no longer draws additional random-seeming straight lines in weird places (Marco Martin, link)

Shift+dragging windows to custom-tile them now works even if you’ve set your keyboard to do something exotic like emulate the Caps Lock key when pressing both Shift keys together (Xaver Hugl, link)

Fixed a case where the cursor failed to disappear as expected in certain WINE games (Vlad Zahorodnii, link)

Fixed a memory leak seen in Spectacle when recording the screen (Aleix Pol Gonzalez, link)

Other bug information of note:


Gwenview now has a minimal “Spotlight View” mode in which all the normal UI is hidden, and all you see is the image and the window titlebar (Ravi Saifullin, Gwenview 24.05. Link):

Before you ask, no this is not my paintjob! But I do plan to use it as inspiration 🙂

The warning on System Settings’ Proxy page no longer inaccurately warns you that Chromium-based browsers don’t respect it, which isn’t true anymore (Someone going by the pseudonym “Chaotic Abide”, kio-extras 25.04. Link)

Fixed the most common crash in Discover for Plasma 6.1, and we’re scoping out options for fixing it for 6.0 as well (Ivan Tkachenko, Plasma 6.1. Link)

System Settings’ Screen Locking page now has a clearer UI for selecting times (Kristen McWilliam, Plasma 6.1. Link):

There’s now a KWin window rule you can use for controlling the status of Adaptive Sync for individual windows (Ravil Saifullin, Plasma 6.1. Link)

Performance & Technical

KWin now supports direct scan-out when run in a nested manner inside another compositor (Xaver Hugl, Plasma 6.1. Link)

Landed some major performance improvements for thumbnail generation in Gwenview and file listing in general (Arjen Hiemstra, Mega-Release 6. Link 1 and link 2)

Landed some major performance improvements for Spectacle’s Rectangular Region mode (Noah Davis, Spectacle 24.05. Link)

The spacings used throughout Plasma and Kirigami-based apps are no longer based on font sizes, and are now simply hardcoded to various static values, as they are in QtWidgets-based apps. This should slightly increase visual consistency everywhere, and make it possible over time to build UIs with more predictability in their spacings. This is more of a long-term thing, but it’s an exciting first step! (Noah Davis, Kirigami 6.0. Link)

…And Everything Else

This blog only covers the tip of the iceberg! If you’re hungry for more, check out, where you can find more news from other KDE contributors.

How You Can Help

Thanks to you, our Plasma 6 fundraiser has been a crazy success! I originally thought the goal of 500 new KDE e.V. supporting members was over-optimistic, but you’ve all proven me happily wrong. We’re now up to an amazing 825 members, blown past our stretch goals, and 1000 members by launch time seems like it might even be feasible. Thank you everyone for the confidence you’ve shown in us; we’ll try not to screw it up! 🙂 For those who haven’t donated to become members yet, spreading the wealth via this fundraiser is a great way to share the love. 🙂

If you’re a developer, work on final Qt6/KF6/Plasma 6 issues! Which issues? These issues. Plasma 6 is very close to a release and in a good state, but could still benefit from some final bug-fixing and polishing. And as I mentioned before, if you haven’t tried it out yet, please do!

Otherwise, visit to discover other ways to be part of a project that really matters. Each contributor makes a huge difference in KDE; you are not a number or a cog in a machine! You don’t have to already be a programmer, either. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

Friday, 16 February 2024

Let’s go for my web review for the week 2024-07.

Non-code contributions are the secret to open source success · GitHub

Tags: tech, foss, community

Good reminder that contributions are not only about code. Documentation, support, release management and so on are very important as well and too often underrated.

Extending our Mastodon social media trial - BBC R&D

Tags: tech, bbc, social-media, fediverse

Looks like the BBC likes the fediverse experiment so far. Engagement is even better than on Twitter at times. Let’s hope they keep expanding.

European Court of Human Rights bans weakening of secure end-to-endencryption

Tags: tech, politics

Excellent news, let’s hope this thwarts the commission plans as expected.

Estimating the environmental impact of Generative-AI services using an LCA-based methodology

Tags: tech, ecology, energy, ai, machine-learning, gpt

Interesting paper evaluating a Life Cycle Assessment (LCA) method to estimate the power consumption and environmental impact of generative AI services. This is illustrated on a single service, hopefully we’ll see more such assessments.

Short history of all Windows UI frameworks and libraries

Tags: tech, windows, gui

Confused about which UI frameworks are used in Windows? Here is the list in chronological order.

The Stupidity Manifesto

Tags: culture, empathy

Definitely this, it’s better when you don’t make people feel stupid.

RSS is still pretty great

Tags: tech, rss, blog

Good explanation of what RSS is, where its weaknesses and strengths are.

Too dangerous for C++

Tags: tech, rust, c++, type-systems, multithreading

It’s hard to argue that the Rust type system isn’t superior to the C++ type system… it’s definitely nice how it actively prevents data races at compile time.

The History of Python: Why Python’s Integer Division Floors

Tags: tech, python, mathematics, floats

Some reasons why Python and C behave differently on this matter. It’s a source of mistakes.


Tags: tech, gpu, amd, nvidia, computation

Interesting project, could bring a boost in AMD GPUs usage for CUDA workloads.

Not just NVIDIA: GPU programming that runs everywhere

Tags: tech, python, gpu, computation, webgpu

Interesting to see WebGPU bindings for Python.

WebGPU Best Practices

Tags: tech, 3d, gpu, computation, webgpu

Looks like a nice list of resources to dive deeper with WebGPU

Open-source data multitool | VisiData

Tags: tech, tools, data, python

Looks like a nice tool for quick data exploration straight from the command line.

Magika: AI powered fast and efficient file type identification | Google Open Source Blog

Tags: tech, ai, machine-learning, tools, command-line

Interesting tool for file type detection. Seems very accurate too.

Why Bloat Is Still Software’s Biggest Vulnerability - IEEE Spectrum

Tags: tech, security, architecture, dependencies, supply-chain

Definitely this, the software bloat directly impacts the attack surface of what gets shipped. Even though this is far from a panacea in terms of security, it’s time for people to critically examine their dependencies also for other reasons.

Mastering Programming - by Kent Beck

Tags: tech, craftsmanship, programming

As always from Kent Beck, an excellent set of advices to improve you programming skills.

Deciphering Glyph :: Let Me Tell You A Secret

Tags: tech, communication, management, team

This is a bit cartoonish I’d say but there’s some truth to it. I indeed regularly get onto consulting gigs where you find out that the people already had the solution to their problem. In those cases it’s very often because communication channels are broken somewhere (team don’t feel at liberty to share what they noticed, managers having a hard time to listen, etc.).

Tracking Engineering Time - Jacob Kaplan-Moss

Tags: tech, management, metrics, estimates

Interesting approach when managing at a distance. It tries hard to stay lightweight which is definitely welcome.

What Is in Your Organizational Closet? - esther derby associates, inc.

Tags: management, organization

Interesting idea… indeed organizations can carry legacy processes and ideas as well.

Bye for now!

Thursday, 15 February 2024

We are happy to announce the release of Qt Creator 13 Beta!

Choosing the right system-on-chip (SoC) is probably your first consideration when designing an embedded product, followed closely by deciding whether to use an off-the-shelf board or design your own.

The case for commercial boards in initial designs

For the first product in a new line, consider using a commercially available board that features your chosen SoC. This approach may slightly increase the cost per board compared to building a custom board yourself. However, it lets you build on a vendor’s considerable expertise in areas like SoC characteristics, architectural layout, proper bus design, and errata workarounds. Pre-existing boards offer a significant shortcut in getting your product to market as they can minimize prototype iterations and reduce the risk of crucial mistakes in layout. As you gain experience with your chosen silicon and start looking at moving to higher-volume production, you can then consider whether it makes sense to design and manufacture custom boards to reduce costs and introduce custom functionality.

First step: Picking a vendor

Selecting a CPU architecture is your very first step. While ARM is currently dominating the market, Intel x86 and RISC-V are other possible alternatives. Because toolchains like LLVM and GCC can support all these architectures, your decision will usually depend on factors such as vendor and community support, licensing, power consumption, and clock speeds. Once you’ve selected an architecture, comparing features and prices within that family becomes more straightforward.

Evaluating silicon vendor boards

Silicon vendors such as AMD, Intel, Nvidia, NXP, and Renesas all offer eval boards to help you evaluate their SoCs. These boards are excellent starting points but there are things to consider.

  • Feature overload. Because eval boards are intended to show off the capabilities of their chips, they are often loaded with features. That can be good for trial, but you don’t want to pay for unnecessary hardware once you move to volume production.
  • Limited availability. Eval boards are often intended for very limited distribution, making availability a serious concern. If you’re planning on a very small production run, this might not matter. But it also might force you to move to another platform before you’re ready.
  • Hardware consistency. Eval boards may not have the same process consistency as commercial products. That means you could get multiple hardware revs of the same board within a short timeframe, creating potential software compatibility nightmares and in-field surprises.
  • Support limitations. Support (either engineering assistance or device drivers) may not be at the level you need to build product. That includes some critical aspects such as OS updates. It’s possible the vendor has the capacity or process for consistently delivering commercial quality drivers for their boards that are compatible with the latest Linux releases, but you’ll likely need to ask.

It’s always advisable to consult with a sales representative before using an eval board in a production product. Their feedback can prevent future issues and, if necessary, direct you to distributors for better long-term alternatives.

Choosing a board provider

The other option for using pre-made boards is to go to a board vendor instead of a silicon vendor. They’re creating boards with the intent they’ll be incorporated into products rather than simply for evaluation. When selecting a board provider, consider all aspects, including one of the most important peripherals, the screen. For a more comprehensive guide on selecting hardware, refer to our paper on best practices: Designing Your First Embedded Linux Device: Choosing Your Hardware.

The post Optimizing Embedded Product Design appeared first on KDAB.