After four months of active maintenance and many weeks triaging bugs, the digiKam team is proud to present version 8.7.0 of its open source digital photo manager.
Improvements in Photos, KRetro and better keyboard navigation
Welcome to a new issue of "This Week in KDE Apps"! Every week (or so) we cover as much as possible of what's happening in the world of KDE apps.
As you might have noticed, the frequency of "This Week in KDE Apps" has not been very consistent lately. Particularly during the summer season, I (Carl) have a lot of social obligations and can't ensure regular updates with the small amount of time I have available. If you are a KDE developer, you can help by contributing your updates to the GitLab merge request on invent. In that respect, a huge thanks to Felix Ernst for doing that already for Dolphin.
Getting back to all that's new in the KDE App scene, let's dig in!
Akseli Lahtinen increased the click area of files and folders in the main view and overhauled their styling. It's (subjectively speaking) a lot prettier now! We are trying to make Dolphin more consistent with other list styles in KDE long-term (25.08.0 - link).
Méven Car added a colorful folder icon chooser to the context menu of folders (25.08.0 - link). The Dolphin context menu can be edited in Dolphin's settings window.
Aleksandr Borodetckii lowered the default scroll speed to follow the globally-configured scroll distance more closely. Scrolling one "tick" with the mouse wheel should now move the view by a similar distance in Dolphin as it does in KWrite. In details view mode we made sure that scrolling moves by full item height (25.08.0 - link).
Gleb Kasachou added a setting to optionally elide long file names at the end instead of in the middle, so when the Dolphin window is too narrow to display “a very long file name.txt”, you can now switch between showing “a very…file name.txt” or “a very long file….txt”. Both of these behaviors have been respectfully criticized in the past, so now everyone can set it to their liking (25.08.0 - link).
Bojidar Marinov fixed a visual bug in the default icons view mode in a livestream, as sometimes the file name would have one row of text outside and below the actual file geometry (25.08.0 - link).
Akseli Lahtinen fixed a long-standing issue that could cause Dolphin to crash while interacting with Samba shares (Frameworks 6.16 - link).
Kai Uwe Broulik fixed another long-standing issue where a random "Examining" popup would appear when connecting to a busy Samba share (25.04.3 - link).
Sune Vuorela made the list of certificates used to sign a PDF update when switching the active backend (GnuPG or NSS) (25.08.0 - link). If Kleopatra is installed and the GPG backend is selected, Okular will now propose to view the certificate details in Kleopatra (25.08.0 - link).
Abdus Sami made the number of items in the recent history configurable (25.08.0 - link).
Pablo Ariño ported the Etesync resource away from directly depending on QtWidgets. This decreases the RAM consumption by around 10MiB for each running Etesync instance (25.08.0 - link). Carl then ported the resource away from KWallet to the more multiplatform alternative QtKeychain (25.08.0 - link).
Merkuro Manage your tasks, events and contacts with speed and ease
Oliver Beard fixed various bugs in Photos. Sharing now works again (25.08.0 - link) and the bookmark functionality is now consistently called "bookmark" in the UI (25.08.0 - link). He also ported the thumbnailbar to a standard toolbar (link).
Carl Schwan made it possible to configure some shortcuts in Photos and added a command bar (25.08.0 - link). Additionally, he made it possible to configure which metadata details are available in the sidebar (25.08.0 - link).
Carl also optimized the main view a bit (25.08.0 - link 1, link 2 and link 3), unified the breakpoint at which desktop and mobile mode are switched (25.08.0 - link), fixed the video player which was not completely ported away from Qt5 (25.08.0 - link), and made a large number of small cleanups and code modernizations (link).
Jean-Baptiste Mardelle added an action to extend and collapse items in the effects and folders view. This allows navigating these views with the keyboard (25.08.0 - link).
Carl Schwan added support for Deutsches Jugendherbergswerk (DJH) email confirmations (25.04.03 - link).
Stephan Olbrich added support for Deutscher Alpenverein (DAV) membership cards (25.04.03 - link).
David Pilarčík added support for extracting multiple tickets from one PDF for Leo Express (25.04.03 - link) and improved the extraction of the luma extractor (25.04.03 - link).
Joshua Goins overhauled the server information page (25.08.0 - link). You can now view your server's extended description, terms of service and privacy policy (when applicable).
Efe Çiftci added a "Show Folders" action to Filelight that allows toggling the visibility of the folder list on the left-hand side of the window (25.08.0 - link).
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.
This week, the merge request for the EteSync resource has been reviewed and successfully merged! This marks a key milestone in the project: EteSync is the first resource to be fully refactored, with its UI logic cleanly separated into a standalone configuration plugin.
Based on feedback from my mentors, I made a few final revisions before the merge. One important addition was a .notifyrc file for the EteSync resource. This allows the headless EteSync resource to make use of KNotification for reporting errors or status updates, integrating with the user notification system in a way that doesn’t depend on a UI.
With the resource no longer depending on QtWidgets, and its configuration interface now dynamically loaded, this change contributes to our broader goal of making the Merkuro suite lighter and more adaptable for mobile environments.
After the merge, my mentor Carl checked the memory usage using System Monitor. The improvements were measurable: the EteSync resource now uses approximately 9.5 MiB of RAM, compared to the 22 MiB used prior to the refactor.
The Job Tracker and a D-Bus Debugging
With Etesync out of the way, I turned my full attention back to the PIM Migration Agent. The next logical step was to resolve the KUiServerJobTracker problem I identified last week. My initial plan was to replace it entirely with the progress-reporting tools built directly into Akonadi’s AgentBase. But, while inspecting the Akonadi code, I realized this approach wouldn’t be viable for my use case.
Although AgentBase does provide D-Bus signals for job progress and status updates, these are low-level and do not integrate directly with the system tray or display persistent visual feedback to the user. In contrast, KUiServerV2JobTracker automatically presents progress as desktop notifications or tray-based UI elements.
Still, I implemented the changes, compiled the code, and launched akonadiconsole to test. The good news: the refactored agent started and the configuration plugin loaded. The bad news: they weren’t talking to each other. The D-Bus communication I had set up last week was failing.
This sent me down a debugging rabbit hole. My first hypothesis was that the agent needed its own .service file to properly register on the D-Bus session bus. I spent a good chunk of time creating and tweaking one, but the D-Bus connection simply refused to work as intended. The plugin and the agent remained strangers.
After much investigation I discovered the root cause, and it was a typical environment problem.
akonadiconsole was using the system D-Bus, while my development build of the agent was trying to register on the user session D-Bus managed by my Plasma desktop.
They were on two completely different communication networks! This immediately explained why my custom dbus interface had no effect—akonadiconsole was never even looking for it in the user session. To solve this I ran:
kde-builder - -run akonadictl restart
After this I ran the akonadiconsole once again and this time the D-Bus connection worked as intended.
What’s Next?
For next week, the priorities are:
Re-evaluate the job tracking solution for the Migration Agent, now with a proper understanding of the D-Bus context.
Push forward with removing the final QtWidgets dependencies.
Finalize the plugin-agent communication pathway with reliable, real-time interaction.
The refactor of EteSync and the progress made with D-Bus integration in the Migration Agent continue to move the project toward a more modular and future-proof codebase.
When we were at TU Graz for the KDE Plasma Sprint and Grazer Linuxtage
a few weeks ago the question came up how to practically map such buildings in OpenStreetMap
given their available floor plans. As I’m mostly involved in using rather than creating OSM data I didn’t have
a good answer for that back then. Thanks to input during the following quarterly
OSM Indoor Meetup, you’ll find
some hints on approaches and tools below.
Indoor Mapping
Navigating in complex public buildings is a similar challenge than navigating outdoors, detailed map data is crucial
in both cases. And while indoor mapping is a somewhat niche topic in OSM still, there’s applications such as
Itinerary and Transitous making use of that for
train stations or airports, and Kongress
applying this in conference venues.
For displaying maps split up by floor level we already get somewhat usable results with partial information as
humans are very good in filling in the blanks.
Routing algorithms
however are very dumb and very clever at the same time,
dumb when it comes to making “common sense” assumptions when facing missing information and clever when it comes to finding
creative shortcuts by exploiting incomplete information. So completeness is important here.
Routing algorithm exploiting doors not intended for visitors (left).
And that’s even more the case when looking at accessibility usecases, no matter whether applying human or machine routing.
Every single step somewhere can be a blocker for a wheelchair, and if you rely on tactile guides a mismatch between map
and reality hurts a lot more than when you can fill the gaps by what you see on the spot.
Building plans
The hard part of mapping building interiors is usually to get the geometry of rooms, corridors, walls, etc. in correctly.
Measuring this all by hand in reference to the outer structure is a very tedious job, tools commonly used for outdoor
mapping such as GPS and geo-referenced aerial imagery wont help here.
Images of to scale floor or evacuation plans are usually easier to obtain. Those generally cannot be imported
automatically, but offer a similar help as aerial imagery for outdoor mapping. TU Graz has those available in their
room information system in several variants and formats for example.
We’ll focus on this below.
As always it’s important to make sure the material you use is available
under a suitable license and/or there’s an explicit permission for use for OSM mapping.
Using building plans in JOSM
Setup
While the following assumes you have JOSM set up and connected to your OSM account,
there’s additional plugins needed for this. Those can be installed via “Edit > Preferences… > Plugins”.
The main one is “PicLayer”, “measurement” will also come in handy in many cases.
When using JOSM via Flatpak you’ll likely also want to give it full file system permissions for this.
JOSM is based on Java Swing which has no support for XDG portals for accessing files. While that’s usually
not an issue when editing OSM data it wont be able to open local build plan images otherwise.
Building outline
Editing a building starts with identifying the building outline. In practically all cases that will
already exist in OSM, there might be cases with more than a single outline though, e.g. when a building
has different extents on different floors.
Besides the building plan, aerial imagery available in JOSM can be a useful reference here.
Building outline with aerial image background.
In the above example we see that the existing outline covers the building extent at its top floor, omitting
the parts on the ground floor towards lower right side as well as the small glass extension to the top.
That’s of course worth fixing on its own, and if the rooms you want to map are in that part of the building
it’s the first step anyway. It’s yet another topic though,
so for now we assume the part we want to map is covered by the existing outline.
Aligning the building plan
The next step is then to properly align the building plan image underneath the building outline, as that will
most likely neither be scaled nor rotated correctly after adding it via “Imagery > New picture layer from file…”.
After enabling the building plan layer to be the currently active one
(ie. it having the green checkmark in front of it in the “Layers” sidebar pane),
controls for manually scaling and rotating become available. That works, but can be
rather cumbersome to use.
Much more convenient is the automatic calibration feature of the PicLayer plugin. For this we need to know
the physical length of two lines of the building outline. Whether that’s read from the building plan, measured
in JOSM on the building outline or aerial imagery (which is where the measurement plugin comes handy), or measured
in real life doesn’t really matter.
Calibration can then be started via “Mode > PicLayer auto calibration” in the menu (again, make sure the building
plan layer is enabled), which gets you the following dialog.
JOSM PicLayer calibration dialog.
Follow that from top to bottom:
Select “Add points…” and click on three points on the building plan for which there are corresponding points
in the building outline.
The following two text input fields become enabled then, enter the physical length in meters between
point 1 and 2 as well as 2 and 3.
Click on the left “Select a layer including the building outline as reference…” and pick the OSM data layer
in the follow dialog, by default that’s called “Data Layer 1”.
Finally, select the “Add points…” action on the bottom, answer the following message box with “defined” (ie.
we already have an existing building outline), and then pick the three OSM nodes corresponding to the points
you selected on the building plan.
Completed calibration dialog.
With all that done, the “Run” action becomes available and if everything matches this results in the floor plan
being correctly position behind the building outline. The process can fail e.g. if the plan and the outline can’t
be made to match, e.g. because the measured values were wrong or the selected points weren’t actually the same.
To avoid having to go through this process multiple times, there’s actions in the context menu of the image
layer to save and restore the calibration data.
Mapping room geometry in JOSM
With the building plan correctly aligned we can start to add room geometry. As many buildings have
predominantly rectangular structures, enabling “Edit > Angle Snapping” once in “Draw Mode” tends to
be very helpful. That not only helps with producing 90° angles but it also provides guiding lines
for aligning e.g. multiple walls on a straight line.
In most cases the so-called “thin wall” model is used, that is walls between rooms are mapped as a
one-dimensional line rather than as two-dimensional geometry (“thick wall” model). Exceptions might
be very old buildings with very thick or irregular walls such as castles or cathedrals. While (visual)
renderers and routers would benefit from the higher level of detail of the “thick wall” model it poses
a big challenge for tactile renderers as those can only output a much reduced information density and
“pixel” resolution.
Alignment and angle guides in JOSM.
The bare minimum tagging on new geometry would need to be the level
tag containing the floor level and the indoor tag describing the general type of
structure (room, corridor or open area). There’s a lot more that could be added though
(see below), but that is often better and easier to do on-site.
Don’t forget to also map corridors and open areas as well as possibly missing pieces of outside walls.
Humans tend to automatically fill those in when looking at a map, but routers wont.
Mapping doors
Another thing that’s easiest to add from building plans are doors. Without those routers will steadfastly claim
rooms are impossible to enter.
Doors are generally mapped as points. So that’s a matter of clicking on their center on the room geometry
and tagging the resulting new node with indoor=door and the corresponding level as the bare minimum.
If a door is not meant to be used by the public, e.g. because it’s locked or because it’s an emergency exit,
that’s also crucial to tag as routers will otherwise happily exploit this new shortcut.
See access,
entrance and
exit for this.
Floor level changes
Structures that allows changing between floor levels (staircases, elevators, escalators, ramps, etc)
are also essential to tag as such, with the important part being the level tag containing
the set of floors reachable this way.
Without that routers wont find their way up or down a building.
And everything else
There is a whole lot more details that can be tagged on the new geometry then, such as:
Information about tactile_paving guides and
handrails, which are useful for people with reduced vision.
Adding all those details is much closer to outdoor OSM mapping and can also be done e.g. with mobile editors.
An editor that can do floor-level filtering is still useful, but you can get a long way there without touching geometry,
making this also a much more approachable activity for new OSM contributors.
Interested in more?
For some inexplicable reason you find all this super exciting and want to get more involved? No problem, there’s
plenty of opportunities:
Every week we cover the highlights of what’s happening in the world of KDE Plasma and its associated apps like Discover, System Monitor, and more.
This week we not only continued polishing up Plasma 6.4 in response to feedback (thanks to everyone who submitted bug reports and wrote nice emails to us), but we also started work on bigger improvements to Plasma 6.5.
Probably the biggest one is the next piece of the Wayland session restore puzzle clicking into place: David Edmundson has implemented support for the xx-session-management-v1 Wayland session restore protocol in Qt 6.10! This means that software built on top of Qt 6.10 (for example, Plasma and KDE apps) will be able to start implementing the protocol themselves. Once they do, then finally real session restore will work on Wayland. We're not all the way there yet, but we keep on working to get closer all the time!
But that’s not it! We’ve got a whole lot more, too…
Notable New Features
Plasma 6.5.0
Plasma’s Welcome Center apps now teaches you about the many keyboard shortcuts in Plasma, as well as what the heck the “Meta” key is. (Nate Graham, link)
Plasma’s built-in RDP server now supports syncing clipboard text between the client and server. (Arjen Hiemstra, link)
Refined the tone mapping feature in KWin to improve the look of some screen content when using HDR or EDR. (Xaver Hugl, link)
You can no longer open an infinite number of error messages in Spectacle’s UI by repeatedly doing a thing that triggers them, and then not stopping even though maybe you should. (Noah Davis, link)
Plasma 6.4.2
Spectacle no longer includes a ghostly semi-transparent version of its own menus in screenshots taken within the app when not using any kind of delay. (Ismael Asensio, link)
The “New!” badges applied to newly-installed apps shown in the Kickoff Application Launcher are now more appealing and easier to read by using semantically correct colors from the active color scheme. (Kai Uwe Broulik, link 1 and link 2)
In the Kicker Application Menu widget, you can now activate the power/session actions using the Enter key, in addition to the Space key. Now all the UI elements on that widget can be activated with Enter. (Christoph Wolk, link)
Made the Night Light feature’s color tinting look nicer on certain hardware. (Xaver Hugl, link)
Plasma 6.5.0
The notification telling you that you missed some notifications while you were in Do Not Disturb mode now includes a button you can click on to actually see those missed notifications! (Kristen McWilliam, link)
You can now copy the QR code for clipboard items, in addition to just being able to look at them and scan them. (Ismael Asensio, link)
The “Click here to change the icon” button that’s visible on the Properties window and other QtWidgets-based apps is now more obvious as to what its purpose is. (Kai Uwe Broulik, link 1 and link 2)
The Networks widget now tells you what what it’s doing for more more potential states that it can be in, including “looking for wireless networks” and “uh, I’ve been disabled, dude.” (Nate Graham, link)
System Settings’ Printers page also now gives you a better error message if its service has been disabled. (Mike Noe, link)
On System Settings’ Region & Language page, the error message that tells you language packages couldn’t be installed now actually mentions their names so you can try to troubleshoot it a bit. (Ismael Asensio, link)
Frameworks 6.16
All scrollable views in all QtQuick-based KDE software now have inertial scrolling when scrolled using a touchpad! Note: only with a touchpad, not with a mouse wheel. No inertia there. Say it with me: no inertia for mouse wheels! (Niccolò Venerandi, link)
Improved the accessibility of the common Properties dialog in many ways. (Felix Ernst, link 1 and link 2)
Notable Bug Fixes
Plasma 6.3.6
Made the Environment Canada provider for Plasma’s Weather Report widget work again after they changed the data format. (Ismael Asensio, link)
Plasma 6.4.1
Fixed several crashes in in KDE’s desktop portal implementations. (David Redondo, link 1 and link 2)
If you have a Samsung Odyssey G5 monitor, it no longer turns on and off forever while Powerdevil’s DDC support is enabled, because the monitor’s own DDC implementation is completely broken, so we blacklisted it. (Xaver Hugl, link)
Fixed an accessibility regression that caused the Install and Remove buttons on Discover’s app pages to be excluded from the tab focus chain. (Christoph Wolk, link)
Deleting a file or app that’s been made a favorite in Kicker/Kickoff/etc no longer makes it impossible to un-favorite that thing. (Christoph Wolk, link)
Fixed an issue in the Window List widget that prevented it from being able to minimize or maximize windows. (Christoph Wolk, link)
Fixed an issue in KDE’s desktop portal-based open/save dialog that caused extra UI elements added by apps to appear in the wrong places. (David Redondo, link)
Fixed an issue with the new “relative mode” for drawing tablet styluses that could cause the pointer to disappear when you have two tablets connected at the same time and each of them uses a different input mode. (Vlad Zahorodnii, link)
Fixed two visual glitches that could be caused by re-arranging virtual desktops in the Overview effect’s grid view. (Vlad Zahorodnii, link 1 and link 2)
Fixed an issue that made clicking on Plasma UI elements unreliable when using certain non-default click modes. (Vlad Zahorodnii, link)
Plasma 6.4.2
Fixed a case where System Settings’ Flatpak App Permissions page could cause the whole app to crash (Daniel Hast, link)
Fixed an issue that could sometimes cause Plasma to go back to sleep again right after waking up, when the “Sleep then hibernate” setting is in use. (Myrrh Periwinkle, link)
The appearance of text labels in Folder View pop-ups is once again correct. (Nate Graham, link 1 and link 2)
You’re no longer erroneously prompted to authenticate for a Wireguard VPN whose credentials are already stored in KWallet, and the wallet is set up to automatically open at login. (Jeff Chien, link)
Fixed an issue in the KDE desktop portal’s screenshot implementation that prevented the delay setting from taking effect. (David Redondo, link)
Missing app backends listed in Discover’s Settings page once again show the correct names. (Harald Sitter, link)
The brightness level shown on System Settings’ Display & Monitor page now matches the one shown in Plasma. (Xaver Hugl, link)
Fixed an issue that caused the panel to have too much space in it until restarting Plasma if you stop displaying the date on a horizontally-laid-out Digital Clock widget. (Niccolò Venerandi, link)
Qt 6.8.4
Fixed a Qt bug that caused is to be extremely frustrating to re-arrange Task Manager icons because the drag target would change after you dragged an icon over another one. (Niccolò Venerandi, link)
Fixed an issue that could cause stuttering when playing video content in certain video players when using a variable-refresh-rate screen. (Błażej Szczygieł, link)
Plasma 6.4.1
Fixed a recent performance regression with certain games. (Vlad Zahorodnii, link)
Plasma 6.5.0
Increased the perceived responsiveness of logging into Plasma by optimizing the splash screen code and re-arranging some of the startup steps. (Vlad Zahorodnii, link 1 and link 2)
Slightly reduced the duration of the login animation, which makes logging into Plasma feel a bit snappier. (Vlad Zahorodnii, link)
How You Can Help
KDE has become important in the world, and your time and contributions have helped us get there. As we grow, we need your support to keep KDE sustainable.
You can help KDE by becoming an active community member and getting involved somehow. Each contributor makes a huge difference in KDE — you are not a number or a cog in a machine!
You don’t have to be a programmer, either. Many other opportunities exist:
You can also help us by making a donation! 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.
Dear fans of music & open source music players, in preparation of the upcoming Amarok 3.3 release, a second beta release (3.2.82) has been prepared.
This time, the most important change is the new GStreamer-based audio backend. This enables a number of features that weren't available on Qt6 Phonon
backends, and likely also provides a more reliable audio experience in general.
In addition to audio system work, e.g. more safeguards have been set up around collection scanning code to prevent some potential database issues.
More details on changes are listed in the ChangeLog.
These come in addition to the previous beta 1 changes (Qt6 only, database update).
Please note that due to the database update in beta 1, downgrading from 3.3 betas is not directly possible, and returning to pre-3.3 versions
requires the database (at ~/.local/share/amarok/mysqle/) to be manually backed up beforehand.
The Amarok 3.3 beta 2 source tarball is available on
download.kde.org
and it has been signed with Tuomas Nurmi's GPG key.
In addition to the source code, it is likely that some distributions will provide beta packages.
The various nightly git builds provided by various splendid packagers should also provide a way of using the beta changes
and participating in the testing.
Those of you upgrading to Plasma 6.4.1 (released yesterday) may notice a more substantive change than the type we typically make in bug-fix releases: The “highlight window” effect for Task Manager thumbnails is now off by default. This is the effect that makes other windows fade out when you hover over a window’s thumbnail.
Why did we turn it off? Because we discovered that with certain window arrangements and mouse movements, the current implementation could potentially cause full-screen flickering at greater than 3 Hz, which is potentially capable of triggering seizures in sensitive people.
Now, this is very unlikely. You’d need to open multiple full-screen windows of the same app, hover over their task to show thumbnails for them, move the pointer over one of the thumbnails, and then move it rapidly across all the others.
…Unlikely, but not impossible! And until and unless we can fix the effect to not be so flickery with this specific usage, it’s safer to keep it off. Furthermore, even for people who aren’t photosensitive, it’s currently a really unpleasant visual effect.
This work was done as a part of KDE’s recent accessibility push, and specifically the focused effort to make Plasma fully compliant with new EU accessibility regulations. Work is currently going on at all levels of the software stack, with multiple people involved and multiple sponsors funding it — both KDE e.V. itself, and also outside firms and institutions. If you’d like to see more of this kind of thing, donating to KDE e.V. is always a great idea, as it allows KDE e.V. itself to support an even larger amount and proportion of it.
There seems to be a bit of a doom-and-gloom vibe about accessibility in our community lately, but hopefully it’s clear that not only does KDE care, but it puts its money where its mouth is on this topic! Maybe we’re not 100% there yet, but we’re pointed in the right direction and motivated to continue accelerating towards it.
Plasma's upcoming first-run experience is coming along nicely.
After a bunch of research and discussions we settled on continuing / fixing up
the KISS project (KDE Initial System
Setup) for the new First Run Experience (FRE) / Out-Of-Box Experience (OOBE). It
was in a sort of half finished state.
Since then has been a bunch of work on it such as:
Getting it to compile and run
Whole bunch of fixes, cleanup, and polish to the UI, UX, and code/developer
experience
Implemented the ability to actually create the new user (you could enter a
name and password, but it was all basically placeholder GUI previously)
Added language selection front/back ends
Added basic build / run instructions to the README
Added ECM logging
Cleaned up the debug output which made changes more difficult
Added basic CI (thanks Nico!)
Added keyboard layout selection front/back ends
That last one was more difficult than expected.. turns out keyboard layouts can
be quite complex!
First came some refactoring of the keyboard layouts KCM from plasma-desktop so
we could reuse some of the existing, complex functionality. Then adapting a
UI/UX appropriate for the FRE. Investigating things like keyboard models,
detecting defaults, mapping language to keyboard layout, etc..
Then taking the results of the user choice and figuring out how to apply that
both to the system as a default (systemd-localed dbus call) as well as to the
running Plasma session (setting the value manually in the kxkbrc keyboard
settings file).
As is often the case with software development, that succinct summary belies
the massive amount of work it took to get there! 😅 💪
With that work completed, we have most of what is needed for a minimum viable
product!
Next up:
Granting authentication without a user prompt
Plan: special user with sysusers.d and a polkit rule
Running automatically on first boot & in live sessions
Plan: systemd unit seems promising, but more research is needed
Improve documentation
Especially related to building & running without kde-builder
Think about the name
I am not thrilled with the KISS acronym personally 🤷♀️
There is also obviously a lot of improvements and polish that can be made, but
for now here is a preview of the FRE:
These past few week’s my focus was on exploring input device detection and event handling mechanisms in Linux, with a particular emphasis on game controllers and their potential integration into KWin.
I also spent time reading through KWin’s input-related source code to understand how it currently manages devices, and began reviewing documentation for various Linux input subsystems—including evdev, HID, and /dev/input/jsX in order to evaluate which layer would provide the most reliable and straight forward support for integrating controller recognition.
The time was mostly spent learning how to use different libraries, tools and creating virtual controller prototype.
Tools, Libraries, and Concepts Used
libevdev
libevdev is a library for handling evdev devices.
It provides a higher-level interface over /dev/input/event* and abstracts much of the complexity of input event parsing.
evdev is the generic input event interface. This is the preferred interface for userspace to consume user input, and all clients are encouraged to use it.
-The kernel development community.
libevdev can be used to:
Detect physical game controllers.
Read input events (e.g., joystick, buttons).
Create virtual input device and write/forward events to it from physical game controller.
Useful functions:
libevdev_new(), libevdev_set_fd(int fd, struct libevdev **dev): for opening physical devices.
libevdev_next_event(struct libevdev *dev, unsigned int flags, struct input_event *ev): for polling events.
libevdev_get_id_*(const struct libevdev *dev): to query device meta data.
uinput (User Input Subsystem)
I used the Linux uinput subsystem to create a virtual input device that mirrors a physical controller input.
uinput is what allows us to make a virtual controller out of any evdev device by:
Opening a file discriptor for the input device that will be emulate (i.e. have it input event forwarded).
Forwarding the inputs from a evdev interface device to /dev/uinput (or /dev/input/uinput).
uinput then creates a new node to expose the virtual device as a evdev interface device in /dev/input/event*
From here the idea is that KWin or any other system component can treat the virtual controller as if it were an ordinary HID device.
uinput is a kernel module that makes it possible to emulate input devices from userspace.
By writing to /dev/uinput (or /dev/input/uinput) device, a process can create a virtual input device with specific capabilities.
Once this virtual device is created, the process can send events through it, that will be delivered to userspace and in-kernel consumers.
-The kernel development community.
Useful functions:
libevdev_uinput_create_from_device(const struct libevdev *dev, int uinput_fd, struct libevdev_uinput **uinput_dev): For creating a uinput device based on the given libevdev device.
libevdev_uinput_get_devnode (struct libevdev_uinput *uinput_dev): Return the device node representing this uinput device.
libevdev_uinput_write_event (const struct libevdev_uinput *uinput_dev, unsigned int type, unsigned int code, int value):
Post an event through the uinput device.
Tools used:
libevdev-uinput.h for management of uinput devices via libevdev.
/dev/uinput opened with correct permissions.
Ensuring the current user is in the input group.
Verifying that the uinput kernel module is loaded (using modprobe uinput). Some distros (Ubuntu/Kubuntu) have it built in, not loaded as module, thus modprobe uinput command won't log anything.
Opening /dev/uinput with O_WRONLY | O_NONBLOCK flags using open(), and ensuring no EPERM or EACCES errors were returned.
Optional: Run program as sudo user.
force feedback detection/support
Using ioctl(fd, EVIOCGBIT(EV_FF, ...)) and tools like fftest, I examined:
How to query a device’s force feedback (FF) capabilities to figure out which effects are supported (e.g., rumble, sine wave).
How to upload ff effects to physical game controller and test rumble motors.
This was key to understanding haptic capability support on physical devices.
To enable force feedback, you have to:
have your kernel configured with evdev and a driver that supports your device.
make sure evdev module is loaded and /dev/input/event* device files are created.
Testing & Validation
Used evtest and fftestto test evdev devices and understand their capabilities -
sudo evtest /dev/input/eventX.
Used those same tools to test virtual devices creating using uinput - sudo fftest dev/input/eventX. uinput creates a node device in dev/input/eventX for the virtual input.
Prototype logs validate that a virtual device can be created and events can properly be written to a that virtual device using libevdev.
Takeaways
Using libevdev and libevdev-uinput we can access physical controllers, create virtual controller and read/write low-level input events.
Understanding of the permission requirements to open /dev/input/* and /dev/uinput (use udev rules or run as root).
Tools to test:
evtest and fftest (from input-utils)
udevadm info --name=/dev/input/eventX --attribute-walk
Shows the device hierarchy - how the device is connected to PC and any parent device it connects to.
Built a minimal proof-of-concept C++ program that routes an evdev devices input 1:1 to a virtual controller (via uinput).
Not all controllers support all force feedback types; some failed with EINVAL during upload.
libevdev does not handle FF upload directly — this remains kernel-level and typically involves ioctl().